@qwik.dev/core 2.0.0-beta.43 → 2.0.0-beta.47

package/dist/core-internal.d.ts

@@ -1,10 +1,10 @@
-import type { AsyncLocalStorage } from 'node:async_hooks';
 import type * as CSS_2 from 'csstype';
-import { isBrowser } from './build';
-import { isDev } from './build';
-import { isServer } from './build';
-import { ResolvedManifest } from './optimizer';
-import type { ServerQwikManifest } from './optimizer';
+import { getAsyncLocalStorage as _getAsyncLocalStorage } from './async-local-storage.js';
+import { isBrowser } from './build/index.js';
+import { isDev } from './build/index.js';
+import { isServer } from './build/index.js';
+import { ResolvedManifest } from './optimizer.js';
+import type { ServerQwikManifest } from './optimizer.js';
 
 /**
  * Qwik Optimizer marker function.
@@ -381,12 +381,6 @@ declare type AsyncQRL<T> = ComputeQRL<T>;
  * changed, all tasks which are tracking the AsyncSignal will be re-run and all subscribers
  * (components, tasks etc) that read the AsyncSignal will be updated.
  *
- * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
- * property. The error can be cleared by re-running the async function successfully.
- *
- * While the async function is running, the `.loading` property will be set to `true`. Once the
- * function completes, `loading` will be set to `false`.
- *
  * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
  * retry the component or task once the value resolves.
  *
@@ -394,8 +388,7 @@ declare type AsyncQRL<T> = ComputeQRL<T>;
  * will subscribe to it and return the last resolved value until the new value is ready. As soon as
  * the new value is ready, the subscribers will be updated.
  *
- * If the async function threw an error, reading the `.value` will throw that same error. Read from
- * `.error` to check if there was an error.
+ * If the async function threw an error, reading the `.value` will throw that same error.
  *
  * @deprecated Use `ComputedSignal` instead, it has async support now.
  * @public
@@ -460,19 +453,91 @@ declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
 /** @public */
 declare type Booleanish = boolean | `${boolean}`;
 
+/** @internal */
+export declare const _caC: (props: CatchProps) => JSXOutput;
+
 declare type Capture = {
     [K in keyof HTMLElementEventMap as `capture:${K}`]?: boolean;
 };
 
 /**
- * The current captured scope during QRL invocation. This is used to provide the lexical scope for
- * QRL functions. It is used one time per invocation, synchronously, so it is safe to store it in
- * module scope.
+ * Legacy binding for libraries built before `_capturesObj`; their segments read `_captures[N]` from
+ * their own copy of core, so this live binding is kept in sync.
  *
+ * @deprecated Use `_capturesObj._` instead.
  * @internal
  */
 export declare let _captures: Readonly<unknown[]> | null;
 
