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

package/dist/core-internal.d.ts

@@ -1,11 +1,9 @@
+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 +97,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 +364,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 +433,37 @@ 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 class ChoreArray extends Array<Chore> {
+    add(value: Chore): number;
+    delete(value: Chore): number;
+}
+
+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 +475,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 +501,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 +602,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 +619,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 +643,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 +683,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 +834,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 +855,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 +878,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 +939,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: ChoreArray, 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<unknown> | StoreTarget, 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 +1015,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 +1044,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;
-    setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
-    resolveContext<T>(host: HostElement, contextId: ContextId<T>): T | undefined;
-    getParentHost(host: HostElement): HostElement | null;
+    handleError(err: any, host: _VNode | null): void;
+    setContext<T>(host: _VNode, context: ContextId<T>, value: T): void;
+    resolveContext<T>(host: _VNode, contextId: ContextId<T>): T | undefined;
+    getParentHost(host: _VNode): _VNode | null;
     setHostProp<T>(host: HostElement, name: string, value: T): void;
     getHostProp<T>(host: HostElement, name: string): T | null;
-    scheduleRender(): Promise<void>;
-    private processChores;
     ensureProjectionResolved(vNode: _VirtualVNode): void;
     $getObjectById$: (id: number | string) => unknown;
     getSyncFn(id: number): (...args: unknown[]) => unknown;
@@ -1076,25 +1152,13 @@ _SubscriptionData | null
 ];
 
 /** @internal */
-export declare type _ElementVNode = [
-_VNodeFlags.Element,
-////////////// 0 - Flags
-_VNode | null,
-/////////////// 1 - Parent
-_VNode | null,
-/////////////// 2 - Previous sibling
-_VNode | null,
-/////////////// 3 - Next sibling
-_VNode | null | undefined,
-/// 4 - First child - undefined if children need to be materialize
-_VNode | null | undefined,
-Element,
-//////////////////// 6 - Element
-string | undefined,
-(string | null)[]
-] & {
-    __brand__: 'ElementVNode';
-};
+export declare class _ElementVNode extends _VNode {
+    firstChild: _VNode | null | undefined;
+    lastChild: _VNode | null | undefined;
+    element: Element;
+    elementName: string | undefined;
+    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, firstChild: _VNode | null | undefined, lastChild: _VNode | null | undefined, element: Element, elementName: string | undefined);
+}
 
 /** @internal */
 export declare const _EMPTY_ARRAY: any[];
@@ -1147,6 +1211,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 +1235,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 +1279,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 +1303,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 +1522,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 +1696,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;
 };
@@ -1858,6 +1962,8 @@ declare type PropsProxy = {
     [_CONST_PROPS]: Props | null;
 };
 
+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
  * plain functions to QRL arguments.
@@ -2049,13 +2155,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;
@@ -2393,6 +2498,8 @@ export declare const RenderOnce: FunctionComponent<{
     key?: string | number | null | undefined;
 }>;
 
