@qwik.dev/core 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/core-internal.d.ts

@@ -92,7 +92,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;
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -350,24 +350,85 @@ 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 = {
+declare type AsyncCtx<T = unknown> = {
     track: Tracker;
-    cleanup: (callback: () => void) => void;
+    /**
+     * 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;
 };
 
-/** @public */
-export declare type AsyncFn<T> = (ctx: AsyncCtx) => Promise<T>;
+/**
+ * Note, we don't pass the generic type to AsyncCtx 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.
+ *
+ * @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;
+    $cleanupRequested$: boolean;
+    $canWrite$: boolean;
+    $track$: AsyncCtx<T>['track'] | undefined;
+    $cleanups$: Parameters<AsyncCtx<T>['cleanup']>[0][] | undefined;
+    $abortController$: AbortController | undefined;
+    constructor($signal$: AsyncSignalImpl<T>);
+    get track(): AsyncCtx<T>['track'];
+    get abortSignal(): AbortSignal;
+    /** Backward compatible cache method for resource */
+    cache(): void;
+    get previous(): T | undefined;
+    cleanup(callback: () => void): void;
+}
 
 declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
 
 /** @public */
 export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
-    /** Whether the signal is currently loading. */
+    /**
+     * 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;
-    /** The error that occurred while computing the signal. */
+    /**
+     * The error that occurred while computing the signal, if any. This will be cleared when the
+     * signal is successfully computed.
+     */
     error: Error | undefined;
-    /** A promise that resolves when the value is computed. */
-    promise(): Promise<T>;
+    /**
+     * Poll interval in ms. Writable and immediately effective when the signal has consumers. If set
+     * to `0`, polling stops.
+     */
+    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;
+}
+
+declare const enum AsyncSignalFlags {
+    EAGER_CLEANUP = 32,
+    AWAIT_PREVIOUS = 64
 }
 
 /**
@@ -377,19 +438,26 @@ export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
  *
  * # ================================
  */
-declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef {
+declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
     $untrackedLoading$: boolean;
     $untrackedError$: Error | undefined;
     $loadingEffects$: undefined | Set<EffectSubscription>;
     $errorEffects$: undefined | Set<EffectSubscription>;
-    $destroy$: NoSerialize<() => void> | null;
-    $promiseValue$: T | typeof NEEDS_COMPUTATION;
-    private $promise$;
+    $current$: AsyncJob<T> | null;
+    $jobs$: AsyncJob<T>[];
+    $concurrency$: number;
+    $interval$: number;
+    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $timeoutMs$: number | undefined;
+    $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
-    constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags);
+    constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags, options?: AsyncSignalOptions<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);
@@ -398,11 +466,71 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     get error(): Error | undefined;
     set untrackedError(value: Error | undefined);
     get untrackedError(): Error | undefined;
-    invalidate(): void;
-    promise(): Promise<T>;
-    $computeIfNeeded$(): Promise<void> | undefined;
-    private $promiseComputation$;
-    private setValue;
+    get interval(): number;
+    set interval(value: number);
+    /** Invalidates the signal, causing it to re-compute its value. */
+    invalidate(): Promise<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>;
+    /** Called after SSR/unmount */
+    $destroy$(): Promise<void>;
+    get untrackedValue(): T;
+    private $clearNextPoll$;
+    private $scheduleNextPoll$;
+    private $hasSubscribers$;
+    $requestCleanups$(job: AsyncJob<T>, reason?: any): Promise<void | null>;
+    /** Clean up and trigger signal compute once complete */
+    $runCleanups$(job: AsyncJob<T>): Promise<void>;
+}
+
+/** @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;
+    /**
+     * Wait for previous invocation to complete before running again.
+     *
+     * Defaults to `true`.
+     *
+     * @deprecated Not implemented yet
+     */
+    awaitPrevious?: boolean;
+    /**
+     * In the browser, re-run the function after `interval` ms if subscribers exist, even when no
+     * input state changed. If `0`, does not poll.
+     *
+     * Defaults to `0`.
+     */
+    interval?: number;
+    /**
+     * 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;
 }
 
 /**
@@ -624,11 +752,6 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
     invalidate(): void;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object
-     */
-    force(): void;
     get untrackedValue(): T;
     $computeIfNeeded$(): void;
 }