+/**
+ * Holder for the current captured scope during QRL invocation. This is used to provide the lexical
+ * scope for QRL functions. It is used one time per invocation, synchronously, so it is safe to
+ * store it in one place.
+ *
+ * It is an object (instead of a `let` binding) registered as a singleton, so that duplicated Qwik
+ * modules (e.g. an externalized library and the app both bundling core) share the same holder.
+ * Generated segment code reads captures as `_capturesObj._[N]`.
+ *
+ * @internal
+ */
+export declare const _capturesObj: {
+    _: Readonly<unknown[]> | null;
+};
+
+/** @internal */
+export declare const _caR: () => void;
+
+/** Renders `fallback$` instead of its children when a descendant throws. @public @experimental */
+export declare const Catch: Component<CatchProps>;
+
+/** Structured metadata about a caught error, passed to `onError$`. @public @experimental */
+export declare interface CatchInfo {
+    /** Where the caught error originated. */
+    phase: CatchPhase;
+    /**
+     * Identifies the boundary within the page. Allocated in render order and kept across a resume, so
+     * every report from one boundary shares it — but it shifts when render order changes.
+     */
+    boundaryId: string;
+    /**
+     * The code a production fallback shows for a server-origin error, so a user's bug report matches
+     * your logs. An error caught during SSR reports a second, different digest if the client
+     * re-derives it — the stacks differ.
+     */
+    digest: string;
+}
+
+/** Identifies where an error caught by an error boundary originated. @public @experimental */
+export declare const enum CatchPhase {
+    Render = "render",
+    Event = "event",
+    Hook = "hook"
+}
+
+/** @public @experimental */
+export declare interface CatchProps {
+    /**
+     * Rendered when a descendant throws. The error is always an `Error`, so `{error.message}` is
+     * safe: a non-Error throw is wrapped, and production redacts server-origin errors to a generic
+     * message plus `digest`. Client-origin errors render as thrown — their messages already live in
+     * the browser bundle.
+     *
+     * Wrap `reset` in a handler — `onClick$={() => reset()}`, not `onClick$={reset}` — so it stays
+     * wired in a streamed fallback.
+     */
+    fallback$: QRL<(error: Error & {
+        digest?: string;
+    }, reset: QRL<() => void>) => JSXOutput>;
+    /**
+     * Side effect only; never affects rendering. Receives the original `Error` — a non-Error throw
+     * arrives wrapped, with `cause` set to the raw value.
+     *
+     * An error caught during SSR fires again when the client re-derives it, so dedupe in your
+     * reporter.
+     */
+    onError$?: QRL<(error: Error, info: CatchInfo) => void>;
+}
+
 /**
  * Handles events for bind:checked
  *
@@ -691,49 +756,28 @@ export declare type ComputedReturnType<T> = ComputedSignal<Awaited<T>>;
  * @public
  */
 export declare interface ComputedSignal<T> extends Signal<T> {
-    /** @deprecated Use `trigger()` instead */
-    force(): void;
-    /** Use this to force recalculation. */
-    invalidate(): void;
-    /**
-     * Clear the value and recompute. Unlike `invalidate()`, readers see the loading state (reads
-     * throw the computation promise) instead of the stale value while the new value computes.
-     */
-    clear(): void;
     /**
-     * Whether the signal is currently loading. This will trigger lazy computation of the signal, so
-     * you can use it like this:
+     * Whether the signal is currently loading. Reading it starts a lazy computation if needed.
      *
-     * ```tsx
-     * signal.pending ? <Loading /> : signal.error ? <Error /> : <Component
-     * value={signal.value} />
-     * ```
+     * @experimental
      */
     pending: boolean;
     /**
-     * Lets you read the pending state without subscribing to `.pending` updates. It also triggers
-     * lazy computation of the signal.
+     * The computation error, if any. Reading it starts a lazy computation if needed. While set,
+     * reading `.value` throws the error.
      *
-     * Setting it will trigger listeners for `.pending`.
-     */
-    untrackedPending: boolean;
-    /** @deprecated Use `pending` instead */
-    loading: boolean;
-    /** @deprecated Use `untrackedPending` instead */
-    untrackedLoading: boolean;
-    /**
-     * The error that occurred while computing the signal, if any, including synchronous throws. This
-     * will be cleared when the signal is successfully computed. It also triggers lazy computation of
-     * the signal. While the error is set, reading `.value` throws it.
+     * @experimental
      */
     error: Error | undefined;
+    /** @deprecated Use `trigger()` instead */
+    force(): void;
+    /** Use this to force recalculation. */
+    invalidate(): void;
     /**
-     * Lets you read the error state without subscribing to `.error` updates. It also triggers lazy
-     * computation of the signal.
-     *
-     * Setting it will trigger listeners for `.error`.
+     * Clear the value and recompute. Unlike `invalidate()`, readers see the loading state (reads
+     * throw the computation promise) instead of the stale value while the new value computes.
      */
-    untrackedError: Error | undefined;
+    clear(): void;
     /** A promise that resolves when the value is computed or rejected. */
     promise(): Promise<void>;
     /** Abort the current computation and run cleanups if needed. */
@@ -778,6 +822,7 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     $timeoutMs$: number | undefined;
     $loadingEffects$: undefined | Set<EffectSubscription>;
     $errorEffects$: undefined | Set<EffectSubscription>;
+    $disposed$: boolean | undefined;
     $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $info$: unknown | undefined;
     $infoVersion$: number | undefined;
@@ -855,7 +900,9 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
      * AbortErrors.
      */
     $setError$(job: Job<T>, error: Error): void;
-    /** Called after SSR/unmount */
+    /** Permanently stop computations; keep this cross-package name stable. */
+    $dispose(): void;
+    /** Clean computations after SSR while preserving dependencies for serialization. */
     $destroy$(): Promise<void>;
     private $hasSubscribers$;
     $requestCleanups$(job: Job<T>, reason?: any): void;
@@ -865,6 +912,32 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     $runCleanups$(job: Job<T>): Promise<void> | undefined;
 }
 