+/** @internal */
+/** @internal */
 /** @public */
 export declare interface RenderOptions {
     serverData?: Record<string, any>;
@@ -2413,6 +2520,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 +2623,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 +2655,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,11 +2712,11 @@ 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;
-    $writer$: StreamWriter_2;
+    $writer$: StreamWriter;
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
@@ -2617,6 +2727,14 @@ 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';
+
 /**
  * Serialize data to string using SerializationContext.
  *
@@ -2688,7 +2806,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 +2857,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 +2870,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 +2896,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 +2906,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 +3240,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 +3257,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,38 +3275,22 @@ export declare const SSRStreamBlock: FunctionComponent<{
 }>;
 
 /** @public */
-export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: StreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
+export declare type SSRStreamChildren = AsyncGenerator<JSXChildren, void, any> | ((stream: SSRStreamWriter) => Promise<void>) | (() => AsyncGenerator<JSXChildren, void, any>);
 
 /** @public */
 export declare type SSRStreamProps = {
     children: SSRStreamChildren;
 };
 
+/** @public */
+export declare interface SSRStreamWriter {
+    write(chunk: JSXOutput): void;
+}
+
 declare type StopPropagation = {
     [K in keyof HTMLElementEventMap as `stoppropagation:${K}`]?: boolean;
 };
 
-declare const enum StoreFlags {
-    NONE = 0,
-    RECURSIVE = 1,
-    IMMUTABLE = 2
-}
-
-declare class StoreHandler implements ProxyHandler<StoreTarget> {
-    $flags$: StoreFlags;
-    $container$: Container | null;
-    $effects$: null | Map<string | symbol, Set<EffectSubscription>>;
-    constructor($flags$: StoreFlags, $container$: Container | null);
-    toString(): string;
-    get(target: StoreTarget, prop: string | symbol): any;
-    /** In the case of oldValue and value are the same, the effects are not triggered. */
-    set(target: StoreTarget, prop: string | symbol, value: any): boolean;
-    deleteProperty(target: StoreTarget, prop: string | symbol): boolean;
-    has(target: StoreTarget, prop: string | symbol): boolean;
-    ownKeys(target: StoreTarget): ArrayLike<string | symbol>;
-    getOwnPropertyDescriptor(target: StoreTarget, prop: string | symbol): PropertyDescriptor | undefined;
-}
-
 declare type StoreTarget = Record<string | symbol, any>;
 
 /** @internal */
@@ -3531,20 +3646,11 @@ declare const TaskEvent = "qTask";
 export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => void)>;
 
 /** @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 {
+    textNode: Text | null;
+    text: string | undefined;
+    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, textNode: Text | null, text: string | undefined);
+}
 
 /**
  * Used to signal to Qwik which state should be watched for changes.
@@ -3631,6 +3737,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 +3767,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 +3782,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 +4111,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,35 +4359,60 @@ 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.11-dev+d7daca3
  *
  * @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 {
+    firstChild: _VNode | null | undefined;
+    lastChild: _VNode | null | undefined;
+    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined, 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 extends BackRef {
+    flags: _VNodeFlags;
+    parent: _ElementVNode | _VirtualVNode | null;
+    previousSibling: _VNode | null | undefined;
+    nextSibling: _VNode | null | undefined;
+    props: unknown[] | null;
+    slotParent: _VNode | null;
+    chores: ChoreArray | null;
+    blockedChores: ChoreArray | null;
+    constructor(flags: _VNodeFlags, parent: _ElementVNode | _VirtualVNode | null, previousSibling: _VNode | null | undefined, nextSibling: _VNode | null | undefined);
+    getProp<T>(key: string, getObject: ((id: string) => any) | null): T | null;
+    setProp(key: string, value: any): void;
+    getAttr(key: string): string | null;
+    setAttr(key: string, value: string | null | boolean, journal: VNodeJournal | null): void;
+    toString(): string;
+}
+
+/** @internal */
+export declare const _vnode_ensureElementInflated: (vnode: _VNode) => void;
+
+/** @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_getProps: (vnode: _ElementVNode | _VirtualVNode) => unknown[];
+
+/** @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 +4483,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 +4524,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.
  *
@@ -4400,8 +4531,10 @@ export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
  */
 export declare function withLocale<T>(locale: string, fn: () => T): T;
 
+declare type WrappedProp<T extends object, P extends keyof T> = T extends Signal ? WrappedSignalImpl<PropType<T, P>> : PropType<T, P>;
+
 declare const enum WrappedSignalFlags {
-    UNWRAP = 2
+    UNWRAP = 4
 }
 
 declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
@@ -4410,17 +4543,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;
 }
@@ -4436,12 +4568,9 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
  *
  * @internal
  */
-export declare const _wrapProp: <T extends Record<any, any>, P extends keyof T>(...args: [T, P?]) => any;
+export declare const _wrapProp: <T extends object, P extends keyof T>(...args: [T, P?]) => WrappedProp<T, P>;
 
 /** @internal @deprecated v1 compat */
-export declare const _wrapSignal: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => any;
-
-/** @internal */
-export declare const _wrapStore: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => Signal<T>;
+export declare const _wrapSignal: <T extends object, P extends keyof T>(obj: T, prop: P) => T[P] | WrappedProp<T, P>;
 
 export { }