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

package/dist/async-local-storage.d.ts

@@ -0,0 +1,3 @@
+import type { AsyncLocalStorage } from 'node:async_hooks';
+/** @internal */
+export declare const getAsyncLocalStorage: () => (new <T>() => AsyncLocalStorage<T>) | undefined;

package/dist/async-local-storage.mjs

@@ -0,0 +1,8 @@
+// packages/qwik/src/core/shared/platform/async-local-storage.ts
+var getAsyncLocalStorage = () => {
+  const process = globalThis.process;
+  return process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage;
+};
+export {
+  getAsyncLocalStorage
+};

package/dist/async-local-storage.node.mjs

@@ -0,0 +1,6 @@
+// packages/qwik/src/core/shared/platform/async-local-storage.node.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var getAsyncLocalStorage = () => AsyncLocalStorage;
+export {
+  getAsyncLocalStorage
+};

package/dist/backpatch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/backpatch",
-  "version": "2.0.0-beta.43-dev+e478dfb",
+  "version": "2.0.0-beta.45-dev+596de70",
   "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.43-dev+e478dfb",
+  "version": "2.0.0-beta.45-dev+596de70",
   "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.43-dev+e478dfb
+ * @qwik.dev/core/cli 2.0.0-beta.45-dev+596de70
  * 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
@@ -4244,7 +4244,7 @@ var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 var figures_default = figures;
 var replacements = Object.entries(specialMainSymbols);
 
