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

package/dist/core-internal.d.ts

@@ -108,7 +108,7 @@ declare type AllEventsMap = Omit<AllEventMapRaw, keyof EventCorrectionMap> & Eve
 
 declare type _AllowPlainQrl<Q> = QRLEventHandlerMulti<any, any> extends Q ? Q extends QRLEventHandlerMulti<infer EV, infer EL> ? Q | (EL extends Element ? EventHandler<EV, EL> : never) : Q : Q extends QRL<infer U> ? Q | U : NonNullable<Q> extends never ? Q : QRL<Q> | Q;
 
-declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
+declare type AllSignalFlags = ComputedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -366,56 +366,17 @@ declare interface AriaAttributes {
 /** @public */
 declare type AriaRole = 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | (string & {});
 
-declare type AsyncCtx<T = unknown> = {
-    track: Tracker;
-    /**
-     * Register a cleanup callback to be called when the async computation is aborted or completed.
-     * The next invocation will await the previous cleanup. If you do not want this, do not return a
-     * Promise.
-     */
-    cleanup: (callback: () => void | Promise<void>) => void;
-    /**
-     * A lazily created AbortSignal, for interrupting the async computation when needed, e.g. when the
-     * component is unmounted or the computation is invalidated. Pass it to `fetch` or other APIs that
-     * support it to ensure that unnecessary work is not performed.
-     */
-    readonly abortSignal: AbortSignal;
-    /** The result of the previous computation, if any */
-    readonly previous: T | undefined;
-    /** Extra info passed to `invalidate(info)` for this computation, if any. */
-    readonly info?: unknown;
-};
-
 /**
- * Note, we don't pass the generic type to AsyncCtx because it causes TypeScript to not infer the
+ * Note, we don't pass the generic type to ComputeCtx because it causes TypeScript to not infer the
  * type of the resource correctly. The type is only used for the `previous` property, which is not
  * commonly used, and can be easily cast if needed.
  *
+ * @deprecated Use `useComputed$` with an async function instead.
  * @public
  */
-export declare type AsyncFn<T> = (ctx: 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>;
-    /** First holds the compute promise and then the cleanup promise */
-    $promise$: Promise<void> | null | void;
-    $cleanupRequested$: boolean;
-    $canWrite$: boolean;
-    $track$: AsyncCtx<T>['track'] | undefined;
-    $cleanups$: Parameters<AsyncCtx<T>['cleanup']>[0][] | undefined;
-    $abortController$: AbortController | undefined;
-    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 */
-    cache(): void;
-    get previous(): T | undefined;
-    cleanup(callback: () => void): void;
-}
+export declare type AsyncFn<T> = (ctx: ComputeCtx) => ValueOrPromise<T>;
 
+/** @deprecated Use `ComputeQRL` instead. */
 declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
 
 /**
@@ -440,70 +401,20 @@ declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
  * If the async function threw an error, reading the `.value` will throw that same error. Read from
  * `.error` to check if there was an error.
  *
+ * @deprecated Use `ComputedSignal` instead, it has async support now.
  * @public
  */
-export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
-    /**
-     * Whether the signal is currently loading. This will trigger lazy loading of the signal, so you
-     * can use it like this:
-     *
-     * ```tsx
-     * signal.loading ? <Loading /> : signal.error ? <Error /> : <Component
-     * value={signal.value} />
-     * ```
-     */
-    loading: boolean;
-    /**
-     * Lets you read the loading state without subscribing to `.loading` updates. It also triggers
-     * lazy loading of the signal.
-     *
-     * Setting it will trigger listeners for `.loading`.
-     */
-    untrackedLoading: boolean;
-    /**
-     * The error that occurred while computing the signal, if any. This will be cleared when the
-     * signal is successfully computed. It does not trigger lazy loading of the signal.
-     */
-    error: Error | undefined;
-    /**
-     * Lets you read the error state without subscribing to `.error` updates. It does not trigger lazy
-     * loading of the signal.
-     *
-     * Setting it will trigger listeners for `.error`.
-     */
-    untrackedError: Error | undefined;
-    /**
-     * Expiration time in ms. Writable and immediately effective.
-     *
-     * When set, the signal is invalidated after this many ms. Whether it auto-recomputes depends on
-     * the `poll` property. `0` means no expiration.
-     */
-    expires: number;
-    /**
-     * Whether to automatically re-run the function when the value expires. Writable and immediately
-     * effective. Only relevant when `expires` is set.
-     *
-     * Defaults to `true`.
-     */
-    poll: boolean;
-    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
-    interval: number;
-    /** A promise that resolves when the value is computed or rejected. */
-    promise(): Promise<void>;
-    /** Abort the current computation and run cleanups if needed. */
-    abort(reason?: any): void;
-    /**
-     * Use this to force recalculation. If you pass `info`, it will be provided to the calculation
-     * function.
-     */
-    invalidate(info?: unknown): void;
-}
+export declare type AsyncSignal<T = unknown> = ComputedSignal<T>;
 
 declare const enum AsyncSignalFlags {
     EAGER_CLEANUP = 32,
     CLIENT_ONLY = 64,
     CLEAR_ON_INVALIDATE = 128,
-    NO_POLL = 256
+    NO_POLL = 256,
+    /** The compute fn is async: the async engine (jobs, loading, error) is active */
+    ASYNC_MODE = 512,
+    /** Invoke the compute fn AsyncSignal-style: pass the ComputeCtx argument, no auto-tracking */
+    CTX_ARG = 1024
 }
 
 /**
@@ -513,157 +424,21 @@ declare const enum AsyncSignalFlags {
  *
  * # ================================
  *
+ * The async engine (jobs, loading, error, polling) lives in ComputedSignalImpl; this subclass
+ * configures it from options and switches the compute invocation to CTX_ARG mode: the compute fn
+ * receives the ComputeCtx argument and tracks only via its explicit `track()` (no auto-tracking).
+ *
  * @internal
  */