+/**
+ * A computed signal with its pending and error state exposed.
+ *
+ * @internal
+ */
+export declare interface _ComputedSignalInternal<T> extends ComputedSignal<T> {
+    /**
+     * Lets you read the pending state without subscribing to `.pending` updates. It also triggers
+     * lazy computation of the signal.
+     *
+     * Setting it will trigger listeners for `.pending`.
+     */
+    untrackedPending: boolean;
+    /** @deprecated Use `pending` instead */
+    loading: boolean;
+    /** @deprecated Use `untrackedPending` instead */
+    untrackedLoading: boolean;
+    /**
+     * Lets you read the error state without subscribing to `.error` updates. It also triggers lazy
+     * computation of the signal.
+     *
+     * Setting it will trigger listeners for `.error`.
+     */
+    untrackedError: Error | undefined;
+}
+
 declare type ComputeQRL<T> = _QRLInternal<ComputedFn<T>>;
 
 /** @internal */
@@ -897,7 +970,7 @@ export declare interface _Container {
     $resolveRenderPromise$: (() => void) | null;
     $pendingCount$: number;
     $checkPendingCount$(): void;
-    handleError(err: any, $host$: _HostElement | null, phase?: ErrorBoundaryPhase): void;
+    handleError(err: any, $host$: _HostElement | null, phase?: CatchPhase): 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;
@@ -1089,9 +1162,9 @@ export declare const createAsyncQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: Asyn
  *
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects. Every synchronous signal or store read is tracked automatically; reads after the first
- * `await` must use the `track()` provided on the context argument. When the function is async, the
- * returned signal exposes the async API (`.pending`, `.error`, `.promise()`), and reading an
- * unresolved `.value` throws the computation promise.
+ * `await` must use the `track()` provided on the context argument. When the function is async,
+ * reading an unresolved `.value` throws the computation promise, and reading a failed `.value`
+ * throws the error.
  *
  * @public
  */
@@ -1292,7 +1365,7 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $hoistStyles$(): void;
     $setRawState$(id: number, vParent: _VNode): void;
     parseQRL<T = unknown>(qrlStr: string): QRL<T>;
-    handleError(err: any, host: _VNode | null, phase?: ErrorBoundaryPhase): void;
+    handleError(err: any, host: _VNode | null, phase?: CatchPhase): void;
     setContext<T>(host: _VNode, context: ContextId<T>, value: T): void;
     resolveContext<T>(host: _VNode, contextId: ContextId<T>): T | undefined;
     resolveContextHost(host: _VNode, contextId: ContextId<unknown>): _VNode | null;
@@ -1334,12 +1407,6 @@ declare interface EachProps<T, ITEM extends JSXOutput = JSXOutput> {
 /** @internal */
 export declare const _eaT: ({ track }: TaskCtx) => Promise<void>;
 
-/** @internal */
-export declare const _ebC: (props: ErrorBoundaryProps) => JSXOutput;
-
-/** @internal */
-export declare const _ebR: () => void;
-
 /** @internal */
 export declare const _EFFECT_BACK_REF: unique symbol;
 
@@ -1411,57 +1478,6 @@ export declare const _EMPTY_ARRAY: any[];
 /** @internal */
 export declare const _EMPTY_OBJ: Record<string, any>;
 
-/** Renders `fallback$` instead of its children when a descendant throws. @public @experimental */
-export declare const ErrorBoundary: Component<ErrorBoundaryProps>;
-
-/** Structured metadata about a caught error, passed to `onError$`. @public @experimental */
-export declare interface ErrorBoundaryInfo {
-    /** Where the caught error originated. */
-    phase: ErrorBoundaryPhase;
-    /**
-     * Identifies the boundary within the page. Allocated in render order and kept across a resume, so
-     * every report from one boundary shares it — but it shifts when render order changes.
-     */
-    boundaryId: string;
-    /**
-     * The code a production fallback shows for a server-origin error, so a user's bug report matches
-     * your logs. An error caught during SSR reports a second, different digest if the client
-     * re-derives it — the stacks differ.
-     */
-    digest: string;
-}
-
-/** Identifies where an error caught by an error boundary originated. @public @experimental */
-export declare const enum ErrorBoundaryPhase {
-    Render = "render",
-    Event = "event",
-    Hook = "hook"
-}
-
-/** @public @experimental */
-export declare interface ErrorBoundaryProps {
-    /**
-     * Rendered when a descendant throws. The error is always an `Error`, so `{error.message}` is
-     * safe: a non-Error throw is wrapped, and production redacts server-origin errors to a generic
-     * message plus `digest`. Client-origin errors render as thrown — their messages already live in
-     * the browser bundle.
-     *
-     * Wrap `reset` in a handler — `onClick$={() => reset()}`, not `onClick$={reset}` — so it stays
-     * wired in a streamed fallback.
-     */
-    fallback$: QRL<(error: Error & {
-        digest?: string;
-    }, reset: QRL<() => void>) => JSXOutput>;
-    /**
-     * Side effect only; never affects rendering. Receives the original `Error` — a non-Error throw
-     * arrives wrapped, with `cause` set to the raw value.
-     *
-     * An error caught during SSR fires again when the client re-derives it, so dedupe in your
-     * reporter.
-     */
-    onError$?: QRL<(error: Error, info: ErrorBoundaryInfo) => void>;
-}
-
 /** @public */
 export declare const event$: <T>(qrl: T) => QRL<T>;
 
@@ -1528,8 +1544,7 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
-/** @internal */
-export declare const _getAsyncLocalStorage: () => (new <T>() => AsyncLocalStorage<T>) | undefined;
+export { _getAsyncLocalStorage }
 
 /**
  * Returns the client build manifest, which includes the mappings from symbols to bundles, the
@@ -1583,6 +1598,13 @@ export declare const getPlatform: () => CorePlatform;
 /** @internal */
 export declare function _getQContainerElement(element: Element): Element | null;
 
+/**
+ * Read a singleton registered with `registerSingleton`, if any.
+ *
+ * @internal
+ */
+export declare const _getSingleton: <T>(key: string) => T | undefined;
+
 /** @internal */
 export declare function _getSubscriber(effect: Consumer, prop: _EffectProperty | string, data?: _SubscriptionData): EffectSubscription;
 
@@ -1600,7 +1622,10 @@ export { h as createElement }
 export { h }
 
 /** @internal */
-export declare function _handleSSRError(container: SSRContainer, err: any, host: ISsrNode | null, phase: ErrorBoundaryPhase): void;
+export declare function _handleSSRError(container: SSRContainer, err: any, host: ISsrNode | null, phase: CatchPhase): void;
+
+/** @internal */
+export declare function _hasSlotProps(props: Props | null | undefined): boolean;
 
 /**
  * @returns True if the store has effects for the given prop
@@ -1613,7 +1638,7 @@ export declare const _hasStoreEffects: (value: StoreTarget, prop: keyof StoreTar
  *
  * When called by the qwikloader or the test dispatch, `this` is the serialized captures string
  * which we deserialize to get the host VNode. When called through `_qDispatch` (client-rendered),
- * `_captures` is already set by `ensureQrlCaptures` in the QRL call chain.
+ * `_capturesObj._` is already set by `ensureQrlCaptures` in the QRL call chain.
  *
  * @internal
  */
@@ -1865,6 +1890,7 @@ declare interface ISsrNode {
     readonly [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | null;
     setProp(name: string, value: any): void;
     getProp(name: string): any;
+    hasSlotProps(): boolean;
     removeProp(name: string): void;
     addChild(child: ISsrNode): void;
     setTreeNonUpdatable(): void;
@@ -1905,7 +1931,7 @@ declare class Job<T> implements ComputeCtx<T> {
     /** Backward compatible cache method for resource */
     cache(): void;
     get previous(): T | undefined;
-    cleanup(callback: () => void): void;
+    cleanup: (callback: () => void) => void;
 }
 
 /**
@@ -2346,9 +2372,24 @@ declare type Passive = {
     [K in keyof HTMLElementEventMap as `passive:${K}`]?: boolean;
 };
 
+/** @internal */
+export declare const _peC: (props: PendingProps) => JSXNodeInternal<string>[];
+
+/** @public @experimental */
+export declare const Pending: Component<PendingProps>;
+
+/** @public @experimental */
+export declare type PendingProps = {
+    fallback$?: QRL<() => JSXOutput>;
+    delay?: number;
+};
+
+/** @internal */
+export declare const _peT: ({ track, cleanup }: TaskCtx) => void;
+
 declare type PopoverTargetAction = 'hide' | 'show' | 'toggle';
 
-declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
+declare type PossibleEvents = Event | typeof TaskEvent | typeof RenderEvent;
 
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class. You
@@ -2377,6 +2418,8 @@ export declare const PrefetchServiceWorker: (opts: {
     nonce?: string;
 }) => JSXOutput;
 
+declare type Preload = (item: string | string[], probability?: number) => void;
+
 /**
  * Preprocess the state data to:
  *
@@ -2513,7 +2556,7 @@ export declare interface _QDocument extends Document {
     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. */
+    /** Processes an out-of-order Pending segment after its resolved HTML is swapped in. */
     qProcessOOOS?: (boundaryId: number, revealNode: Element | null) => void;
     /** Routes `qerror` to the owning container; installed once per document, shared by all bundles. */
     qErrorHandler?: (e: Event) => void;
@@ -2910,6 +2953,14 @@ export declare type QwikSVGElements = {
     [K in keyof Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: SVGProps<SVGElementTagNameMap[K]>;
 };
 
+/**
+ * A marker symbol shared by every copy of this Qwik version. `Symbol.for` keys are global to the
+ * realm, so the version keeps markers apart when several Qwik versions share a page.
+ *
+ * @internal
+ */
+export declare const _qwikSymbol: <S extends symbol = symbol>(name: string) => S;
+
 /** Emitted by qwik-loader on document when a module was lazily loaded @public */
 export declare type QwikSymbolEvent = CustomEvent<{
     symbol: string;
@@ -2972,6 +3023,22 @@ declare type RefFnInterface<EL> = {
     (el: EL): void;
 };
 
+/**
+ * Registers the function of an inlined QRL by its hash, so the server can call it by hash. The
+ * router uses it for the `server$` functions of a library kept external on the server, whose build
+ * inlines its QRLs instead of emitting segments.
+ *
+ * @internal
+ */
+export declare const _regInlinedQrl: (qrl: QRL) => void;
+
+/**
+ * Get or create a singleton shared by all Qwik module instances in this process/version.
+ *
+ * @internal
+ */
+export declare const _registerSingleton: <T>(key: string, factory: () => T) => T;
+
 /**
  * Register a QRL symbol globally for lookup by its hash. This is used by the optimizer to register
  * the names passed in `reg_ctx_name`.
@@ -3037,6 +3104,9 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
+/** @internal */
+export declare const _requestPreload: Preload;
+
 /** @internal */
 export declare const _reR: () => boolean;
 
@@ -3068,21 +3138,13 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
  *   return (
  *     <div>
  *       <input name="city" bind:value={city} />
- *       <div>
- *         Temperature:{' '}
- *         {weather.pending
- *           ? 'Loading...'
- *           : weather.error
- *             ? `Error: ${weather.error.message}`
- *             : weather.value.temp}
- *       </div>
+ *       <div>Temperature: {weather.value.temp}</div>
  *     </div>
  *   );
  * });
  * ```
  *
- * @deprecated Use `useComputed$` instead. Read the `pending` and `error` properties from the
- *   returned signal to determine the status.
+ * @deprecated Use `useComputed$` instead.
  * @public
  */
 export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
@@ -3137,7 +3199,7 @@ declare interface ResourceReturnInternal<T> {
     __brand: 'resource';
     value: Promise<T>;
     loading: boolean;
-    signal: AsyncSignal<{
+    signal: _ComputedSignalInternal<{
         r: T;
     }>;
 }
@@ -3252,7 +3314,7 @@ declare interface SerializationContext {
     $setSyncFnOffset$(offset: number, existingFns?: string[]): void;
     $isSsrNode$: (obj: unknown) => obj is ISsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
-    $markSsrNodeForSerialization$: (node: ISsrNode, flags: number) => void;
+    $markSsrNodeForSerialization$: (node: ISsrNode, flags: number, isStateRoot?: boolean) => void;
     $writer$: SSRInternalStreamWriter;
     $setWriter$(writer: SSRInternalStreamWriter): void;
     $syncFns$: string[];
@@ -3447,7 +3509,7 @@ 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, phase?: ErrorBoundaryPhase): void;
+    abstract handleError(err: any, $host$: _HostElement | null, phase?: CatchPhase): 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;
@@ -3524,12 +3586,6 @@ declare class SignalImpl<T = any> implements Signal<T> {
     };
 }
 
-declare interface SimplifiedServerRequestEvent<T = unknown> {
-    url: URL;
-    locale: string | undefined;
-    request: Request;
-}
-
 /** @public */
 declare type Size = number | string;
 
@@ -3806,9 +3862,9 @@ declare interface SSRContainer extends _Container {
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
     $noScriptHere$: number;
-    /** Innermost open ErrorBoundary content host, so the walker can skip an errored subtree. */
+    /** Innermost open Catch content host, so the walker can skip an errored subtree. */
     $errorContentHost$: ISsrNode | null;
-    /** Set when an ErrorBoundary caught during this container's render. */
+    /** Set when a Catch caught during this container's render. */
     $hasBoundaryError$?: boolean;
     /**
      * Lets the container place a root-level `useOn` placeholder `<script>` itself when injecting it
@@ -3989,21 +4045,6 @@ export declare class _SubscriptionPatch {
     constructor(rootId?: number, subscriptions?: Set<EffectSubscription> | Map<string | symbol, Set<EffectSubscription>>);
 }
 
-/** @internal */
-export declare const _suC: (props: SuspenseProps) => JSXNodeInternal<string>[];
-
-/** @public @experimental */
-export declare const Suspense: typeof _suC;
-
-/** @public @experimental */
-export declare type SuspenseProps = {
-    fallback?: JSXOutput;
-    delay?: number;
-};
-
-/** @internal */
-export declare const _suT: ({ track, cleanup }: TaskCtx) => void;
-
 /**
  * The TS types don't include the SVG attributes so we have to define them ourselves
  *
@@ -4346,7 +4387,8 @@ declare const enum TaskFlags {
     DIRTY = 4,
     RENDER_BLOCKING = 8,
     NEEDS_CLEANUP = 16,
-    EVENTS_REGISTERED = 32
+    EVENTS_REGISTERED = 32,
+    EXECUTED = 64
 }
 
 /** @public */
@@ -4494,9 +4536,8 @@ export declare function _updateProjectionProps(container: _Container, vnode: _Vi
  *
  * Every synchronous signal or store read is tracked automatically. Reads after an `await` are not:
  * the tracking context is lost, so track them explicitly with the `track()` provided on the context
- * argument. When the function is async, the returned signal exposes the async API: reading an
- * unresolved `.value` throws the computation promise, and `.pending` and `.error` expose the
- * computation state.
+ * argument. When the function is async, reading an unresolved `.value` throws the computation
+ * promise, and reading a failed `.value` throws the error.
  *
  * The function must not have any side effects.
  *
@@ -4655,7 +4696,7 @@ export declare const useId: () => string;
  * NOTE: `useLexicalScope` method can only be used in the synchronous portion of the callback
  * (before any `await` statements.)
  *
- * @deprecated Use `_captures` instead.
+ * @deprecated Use `_capturesObj._` instead.
  * @internal
  */
 export declare const useLexicalScope: <VARS extends any[]>() => VARS;
@@ -5040,6 +5081,12 @@ export declare const useStylesScopedQrl: (styles: QRL<string>) => UseStylesScope
  * function to wrap property reads. This creates subscriptions that will trigger the `taskFn` to
  * rerun.
  *
+ * Cleanup callbacks registered with `cleanup()` or returned from the task may be async. When a task
+ * reruns, Qwik waits for the previous cleanup to finish before starting the next invocation.
+ *
+ * During SSR, the cleanup function is called immediately after SSR completes. Therefore, it is not
+ * called on the client side after resuming, but only the second time the task runs on the client.
+ *
  * @param task - Function which should be re-executed when changes to the inputs are detected
  * @public
  *
@@ -5113,6 +5160,14 @@ export declare const useTaskQrl: (qrl: QRL<TaskFn>, opts?: TaskOptions) => void;
  * });
  * ```
  *
+ * Visible Tasks are a variant of Tasks that only run in the browser, and are registered but not
+ * executed during SSR. They are useful for running code that should only execute in the browser,
+ * such as code that interacts with the DOM or browser APIs.
+ *
+ * Cleanup callbacks registered with `cleanup()` or returned from the task may be async. When a
+ * visible task reruns, Qwik waits for the previous cleanup to finish before starting the next
+ * invocation.
+ *
  * @public
  */
 export declare const useVisibleTask$: (fn: TaskFn, opts?: OnVisibleTaskOptions) => void;
@@ -5141,7 +5196,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.43-dev+e478dfb
+ * 2.0.0-beta.47-dev+919c91b
  *
  * @public
  */
@@ -5315,9 +5370,15 @@ export declare const _waitUntilRendered: (container: _Container) => Promise<void
 /** @internal */
 export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: SSRRenderJSXOptions): Promise<void>;
 
+/** @internal */
+export declare const _whenContainerDataReady: <T>(container: ClientContainer, callback: () => T | Promise<T>) => T | Promise<T>;
+
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
  *
+ * `fn` may be async. The locale stays set until the returned promise settles, even when
+ * AsyncLocalStorage is not available.
+ *
  * @public
  */
 export declare function withLocale<T>(locale: string, fn: () => T): T;