@@ -660,8 +783,8 @@ export declare interface _Container {
     $buildBase$: string | null;
     $renderPromise$: Promise<void> | null;
     $resolveRenderPromise$: (() => void) | null;
-    $cursorCount$: number;
-    $pausedCursorCount$: number;
+    $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;
@@ -835,19 +958,15 @@ export declare interface CorrectedToggleEvent extends Event {
 }
 
 /**
- * Create an async computed signal which is calculated from the given QRL. A computed signal is a
- * signal which is calculated from other signals or async operation. When the signals change, the
- * computed signal is recalculated.
- *
- * The QRL must be a function which returns the value of the signal. The function must not have side
- * effects, and it can be async.
+ * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
+ * standalone version of `useAsync$`.
  *
  * @public
  */
-export declare const createAsync$: <T>(qrl: () => Promise<T>, options?: ComputedOptions) => AsyncSignal<T>;
+export declare const createAsync$: <T>(qrl: (arg: AsyncCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /** @internal */
-export declare const createAsyncQrl: <T>(qrl: QRL<(ctx: AsyncCtx) => Promise<T>>, options?: ComputedOptions) => 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
@@ -857,7 +976,7 @@ export declare const createAsyncQrl: <T>(qrl: QRL<(ctx: AsyncCtx) => Promise<T>>
  * 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 `useAsync$` instead.
+ * If you need the function to be async, use `createAsync$` instead (don't forget to use `track()`).
  *
  * @public
  */
@@ -918,6 +1037,21 @@ export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: Compute
  */
 export declare const createContextId: <STATE = unknown>(name: string) => ContextId<STATE>;
 
+/**
+ * Creates a QRL instance to represent a lazily loaded value. Normally this is a function, but it
+ * can be any value.
+ *
+ * When the value is a function, calling the returned qrl will load the underlying code when
+ * invoked, and call it with the captured scope. This always returns a promise since the code may
+ * not be loaded yet.
+ *
+ * To get the underlying function without invoking it, await `qrl.resolve()` and then `qrl.resolved`
+ * holds the loaded function, wrapped with the captured scope.
+ *
+ * @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) => _QRLInternal<TYPE>;
+
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
  * details.
@@ -962,7 +1096,7 @@ declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $el$: HostElement;
     $qrl$: _QRLInternal<T>;
     $state$: B | undefined;
-    $destroy$: NoSerialize<() => void> | null;
+    $destroy$: (() => void) | null;
 }
 
 /**
@@ -971,7 +1105,7 @@ declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
  * @param rawStateData - Data to deserialize
  * @internal
  */
-export declare function _deserialize(rawStateData: string | null): unknown[];
+export declare function _deserialize<T>(rawStateData: string): T;
 
 declare interface DeserializeContainer {
     $getObjectById$: (id: number | string) => unknown;
@@ -1768,12 +1902,6 @@ 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;
 
-/**
- * Special value used to mark that a given signal needs to be computed. This is essentially a
- * "marked as dirty" flag.
- */
-declare const NEEDS_COMPUTATION: any;
-
 declare interface NodePropData {
     $scopedStyleIdPrefix$: string | null;
     $isConst$: boolean;
@@ -1866,7 +1994,7 @@ declare type PascalCaseNames = 'AnimationEnd' | 'AnimationIteration' | 'Animatio
 
 declare type PopoverTargetAction = 'hide' | 'show' | 'toggle';
 
-declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent | typeof ResourceEvent;
+declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
 
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class. You
@@ -2228,6 +2356,12 @@ declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : u
  */
 export declare const _qrlSync: <TYPE extends Function>(fn: TYPE, serializedFn?: string) => SyncQRL<TYPE>;
 
+/** @internal */
+export declare function _qrlToString(serializationContext: SerializationContext, qrl: _QRLInternal | SyncQRLInternal): string;
+
+/** @internal */
+export declare function _qrlToString(serializationContext: SerializationContext, qrl: _QRLInternal | SyncQRLInternal, raw: true): [string, string, string | null];
+
 /** @public @deprecated Use `AnimationEvent` and use the second argument to the handler function for the current event target */
 export declare type QwikAnimationEvent<T = Element> = NativeAnimationEvent;
 
@@ -2595,6 +2729,14 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
+/**
+ * Resumes selected state (e.g. polling AsyncSignals) by deserializing captures. Used for
+ * document:onQIdle to resume async signals with active polling.
+ *
+ * @internal
+ */
+export declare function _res(this: string | undefined, _: any, element: Element): void;
+
 /** @internal */
 export declare const _resolveContextWithoutSequentialScope: <STATE>(context: ContextId<STATE>) => STATE | undefined;
 
@@ -2607,73 +2749,49 @@ declare interface ResolvedManifest {
 }
 
 /**
- * This method works like an async memoized function that runs whenever some tracked value changes
- * and returns some data.
- *
- * `useResource` however returns immediate a `ResourceReturn` object that contains the data and a
- * state that indicates if the data is available or not.
- *
- * The status can be one of the following:
- *
- * - `pending` - the data is not yet available.
- * - `resolved` - the data is available.
- * - `rejected` - the data is not available due to an error or timeout.
- *
- * 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`.
- *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
- *
  * ```tsx
  * const Cmp = component$(() => {
- *   const cityS = useSignal('');
+ *   const city = useSignal('');
  *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
+ *   const weather = useAsync$(async ({ track, cleanup, abortSignal }) => {
+ *     const cityName = track(city);
  *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
+ *       signal: abortSignal,
  *     });
- *     const data = await res.json();
- *     return data as { temp: number };
+ *     const temp = (await res.json()) as { temp: number };
+ *     return temp;
  *   });
  *
  *   return (
  *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
+ *       <input name="city" bind:value={city} />
+ *       <div>
+ *         Temperature:{' '}
+ *         {weather.loading
+ *           ? 'Loading...'
+ *           : weather.error
+ *             ? `Error: ${weather.error.message}`
+ *             : weather.value.temp}
+ *       </div>
  *     </div>
  *   );
  * });
  * ```
  *
+ * @deprecated Use `useAsync$` instead, which is more efficient, and has a more flexible API. Just
+ *   read the `loading` and `error` properties from the returned signal to determine the status.
  * @public
- * @see Resource
- * @see ResourceReturn
  */
-export declare const Resource: <T>(props: ResourceProps<T>) => JSXOutput;
+export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
 
 /** @public */
-export declare interface ResourceCtx<T> {
-    readonly track: Tracker;
-    cleanup(callback: () => void): void;
+export declare interface ResourceCtx<T = unknown> extends AsyncCtx<T> {
+    /** @deprecated Does not do anything */
     cache(policyOrMilliseconds: number | 'immutable'): void;
-    readonly previous: T | undefined;
 }
 
-declare const ResourceEvent = "qResource";
-
 /** @public */
-export declare type ResourceFn<T> = (ctx: ResourceCtx<unknown>) => ValueOrPromise<T>;
+export declare type ResourceFn<T> = (ctx: ResourceCtx) => ValueOrPromise<T>;
 
 /**
  * Options to pass to `useResource$()`
@@ -2690,10 +2808,7 @@ export declare interface ResourceOptions {
 }
 
 /** @public */
-export declare interface ResourcePending<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourcePending<T> = ResourceReturn<T>;
 
 /** @public */
 export declare interface ResourceProps<T> {
@@ -2704,35 +2819,38 @@ export declare interface ResourceProps<T> {
 }
 
 /** @public */
-export declare interface ResourceRejected<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourceRejected<T> = ResourceReturn<T>;
 
 /** @public */
-export declare interface ResourceResolved<T> {
-    readonly value: Promise<T>;
-    readonly loading: boolean;
-}
+export declare type ResourceResolved<T> = ResourceReturn<T>;
 
 /** @public */
-export declare type ResourceReturn<T> = ResourcePending<T> | ResourceResolved<T> | ResourceRejected<T>;
+export declare type ResourceReturn<T> = {
+    readonly value: Promise<T>;
+    readonly loading: boolean;
+};
 
 declare interface ResourceReturnInternal<T> {
     __brand: 'resource';
-    _state: 'pending' | 'resolved' | 'rejected';
-    _resolved: T | undefined;
-    _error: Error | undefined;
-    _cache: number;
-    _timeout: number;
-    _generation: number;
     value: Promise<T>;
     loading: boolean;
+    signal: AsyncSignal<{
+        r: T;
+    }>;
 }
 
 /** @internal */
 export declare const _restProps: (props: PropsProxy, omit?: string[], target?: Props) => Props;
 
+/**
+ * The resource function wrapper
+ *
+ * @internal
+ */
+export declare const _rsc: <T>(arg: ResourceCtx<T>) => Promise<{
+    r: T;
+}>;
+
 /**
  * This is called by qwik-loader to run a QRL. It has to be synchronous when possible.
  *
@@ -2753,7 +2871,7 @@ declare interface SegmentEntryStrategy {
 }
 
 declare interface SerializationContext {
-    $serialize$: () => void;
+    $serialize$: () => ValueOrPromise<void>;
     $symbolToChunkResolver$: SymbolToChunkResolver;
     /**
      * Map from object to parent and index reference.
@@ -2787,9 +2905,10 @@ declare interface SerializationContext {
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
-    $resources$: Set<ResourceReturnInternal<unknown>>;
     $renderSymbols$: Set<string>;
     $storeProxyMap$: ObjToProxyMap;
+    $eagerResume$: Set<unknown>;
+    $resources$: Set<ResourceReturnInternal<any>>;
     $getProp$: (obj: any, prop: string) => any;
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
@@ -2799,16 +2918,30 @@ declare const enum SerializationSignalFlags {
     SERIALIZATION_STRATEGY_ALWAYS = 16
 }
 
-/** @public */
+/**
+ * Serialization strategy for computed and async signals. This determines whether to serialize their
+ * value during SSR.
+ *
+ * - `never`: The value is never serialized. When the component is resumed, the value will be
+ *   recalculated when it is first read.
+ * - `always`: The value is always serialized. This is the default.
+ *
+ * **IMPORTANT**: When you use `never`, your serialized HTML is smaller, but the recalculation will
+ * trigger subscriptions, meaning that other signals using this signal will recalculate, even if
+ * this signal didn't change.
+ *
+ * This is normally not a problem, but for async signals it may mean fetching something again.
+ *
+ * @public
+ */
 export declare type SerializationStrategy = 'never' | 'always';
 
 /**
  * Serialize data to string using SerializationContext.
  *
- * @param data - Data to serialize
  * @internal
  */
-export declare function _serialize(data: unknown[]): Promise<string>;
+export declare function _serialize<T>(data: T): Promise<string>;
 
 /**
  * Serialize and deserialize custom objects.
@@ -2925,8 +3058,7 @@ export declare abstract class _SharedContainer implements _Container {
     $buildBase$: string | null;
     $renderPromise$: Promise<void> | null;
     $resolveRenderPromise$: (() => void) | null;
-    $cursorCount$: number;
-    $pausedCursorCount$: number;
+    $pendingCount$: number;
     constructor(serverData: Record<string, any>, locale: string);
     trackSignalValue<T>(signal: Signal, subscriber: HostElement, property: string, data: _SubscriptionData): T;
     serializationCtxFactory(NodeConstructor: {
@@ -2938,6 +3070,7 @@ export declare abstract class _SharedContainer implements _Container {
             __brand__: 'DomRef';
         };
     } | 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;
@@ -3669,6 +3802,8 @@ declare type SymbolToChunkResolver = (symbol: string) => string;
  */
 export declare const sync$: <T extends Function>(fn: T) => SyncQRL<T>;
 
+declare const SYNC_QRL = "<sync>";
+
 /** @public */
 export declare type SyncQRL<TYPE extends Function> = QRL<TYPE> & {
     __brand__SyncQRL__: TYPE;
@@ -3676,6 +3811,12 @@ export declare type SyncQRL<TYPE extends Function> = QRL<TYPE> & {
     dev?: QRLDev | null;
 } & BivariantQrlFn<QrlArgs<TYPE>, QrlReturn<TYPE>>;
 
+declare type SyncQRLInternal = _QRLInternal & SyncQRLSymbol;
+
+declare interface SyncQRLSymbol {
+    $symbol$: typeof SYNC_QRL;
+}
+
 declare type TableCellSpecialAttrs = {
     align?: 'left' | 'center' | 'right' | 'justify' | 'char' | undefined;
     height?: Size | undefined;
@@ -3683,14 +3824,14 @@ declare type TableCellSpecialAttrs = {
     valign?: 'top' | 'middle' | 'bottom' | 'baseline' | undefined;
 };
 
-declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B> | ResourceReturnInternal<B>> {
+declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
     $flags$: number;
     $index$: number;
     $el$: HostElement;
     $qrl$: _QRLInternal<T>;
-    $state$: Signal<B> | ResourceReturnInternal<B> | undefined;
-    $destroy$: NoSerialize<() => void> | null;
-    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: _QRLInternal<T>, $state$: Signal<B> | ResourceReturnInternal<B> | undefined, $destroy$: NoSerialize<() => void> | null);
+    $state$: Signal<B> | undefined;
+    $destroy$: (() => void) | null;
+    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: _QRLInternal<T>, $state$: Signal<B> | undefined, $destroy$: (() => void) | null);
 }
 
 /**
@@ -3860,10 +4001,10 @@ export declare const unwrapStore: <T>(value: T) => T;
  *
  * @public
  */
-export declare const useAsync$: <T>(qrl: AsyncFn<T>, options?: ComputedOptions | undefined) => AsyncSignal<T>;
+export declare const useAsync$: <T>(qrl: AsyncFn<T>, options?: AsyncSignalOptions<T> | undefined) => AsyncSignal<T>;
 
 /** @internal */
-export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: ComputedOptions) => AsyncSignal<T>;
+export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
 
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -4023,7 +4164,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 Read from `_captures` directly instead.
+ * @deprecated Use `_captures` instead.
  * @internal
  */
 export declare const useLexicalScope: <VARS extends any[]>() => VARS;
@@ -4116,45 +4257,15 @@ 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`.
  *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
- *
- * ```tsx
- * const Cmp = component$(() => {
- *   const cityS = useSignal('');
- *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
- *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
- *     });
- *     const data = await res.json();
- *     return data as { temp: number };
- *   });
- *
- *   return (
- *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
- *     </div>
- *   );
- * });
- * ```
- *
+ * @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.
  * @public
+ * @see useAsync$
  * @see Resource
  * @see ResourceReturn
  */
-export declare const useResource$: <T>(generatorFn: ResourceFn<T>, opts?: ResourceOptions) => ResourceReturn<T>;
+export declare const useResource$: <T>(qrl: ResourceFn<T>, opts?: ResourceOptions | undefined) => ResourceReturn<T>;
 
 /** @internal */
 export declare const useResourceQrl: <T>(qrl: QRL<ResourceFn<T>>, opts?: ResourceOptions) => ResourceReturn<T>;
@@ -4525,7 +4636,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.21-dev+c008e88
+ * 2.0.0-beta.23-dev+03de42d
  *
  * @public
  */
@@ -4577,7 +4688,7 @@ export declare const _vnode_isTextVNode: (vNode: _VNode) => vNode is _TextVNode;
 export declare const _vnode_isVirtualVNode: (vNode: _VNode) => vNode is _VirtualVNode;
 
 /** @internal */
-export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean, container?: ClientContainer | null): string;
+export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean, container?: _Container | null): string;
 
 /**
  * Array of numbers which describes virtual nodes in the tree.
@@ -4693,11 +4804,6 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
     [_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;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object.
-     */
-    force(): void;
     get untrackedValue(): T;
     $computeIfNeeded$(): void;
     $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;