-export declare class _AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
-    $untrackedLoading$: boolean;
-    $untrackedError$: Error | undefined;
-    $current$: AsyncJob<T> | null;
-    $jobs$: AsyncJob<T>[] | undefined;
-    $concurrency$: number | undefined;
-    $expires$: number | undefined;
-    $timeoutMs$: number | undefined;
-    $loadingEffects$: undefined | Set<EffectSubscription>;
-    $errorEffects$: undefined | Set<EffectSubscription>;
-    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
-    $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
-    $info$: unknown | undefined;
-    $infoVersion$: number | 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);
-    /**
-     * Read the value, subscribing if in a tracking context. Triggers computation if needed.
-     *
-     * Setting the value will mark the signal as not loading and clear any error, and prevent any
-     * pending computations from writing their results.
-     *
-     * If you want to set the value without affecting loading or error state, set `untrackedValue`
-     * instead and make sure to trigger effects manually if needed.
-     *
-     * If you want to abort pending computations when setting, you have to call `abort()` manually.
-     */
-    get value(): T;
-    set value(value: T);
-    /**
-     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
-     * has resolved or rejected.
-     *
-     * Accessing .loading will trigger computation if needed, since it's often used like
-     * `signal.loading ? <Loading /> : signal.value`.
-     */
-    get loading(): boolean;
-    set untrackedLoading(value: boolean);
-    get untrackedLoading(): boolean;
-    /** The error that occurred when the signal was resolved. */
-    get error(): Error | undefined;
-    set untrackedError(value: Error | undefined);
-    get untrackedError(): Error | undefined;
-    get expires(): number;
-    set expires(value: number);
-    get poll(): boolean;
-    set poll(value: boolean);
-    /** @deprecated Use `expires` and `poll` instead. */
-    get interval(): number;
-    set interval(value: number);
-    /** Invalidates the signal, causing it to re-compute its value. */
-    invalidate(info?: unknown): Promise<void>;
-    $setInvalid$(allowRecalc: boolean, mustClear: boolean | number): void;
-    /** Abort the current computation and run cleanups if needed. */
-    abort(reason?: any): void;
-    /** Schedule eager cleanup on next macro task if no subscribers remain. */
-    $scheduleEagerCleanup$(): void;
-    /** Returns a promise resolves when the signal finished computing. */
-    promise(): Promise<void>;
-    /** Run the computation if needed */
-    $computeIfNeeded$(): void;
-    $runComputation$(running: AsyncJob<T>): Promise<void>;
-    /**
-     * Sets the error from the given job. We only accept errors from the current job and we ignore
-     * AbortErrors.
-     */
-    $setError$(job: AsyncJob<T>, error: Error): void;
-    /** Called after SSR/unmount */
-    $destroy$(): Promise<void>;
-    private $clearNextPoll$;
-    private $scheduleNextPoll$;
-    private $hasSubscribers$;
-    $requestCleanups$(job: AsyncJob<T>, reason?: any): void;
-    /** Clean up and trigger signal compute once complete */
-    $runCleanups$(job: AsyncJob<T>): Promise<void> | undefined;
+export declare class _AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements AsyncSignal<T> {
+    constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: number, options?: AsyncSignalOptions<T>);
 }
 
-/** @public */
-export declare interface AsyncSignalOptions<T> extends ComputedOptions {
-    /** Like useSignal's `initial`; prevents the throw on first read when uninitialized */
-    initial?: T | (() => T);
-    /**
-     * Maximum number of concurrent computations. Use `0` for unlimited.
-     *
-     * Defaults to `1`.
-     */
-    concurrency?: number;
-    /**
-     * When subscribers drop to 0, run cleanup in the next tick, instead of waiting for the function
-     * inputs to change.
-     *
-     * Defaults to `false`, meaning cleanup happens only when inputs change.
-     */
-    eagerCleanup?: boolean;
-    /**
-     * Time in milliseconds after which the value expires.
-     *
-     * When the value expires and subscribers exist, the signal is invalidated. If `poll` is `true`
-     * (default), the function is re-run automatically. If `poll` is `false`, the value is marked
-     * stale and recomputation happens when reading `.value` or `.loading`.
-     *
-     * `0` (default) means no expiration.
-     */
-    expires?: number;
-    /**
-     * Whether to automatically re-run the function when the value expires. Only relevant when
-     * `expires` is set.
-     *
-     * Defaults to `true`.
-     */
-    poll?: boolean;
-    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
-    interval?: number;
-    /**
-     * When true, the async computation is postponed to the browser. On SSR, the signal remains
-     * INVALID and does not execute the function. On the client, it will compute on first read.
-     *
-     * Defaults to `false`.
-     */
-    clientOnly?: boolean;
-    /**
-     * When true (default), the previous value is kept while the signal re-computes after
-     * invalidation, so reads return stale data instead of throwing a promise. Reactivity will then
-     * update the readers when the new value is ready.
-     *
-     * When false, invalidation clears the value so reads throw the computation promise (like the
-     * initial load), which is useful for navigations where showing old data would be confusing.
-     *
-     * Note that polling invalidations (`expires` with `poll: true`) are not affected by this option
-     * and will keep the old value while the new value is loading, to avoid flashing loaders.
-     *
-     * This option only affects manual invalidations via `invalidate()`, and non-polling expirations
-     * (`poll: false`, or there are no subscribers).
-     *
-     * Defaults to `true`.
-     */
-    allowStale?: boolean;
-    /**
-     * Maximum time in milliseconds to wait for the async computation to complete. If exceeded, the
-     * computation is aborted and an error is thrown.
-     *
-     * If `0`, no timeout is applied.
-     *
-     * Defaults to `0`.
-     */
-    timeout?: number;
-}
+/**
+ * @deprecated Use `ComputedOptions` instead.
+ * @public
+ */
+export declare type AsyncSignalOptions<T> = ComputedOptions<T>;
 
 /**
  * Replace given element's props with custom types and return all props specific to the element. Use
@@ -709,7 +484,7 @@ export declare let _captures: Readonly<unknown[]> | null;
  *
  * @internal
  */
