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

package/dist/starters/adapters/bun/src/entry.bun.ts

@@ -8,6 +8,7 @@
  * - https://bun.sh/docs/api/http
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import { createQwikRouter } from "@qwik.dev/router/middleware/bun";
 import render from "./entry.ssr";
 
@@ -25,7 +26,41 @@ const port = Number(Bun.env.PORT ?? 3000);
 // eslint-disable-next-line no-console
 console.log(`Server started: http://localhost:${port}/`);
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Bun from crashing, but it does provide better diagnostics.
+// See Bun and Node process event docs for runtime-specific behavior.
+process.on("uncaughtException", (error) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", { error });
+});
+
+process.on("unhandledRejection", (reason) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled rejection during request", {
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      reason,
+    });
+    return;
+  }
+
+  console.error("Unhandled rejection outside request", { reason });
+});
+
 Bun.serve({
+  maxRequestBodySize: 10 * 1024 * 1024,
   async fetch(request: Request) {
     const staticResponse = await staticFile(request);
     if (staticResponse) {

package/dist/starters/adapters/cloud-run/src/entry.cloud-run.tsx

@@ -7,6 +7,7 @@
  * - https://qwik.dev/docs/deployments/gcp-cloud-run/
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import {
   createQwikRouter,
   type PlatformNode,
@@ -77,6 +78,25 @@ const { router, staticFile } = createQwikRouter({
 
 const server = createServer();
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Node from crashing, but it does provide better diagnostics for uncaught exceptions.
+// See the Node documentation to handle uncaught exceptions and unhandled rejections in your app.
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      origin,
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", { origin, error });
+});
+
 server.on("request", (req, res) => {
   for (const header of Object.entries(DEFAULT_HEADERS)) {
     res.setHeader(...header);

package/dist/starters/adapters/deno/src/entry.deno.ts

@@ -8,6 +8,7 @@
  * - https://docs.deno.com/runtime/tutorials/http_server
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import { createQwikRouter } from "@qwik.dev/router/middleware/deno";
 import render from "./entry.ssr";
 
@@ -25,6 +26,46 @@ const port = Number(Deno.env.get("PORT") ?? 3009);
 /* eslint-disable */
 console.log(`Server starter: http://localhost:${port}/app/`);
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Deno from crashing, but it does provide better diagnostics.
+// See Deno runtime event docs for error and unhandled rejection behavior.
+globalThis.addEventListener("error", (event: ErrorEvent) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error: event.error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", {
+    error: event.error,
+  });
+});
+
+globalThis.addEventListener(
+  "unhandledrejection",
+  (event: PromiseRejectionEvent) => {
+    const requestEv = getRequestEvent();
+    if (requestEv) {
+      console.error("Unhandled rejection during request", {
+        method: requestEv.method,
+        url: requestEv.url.href,
+        headersSent: requestEv.headersSent,
+        reason: event.reason,
+      });
+      return;
+    }
+
+    console.error("Unhandled rejection outside request", {
+      reason: event.reason,
+    });
+  },
+);
+
 Deno.serve({ port }, async (request: Request, info: any) => {
   const staticResponse = await staticFile(request);
   if (staticResponse) {

package/dist/starters/adapters/express/src/entry.express.tsx

@@ -7,6 +7,7 @@
  * - https://qwik.dev/docs/deployments/node/
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import {
   createQwikRouter,
   type PlatformNode,
@@ -46,6 +47,25 @@ const { router } = createQwikRouter({
 // https://expressjs.com/
 const app = express();
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Node from crashing, but it does provide better diagnostics for uncaught exceptions.
+// See the Node documentation to handle uncaught exceptions and unhandled rejections in your app.
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      origin,
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", { origin, error });
+});
+
 // Enable gzip compression
 // app.use(compression());
 

package/dist/starters/adapters/fastify/src/entry.fastify.tsx

@@ -7,6 +7,7 @@
  * - https://qwik.dev/docs/deployments/node/
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import { type PlatformNode } from "@qwik.dev/router/middleware/node";
 import "dotenv/config";
 import Fastify from "fastify";
@@ -27,6 +28,25 @@ const assetsDir = join(distDir, "assets");
 const PORT = parseInt(process.env.PORT ?? "3000");
 const HOST = process.env.HOST ?? "0.0.0.0";
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Node from crashing, but it does provide better diagnostics for uncaught exceptions.
+// See the Node documentation to handle uncaught exceptions and unhandled rejections in your app.
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      origin,
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", { origin, error });
+});
+
 const start = async () => {
   // Create the fastify server
   // https://fastify.dev/docs/latest/Guides/Getting-Started/

package/dist/starters/adapters/fastify/src/plugins/fastify-qwik.ts

@@ -43,7 +43,16 @@ const qwikPlugin: FastifyPluginAsync<FastifyQwikOptions> = async (
   fastify.removeAllContentTypeParsers();
 
   fastify.setNotFoundHandler(async (request, response) => {
-    await router(request.raw, response.raw, (err) => fastify.log.error(err));
+    await router(
+      request.raw,
+      response.raw,
+      (err) => {
+        if (err) {
+          response.send(err);
+        }
+      },
+      { bodyLimit: request.routeOptions.bodyLimit },
+    );
   });
 };
 

package/dist/starters/adapters/node-server/src/entry.node-server.tsx

@@ -7,6 +7,7 @@
  * - https://qwik.dev/docs/deployments/node/
  *
  */
+import { getRequestEvent } from "@qwik.dev/router";
 import { createQwikRouter } from "@qwik.dev/router/middleware/node";
 import { createServer } from "node:http";
 import render from "./entry.ssr";
@@ -24,6 +25,25 @@ const { router, staticFile } = createQwikRouter({
 
 const server = createServer();
 
+// Optional request-aware diagnostics for crashes that escape request boundaries.
+// This does not prevent Node from crashing, but it does provide better diagnostics for uncaught exceptions.
+// See the Node documentation to handle uncaught exceptions and unhandled rejections in your app.
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+  const requestEv = getRequestEvent();
+  if (requestEv) {
+    console.error("Unhandled exception during request", {
+      origin,
+      method: requestEv.method,
+      url: requestEv.url.href,
+      headersSent: requestEv.headersSent,
+      error,
+    });
+    return;
+  }
+
+  console.error("Unhandled exception outside request", { origin, error });
+});
+
 server.on("request", (req, res) => {
   staticFile(req, res, () => {
     router(req, res, () => {});

package/dist/testing/index.d.ts

@@ -17,13 +17,17 @@ declare interface AddRootFn {
     (obj: unknown, returnRef: true): SeenRef;
 }
 
-declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
+declare type AllSignalFlags = ComputedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
 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
 }
 
 /** Class for back reference to the EffectSubscription */
@@ -56,6 +60,12 @@ declare const enum ChoreBits {
     DIRTY_MASK = 1023
 }
 
+declare const enum ComputedSignalFlags {
+    INVALID = 1,
+    RUN_EFFECTS = 2,
+    PRESERVE_ON_SEQ_CLEANUP = 4
+}
+
 /** @internal */
 declare const _CONST_PROPS: unique symbol;
 
@@ -190,15 +200,6 @@ export declare const createDOM: ({ html }?: {
     userEvent: (queryOrElement: string | Element | keyof HTMLElementTagNameMap | null, eventNameCamel: string | keyof WindowEventMap, eventPayload?: any) => Promise<Event | null>;
 }>;
 
-declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
-    $flags$: number;
-    $index$: number;
-    $el$: HostElement;
-    $qrl$: QRLInternal<T>;
-    $state$: B | undefined;
-    $destroy$: (() => void) | null;
-}
-
 /** @public */
 declare interface DevJSX {
     fileName: string;
@@ -226,6 +227,7 @@ declare const _EFFECT_BACK_REF: unique symbol;
 
 declare type EffectBackRef = SignalImpl | StoreTarget | PropsProxy;
 
+/** @internal */
 declare const enum EffectProperty {
     COMPONENT = ":",
     VNODE = "."
@@ -324,6 +326,7 @@ declare type FunctionComponent<P = unknown> = {
 /** @public */
 export declare function getTestPlatform(): TestPlatform;
 
+/** @internal */
 declare type HostElement = VNode | ISsrNode;
 
 /** @public */
@@ -676,6 +679,8 @@ declare type QRL<TYPE = unknown> = {
 
 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;
@@ -690,8 +695,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;
@@ -708,7 +713,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
@@ -817,11 +822,6 @@ 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. */
@@ -857,11 +857,13 @@ declare interface SimplifiedServerRequestEvent<T = unknown> {
 declare interface SSRInternalStreamWriter extends StreamWriter_2 {
     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
 }
 
 /** @public */
@@ -874,6 +876,8 @@ export declare function ssrRenderToDom(jsx: JSXOutput, opts?: {
     qwikLoader?: boolean;
     /** Override the SSR container tag name. */
     containerTagName?: string;
+    /** Root-count threshold for eager yielded state prewarm during client resume. */
+    statePrewarm?: number | false;
     /** Stream rendered chunks while still collecting the final HTML. */
     stream?: StreamWriter;
     /** Configure SSR streaming. */
@@ -911,20 +915,30 @@ declare class SubscriptionData {
 
 declare type SymbolToChunkResolver = (symbol: string) => string;
 
-declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
-    $flags$: number;
+/** @internal */
+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);
 }
 
 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 */
 declare interface TestPlatform extends CorePlatform {
     /**
@@ -992,7 +1006,7 @@ declare abstract class VNode implements BackRef {
 
 /** @public */
 export declare function vnode_fromJSX(jsx: JSXOutput): {
-    vParent: _VirtualVNode | _ElementVNode;
+    vParent: _ElementVNode | _VirtualVNode;
     vNode: _VNode | null;
     document: _QDocument;
     container: ClientContainer_2;
@@ -1099,10 +1113,6 @@ export declare function walkJSX(jsx: JSXOutput, apply: {
     text: (text: _Stringifiable) => void;
 }): void;
 
-declare const enum WrappedSignalFlags {
-    UNWRAP = 4
-}
-
 declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $args$: any[];
     $func$: (...args: any[]) => T;
@@ -1110,7 +1120,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;