-// node_modules/.pnpm/yoctocolors@2.1.2/node_modules/yoctocolors/base.js
+// node_modules/.pnpm/yoctocolors@2.2.0/node_modules/yoctocolors/base.js
 import tty from "node:tty";
 var hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
 var format = (open, close) => {
@@ -4277,6 +4277,10 @@ var bold2 = format(1, 22);
 var dim2 = format(2, 22);
 var italic2 = format(3, 23);
 var underline2 = format(4, 24);
+var underlineDouble = format("4:2", 24);
+var underlineCurly = format("4:3", 24);
+var underlineDotted = format("4:4", 24);
+var underlineDashed = format("4:5", 24);
 var overline = format(53, 55);
 var inverse2 = format(7, 27);
 var hidden2 = format(8, 28);
@@ -4313,6 +4317,22 @@ var bgBlueBright = format(104, 49);
 var bgMagentaBright = format(105, 49);
 var bgCyanBright = format(106, 49);
 var bgWhiteBright = format(107, 49);
+var underlineBlack = format("58;5;0", 59);
+var underlineRed = format("58;5;1", 59);
+var underlineGreen = format("58;5;2", 59);
+var underlineYellow = format("58;5;3", 59);
+var underlineBlue = format("58;5;4", 59);
+var underlineMagenta = format("58;5;5", 59);
+var underlineCyan = format("58;5;6", 59);
+var underlineWhite = format("58;5;7", 59);
+var underlineGray = format("58;5;8", 59);
+var underlineRedBright = format("58;5;9", 59);
+var underlineGreenBright = format("58;5;10", 59);
+var underlineYellowBright = format("58;5;11", 59);
+var underlineBlueBright = format("58;5;12", 59);
+var underlineMagentaBright = format("58;5;13", 59);
+var underlineCyanBright = format("58;5;14", 59);
+var underlineWhiteBright = format("58;5;15", 59);
 
 // node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/verbose/default.js
 var defaultVerboseFunction = ({
@@ -6698,7 +6718,7 @@ function parseMilliseconds(milliseconds) {
   throw new TypeError("Expected a finite number or bigint");
 }
 
-// node_modules/.pnpm/pretty-ms@9.3.0/node_modules/pretty-ms/index.js
+// node_modules/.pnpm/pretty-ms@9.3.1/node_modules/pretty-ms/index.js
 var isZero = (value) => value === 0 || value === 0n;
 var pluralize = (word, count2) => count2 === 1 || count2 === 1n ? word : `${word}s`;
 var SECOND_ROUNDING_EPSILON = 1e-7;
@@ -6771,7 +6791,8 @@ function prettyMilliseconds(milliseconds, options) {
         const millisecondsAndBelow = milliseconds2 + microseconds / 1e3 + nanoseconds / 1e6;
         const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
         const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
-        const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+        const maximumMilliseconds = 1e3 - 10 ** -millisecondsDecimalDigits;
+        const millisecondsString = millisecondsDecimalDigits ? Math.min(millisecondsAndBelow, maximumMilliseconds).toFixed(millisecondsDecimalDigits) : Math.min(roundedMilliseconds, maximumMilliseconds);
         add(
           Number.parseFloat(millisecondsString),
           "millisecond",
@@ -12966,7 +12987,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.43-dev+e478dfb");
+  console.log("2.0.0-beta.45-dev+596de70");
 }
 export {
   runCli,

package/dist/core-internal.d.ts

@@ -1,5 +1,5 @@
-import type { AsyncLocalStorage } from 'node:async_hooks';
 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';
@@ -381,12 +381,6 @@ declare type AsyncQRL<T> = ComputeQRL<T>;
  * changed, all tasks which are tracking the AsyncSignal will be re-run and all subscribers
  * (components, tasks etc) that read the AsyncSignal will be updated.
  *
- * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
- * property. The error can be cleared by re-running the async function successfully.
- *
- * While the async function is running, the `.loading` property will be set to `true`. Once the
- * function completes, `loading` will be set to `false`.
- *
  * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
  * retry the component or task once the value resolves.
  *
@@ -394,8 +388,7 @@ declare type AsyncQRL<T> = ComputeQRL<T>;
  * will subscribe to it and return the last resolved value until the new value is ready. As soon as
  * the new value is ready, the subscribers will be updated.
  *
- * If the async function threw an error, reading the `.value` will throw that same error. Read from
- * `.error` to check if there was an error.
+ * If the async function threw an error, reading the `.value` will throw that same error.
  *
  * @deprecated Use `ComputedSignal` instead, it has async support now.
  * @public
@@ -700,40 +693,6 @@ export declare interface ComputedSignal<T> extends Signal<T> {
      * throw the computation promise) instead of the stale value while the new value computes.
      */
     clear(): void;
-    /**
-     * Whether the signal is currently loading. This will trigger lazy computation of the signal, so
-     * you can use it like this:
-     *
-     * ```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;
     /** A promise that resolves when the value is computed or rejected. */
     promise(): Promise<void>;
     /** Abort the current computation and run cleanups if needed. */
@@ -778,6 +737,7 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     $timeoutMs$: number | undefined;
     $loadingEffects$: undefined | Set<EffectSubscription>;
     $errorEffects$: undefined | Set<EffectSubscription>;
+    $disposed$: boolean | undefined;
     $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $info$: unknown | undefined;
     $infoVersion$: number | undefined;
@@ -855,7 +815,9 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
      * AbortErrors.
      */
     $setError$(job: Job<T>, error: Error): void;
-    /** Called after SSR/unmount */
+    /** Permanently stop computations; keep this cross-package name stable. */
+    $dispose(): void;
+    /** Clean computations after SSR while preserving dependencies for serialization. */
     $destroy$(): Promise<void>;
     private $hasSubscribers$;
     $requestCleanups$(job: Job<T>, reason?: any): void;
@@ -865,6 +827,48 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     $runCleanups$(job: Job<T>): Promise<void> | undefined;
 }
 
+/**
+ * A computed signal with its pending and error state exposed.
+ *
+ * @internal
+ */
+export declare interface _ComputedSignalInternal<T> extends ComputedSignal<T> {
+    /**
+     * 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;
+}
+
 declare type ComputeQRL<T> = _QRLInternal<ComputedFn<T>>;
 
 /** @internal */
@@ -1089,9 +1093,9 @@ export declare const createAsyncQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: Asyn
  *
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects. Every synchronous signal or store read is tracked automatically; reads after the first
- * `await` must use the `track()` provided on the context argument. When the function is async, the
- * returned signal exposes the async API (`.pending`, `.error`, `.promise()`), and reading an
- * unresolved `.value` throws the computation promise.
+ * `await` must use the `track()` provided on the context argument. When the function is async,
+ * reading an unresolved `.value` throws the computation promise, and reading a failed `.value`
+ * throws the error.
  *
  * @public
  */
@@ -1528,8 +1532,7 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
-/** @internal */
-export declare const _getAsyncLocalStorage: () => (new <T>() => AsyncLocalStorage<T>) | undefined;
+export { _getAsyncLocalStorage }
 
 /**
  * Returns the client build manifest, which includes the mappings from symbols to bundles, the
@@ -1905,7 +1908,7 @@ declare class Job<T> implements ComputeCtx<T> {
     /** Backward compatible cache method for resource */
     cache(): void;
     get previous(): T | undefined;
-    cleanup(callback: () => void): void;
+    cleanup: (callback: () => void) => void;
 }
 
 /**
@@ -2348,7 +2351,7 @@ declare type Passive = {
 
 declare type PopoverTargetAction = 'hide' | 'show' | 'toggle';
 
-declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
+declare type PossibleEvents = Event | typeof TaskEvent | typeof RenderEvent;
 
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class. You
@@ -3068,21 +3071,13 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
  *   return (
  *     <div>
  *       <input name="city" bind:value={city} />
- *       <div>
- *         Temperature:{' '}
- *         {weather.pending
- *           ? 'Loading...'
- *           : weather.error
- *             ? `Error: ${weather.error.message}`
- *             : weather.value.temp}
- *       </div>
+ *       <div>Temperature: {weather.value.temp}</div>
  *     </div>
  *   );
  * });
  * ```
  *
- * @deprecated Use `useComputed$` instead. Read the `pending` and `error` properties from the
- *   returned signal to determine the status.
+ * @deprecated Use `useComputed$` instead.
  * @public
  */
 export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
@@ -3137,7 +3132,7 @@ declare interface ResourceReturnInternal<T> {
     __brand: 'resource';
     value: Promise<T>;
     loading: boolean;
-    signal: AsyncSignal<{
+    signal: _ComputedSignalInternal<{
         r: T;
     }>;
 }
@@ -3524,12 +3519,6 @@ declare class SignalImpl<T = any> implements Signal<T> {
     };
 }
 
-declare interface SimplifiedServerRequestEvent<T = unknown> {
-    url: URL;
-    locale: string | undefined;
-    request: Request;
-}
-
 /** @public */
 declare type Size = number | string;
 
@@ -4346,7 +4335,8 @@ declare const enum TaskFlags {
     DIRTY = 4,
     RENDER_BLOCKING = 8,
     NEEDS_CLEANUP = 16,
-    EVENTS_REGISTERED = 32
+    EVENTS_REGISTERED = 32,
+    EXECUTED = 64
 }
 
 /** @public */
@@ -4494,9 +4484,8 @@ export declare function _updateProjectionProps(container: _Container, vnode: _Vi
  *
  * Every synchronous signal or store read is tracked automatically. Reads after an `await` are not:
  * the tracking context is lost, so track them explicitly with the `track()` provided on the context
- * argument. When the function is async, the returned signal exposes the async API: reading an
- * unresolved `.value` throws the computation promise, and `.pending` and `.error` expose the
- * computation state.
+ * argument. When the function is async, reading an unresolved `.value` throws the computation
+ * promise, and reading a failed `.value` throws the error.
  *
  * The function must not have any side effects.
  *
@@ -5141,7 +5130,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.43-dev+e478dfb
+ * 2.0.0-beta.45-dev+596de70
  *
  * @public
  */
@@ -5318,6 +5307,9 @@ export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: S
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
  *
+ * `fn` may be async. The locale stays set until the returned promise settles, even when
+ * AsyncLocalStorage is not available.
+ *
  * @public
  */
 export declare function withLocale<T>(locale: string, fn: () => T): T;