@qwik.dev/core 2.0.0-beta.30 → 2.0.0-beta.31

package/dist/core-internal.d.ts

@@ -380,6 +380,8 @@ declare type AsyncCtx<T = unknown> = {
     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;
 };
 
 /**
@@ -394,6 +396,8 @@ export declare type AsyncFn<T> = (ctx: AsyncCtx) => ValueOrPromise<T>;
 /** Retains job metadata and also serves as the argument for the compute function */
 declare class AsyncJob<T> implements AsyncCtx<T> {
     readonly $signal$: AsyncSignalImpl<T>;
+    readonly info: unknown;
+    readonly $infoVersion$: number;
     /** First holds the compute promise and then the cleanup promise */
     $promise$: Promise<void> | null;
     $cleanupRequested$: boolean;
@@ -401,7 +405,7 @@ declare class AsyncJob<T> implements AsyncCtx<T> {
     $track$: AsyncCtx<T>['track'] | undefined;
     $cleanups$: Parameters<AsyncCtx<T>['cleanup']>[0][] | undefined;
     $abortController$: AbortController | undefined;
-    constructor($signal$: AsyncSignalImpl<T>);
+    constructor($signal$: AsyncSignalImpl<T>, info: unknown, $infoVersion$: number);
     get track(): AsyncCtx<T>['track'];
     get abortSignal(): AbortSignal;
     /** Backward compatible cache method for resource */
@@ -453,14 +457,22 @@ export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
      */
     error: Error | undefined;
     /**
-     * Poll interval in ms. Writable and immediately effective when the signal has consumers. If set
-     * to `0`, polling stops.
+     * Staleness/poll interval in ms. Writable and immediately effective.
+     *
+     * - **Positive**: Poll — re-compute after this many ms when subscribers exist.
+     * - **Negative**: Stale-only — mark stale after `|interval|` ms, no auto-recompute.
+     * - **`0`**: No staleness tracking or polling.
      */
     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 AsyncSignalFlags {
@@ -485,12 +497,27 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     $concurrency$: number;
     $interval$: number;
     $timeoutMs$: number | undefined;
+    $info$: unknown;
+    $infoVersion$: number;
     $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $computationTimeoutId$: ReturnType<typeof setTimeout> | 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.
@@ -508,7 +535,7 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     get interval(): number;
     set interval(value: number);
     /** Invalidates the signal, causing it to re-compute its value. */
-    invalidate(): Promise<void>;
+    invalidate(info?: unknown): 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. */
@@ -554,10 +581,12 @@ export declare interface AsyncSignalOptions<T> extends ComputedOptions {
      */
     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.
+     * Controls staleness and polling behavior.
      *
-     * Defaults to `0`.
+     * - **Positive**: Re-run the function after `interval` ms if subscribers exist (polling).
+     * - **Negative**: Mark the value as stale after `|interval|` ms, but do NOT auto-recompute.
+     *   Consumers can check staleness and manually trigger recomputation.
+     * - **`0`** (default): No staleness tracking or polling.
      */
     interval?: number;
     /**
@@ -630,7 +659,8 @@ declare const enum ChoreBits {
     CHILDREN = 32,
     CLEANUP = 64,
     RECONCILE = 128,
-    DIRTY_MASK = 255
+    ERROR_WRAP = 256,
+    DIRTY_MASK = 511
 }
 
 /**
@@ -1439,11 +1469,18 @@ export { h }
 export declare const _hasStoreEffects: (value: StoreTarget, prop: keyof StoreTarget) => boolean;
 
 /**
- * HMR event handler. Replaces the component QRL with a fresh one and marks dirty.
+ * HMR event handler. The host VNode is captured at registration time via QRL captures.
+ *
+ * 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.
  *
  * @internal
  */
-export declare const _hmr: (event: Event, element: Element) => void;
+export declare const _hmr: (this: string | undefined, event: CustomEvent<{
+    files: string[];
+    t: number;
+}>, element: Element) => void;
 
 declare type HostElement = _VNode | ISsrNode;
 
@@ -1875,6 +1912,7 @@ declare class LazyRef<TYPE = unknown> {
     $ref$?: (null | ValueOrPromise<TYPE>) | undefined;
     $container$: _Container | undefined;
     dev?: QRLDev | null | undefined;
+    qrls?: Set<any>;
     constructor($chunk$: string | null, $symbol$: string, $symbolFn$: undefined | null | (() => Promise<Record<string, TYPE>>), $ref$?: (null | ValueOrPromise<TYPE>) | undefined, container?: _Container | null);
     /** We don't read hash very often so let's not allocate a string for every QRL */
     get $hash$(): string;
@@ -2409,6 +2447,7 @@ declare type QRLInternalMethods<TYPE> = {
     /** If this returns false, the function execution will be skipped */
     beforeFn?: () => void | false): TYPE extends (...args: any) => any ? (...args: Parameters<TYPE>) => ValueOrPromise<ReturnType<TYPE> | undefined> : unknown;
     $callFn$(withThis: unknown, ...args: QrlArgs<TYPE>): ValueOrPromise<QrlReturn<TYPE>>;
+    $setDev$(dev: QRLDev | null): void;
     /**
      * "with captures" - Get a new QRL for these captures, reusing the lazy ref. It's an internal
      * method but we need to have a stable name because it gets called in user code by the optimizer,
@@ -3390,6 +3429,7 @@ declare interface SSRContainer extends _Container {
     readonly resolvedManifest: ResolvedManifest;
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
+    $noScriptHere$: number;
     write(text: string): void;
     openContainer(): void;
     closeContainer(): ValueOrPromise<void>;
@@ -4621,7 +4661,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.30-dev+5421ed4
+ * 2.0.0-beta.31-dev+906321a
  *
  * @public
  */