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

package/build.d.ts

@@ -1,2 +1,2 @@
 // re-export for typescript in old resolution mode
-export * from './dist/build';
+export * from './dist/build/index.js';

package/dist/backpatch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/backpatch",
-  "version": "2.0.0-beta.45-dev+596de70",
+  "version": "2.0.0-beta.47-dev+919c91b",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/build",
-  "version": "2.0.0-beta.45-dev+596de70",
+  "version": "2.0.0-beta.47-dev+919c91b",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/cli 2.0.0-beta.45-dev+596de70
+ * @qwik.dev/core/cli 2.0.0-beta.47-dev+919c91b
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -12987,7 +12987,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.45-dev+596de70");
+  console.log("2.0.0-beta.47-dev+919c91b");
 }
 export {
   runCli,

package/dist/core-internal.d.ts

@@ -1,10 +1,10 @@
 import type * as CSS_2 from 'csstype';
-import { getAsyncLocalStorage as _getAsyncLocalStorage } from './async-local-storage';
-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.
@@ -453,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
  *
@@ -684,6 +756,19 @@ export declare type ComputedReturnType<T> = ComputedSignal<Awaited<T>>;
  * @public
  */
 export declare interface ComputedSignal<T> extends Signal<T> {
+    /**
+     * Whether the signal is currently loading. Reading it starts a lazy computation if needed.
+     *
+     * @experimental
+     */
+    pending: boolean;
+    /**
+     * The computation error, if any. Reading it starts a lazy computation if needed. While set,
+     * reading `.value` throws the error.
+     *
+     * @experimental
+     */
+    error: Error | undefined;
     /** @deprecated Use `trigger()` instead */
     force(): void;
     /** Use this to force recalculation. */
@@ -833,16 +918,6 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
  * @internal
  */
 export declare interface _ComputedSignalInternal<T> extends ComputedSignal<T> {
-    /**
-     * 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.
@@ -854,12 +929,6 @@ export declare interface _ComputedSignalInternal<T> extends ComputedSignal<T> {
     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.
@@ -901,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;
@@ -1296,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;
@@ -1338,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;
 
@@ -1415,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>;
 
@@ -1586,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;
 
@@ -1603,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
@@ -1616,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
  */
@@ -1868,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;
@@ -2349,6 +2372,21 @@ 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 | typeof TaskEvent | typeof RenderEvent;
@@ -2380,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:
  *
@@ -2516,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;
@@ -2913,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;
@@ -2975,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`.
@@ -3040,6 +3104,9 @@ export declare interface RenderSSROptions {
     manifestHash: string;
 }
 
+/** @internal */
+export declare const _requestPreload: Preload;
+
 /** @internal */
 export declare const _reR: () => boolean;
 
@@ -3247,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[];
@@ -3442,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;
@@ -3795,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
@@ -3978,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
  *
@@ -4644,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;
@@ -5029,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
  *
@@ -5102,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;
@@ -5130,7 +5196,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.45-dev+596de70
+ * 2.0.0-beta.47-dev+919c91b
  *
  * @public
  */
@@ -5304,6 +5370,9 @@ 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.
  *