@qwik.dev/core 2.0.0-beta.35 → 2.0.0-beta.37

package/dist/core-internal.d.ts

@@ -397,7 +397,7 @@ export declare type AsyncFn<T> = (ctx: AsyncCtx) => ValueOrPromise<T>;
 
 /** Retains job metadata and also serves as the argument for the compute function */
 declare class AsyncJob<T> implements AsyncCtx<T> {
-    readonly $signal$: AsyncSignalImpl<T>;
+    readonly $signal$: _AsyncSignalImpl<T>;
     /** First holds the compute promise and then the cleanup promise */
     $promise$: Promise<void> | null | void;
     $cleanupRequested$: boolean;
@@ -407,7 +407,7 @@ declare class AsyncJob<T> implements AsyncCtx<T> {
     $abortController$: AbortController | undefined;
     info: unknown;
     $infoVersion$: number | undefined;
-    constructor($signal$: AsyncSignalImpl<T>, info: unknown, $infoVersion$: number | undefined);
+    constructor($signal$: _AsyncSignalImpl<T>, info: unknown, $infoVersion$: number | undefined);
     get track(): AsyncCtx<T>['track'];
     get abortSignal(): AbortSignal;
     /** Backward compatible cache method for resource */
@@ -515,7 +515,7 @@ declare const enum AsyncSignalFlags {
  *
  * @internal
  */
-declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
+export declare class _AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
     $untrackedLoading$: boolean;
     $untrackedError$: Error | undefined;
     $current$: AsyncJob<T> | null;
@@ -529,7 +529,7 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $info$: unknown | undefined;
     $infoVersion$: number | undefined;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags, options?: AsyncSignalOptions<T>);
     get untrackedValue(): T;
     set untrackedValue(value: T);
@@ -716,13 +716,14 @@ declare const enum ChoreBits {
     TASKS = 1,
     NODE_DIFF = 2,
     COMPONENT = 4,
-    NODE_PROPS = 8,
-    COMPUTE = 16,
-    CHILDREN = 32,
-    CLEANUP = 64,
-    RECONCILE = 128,
-    ERROR_WRAP = 256,
-    DIRTY_MASK = 511
+    INLINE_COMPONENT = 8,
+    NODE_PROPS = 16,
+    COMPUTE = 32,
+    CHILDREN = 64,
+    CLEANUP = 128,
+    RECONCILE = 256,
+    ERROR_WRAP = 512,
+    DIRTY_MASK = 1023
 }
 
 /**
@@ -745,8 +746,10 @@ export declare interface ClientContainer extends _Container {
     $locale$: string;
     qManifestHash: string;
     rootVNode: _ElementVNode;
-    $forwardRefs$: 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;
 }
 
@@ -875,7 +878,7 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
      */
     $computeQrl$: S;
     $flags$: SignalFlags | SerializationSignalFlags;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
     invalidate(): void;
     get untrackedValue(): T;
@@ -897,12 +900,14 @@ 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 | SignalImpl | ISsrNode;
+declare type Consumer = _Task | _VNode | SignalImpl | ISsrNode;
 
 /** @internal */
 export declare interface _Container {
     readonly $version$: string;
     readonly $storeProxyMap$: ObjToProxyMap;
+    $rootContainer$: _Container | null;
+    $isOutOfOrderSegment$: boolean;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     readonly $serverData$: Record<string, any>;
@@ -913,13 +918,13 @@ export declare interface _Container {
     $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;
+    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
@@ -928,7 +933,7 @@ export 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';
@@ -957,6 +962,8 @@ export declare interface _ContainerElement extends HTMLElement {
     qVNodeRefs?: Map<number, Element | _ElementVNode>;
     /** String from `<script type="qwik/vnode">` tag. */
     qVnodeData?: string;
+    /** Segment-local strings from `<script type="qwik/vnode" q:r="...">` tags. */
+    qSegmentVnodeData?: Map<string, string>;
 }
 
 /**
@@ -1094,7 +1101,7 @@ export declare interface CorrectedToggleEvent extends Event {
 export declare const createAsync$: <T>(qrl: (arg: AsyncCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /** @internal */
-export declare const createAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignalImpl<T>;
+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
@@ -1209,6 +1216,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> {
     /**
@@ -1221,6 +1231,9 @@ export declare interface CSSProperties extends CSS_2.Properties<string | number>
     [v: `--${string}`]: string | number | undefined;
 }
 
+/** @internal */
+export declare const _delay: (timeout: number) => Promise<unknown>;
+
 declare class DeleteOperation {
     target: Element | Text;
     constructor(target: Element | Text);
@@ -1229,7 +1242,7 @@ declare class DeleteOperation {
 declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $flags$: number;
     $index$: number;
-    $el$: HostElement;
+    $el$: _HostElement;
     $qrl$: _QRLInternal<T>;
     $state$: B | undefined;
     $destroy$: (() => void) | null;
@@ -1245,11 +1258,12 @@ export declare function _deserialize<T>(rawStateData: string): T;
 
 declare interface DeserializeContainer {
     $getObjectById$: (id: number | string) => unknown;
+    $getForwardRef$: (id: number) => number | string | undefined;
     element: HTMLElement | null;
     getSyncFn: (id: number) => (...args: unknown[]) => unknown;
     $state$?: unknown[];
     $storeProxyMap$: ObjToProxyMap;
-    $forwardRefs$: Array<number> | null;
+    $forwardRefs$: Array<number | string> | null;
 }
 
 /** @public */
@@ -1279,14 +1293,17 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $storeProxyMap$: ObjToProxyMap;
     $qFuncs$: Array<(...args: unknown[]) => unknown>;
     $instanceHash$: string;
-    $forwardRefs$: Array<number> | null;
+    $forwardRefs$: Array<number | string> | null;
     vNodeLocate: (id: string | Element) => _VNode;
     private $rawStateData$;
     private $stateData$;
+    private $rootForwardRefs$;
     private $styleIds$;
     constructor(element: _ContainerElement);
     /** Tear down this container so stale references fail gracefully. */
     $destroy$(): void;
+    private $processRootStateScript$;
+    private $stateScriptSelector$;
     /**
      * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
      * component inline to <head>)
@@ -1302,10 +1319,11 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     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;
+    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. */
@@ -1315,7 +1333,7 @@ export { DomContainer }
 export { DomContainer as _DomContainer }
 
 declare type DomRef = {
-    $ssrNode$: SsrNode;
+    $ssrNode$: ISsrNode;
 };
 
 /** @internal */
@@ -1343,7 +1361,8 @@ export declare const _EFFECT_BACK_REF: unique symbol;
 
 declare type EffectBackRef = SignalImpl | StoreTarget | PropsProxy;
 
-declare const enum EffectProperty {
+/** @internal */
+export declare const enum _EffectProperty {
     COMPONENT = ":",
     VNODE = "."
 }
@@ -1386,12 +1405,15 @@ declare const enum EffectProperty {
  */
 declare class EffectSubscription {
     consumer: Consumer;
-    property: EffectProperty | string;
+    property: _EffectProperty | string;
     backRef: Set<EffectBackRef> | null;
     data: _SubscriptionData | null;
-    constructor(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 const _ELEMENT_SEQ = "q:seq";
+
 /** @internal */
 export declare class _ElementVNode extends _VirtualVNode {
     node: Element;
@@ -1497,7 +1519,7 @@ export declare const _getContextContainer: () => _Container | undefined;
 export declare const _getContextEvent: () => unknown;
 
 /** @internal */
-export declare const _getContextHostElement: () => HostElement | undefined;
+export declare const _getContextHostElement: () => _HostElement | undefined;
 
 /** @public */
 declare function getDomContainer(element: Element): ClientContainer;
@@ -1531,6 +1553,9 @@ export declare const getPlatform: () => CorePlatform;
 /** @internal */
 export declare function _getQContainerElement(element: Element): Element | null;
 
+/** @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;
 
@@ -1564,7 +1589,8 @@ export declare const _hmr: (this: string | undefined, event: CustomEvent<{
     t: number;
 }>, element: Element) => void;
 
-declare type HostElement = _VNode | ISsrNode;
+/** @internal */
+export declare type _HostElement = _VNode | ISsrNode;
 
 /** @public */
 declare type HTMLAttributeAnchorTarget = '_self' | '_blank' | '_parent' | '_top' | (string & {});
@@ -1675,6 +1701,16 @@ export declare const _IMMUTABLE: unique symbol;
  */
 export declare const implicit$FirstArg: <FIRST, REST extends any[], RET>(fn: (qrl: QRL<FIRST>, ...rest: REST) => RET) => ((qrl: FIRST, ...rest: REST) => RET);
 
+/**
+ * Inject a pre-loaded value into an AsyncSignal while preserving track() 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: AsyncSignal<unknown>, value: unknown) => void;
+
 /**
  * Create an inlined QRL. This is mostly useful on the server side for serialization.
  *
@@ -1696,6 +1732,16 @@ declare class InsertOrMoveOperation {
     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
  *
@@ -1719,10 +1765,17 @@ 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 {
     /** The Virtual parent component for the current component code */
-    $hostElement$: HostElement | undefined;
+    $hostElement$: _HostElement | undefined;
     /** The event we're currently handling */
     $event$: PossibleEvents | undefined;
     $effectSubscriber$: EffectSubscription | undefined;
@@ -1770,8 +1823,10 @@ declare interface ISsrNode {
     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;
@@ -1786,7 +1841,7 @@ export declare const _isStore: (value: object) => boolean;
 export declare function _isStringifiable(value: unknown): value is _Stringifiable;
 
 /** @internal */
-export declare const _isTask: (value: any) => value is Task;
+export declare const _isTask: (value: any) => value is _Task;
 
 /** @internal */
 declare interface IStreamHandler {
@@ -2063,6 +2118,9 @@ export declare const _mapArray_get: <T>(array: (T | null)[], key: string, start:
 /** @internal */
 export declare const _mapArray_set: <T>(array: (T | null)[], key: string, value: T | null, start: number, allowNullValue?: boolean) => void;
 
+declare class MaybeAsyncSignal {
+}
+
 declare type MediaSpecialAttrs = {
     crossOrigin?: HTMLCrossOriginAttribute;
 };
@@ -2103,6 +2161,9 @@ 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;
@@ -2179,6 +2240,26 @@ 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;
 
@@ -2275,7 +2356,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];
@@ -2352,6 +2433,12 @@ export declare type PublicProps<PROPS> = (PROPS extends Record<any, any> ? Omit<
 /** @internal */
 export declare interface _QDocument extends Document {
     qVNodeData: WeakMap<Element, string>;
+    /** 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;
 }
 
 /**
@@ -2781,7 +2868,7 @@ export declare interface ReadonlySignal<T = unknown> {
 }
 
 /** @internal */
-export declare const _reC: (props: RevealProps) => JSXNodeInternal<FunctionComponent<    {
+export declare const _reC: (props: RevealProps) => JSXNodeInternal<InternalServerComponent<SSRRevealSlotProps>> | JSXNodeInternal<FunctionComponent<    {
 name?: string;
 children?: JSXChildren;
 }>>;
@@ -2978,9 +3065,25 @@ export declare const _restProps: (props: PropsProxy, omit?: string[], target?: P
 /** @internal */
 export declare const _reT: ({ cleanup }: TaskCtx) => void;
 
+/**
+ * Retries a function that throws a promise. If you pass `onError`, you're responsible for handling
+ * errors.
+ *
+ * @internal
+ */
+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: {
+        pending: {
+            untrackedValue: number;
+        };
+    };
+}
+
 /** @public @experimental */
 export declare type RevealOrder = 'parallel' | 'sequential' | 'reverse' | 'together';
 
@@ -2990,6 +3093,14 @@ export declare type RevealProps = {
     collapsed?: boolean;
 };
 
+declare interface RevealRegistrationLike<ITEM extends RevealItemLike = RevealItemLike> {
+    reveal: {
+        order: RevealOrder;
+        items: ITEM[];
+    };
+    item: ITEM;
+}
+
 /**
  * The resource function wrapper
  *
@@ -3012,8 +3123,15 @@ declare type SeenRef = {
     $parent$?: SeenRef | null;
 };
 
+declare interface SegmentRenderContext {
+    container: SSRSegmentContainer;
+    writer: SSRInternalStreamWriter;
+    htmlChunks: SSRSegmentWriteChunk[];
+}
+
 declare interface SerializationContext {
     $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.
@@ -3036,14 +3154,26 @@ declare interface SerializationContext {
      * Returns the index of the root object.
      */
     $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[];
-    $promoteToRoot$: (ref: SeenRef, index?: number) => void;
+    $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;
+    $markSsrNodeForSerialization$: (node: ISsrNode, flags: number) => void;
+    $writer$: SSRInternalStreamWriter;
+    $setWriter$(writer: SSRInternalStreamWriter): void;
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
@@ -3178,7 +3308,7 @@ declare class SetAttributeOperation {
 }
 
 /** @internal */
-export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, hasMovedCaptures: boolean): string | null;
+export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, hasMovedCaptures: boolean): string | SSRWriteChunk[] | null;
 
 /**
  * Sets the `CorePlatform`.
@@ -3212,6 +3342,8 @@ declare class SetTextOperation {
 export declare abstract class _SharedContainer implements _Container {
     readonly $version$: string;
     readonly $storeProxyMap$: ObjToProxyMap;
+    $rootContainer$: _Container | null;
+    $isOutOfOrderSegment$: boolean;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     $serverData$: Record<string, any>;
@@ -3222,7 +3354,7 @@ export declare abstract class _SharedContainer implements _Container {
     $resolveRenderPromise$: (() => void) | null;
     $pendingCount$: number;
     constructor(serverData: Record<string, any>, locale: string);
-    trackSignalValue<T>(signal: Signal, subscriber: HostElement, property: string, data: _SubscriptionData): T;
+    trackSignalValue<T>(signal: Signal, subscriber: _HostElement, property: string, data: _SubscriptionData): T;
     serializationCtxFactory(NodeConstructor: {
         new (...rest: any[]): {
             __brand__: 'SsrNode';
@@ -3233,14 +3365,14 @@ export declare abstract class _SharedContainer implements _Container {
         };
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
     $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;
+    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;
 }
 
 /**
@@ -3569,14 +3701,21 @@ declare interface SSRContainer extends _Container {
     readonly tag: string;
     readonly isHtml: boolean;
     readonly size: number;
-    readonly writer: StreamWriter;
+    readonly writer: SSRInternalStreamWriter;
     readonly streamHandler: IStreamHandler;
     readonly serializationCtx: SerializationContext;
     readonly symbolToChunkResolver: SymbolToChunkResolver;
     readonly resolvedManifest: ResolvedManifest;
+    readonly outOfOrderStreaming: boolean;
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
     $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>;
@@ -3593,18 +3732,24 @@ declare interface SSRContainer extends _Container {
     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: {
-        currentStyleScoped: string | null;
-        parentComponentFrame: ISsrComponentFrame | null;
-    }): 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;
 }
 
@@ -3613,23 +3758,56 @@ 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>;
+    toString(remap?: number[]): string;
+}
 
 declare const enum SsrNodeFlags {
     Updatable = 1
 }
 
+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 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[];
+};
+
 /** @public */
 export declare const SSRStream: FunctionComponent<SSRStreamProps>;
 
@@ -3651,10 +3829,24 @@ export declare interface SSRStreamWriter {
     write(chunk: JSXOutput): void;
 }
 
+/** @internal */
+declare type SSRWriteChunk = string | number | SSRRootRefPathChunk;
+
+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;
 };
 
+/** @internal */
+export declare const enum _StoreFlags {
+    NONE = 0,
+    RECURSIVE = 1,
+    IMMUTABLE = 2
+}
+
 declare type StoreTarget = Record<string | symbol, any>;
 
 /** @internal */
@@ -3674,10 +3866,14 @@ export declare class _SubscriptionData {
 }
 
 /** @internal */
-export declare const _suC: (props: SuspenseProps) => JSXNodeInternal<FunctionComponent<    {
-children?: any;
-key?: string | number | null;
-}>>;
+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;
@@ -3999,16 +4195,17 @@ declare type TableCellSpecialAttrs = {
     valign?: 'top' | 'middle' | 'bottom' | 'baseline' | undefined;
 };
 
-declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
+/** @internal */
+export declare class _Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
     $flags$: number;
     $index$: number;
-    $el$: HostElement;
+    $el$: _HostElement;
     $qrl$: _QRLInternal<T>;
     $state$: Signal<B> | undefined;
     $destroy$: (() => void) | null;
     $destroyPromise$: Promise<void> | undefined;
     $taskPromise$: Promise<void> | null;
-    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: _QRLInternal<T>, $state$: Signal<B> | undefined, $destroy$: (() => void) | null);
+    constructor($flags$: number, $index$: number, $el$: _HostElement, $qrl$: _QRLInternal<T>, $state$: Signal<B> | undefined, $destroy$: (() => void) | null);
 }
 
 /**
@@ -4842,7 +5039,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.35-dev+4603135
+ * 2.0.0-beta.37-dev+82dc74d
  *
  * @public
  */
@@ -5013,10 +5210,7 @@ declare type VNodeOperation = DeleteOperation | RemoveAllChildrenOperation | Set
 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.
@@ -5036,8 +5230,8 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $func$: (...args: any[]) => T;
     $funcStr$: string | null;
     $flags$: AllSignalFlags;
-    $hostElement$: HostElement | undefined;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
+    $hostElement$: _HostElement | undefined;
+    [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
     invalidate(): void;
     get untrackedValue(): T;