-export declare function _chk(this: string | undefined, _: any, element: HTMLInputElement): void;
+export declare function _chk(this: string | undefined, _: any, element: HTMLInputElement): void | Promise<void>;
 
 declare const enum ChoreBits {
     NONE = 0,
@@ -838,17 +613,117 @@ declare type ComponentChildren<PROPS> = PROPS extends {
 /** @internal */
 export declare const componentQrl: <PROPS extends Record<any, any>>(componentQrl: QRL<OnRenderFn<PROPS>>) => Component<PROPS>;
 
-/** @public */
-export declare type ComputedFn<T> = () => T;
+declare type ComputeCtx<T = unknown> = {
+    /**
+     * Track reactive reads so the computation re-runs when they change. Computed functions track
+     * synchronous reads automatically, but after the first `await` the tracking context is lost, so
+     * later reads must go through `track()`.
+     */
+    readonly track: Tracker;
+    /**
+     * Register a cleanup callback to be called when the async computation is aborted or completed.
+     * The next invocation will await the previous cleanup. If you do not want this, do not return a
+     * Promise.
+     */
+    cleanup: (callback: () => void | Promise<void>) => void;
+    /**
+     * A lazily created AbortSignal, for interrupting the async computation when needed, e.g. when the
+     * component is unmounted or the computation is invalidated. Pass it to `fetch` or other APIs that
+     * support it to ensure that unnecessary work is not performed.
+     */
+    readonly abortSignal: AbortSignal;
+    /** The result of the previous computation, if any */
+    readonly previous: T | undefined;
+    /** Extra info passed to `invalidate(info)` for this computation, if any. */
+    readonly info?: unknown;
+};
+
+/**
+ * The compute function. The context provides `track()`, `previous` (the last computed value),
+ * `info` (the argument of the `invalidate(info)` call that triggered this computation), `cleanup()`
+ * and `abortSignal`. Synchronous reactive state reads are tracked automatically, use `untrack()` to
+ * read signals without tracking. Return a `Promise` (or use an `async` function) for async values.
+ * After the first `await`, reads are no longer tracked automatically and must use `track()`.
+ *
+ * @public
+ */
+export declare type ComputedFn<T> = (ctx: ComputeCtx) => ValueOrPromise<T>;
 
 /** @public */
-export declare interface ComputedOptions {
+export declare interface ComputedOptions<T = unknown> {
     serializationStrategy?: SerializationStrategy;
     container?: _Container;
+    /** Like useSignal's `initial`; prevents the throw on first read when uninitialized */
+    initial?: Awaited<T> | (() => Awaited<T>);
+    /**
+     * Maximum number of concurrent computations. Use `0` for unlimited.
+     *
+     * Defaults to `1`.
+     */
+    concurrency?: number;
+    /**
+     * When subscribers drop to 0, run cleanup in the next tick, instead of waiting for the function
+     * inputs to change.
+     *
+     * Defaults to `false`, meaning cleanup happens only when inputs change.
+     */
+    eagerCleanup?: boolean;
+    /**
+     * Time in milliseconds after which the value expires.
+     *
+     * When the value expires and subscribers exist, the signal is invalidated. If `poll` is `true`
+     * (default), the function is re-run automatically. If `poll` is `false`, the value is marked
+     * stale and recomputation happens when reading `.value` or `.loading`.
+     *
+     * `0` (default) means no expiration.
+     */
+    expires?: number;
+    /**
+     * Whether to automatically re-run the function when the value expires. Only relevant when
+     * `expires` is set.
+     *
+     * Defaults to `true`.
+     */
+    poll?: boolean;
+    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
+    interval?: number;
+    /**
+     * When true, the async computation is postponed to the browser. On SSR, the signal remains
+     * INVALID and does not execute the function. On the client, it will compute on first read.
+     *
+     * Defaults to `false`.
+     */
+    clientOnly?: boolean;
+    /**
+     * When true (default), the previous value is kept while the signal re-computes after
+     * invalidation, so reads return stale data instead of throwing a promise. Reactivity will then
+     * update the readers when the new value is ready.
+     *
+     * When false, invalidation clears the value so reads throw the computation promise (like the
+     * initial load), which is useful for navigations where showing old data would be confusing.
+     *
+     * Note that polling invalidations (`expires` with `poll: true`) are not affected by this option
+     * and will keep the old value while the new value is loading, to avoid flashing loaders.
+     *
+     * This option only affects manual invalidations via `invalidate()`, and non-polling expirations
+     * (`poll: false`, or there are no subscribers).
+     *
+     * Defaults to `true`.
+     */
+    allowStale?: boolean;
+    /**
+     * Maximum time in milliseconds to wait for the async computation to complete. If exceeded, the
+     * computation is aborted and an error is thrown.
+     *
+     * If `0`, no timeout is applied.
+     *
+     * Defaults to `0`.
+     */
+    timeout?: number;
 }
 
 /** @public */
-export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ComputedSignal<T>;
+export declare type ComputedReturnType<T> = ComputedSignal<Awaited<T>>;
 
 /**
  * A computed signal is a signal which is calculated from other signals. When the signals change,
@@ -862,28 +737,194 @@ export declare interface ComputedSignal<T> extends Signal<T> {
     force(): void;
     /** Use this to force recalculation. */
     invalidate(): void;
+    /**
+     * Whether the signal is currently loading. This will trigger lazy computation of the signal, so
+     * you can use it like this:
+     *
+     * ```tsx
+     * signal.pending ? <Loading /> : signal.error ? <Error /> : <Component
+     * value={signal.value} />
+     * ```
+     */
+    pending: boolean;
+    /**
+     * Lets you read the pending state without subscribing to `.pending` updates. It also triggers
+     * lazy computation of the signal.
+     *
+     * Setting it will trigger listeners for `.pending`.
+     */
+    untrackedPending: boolean;
+    /** @deprecated Use `pending` instead */
+    loading: boolean;
+    /** @deprecated Use `untrackedPending` instead */
+    untrackedLoading: boolean;
+    /**
+     * The error that occurred while computing the signal, if any, including synchronous throws. This
+     * will be cleared when the signal is successfully computed. It also triggers lazy computation of
+     * the signal. While the error is set, reading `.value` throws it.
+     */
+    error: Error | undefined;
+    /**
+     * Lets you read the error state without subscribing to `.error` updates. It also triggers lazy
+     * computation of the signal.
+     *
+     * Setting it will trigger listeners for `.error`.
+     */
+    untrackedError: Error | undefined;
+    /**
+     * Expiration time in ms. Writable and immediately effective.
+     *
+     * When set, the signal is invalidated after this many ms. Whether it auto-recomputes depends on
+     * the `poll` property. `0` means no expiration.
+     */
+    expires: number;
+    /**
+     * Whether to automatically re-run the function when the value expires. Writable and immediately
+     * effective. Only relevant when `expires` is set.
+     *
+     * Defaults to `true`.
+     */
+    poll: boolean;
+    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
+    interval: number;
+    /** A promise that resolves when the value is computed or rejected. */
+    promise(): Promise<void>;
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason?: any): void;
+    /**
+     * Use this to force recalculation. If you pass `info`, it will be provided to the calculation
+     * function.
+     */
+    invalidate(info?: unknown): void;
+}
+
+declare const enum ComputedSignalFlags {
+    INVALID = 1,
+    RUN_EFFECTS = 2,
+    PRESERVE_ON_SEQ_CLEANUP = 4
 }
 
 /**
  * A signal which is computed from other signals.
  *
- * The value is available synchronously, but the computation is done lazily.
+ * Sync compute functions resolve synchronously and every read they perform is auto-tracked. When
+ * the compute function turns out to be async (it returned a promise), the signal lazily switches on
+ * the async engine — jobs, `loading`, `error`, polling — giving it the same API as an AsyncSignal.
+ * Auto-tracking only covers reads before the first await point (the invoke context is lost after
+ * it); later reads must use the ComputeCtx `track()`.
  */
 declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> extends SignalImpl<T> implements BackRef {
     /**
      * The compute function is stored here.
      *
-     * The computed functions must be executed synchronously (because of this we need to eagerly
-     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
+     * Sync computed functions must be executed synchronously (because of this we need to eagerly
+     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous).
      */
     $computeQrl$: S;
-    $flags$: SignalFlags | SerializationSignalFlags;
+    $flags$: number;
     [_EFFECT_BACK_REF]: Map<_EffectProperty | string, EffectSubscription> | undefined;
-    constructor(container: _Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
-    invalidate(): void;
+    $untrackedPending$: boolean | undefined;
+    $untrackedError$: Error | undefined;
+    $current$: Job<T> | null | undefined;
+    $jobs$: Job<T>[] | undefined;
+    $concurrency$: number | undefined;
+    $expires$: number | undefined;
+    $timeoutMs$: number | undefined;
+    $loadingEffects$: undefined | Set<EffectSubscription>;
+    $errorEffects$: undefined | Set<EffectSubscription>;
+    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $info$: unknown | undefined;
+    $infoVersion$: number | undefined;
+    constructor(container: _Container | null, fn: S, flags?: number, options?: ComputedOptions<T>);
+    invalidate(info?: unknown): void;
+    /**
+     * Read the value, subscribing if in a tracking context. Triggers computation if needed.
+     *
+     * Setting the value will mark the signal as not loading and clear any error, and prevent any
+     * pending computations from writing their results.
+     *
+     * If you want to set the value without affecting loading or error state, set `untrackedValue`
+     * instead and make sure to trigger effects manually if needed.
+     *
+     * If you want to abort pending computations when setting, you have to call `abort()` manually.
+     */
+    get value(): T;
+    set value(value: T);
     get untrackedValue(): T;
     set untrackedValue(value: T);
+    /**
+     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
+     * has resolved or rejected (or the compute function is synchronous).
+     *
+     * Accessing `.pending` will trigger computation if needed, since it's often used like
+     *
+     * ```ts
+     * signal.pending ? <Loading /> : signal.value
+     * ```
+     */
+    get pending(): boolean;
+    set untrackedPending(value: boolean);
+    get untrackedPending(): boolean;
+    /** @deprecated Use `pending` instead */
+    get loading(): boolean;
+    /** @deprecated Use `untrackedPending` instead */
+    get untrackedLoading(): boolean;
+    set untrackedLoading(value: boolean);
+    /**
+     * The error the compute function threw or rejected with.
+     *
+     * Accessing .error will trigger computation if needed, since it's often used like
+     *
+     * ```ts
+     * signal.error ? <Failed /> : signal.value
+     * ```
+     */
+    get error(): Error | undefined;
+    set untrackedError(value: Error | undefined);
+    get untrackedError(): Error | undefined;
+    get expires(): number;
+    set expires(value: number);
+    get poll(): boolean;
+    set poll(value: boolean);
+    /** @deprecated Use `expires` and `poll` instead. */
+    get interval(): number;
+    set interval(value: number);
+    $setInvalid$(allowRecalc: boolean, mustClear: boolean | number): void;
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason?: any): void;
+    /** Schedule eager cleanup on next macro task if no subscribers remain. */
+    $scheduleEagerCleanup$(): void;
+    /** Returns a promise resolves when the signal finished computing. */
+    promise(): Promise<void>;
+    /** Run the computation if needed */
     $computeIfNeeded$(): void;
+    /**
+     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (useAsync$, useResource$)
+     * only track via its explicit track(). Computeds auto-track every synchronous read instead; after
+     * the first await they must use the explicit track() too.
+     */
+    $invokeComputeFn$(fn: Function, job: Job<T>): T | Promise<T>;
+    /** Start an async computation (the async engine; assumes the INVALID flag is set) */
+    $computeAsync$(): void;
+    $runComputation$(running: Job<T>): Promise<void>;
+    /** Await the computation and publish its result, error, and loading transitions. */
+    $settleComputation$(running: Job<T>, compute: () => ValueOrPromise<T>): Promise<void>;
+    /**
+     * Sets the error from the given job. We only accept errors from the current job and we ignore
+     * AbortErrors.
+     */
+    $setError$(job: Job<T>, error: Error): void;
+    /** Called after SSR/unmount */
+    $destroy$(): Promise<void>;
+    private $clearNextPoll$;
+    private $scheduleNextPoll$;
+    private $hasSubscribers$;
+    $requestCleanups$(job: Job<T>, reason?: any): void;
+    /** Run a job's cleanup callbacks, returning a promise when any of them are async. */
+    $runCleanupCallbacks$(job: Job<T>): Promise<void> | undefined;
+    /** Clean up and trigger signal compute once complete */
+    $runCleanups$(job: Job<T>): Promise<void> | undefined;
 }
 
 declare type ComputeQRL<T> = _QRLInternal<ComputedFn<T>>;
@@ -945,6 +986,13 @@ export declare interface _Container {
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
 }
 
+declare const enum ContainerDataProcessState {
+    NotStarted = 0,
+    ProcessingVNode = 1,
+    ProcessingState = 2,
+    ProcessingStateDone = 3
+}
+
 /** @internal */
 export declare interface _ContainerElement extends HTMLElement {
     qContainer?: ClientContainer;
@@ -962,6 +1010,7 @@ export declare interface _ContainerElement extends HTMLElement {
     qVNodeRefs?: Map<number, Element | _ElementVNode>;
     /** String from `<script type="qwik/vnode">` tag. */
     qVnodeData?: string;
+    qDestroy?: () => void;
     /** Segment-local strings from `<script type="qwik/vnode" q:r="...">` tags. */
     qSegmentVnodeData?: Map<string, string>;
 }
@@ -1096,9 +1145,10 @@ export declare interface CorrectedToggleEvent extends Event {
  * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
  * standalone version of `useAsync$`.
  *
+ * @deprecated Use `createComputed$` instead, it has async support now.
  * @public
  */
-export declare const createAsync$: <T>(qrl: (arg: AsyncCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
+export declare const createAsync$: <T>(qrl: (arg: ComputeCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /** @internal */
 export declare const createAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => _AsyncSignalImpl<T>;
@@ -1109,16 +1159,17 @@ export declare const createAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSi
  * recalculated.
  *
  * The QRL must be a function which returns the value of the signal. The function must not have side
- * effects, and it must be synchronous.
- *
- * If you need the function to be async, use `createAsync$` instead (don't forget to use `track()`).
+ * effects. Every synchronous signal or store read is tracked automatically; reads after the first
+ * `await` must use the `track()` provided on the context argument. When the function is async, the
+ * returned signal exposes the async API (`.pending`, `.error`, `.promise()`), and reading an
+ * unresolved `.value` throws the computation promise.
  *
  * @public
  */
-export declare const createComputed$: <T>(qrl: () => T, options?: ComputedOptions) => ComputedReturnType<T>;
+export declare const createComputed$: <T>(qrl: (ctx: ComputeCtx) => ValueOrPromise<T>, options?: ComputedOptions<T>) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: ComputedOptions) => ComputedSignalImpl<T>;
+export declare const createComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions<T>) => ComputedSignalImpl<T>;
 
 /**
  * Create a context ID to be used in your application. The name should be written with no spaces.
@@ -1188,7 +1239,7 @@ export declare function _createDeserializeContainer(stateData: unknown[]): Deser
  *
  * @internal
  */
-export declare const _createQRL: <TYPE>(chunk: string | null, symbol: string, symbolRef?: null | ValueOrPromise<TYPE>, symbolFn?: null | (() => Promise<Record<string, TYPE>>), captures?: Readonly<unknown[]> | string | null, container?: _Container) => _QRLInternal<TYPE>;
+export declare const _createQRL: <TYPE>(chunk: string | null, symbol: string, symbolRef?: null | ValueOrPromise<TYPE>, symbolFn?: null | (() => Promise<Record<string, TYPE>>), captures?: QrlCaptures, container?: _Container) => _QRLInternal<TYPE>;
 
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
@@ -1239,26 +1290,21 @@ declare class DeleteOperation {
     constructor(target: Element | Text);
 }
 
-declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
-    $flags$: number;
-    $index$: number;
-    $el$: _HostElement;
-    $qrl$: _QRLInternal<T>;
-    $state$: B | undefined;
-    $destroy$: (() => void) | null;
-}
-
 /**
- * Deserialize data from string to an array of objects.
+ * Deserialize data from string.
  *
  * @param rawStateData - Data to deserialize
  * @internal
  */
-export declare function _deserialize<T>(rawStateData: string): T;
+export declare function _deserialize<T>(rawStateData: string): Promise<T>;
 
 declare interface DeserializeContainer {
     $getObjectById$: (id: number | string) => unknown;
     $getForwardRef$: (id: number) => number | string | undefined;
+    $pendingStoreTargets$?: Map<object, {
+        t: number;
+        v: unknown;
+    }>;
     element: HTMLElement | null;
     getSyncFn: (id: number) => (...args: unknown[]) => unknown;
     $state$?: unknown[];
@@ -1295,15 +1341,17 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $instanceHash$: string;
     $forwardRefs$: Array<number | string> | null;
     vNodeLocate: (id: string | Element) => _VNode;
+    $containerDataProcessState$: ContainerDataProcessState;
+    $containerStateReadyCallbacks$: Array<() => void> | undefined;
+    $containerStateDataState$: unknown;
     private $rawStateData$;
     private $stateData$;
     private $rootForwardRefs$;
     private $styleIds$;
     constructor(element: _ContainerElement);
+    $processContainerData$(): Generator<void, void, void>;
     /** 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>)
@@ -1587,7 +1635,7 @@ export declare const _hasStoreEffects: (value: StoreTarget, prop: keyof StoreTar
 export declare const _hmr: (this: string | undefined, event: CustomEvent<{
     files: string[];
     t: number;
-}>, element: Element) => void;
+}>, element: Element) => void | Promise<void>;
 
 /** @internal */
 export declare type _HostElement = _VNode | ISsrNode;
@@ -1702,14 +1750,14 @@ 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).
+ * Inject a pre-loaded value into a signal while preserving subscriptions. Calls `invalidate({__v})`
+ * so the compute function reads the value from `info`, then triggers an immediate synchronous
+ * compute via the private `$computeIfNeeded$()` method (which is mangled in core builds, so callers
+ * from other packages must go through this helper).
  *
  * @internal
  */
-export declare const _injectAsyncSignalValue: (signal: AsyncSignal<unknown>, value: unknown) => void;
+export declare const _injectAsyncSignalValue: (signal: ComputedSignal<unknown>, value: unknown) => void;
 
 /**
  * Create an inlined QRL. This is mostly useful on the server side for serialization.
@@ -1851,6 +1899,27 @@ declare interface IStreamHandler {
     streamBlockEnd(): ValueOrPromise<void>;
 }
 
+/** Retains job metadata and also serves as the argument for CTX_ARG compute functions */
+declare class Job<T> implements ComputeCtx<T> {
+    readonly $signal$: ComputedSignalImpl<T, any>;
+    /** First holds the compute promise and then the cleanup promise */
+    $promise$: Promise<void> | null | void;
+    $cleanupRequested$: boolean;
+    $canWrite$: boolean;
+    $track$: Tracker | undefined;
+    $cleanups$: Parameters<ComputeCtx<T>['cleanup']>[0][] | undefined;
+    $abortController$: AbortController | undefined;
+    info: unknown;
+    $infoVersion$: number | undefined;
+    constructor($signal$: ComputedSignalImpl<T, any>, info: unknown, $infoVersion$: number | undefined);
+    get track(): Tracker;
+    get abortSignal(): AbortSignal;
+    /** Backward compatible cache method for resource */
+    cache(): void;
+    get previous(): T | undefined;
+    cleanup(callback: () => void): void;
+}
+
 /**
  * Used by the JSX transpilers to create a JSXNode. Note that the optimizer will normally not use
  * this, instead using _jsxSplit and _jsxSorted directly.
@@ -2118,6 +2187,16 @@ 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;
 
+/**
+ * Mark this signal as owned outside of the component that read it.
+ *
+ * Externally owned signals are preserved when found in a component's sequential scope during
+ * component cleanup.
+ *
+ * @internal
+ */
+export declare const _markSignalAsExternallyOwned: (signal: ComputedSignal<unknown>) => void;
+
 declare class MaybeAsyncSignal {
 }
 
@@ -2433,6 +2512,14 @@ export declare type PublicProps<PROPS> = (PROPS extends Record<any, any> ? Omit<
 /** @internal */
 export declare interface _QDocument extends Document {
     qVNodeData: WeakMap<Element, string>;
+    /** True once root document VNode data has been scheduled at least once. */
+    qVNodeDataStarted?: boolean;
+    /** True when root, segment, and patch VNode data work is fully drained. */
+    qVNodeDataReady?: boolean;
+    /** Internal yielding state for queued VNode data jobs. */
+    qVNodeDataState?: unknown;
+    /** Callbacks waiting for root, segment, and patch VNode data work to drain. */
+    qVNodeDataCallbacks?: Array<() => void>;
     /** True once the root document VNode data has been fully processed. */
     qVNodeDataProcessed?: boolean;
     /** Processes one vnode patch script. */
@@ -2592,6 +2679,8 @@ export declare const qrl: <T = any>(chunkOrFn: string | (() => Promise<any>), sy
 
 declare type QrlArgs<T> = T extends (...args: infer ARGS) => any ? ARGS : unknown[];
 
+declare type QrlCaptures = Readonly<unknown[]> | string | null;
+
 /** @public */
 declare interface QRLDev {
     file: string;
@@ -2616,8 +2705,8 @@ declare type QRLInternalMethods<TYPE> = {
     readonly $chunk$: string | null;
     readonly $symbol$: string;
     readonly $hash$: string;
-    /** If it's a string it's serialized */
-    readonly $captures$?: Readonly<unknown[]> | string | null;
+    /** Captures are stored lazily after deserialization. */
+    readonly $captures$?: QrlCaptures;
     dev?: QRLDev | null;
     resolve(container?: _Container): Promise<TYPE>;
     resolved: undefined | TYPE;
@@ -2634,7 +2723,7 @@ declare type QRLInternalMethods<TYPE> = {
      * method but we need to have a stable name because it gets called in user code by the optimizer,
      * after the $name$ props are mangled
      */
-    w(captures: Readonly<unknown[]> | string | null): _QRLInternal<TYPE>;
+    w(captures: QrlCaptures): _QRLInternal<TYPE>;
     /**
      * "set ref" - Set the ref of the QRL. It's an internal method but we need to have a stable name
      * because it gets called in user code by the optimizer, after the $name$ props are mangled
@@ -2963,7 +3052,7 @@ export declare const _reR: () => boolean;
  *
  * @internal
  */
-export declare function _res(this: string | undefined, _: any, element: Element): void;
+export declare function _res(this: string | undefined, _: any, element: Element): void | Promise<void>;
 
 /** @internal */
 export declare const _resolveContextWithoutSequentialScope: <STATE>(context: ContextId<STATE>) => STATE | undefined;
@@ -3005,7 +3094,7 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
 export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
 
 /** @public */
-export declare interface ResourceCtx<T = unknown> extends AsyncCtx<T> {
+export declare interface ResourceCtx<T = unknown> extends ComputeCtx<T> {
     /** @deprecated Does not do anything */
     cache(policyOrMilliseconds: number | 'immutable'): void;
 }
@@ -3375,6 +3464,25 @@ export declare abstract class _SharedContainer implements _Container {
     abstract $appendStyle$(content: string, styleId: string, host: _HostElement, scoped: boolean): void;
 }
 
+/** @internal */
+export declare const _shC: (props: ShowProps<any>) => JSXNode<unknown>;
+
+/** @public @experimental */
+export declare const Show: ShowComponent;
+
+/** @public @experimental */
+export declare type ShowComponent = <WHEN = unknown, THEN extends JSXOutput = JSXOutput, ELSE extends JSXOutput = JSXOutput>(props: PublicProps<ShowProps<WHEN, THEN, ELSE>>, key: string | null, flags: number, dev?: DevJSX) => JSXOutput;
+
+/** @public @experimental */
+export declare interface ShowProps<WHEN = unknown, THEN extends JSXOutput = JSXOutput, ELSE extends JSXOutput = JSXOutput> {
+    when$: QRL<() => WHEN>;
+    then$: QRL<(when: WHEN) => THEN>;
+    else$?: QRL<(when: WHEN) => ELSE>;
+}
+
+/** @internal */
+export declare const _shT: ({ track }: TaskCtx) => ValueOrPromise<void | undefined>;
+
 /**
  * A signal is a reactive value which can be read and written. When the signal is written, all tasks
  * which are tracking the signal will be re-run and all components that read the signal will be
@@ -3399,11 +3507,6 @@ export declare interface Signal<T = any> {
     trigger(): void;
 }
 
-declare const enum SignalFlags {
-    INVALID = 1,
-    RUN_EFFECTS = 2
-}
-
 declare class SignalImpl<T = any> implements Signal<T> {
     $untrackedValue$: T;
     /** Store a list of effects which are dependent on this signal. */
@@ -3762,11 +3865,13 @@ export declare type SSRHintProps = {
 declare interface SSRInternalStreamWriter extends StreamWriter {
     writeRootRef(id: number): ValueOrPromise<void>;
     writeRootRefPath(path: number[]): ValueOrPromise<void>;
+    writeRootRefDelta(id: number, base: number): ValueOrPromise<void>;
     toString(remap?: number[]): string;
 }
 
 declare const enum SsrNodeFlags {
-    Updatable = 1
+    Updatable = 1,
+    WarnedStreamedChore = 2
 }
 
 declare type SSROutOfOrderSegment = SegmentRenderContext;
@@ -3785,6 +3890,12 @@ declare type SSRRevealSlotProps = {
     coordinator: OutOfOrderRevealCoordinator;
 };
 
+/** @internal */
+declare interface SSRRootRefDeltaChunk {
+    readonly id: number;
+    readonly base: number;
+}
+
 /** @internal */
 declare interface SSRRootRefPathChunk {
     readonly path: number[];
@@ -3806,6 +3917,10 @@ declare type SSRSegmentWriteChunk = string | {
 } | {
     readonly type: 'root-ref-path';
     readonly localPath: number[];
+} | {
+    readonly type: 'root-ref-delta';
+    readonly localId: number;
+    readonly localBaseId: number;
 };
 
 /** @public */
@@ -3830,7 +3945,7 @@ export declare interface SSRStreamWriter {
 }
 
 /** @internal */
-declare type SSRWriteChunk = string | number | SSRRootRefPathChunk;
+declare type SSRWriteChunk = string | number | SSRRootRefPathChunk | SSRRootRefDeltaChunk;
 
 declare type StackFn = () => ValueOrPromise<void>;
 
@@ -4196,16 +4311,15 @@ declare type TableCellSpecialAttrs = {
 };
 
 /** @internal */
-export declare class _Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
-    $flags$: number;
+export declare class _Task<T = unknown, B = T> extends BackRef {
+    $flags$: TaskFlags;
     $index$: number;
     $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$: TaskFlags, $index$: number, $el$: _HostElement, $qrl$: _QRLInternal<T>, $destroy$: (() => void) | null);
 }
 
 /**
@@ -4214,7 +4328,7 @@ export declare class _Task<T = unknown, B = T> extends BackRef implements Descri
  *
  * @internal
  */
-export declare function _task(this: string, _event: Event, element: Element): void;
+export declare function _task(this: string, _event: Event, element: Element): void | Promise<void>;
 
 /** @public */
 export declare interface TaskCtx {
@@ -4224,6 +4338,16 @@ export declare interface TaskCtx {
 
 declare const TaskEvent = "qTask";
 
+/** @internal */
+declare const enum TaskFlags {
+    VISIBLE_TASK = 1,
+    TASK = 2,
+    DIRTY = 4,
+    RENDER_BLOCKING = 8,
+    NEEDS_CLEANUP = 16,
+    EVENTS_REGISTERED = 32
+}
+
 /** @public */
 export declare type TaskFn = (ctx: TaskCtx) => ValueOrPromise<void | (() => ValueOrPromise<void>)>;
 
@@ -4380,11 +4504,16 @@ export declare function _updateProjectionProps(container: _Container, vnode: _Vi
  * will subscribe to it and return the last resolved value until the new value is ready. As soon as
  * the new value is ready, the subscribers will be updated.
  *
+ * @deprecated Use `useComputed$` instead, it has async support now. It auto-tracks synchronous
+ *   reads; after the first `await`, use the provided `track()` like before.
  * @public
  */
 export declare const useAsync$: <T>(qrl: AsyncFn<T>, options?: AsyncSignalOptions<T> | undefined) => AsyncSignal<T>;
 
-/** @internal */
+/**
+ * @deprecated Use `useComputed$` instead, it has async support now.
+ * @internal
+ */
 export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /**
@@ -4393,14 +4522,20 @@ export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSigna
  * recalculated, and if the result changed, all tasks which are tracking the signal will be re-run
  * and all components that read the signal will be re-rendered.
  *
- * The function must be synchronous and must not have any side effects.
+ * Every synchronous signal or store read is tracked automatically. Reads after an `await` are not:
+ * the tracking context is lost, so track them explicitly with the `track()` provided on the context
+ * argument. When the function is async, the returned signal exposes the async API: reading an
+ * unresolved `.value` throws the computation promise, and `.pending` and `.error` expose the
+ * computation state.
+ *
+ * The function must not have any side effects.
  *
  * @public
  */
-export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions | undefined) => ComputedReturnType<T>;
+export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions<T> | undefined) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions) => ComputedReturnType<T>;
+export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions<T>) => ComputedReturnType<T>;
 
 /**
  * Stores a value which is retained for the lifetime of the component. Subsequent calls to
@@ -4660,11 +4795,11 @@ export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], ev
  * Be careful when using a `try/catch` statement in `useResource$`. If you catch the error and don't
  * re-throw it (or a new Error), the resource status will never be `rejected`.
  *
- * @deprecated Use `useAsync$` instead, which is more powerful and flexible. `useResource$` is still
- *   available for backward compatibility but it is recommended to migrate to `useAsync$` for new
- *   code and when updating existing code.
+ * @deprecated Use `useComputed$` instead, which is more powerful and flexible. `useResource$` is
+ *   still available for backward compatibility but it is recommended to migrate to `useComputed$`
+ *   for new code and when updating existing code.
  * @public
- * @see useAsync$
+ * @see useComputed$
  * @see Resource
  * @see ResourceReturn
  */
@@ -5023,7 +5158,7 @@ export declare const useVisibleTaskQrl: (qrl: QRL<TaskFn>, opts?: OnVisibleTaskO
  *
  * @internal
  */
-export declare function _val(this: string | undefined, _: any, element: HTMLInputElement): void;
+export declare function _val(this: string | undefined, _: any, element: HTMLInputElement): void | Promise<void>;
 
 /**
  * Type representing a value which is either resolve or a promise.
@@ -5039,7 +5174,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.37-dev+82dc74d
+ * 2.0.0-beta.38-dev+0339f17
  *
  * @public
  */
@@ -5221,10 +5356,6 @@ 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 = 4
-}
-
 declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $args$: any[];
     $func$: (...args: any[]) => T;
@@ -5232,7 +5363,7 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $flags$: AllSignalFlags;
     $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);
+    constructor(container: _Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: AllSignalFlags);
     invalidate(): void;
     get untrackedValue(): T;
     $computeIfNeeded$(): void;