@qwik.dev/core 2.0.0-beta.37 → 2.0.0-beta.39

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.37-dev+82dc74d
+ * @qwik.dev/core/testing 2.0.0-beta.39-dev+6fb620f
  * 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
@@ -13,7 +13,11 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -21426,7 +21430,7 @@ import { _isJSXNode, _isStringifiable } from "@qwik.dev/core/internal";
 import { expect } from "vitest";
 
 // packages/qwik/src/core/client/vnode-utils.ts
-import { isDev as isDev27 } from "@qwik.dev/core/build";
+import { isDev as isDev26 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/utils/qdev.ts
 var qDev = globalThis.qDev !== false;
@@ -21619,8 +21623,8 @@ See https://qwik.dev/docs/core/tasks/#use-method-rules`,
       // 27
       "Cannot coerce a Signal, use `.value` instead",
       // 28
-      "useComputed$ QRL {{0}} {{1}} cannot return a Promise",
-      // 29
+      "",
+      // 29 (cleared: useComputed$ now supports async functions)
       `===
 Qwik version {{0}} already imported while importing {{1}}.
 This can lead to issues due to duplicated shared structures.
@@ -21636,8 +21640,14 @@ Verify that the Qwik libraries you're using are in "resolve.noExternal[]" and in
       // 33
       "Serialization Error: Cannot serialize function: {{0}}",
       // 34
-      "Cannot read .value of a clientOnly async signal during SSR. Use .loading to check state, or provide an initial value."
+      "Cannot read .value of a clientOnly async signal during SSR. Use .loading to check state, or provide an initial value.",
       // 35
+      "Invalid element name for SSR {{0}}",
+      // 36
+      "Invalid serialized Promise dependency",
+      // 37
+      "Invalid serialized Uint8Array payload"
+      // 38
     ];
     let text = MAP[code2] ?? "";
     if (parts.length) {
@@ -21722,6 +21732,7 @@ var VirtualTypeName = {
 
 // packages/qwik/src/core/shared/utils/markers.ts
 var OnRenderProp = "q:renderFn";
+var QComponentHash = "q:componentHash";
 var QTargetElement = "q:targetEl";
 var ComponentStylesPrefixContent = "\u26A1\uFE0F";
 var QSlot = "q:slot";
@@ -21750,13 +21761,13 @@ var QBaseAttr = "q:base";
 var QLocaleAttr = "q:locale";
 var QManifestHashAttr = "q:manifest-hash";
 var QInstanceAttr = "q:instance";
+var QStatePrewarmAttr = "q:prewarm";
 var QContainerIsland = "q:container-island";
 var QContainerIslandEnd = "/" + QContainerIsland;
 var QIgnore = "q:ignore";
 var QIgnoreEnd = "/" + QIgnore;
 var QContainerAttr = "q:container";
 var QContainerAttrEnd = "/" + QContainerAttr;
-var QCursorBoundary = "q:cursorBoundary";
 var QTemplate = "q:template";
 var QContainerSelector = "[q\\:container]:not([q\\:container=" + "html" /* HTML */ + "]):not([q\\:container=" + "text" /* TEXT */ + "])";
 var HTML_NS = "http://www.w3.org/1999/xhtml";
@@ -21779,6 +21790,7 @@ var NON_SERIALIZABLE_MARKER_PREFIX = ":";
 var USE_ON_LOCAL = NON_SERIALIZABLE_MARKER_PREFIX + "on";
 var USE_ON_LOCAL_SEQ_IDX = NON_SERIALIZABLE_MARKER_PREFIX + "onIdx";
 var USE_ON_LOCAL_FLAGS = NON_SERIALIZABLE_MARKER_PREFIX + "onFlags";
+var QCursorBoundary = NON_SERIALIZABLE_MARKER_PREFIX + "cursorBoundary";
 var NEAREST_CURSOR_BOUNDARY = NON_SERIALIZABLE_MARKER_PREFIX + "nearestCursorBoundary";
 var Q_PROPS_SEPARATOR = ":";
 var dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
@@ -21934,7 +21946,7 @@ function retryOnPromise(fn, onError = justThrow) {
 }
 
 // packages/qwik/src/core/client/dom-container.ts
-import { isDev as isDev24 } from "@qwik.dev/core/build";
+import { isDev as isDev23 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/utils/event-names.ts
 var EVENT_SUFFIX = "$";
@@ -22016,10 +22028,10 @@ var isRecoverable = (err) => {
 var NEEDS_COMPUTATION = /* @__PURE__ */ Symbol("invalid");
 var EffectSubscription = class {
   constructor(consumer, property, backRef = null, data = null) {
-    this.consumer = consumer;
-    this.property = property;
-    this.backRef = backRef;
-    this.data = data;
+    __publicField(this, "consumer", consumer);
+    __publicField(this, "property", property);
+    __publicField(this, "backRef", backRef);
+    __publicField(this, "data", data);
   }
 };
 var STORE_TARGET = /* @__PURE__ */ Symbol("store.target");
@@ -22040,7 +22052,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser3, isDev as isDev23 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser3, isDev as isDev22, isServer as isServer10 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/qrl/qrl-class-dev.ts
 import { isBrowser } from "@qwik.dev/core/build";
@@ -22051,7 +22063,7 @@ var initLazyRefDev = (lazy) => {
   }
 };
 var initQrlClassDev = (lazy, captures, qrl) => {
-  if (captures && typeof captures === "object") {
+  if (Array.isArray(captures)) {
     for (let i2 = 0; i2 < captures.length; i2++) {
       const item = captures[i2];
       verifySerializable(item, "Captured variable in the closure can not be serialized");
@@ -22183,16 +22195,24 @@ function qrlToString(serializationContext, qrl, raw) {
     symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
   }
   const captures = qrl.getCaptured();
-  let captureIds = null;
+  let captureDeltas = null;
   if (captures && captures.length > 0) {
-    captureIds = captures.map((ref) => `${serializationContext.$addRoot$(ref)}`).join(" ");
+    let previous = 0;
+    let output = "";
+    for (let i2 = 0; i2 < captures.length; i2++) {
+      const captureId = serializationContext.$addRoot$(captures[i2]);
+      const delta = captureId - previous;
+      previous = captureId;
+      output += (i2 === 0 ? "" : " ") + delta;
+    }
+    captureDeltas = output;
   }
   if (raw) {
-    return [chunk, symbol, captureIds];
+    return [chunk, symbol, captureDeltas];
   }
   let qrlStringInline = `${chunk}#${symbol}`;
-  if (captureIds) {
-    qrlStringInline += `#${captureIds}`;
+  if (captureDeltas) {
+    qrlStringInline += `#${captureDeltas}`;
   }
   return qrlStringInline;
 }
@@ -22209,8 +22229,12 @@ function createQRLWithBackChannel(chunk, symbol, captures, container) {
   return createQRL(chunk, symbol, null, qrlImporter, captures, container);
 }
 function parseQRL(qrl, container) {
-  const [chunk, symbol, captures] = qrl.split("#");
-  return createQRLWithBackChannel(chunk, symbol, captures || null, container);
+  const firstHash = qrl.indexOf("#");
+  const secondHash = qrl.indexOf("#", firstHash + 1);
+  const chunk = qrl.slice(0, firstHash);
+  const symbol = secondHash === -1 ? qrl.slice(firstHash + 1) : qrl.slice(firstHash + 1, secondHash);
+  const captures = secondHash !== -1 && secondHash + 1 < qrl.length ? qrl.slice(secondHash + 1) : null;
+  return createQRLWithBackChannel(chunk, symbol, captures, container);
 }
 var QRL_RUNTIME_CHUNK = "mock-chunk";
 
@@ -22220,7 +22244,16 @@ function runEventHandlerQRL(handler, event, element, ctx) {
     return;
   }
   if (!ctx) {
-    ctx = newInvokeContextFromDOM(event, element);
+    const container2 = getDomContainer(element);
+    return whenContainerDataReady(
+      container2,
+      () => runEventHandlerQRL(
+        handler,
+        event,
+        element,
+        newInvokeContextFromDOM(event, element, container2)
+      )
+    );
   }
   const container = ctx.$container$;
   const hostElement = ctx.$hostElement$;
@@ -22435,7 +22468,7 @@ function createPropsProxy(owner) {
 }
 var PropsProxyHandler = class {
   constructor(owner) {
-    this.owner = owner;
+    __publicField(this, "owner", owner);
     __publicField(this, "$effects$");
     __publicField(this, "$container$", null);
   }
@@ -22464,7 +22497,7 @@ var PropsProxyHandler = class {
         addPropsProxyEffect(this, prop);
       }
     }
-    return value instanceof WrappedSignalImpl && value.$flags$ & 4 /* UNWRAP */ ? value.value : value;
+    return value instanceof WrappedSignalImpl ? value.value : value;
   }
   set(_, prop, value) {
     if (prop === _OWNER) {
@@ -22605,8 +22638,8 @@ var isPropsProxy = (obj) => {
   return obj && _VAR_PROPS in obj;
 };
 
-// packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
-import { isBrowser as isBrowser2, isDev as isDev11, isServer as isServer5 } from "@qwik.dev/core/build";
+// packages/qwik/src/core/reactive-primitives/impl/computed-signal-impl.ts
+import { isBrowser as isBrowser2, isDev as isDev10, isServer as isServer5 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscriber.ts
 import { isServer as isServer4 } from "@qwik.dev/core/build";
@@ -22692,89 +22725,11 @@ var cleanupFn = (target, handleError) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/computed-signal-impl.ts
-import { isDev as isDev10 } from "@qwik.dev/core/build";
 var DEBUG2 = false;
 var log2 = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToString));
-var _a2, _b;
-var ComputedSignalImpl = class extends (_b = SignalImpl, _a2 = _EFFECT_BACK_REF, _b) {
-  constructor(container, fn, flags = 1 /* INVALID */ | 16 /* SERIALIZATION_STRATEGY_ALWAYS */) {
-    super(container || tryGetInvokeContext()?.$container$, NEEDS_COMPUTATION);
-    /**
-     * The compute function is stored here.
-     *
-     * The computed functions must be executed synchronously (because of this we need to eagerly
-     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
-     */
-    __publicField(this, "$computeQrl$");
-    __publicField(this, "$flags$");
-    __publicField(this, _a2);
-    this.$computeQrl$ = fn;
-    this.$flags$ = flags;
-  }
-  invalidate() {
-    this.$flags$ |= 1 /* INVALID */;
-    const ctx = newInvokeContext();
-    ctx.$container$ = this.$container$ || void 0;
-    const running = retryOnPromise(invokeApply.bind(this, ctx, this.$computeIfNeeded$));
-    if (running) {
-      running.catch((err) => {
-        if (this.$container$) {
-          this.$container$.handleError(err, null);
-        } else {
-          console.error("Error during computation", err);
-        }
-      });
-    }
-  }
-  get untrackedValue() {
-    this.$computeIfNeeded$();
-    isDev10 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
-    return this.$untrackedValue$;
-  }
-  set untrackedValue(value) {
-    this.$untrackedValue$ = value;
-  }
-  $computeIfNeeded$() {
-    if (!(this.$flags$ & 1 /* INVALID */)) {
-      return;
-    }
-    const computeQrl = this.$computeQrl$;
-    throwIfQRLNotResolved(computeQrl);
-    const ctx = tryGetInvokeContext();
-    const previousEffectSubscription = ctx?.$effectSubscriber$;
-    if (ctx) {
-      const effectSubscriber = getSubscriber(this, "." /* VNODE */);
-      clearEffectSubscription(this.$container$, effectSubscriber);
-      ctx.$effectSubscriber$ = effectSubscriber;
-    }
-    try {
-      const untrackedValue = computeQrl.getFn(ctx)();
-      if (isPromise(untrackedValue)) {
-        throw qError(29 /* computedNotSync */, [
-          computeQrl.dev ? computeQrl.dev.file : "",
-          computeQrl.$hash$
-        ]);
-      }
-      DEBUG2 && log2("Signal.$compute$", untrackedValue);
-      this.$flags$ &= ~1 /* INVALID */;
-      super.value = untrackedValue;
-    } finally {
-      if (ctx) {
-        ctx.$effectSubscriber$ = previousEffectSubscription;
-      }
-    }
-  }
-};
-
-// packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
-var DEBUG3 = false;
-var log3 = (...args) => (
-  // eslint-disable-next-line no-console
-  console.log("ASYNC COMPUTED SIGNAL", ...args.map(qwikDebugToString))
-);
-var AsyncJob = class {
+var Job = class {
   constructor($signal$, info, $infoVersion$) {
-    this.$signal$ = $signal$;
+    __publicField(this, "$signal$", $signal$);
     /** First holds the compute promise and then the cleanup promise */
     __publicField(this, "$promise$", null);
     __publicField(this, "$cleanupRequested$", false);
@@ -22792,8 +22747,8 @@ var AsyncJob = class {
   }
   /** Backward compatible cache method for resource */
   cache() {
-    isDev11 && console.error(
-      "useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `expires` option for polling behavior."
+    isDev10 && console.error(
+      "useResource cache() method does not do anything. Use `useComputed$` instead of `useResource$`; for polling use the `usePoll` hook from `@qwik.dev/utils`."
     );
   }
   get previous() {
@@ -22808,74 +22763,70 @@ var AsyncJob = class {
     }
   }
 };
-var _a3, _b2;
-var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BACK_REF, _b2) {
+var _a2, _b;
+var ComputedSignalImpl = class extends (_b = SignalImpl, _a2 = _EFFECT_BACK_REF, _b) {
   constructor(container, fn, flags = 1 /* INVALID */ | 16 /* SERIALIZATION_STRATEGY_ALWAYS */, options) {
-    super(container, fn, flags);
-    __publicField(this, "$untrackedLoading$", false);
-    __publicField(this, "$untrackedError$");
-    __publicField(this, "$current$", null);
-    __publicField(this, _a3);
+    super(container || tryGetInvokeContext()?.$container$, NEEDS_COMPUTATION);
+    /**
+     * The compute function is stored here.
+     *
+     * Sync computed functions must be executed synchronously (because of this we need to eagerly
+     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous).
+     */
+    __publicField(this, "$computeQrl$");
+    __publicField(this, "$flags$");
+    __publicField(this, _a2);
+    this.$computeQrl$ = fn;
+    this.$flags$ = flags;
     if (!options) {
       return;
     }
     const initial = options.initial;
     if (initial !== void 0) {
-      const initialValue = typeof initial === "function" ? initial() : initial;
-      this.$untrackedValue$ = initialValue;
+      this.$untrackedValue$ = typeof initial === "function" ? initial() : initial;
     }
     const concurrency = options.concurrency;
     if (concurrency !== void 0 && concurrency >= 0 && concurrency !== 1) {
       this.$concurrency$ = concurrency;
       this.$jobs$ = [];
     }
-    const timeout = options.timeout;
-    if (timeout) {
-      this.$timeoutMs$ = timeout;
+    if (options.timeout) {
+      this.$timeoutMs$ = options.timeout;
     }
     if (options.eagerCleanup) {
       this.$flags$ |= 32 /* EAGER_CLEANUP */;
     }
     if (options.clientOnly) {
-      this.$flags$ |= 64 /* CLIENT_ONLY */;
-    }
-    if (options.allowStale === false) {
-      if (isDev11 && initial !== void 0) {
-        throw new Error(
-          "allowStale: false and initial cannot be used together. allowStale: false clears the value on invalidation, which conflicts with providing an initial value."
-        );
-      }
-      this.$flags$ |= 128 /* CLEAR_ON_INVALIDATE */;
-    }
-    const expires = options.expires ?? (options.interval ? Math.abs(options.interval) : void 0);
-    if (expires) {
-      this.expires = expires;
-    }
-    if (options.poll === false || options.interval !== void 0 && options.interval < 0) {
-      this.$flags$ |= 256 /* NO_POLL */;
+      this.$flags$ |= 64 /* CLIENT_ONLY */ | 512 /* ASYNC_MODE */;
     }
   }
-  get untrackedValue() {
-    this.$computeIfNeeded$();
-    if (this.$current$?.$promise$) {
-      if (this.$untrackedValue$ === NEEDS_COMPUTATION || (qTest ? isServerPlatform() : isServer5)) {
-        DEBUG3 && log3("Throwing promise while computing initial value", this);
-        throw this.$current$?.$promise$;
-      }
-      DEBUG3 && log3("Returning stale value", this.$untrackedValue$, "while computing", this.$current$);
-      return this.$untrackedValue$;
+  /** Clear the value so readers see the loading state, then recompute. */
+  clear() {
+    this.$untrackedValue$ = NEEDS_COMPUTATION;
+    this.invalidate();
+  }
+  invalidate(info) {
+    if (arguments.length > 0) {
+      this.$info$ = info;
+      this.$infoVersion$ = this.$infoVersion$ === void 0 ? 1 : this.$infoVersion$ + 1;
     }
-    if (this.$untrackedError$) {
-      DEBUG3 && log3("Throwing error while reading value", this);
-      throw this.$untrackedError$;
+    if (this.$flags$ & 512 /* ASYNC_MODE */) {
+      this.$setInvalid$(true);
+      return;
     }
-    if ((qTest ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */ && this.$untrackedValue$ === NEEDS_COMPUTATION) {
-      throw qError(35 /* asyncClientOnlyValueDuringSSR */);
+    this.$flags$ |= 1 /* INVALID */;
+    const ctx = newInvokeContext();
+    ctx.$container$ = this.$container$ || void 0;
+    const running = retryOnPromise(invokeApply.bind(this, ctx, this.$computeIfNeeded$));
+    if (isPromise(running)) {
+      running.catch((err) => {
+        if (this.$container$) {
+          this.$container$.handleError(err, null);
+        } else {
+          console.error("Error during computation", err);
+        }
+      });
     }
-    return this.$untrackedValue$;
-  }
-  set untrackedValue(value) {
-    this.$untrackedValue$ = value;
   }
   /**
    * Read the value, subscribing if in a tracking context. Triggers computation if needed.
@@ -22893,32 +22844,60 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
   }
   set value(value) {
     this.$flags$ &= ~1 /* INVALID */;
-    this.untrackedLoading = false;
     this.untrackedError = void 0;
-    this.$info$ = void 0;
-    if (this.$jobs$) {
-      for (let i2 = 0; i2 < this.$jobs$.length; i2++) {
-        this.$jobs$[i2].$canWrite$ = false;
+    if (this.$flags$ & 512 /* ASYNC_MODE */) {
+      this.untrackedPending = false;
+      this.$info$ = void 0;
+      if (this.$jobs$) {
+        for (let i2 = 0; i2 < this.$jobs$.length; i2++) {
+          this.$jobs$[i2].$canWrite$ = false;
+        }
+      } else if (this.$current$) {
+        this.$current$.$canWrite$ = false;
       }
-    } else if (this.$current$) {
-      this.$current$.$canWrite$ = false;
+      super.value = value;
+      return;
     }
-    this.$clearNextPoll$();
     super.value = value;
-    this.$scheduleNextPoll$();
+  }
+  get untrackedValue() {
+    this.$computeIfNeeded$();
+    if (this.$current$?.$promise$) {
+      if (this.$untrackedValue$ === NEEDS_COMPUTATION || (qTest ? isServerPlatform() : isServer5)) {
+        DEBUG2 && log2("Throwing promise while computing initial value", this);
+        throw this.$current$?.$promise$;
+      }
+      DEBUG2 && log2("Returning stale value", this.$untrackedValue$, "while computing", this.$current$);
+      return this.$untrackedValue$;
+    }
+    if (this.$untrackedError$) {
+      DEBUG2 && log2("Throwing error while reading value", this);
+      throw this.$untrackedError$;
+    }
+    if ((qTest ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */ && this.$untrackedValue$ === NEEDS_COMPUTATION) {
+      throw qError(35 /* asyncClientOnlyValueDuringSSR */);
+    }
+    isDev10 && !(this.$flags$ & 512 /* ASYNC_MODE */) && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    return this.$untrackedValue$;
+  }
+  set untrackedValue(value) {
+    this.$untrackedValue$ = value;
   }
   /**
    * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
-   * has resolved or rejected.
+   * has resolved or rejected (or the compute function is synchronous).
    *
-   * Accessing .loading will trigger computation if needed, since it's often used like
-   * `signal.loading ? <Loading /> : signal.value`.
+   * Accessing `.pending` will trigger computation if needed, since it's often used like
+   *
+   * ```ts
+   * signal.pending ? <Loading /> : signal.value
+   * ```
    */
-  get loading() {
-    const val = this.untrackedLoading;
+  get pending() {
+    const val = this.untrackedPending;
     const ctx = tryGetInvokeContext();
     if (ctx && (this.$container$ || (this.$container$ = ctx.$container$ || null))) {
-      isDev11 && assertTrue(
+      isDev10 && assertTrue(
         !ctx.$container$ || ctx.$container$ === this.$container$,
         "Do not use signals across containers"
       );
@@ -22931,27 +22910,46 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     }
     return val;
   }
-  set untrackedLoading(value) {
-    if (value !== this.$untrackedLoading$) {
-      this.$untrackedLoading$ = value;
-      DEBUG3 && log3("Set untrackedLoading", value);
+  set untrackedPending(value) {
+    if (value !== !!this.$untrackedPending$) {
+      this.$untrackedPending$ = value;
+      DEBUG2 && log2("Set untrackedPending", value);
       scheduleEffects(this.$container$, this, this.$loadingEffects$);
     }
   }
-  get untrackedLoading() {
+  get untrackedPending() {
     this.$computeIfNeeded$();
     if ((qTest ? isServerPlatform() : isServer5) && this.$current$?.$promise$) {
-      DEBUG3 && log3("Throwing loading promise for SSR");
+      DEBUG2 && log2("Throwing loading promise for SSR");
       throw this.$current$?.$promise$;
     }
-    return this.$untrackedLoading$;
+    return !!this.$untrackedPending$;
   }
-  /** The error that occurred when the signal was resolved. */
+  /** @deprecated Use `pending` instead */
+  get loading() {
+    return this.pending;
+  }
+  /** @deprecated Use `untrackedPending` instead */
+  get untrackedLoading() {
+    return this.untrackedPending;
+  }
+  set untrackedLoading(value) {
+    this.untrackedPending = value;
+  }
+  /**
+   * The error the compute function threw or rejected with.
+   *
+   * Accessing .error will trigger computation if needed, since it's often used like
+   *
+   * ```ts
+   * signal.error ? <Failed /> : signal.value
+   * ```
+   */
   get error() {
     const val = this.untrackedError;
     const ctx = tryGetInvokeContext();
     if (ctx && (this.$container$ || (this.$container$ = ctx.$container$ || null))) {
-      isDev11 && assertTrue(
+      isDev10 && assertTrue(
         !ctx.$container$ || ctx.$container$ === this.$container$,
         "Do not use signals across containers"
       );
@@ -22971,59 +22969,14 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     }
   }
   get untrackedError() {
-    return this.$untrackedError$;
-  }
-  get expires() {
-    return this.$expires$ || 0;
-  }
-  set expires(value) {
-    this.$clearNextPoll$();
-    this.$expires$ = value;
-    if (this.$expires$ && this.$hasSubscribers$()) {
-      this.$scheduleNextPoll$();
-    }
-  }
-  get poll() {
-    return !(this.$flags$ & 256 /* NO_POLL */);
-  }
-  set poll(value) {
-    if (value) {
-      this.$flags$ &= ~256 /* NO_POLL */;
-    } else {
-      this.$flags$ |= 256 /* NO_POLL */;
-    }
-    if (this.$expires$ && this.$hasSubscribers$()) {
-      this.$clearNextPoll$();
-      this.$scheduleNextPoll$();
-    }
-  }
-  /** @deprecated Use `expires` and `poll` instead. */
-  get interval() {
-    const expires = this.$expires$ || 0;
-    return this.$flags$ & 256 /* NO_POLL */ ? -expires : expires;
-  }
-  set interval(value) {
-    if (value < 0) {
-      this.$flags$ |= 256 /* NO_POLL */;
-    } else {
-      this.$flags$ &= ~256 /* NO_POLL */;
-    }
-    this.expires = Math.abs(value);
-  }
-  /** Invalidates the signal, causing it to re-compute its value. */
-  async invalidate(info) {
-    if (arguments.length > 0) {
-      this.$info$ = info;
-      this.$infoVersion$ = this.$infoVersion$ === void 0 ? 1 : this.$infoVersion$ + 1;
+    this.$computeIfNeeded$();
+    if ((qTest ? isServerPlatform() : isServer5) && this.$current$?.$promise$) {
+      throw this.$current$?.$promise$;
     }
-    this.$setInvalid$(true, this.$flags$ & 128 /* CLEAR_ON_INVALIDATE */);
+    return this.$untrackedError$;
   }
-  $setInvalid$(allowRecalc, mustClear) {
+  $setInvalid$(allowRecalc) {
     this.$flags$ |= 1 /* INVALID */;
-    this.$clearNextPoll$();
-    if (mustClear) {
-      this.$untrackedValue$ = NEEDS_COMPUTATION;
-    }
     if (allowRecalc && (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size)) {
       Promise.resolve().then(() => this.$computeIfNeeded$());
     }
@@ -23060,12 +23013,84 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     if (!(this.$flags$ & 1 /* INVALID */)) {
       return;
     }
+    if (this.$flags$ & 512 /* ASYNC_MODE */) {
+      return this.$computeAsync$();
+    }
+    const computeQrl = this.$computeQrl$;
+    throwIfQRLNotResolved(computeQrl);
+    const prevJob = this.$current$;
+    if (prevJob && !prevJob.$cleanupRequested$) {
+      prevJob.$cleanupRequested$ = true;
+      prevJob.$abortController$?.abort();
+      this.$runCleanupCallbacks$(prevJob);
+    }
+    const running = new Job(this, this.$info$, this.$infoVersion$);
+    this.$current$ = running;
+    let result;
+    try {
+      result = this.$invokeComputeFn$(computeQrl.resolved, running);
+    } catch (err) {
+      if (isPromise(err)) {
+        throw err;
+      }
+      if (running.$infoVersion$ === this.$infoVersion$) {
+        this.$info$ = void 0;
+      }
+      this.$flags$ &= ~1 /* INVALID */;
+      this.$setError$(running, err);
+      return;
+    }
+    if (isPromise(result)) {
+      this.$flags$ |= 512 /* ASYNC_MODE */;
+      this.$flags$ &= ~1 /* INVALID */;
+      let first = result;
+      const compute = () => {
+        const r = first ?? this.$invokeComputeFn$(this.$computeQrl$.resolved, running);
+        first = void 0;
+        return r;
+      };
+      running.$promise$ = this.$settleComputation$(running, () => retryOnPromise(compute));
+      return;
+    }
+    DEBUG2 && log2("Signal.$compute$", result);
+    if (running.$infoVersion$ === this.$infoVersion$) {
+      this.$info$ = void 0;
+    }
+    this.$flags$ &= ~1 /* INVALID */;
+    this.untrackedError = void 0;
+    super.value = result;
+  }
+  /**
+   * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (useAsync$, useResource$)
+   * only track via its explicit track(). Computeds auto-track every synchronous read instead; after
+   * the first await they must use the explicit track() too.
+   */
+  $invokeComputeFn$(fn, job) {
+    const computeFn = fn;
+    if (this.$flags$ & 1024 /* CTX_ARG */) {
+      let iCtx = tryGetInvokeContext();
+      if (iCtx?.$effectSubscriber$) {
+        iCtx = { ...iCtx, $effectSubscriber$: void 0 };
+      }
+      return invokeApply(iCtx, computeFn, [job]);
+    }
+    const container = this.$container$ || (this.$container$ = tryGetInvokeContext()?.$container$ || null);
+    const subscriber = getSubscriber(this, "." /* VNODE */);
+    if (container) {
+      clearEffectSubscription(container, subscriber);
+    }
+    const ctx = newInvokeContext();
+    ctx.$container$ = container || void 0;
+    ctx.$effectSubscriber$ = subscriber;
+    return invokeApply(ctx, computeFn, [job]);
+  }
+  /** Start an async computation (the async engine; assumes the INVALID flag is set) */
+  $computeAsync$() {
     if ((qTest ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */) {
-      this.$untrackedLoading$ = true;
+      this.$untrackedPending$ = true;
       this.$container$?.serializationCtx.$eagerResume$.add(this);
       return;
     }
-    this.$clearNextPoll$();
     this.$flags$ &= ~1 /* INVALID */;
     const current = this.$current$;
     if (current) {
@@ -23073,13 +23098,13 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     }
     const limit = this.$concurrency$ === 0 ? Number.POSITIVE_INFINITY : this.$concurrency$ ?? 1;
     if (this.$jobs$ ? this.$jobs$.length >= limit : current?.$promise$) {
-      DEBUG3 && log3(`Concurrency limit ${limit} reached, not starting new computation`);
+      DEBUG2 && log2(`Concurrency limit ${limit} reached, not starting new computation`);
       this.$flags$ |= 1 /* INVALID */;
       return;
     }
-    DEBUG3 && log3("Starting new async computation");
+    DEBUG2 && log2("Starting new async computation");
     const infoVersion = this.$infoVersion$;
-    const running = new AsyncJob(this, this.$info$, infoVersion);
+    const running = new Job(this, this.$info$, infoVersion);
     this.$current$ = running;
     if (this.$jobs$) {
       this.$jobs$.push(running);
@@ -23087,29 +23112,36 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     running.$promise$ = this.$runComputation$(running);
   }
   async $runComputation$(running) {
-    const isCurrent = () => running === this.$current$;
     let fn = this.$computeQrl$.resolved;
     if (!fn) {
-      this.untrackedLoading = true;
+      this.untrackedPending = true;
       fn = await this.$computeQrl$.resolve();
       if (running.$abortController$?.signal.aborted) {
-        DEBUG3 && log3("Computation aborted before it started");
+        DEBUG2 && log2("Computation aborted before it started");
         running.$promise$ = null;
         return;
       }
     }
+    if (this.$timeoutMs$) {
+      this.$computationTimeoutId$ = setTimeout(() => {
+        const error = new Error(`timeout ${this.$timeoutMs$}ms`);
+        this.$setError$(running, error);
+        running.$abortController$?.abort(error);
+      }, this.$timeoutMs$);
+    }
+    return this.$settleComputation$(
+      running,
+      () => retryOnPromise(() => this.$invokeComputeFn$(fn, running))
+    );
+  }
+  /** Await the computation and publish its result, error, and loading transitions. */
+  async $settleComputation$(running, compute) {
+    const isCurrent = () => running === this.$current$;
     try {
-      if (this.$timeoutMs$) {
-        this.$computationTimeoutId$ = setTimeout(() => {
-          const error = new Error(`timeout ${this.$timeoutMs$}ms`);
-          this.$setError$(running, error);
-          running.$abortController$?.abort(error);
-        }, this.$timeoutMs$);
-      }
-      const valuePromise = retryOnPromise(fn.bind(null, running));
+      const valuePromise = compute();
       let value;
       if (isPromise(valuePromise)) {
-        this.untrackedLoading = true;
+        this.untrackedPending = true;
         value = await valuePromise;
       } else {
         value = valuePromise;
@@ -23127,13 +23159,13 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
             }
           }
         }
-        DEBUG3 && log3("Promise resolved", value);
+        DEBUG2 && log2("Promise resolved", value);
         this.untrackedError = void 0;
         super.value = value;
       }
     } catch (err) {
       running.$promise$ = null;
-      DEBUG3 && log3("Error caught in promise.catch", err);
+      DEBUG2 && log2("Error caught in promise.catch", err);
       this.$setError$(running, err);
     }
     if (isCurrent()) {
@@ -23142,11 +23174,10 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
         this.$info$ = void 0;
       }
       if (this.$flags$ & 1 /* INVALID */) {
-        DEBUG3 && log3("Computation finished but signal is invalid, re-running");
+        DEBUG2 && log2("Computation finished but signal is invalid, re-running");
         this.$computeIfNeeded$();
       } else {
-        this.untrackedLoading = false;
-        this.$scheduleNextPoll$();
+        this.untrackedPending = false;
       }
     }
   }
@@ -23167,7 +23198,6 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
   }
   /** Called after SSR/unmount */
   async $destroy$() {
-    this.$clearNextPoll$();
     clearTimeout(this.$computationTimeoutId$);
     const current = this.$current$;
     if (current) {
@@ -23179,25 +23209,6 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
       await current?.$promise$;
     }
   }
-  $clearNextPoll$() {
-    if (this.$pollTimeoutId$ !== void 0) {
-      clearTimeout(this.$pollTimeoutId$);
-      this.$pollTimeoutId$ = void 0;
-    }
-  }
-  $scheduleNextPoll$() {
-    if ((qTest ? isServerPlatform() : isServer5) || !this.$expires$) {
-      return;
-    }
-    this.$clearNextPoll$();
-    const allowRecalc = !(this.$flags$ & 256 /* NO_POLL */);
-    const mustClear = this.$flags$ & 128 /* CLEAR_ON_INVALIDATE */ && !allowRecalc;
-    this.$pollTimeoutId$ = setTimeout(
-      () => this.$setInvalid$(allowRecalc, mustClear),
-      this.$expires$
-    );
-    this.$pollTimeoutId$?.unref?.();
-  }
   $hasSubscribers$() {
     return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
   }
@@ -23205,15 +23216,14 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     if (job.$cleanupRequested$) {
       return;
     }
-    DEBUG3 && log3("Requesting cleanups for job", job);
+    DEBUG2 && log2("Requesting cleanups for job", job);
     job.$cleanupRequested$ = true;
     job.$abortController$?.abort(reason);
     job.$promise$ = maybeThen(job.$promise$, () => this.$runCleanups$(job));
   }
-  /** Clean up and trigger signal compute once complete */
-  $runCleanups$(job) {
+  /** Run a job's cleanup callbacks, returning a promise when any of them are async. */
+  $runCleanupCallbacks$(job) {
     const cleanups = job.$cleanups$;
-    DEBUG3 && log3("cleanup start", job);
     const onError = (err) => {
       const handleError = this.$container$?.handleError;
       if (handleError) {
@@ -23222,24 +23232,9 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
         console.error("Error in async signal cleanup", err);
       }
     };
-    const onDone = () => {
-      job.$promise$ = null;
-      if (cleanups) {
-        cleanups.length = 0;
-      }
-      DEBUG3 && log3("cleanup finished", job);
-      const jobs = this.$jobs$;
-      if (jobs) {
-        const idx = jobs.indexOf(job);
-        if (idx !== -1) {
-          jobs.splice(idx, 1);
-        }
-      }
-      this.$computeIfNeeded$();
-    };
     let promiseChain = void 0;
     if (cleanups) {
-      DEBUG3 && log3("cleanup start for real", job);
+      DEBUG2 && log2("cleanup start for real", job);
       for (let i2 = 0; i2 < cleanups.length; i2++) {
         try {
           const result = cleanups[i2]();
@@ -23250,7 +23245,26 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
           onError(err);
         }
       }
+      cleanups.length = 0;
     }
+    return promiseChain;
+  }
+  /** Clean up and trigger signal compute once complete */
+  $runCleanups$(job) {
+    DEBUG2 && log2("cleanup start", job);
+    const onDone = () => {
+      job.$promise$ = null;
+      DEBUG2 && log2("cleanup finished", job);
+      const jobs = this.$jobs$;
+      if (jobs) {
+        const idx = jobs.indexOf(job);
+        if (idx !== -1) {
+          jobs.splice(idx, 1);
+        }
+      }
+      this.$computeIfNeeded$();
+    };
+    const promiseChain = this.$runCleanupCallbacks$(job);
     if (promiseChain) {
       return promiseChain.then(onDone);
     } else {
@@ -23279,8 +23293,8 @@ var implicit$FirstArg = (fn) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/serializer-signal-impl.ts
-var DEBUG4 = false;
-var log4 = (...args) => console.log("SERIALIZER SIGNAL", ...args.map(qwikDebugToString));
+var DEBUG3 = false;
+var log3 = (...args) => console.log("SERIALIZER SIGNAL", ...args.map(qwikDebugToString));
 var SerializerSignalImpl = class extends ComputedSignalImpl {
   constructor(container, argQrl) {
     super(
@@ -23307,7 +23321,7 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
     );
     this.$didInitialize$ = true;
     this.$flags$ &= ~1 /* INVALID */;
-    DEBUG4 && log4("SerializerSignal.$compute$", untrackedValue);
+    DEBUG3 && log3("SerializerSignal.$compute$", untrackedValue);
     const didChange = this.$didInitialize$ && untrackedValue !== "undefined" || untrackedValue !== this.$untrackedValue$;
     if (didChange) {
       this.$untrackedValue$ = untrackedValue;
@@ -23316,6 +23330,13 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
   }
 };
 
+// packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
+var AsyncSignalImpl = class extends ComputedSignalImpl {
+  constructor(container, fn, flags = 1 /* INVALID */ | 16 /* SERIALIZATION_STRATEGY_ALWAYS */, options) {
+    super(container, fn, flags | 512 /* ASYNC_MODE */ | 1024 /* CTX_ARG */, options);
+  }
+};
+
 // packages/qwik/src/core/reactive-primitives/signal-api.ts
 var createSerializerSignal = (arg) => {
   return new SerializerSignalImpl(null, arg);
@@ -23433,8 +23454,11 @@ function setCursorPosition(container, cursorData, position) {
   }
 }
 function mergeCursors(container, newCursorData, oldCursor) {
-  removeCursorFromQueue(oldCursor, container);
   const oldCursorData = getCursorData(oldCursor);
+  if (!oldCursorData || oldCursorData === newCursorData) {
+    return;
+  }
+  removeCursorFromQueue(oldCursor, container);
   mergeCursorData(newCursorData, oldCursorData);
 }
 function mergeCursorData(newCursorData, oldCursorData) {
@@ -23493,7 +23517,7 @@ function setCursorData(vNode, cursorData) {
 }
 
 // packages/qwik/src/core/client/vnode-diff.ts
-import { isDev as isDev14 } from "@qwik.dev/core/build";
+import { isDev as isDev13 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscription-data.ts
 var SubscriptionData = class {
@@ -23504,11 +23528,11 @@ var SubscriptionData = class {
 };
 
 // packages/qwik/src/core/shared/component.public.ts
-import { isDev as isDev12 } from "@qwik.dev/core/build";
+import { isDev as isDev11 } from "@qwik.dev/core/build";
 var componentQrl = (componentQrl3) => {
   function QwikComponent(props, key, flags = 0) {
-    isDev12 && assertQrl(componentQrl3);
-    isDev12 && assertNumber(flags, "The Qwik Component was not invoked correctly");
+    isDev11 && assertQrl(componentQrl3);
+    isDev11 && assertNumber(flags, "The Qwik Component was not invoked correctly");
     const hash = qTest ? "sX" : componentQrl3.$hash$.slice(0, 4);
     const finalKey = hash + ":" + (key ? key : "");
     const InnerCmp = () => {
@@ -23538,9 +23562,9 @@ var isObjectEmpty = (obj) => {
 var _hasOwnProperty = Object.prototype.hasOwnProperty;
 var JSXNodeImpl = class {
   constructor(type, varProps, constProps, children, flags, key, toSort, dev) {
-    this.type = type;
-    this.children = children;
-    this.flags = flags;
+    __publicField(this, "type", type);
+    __publicField(this, "children", children);
+    __publicField(this, "flags", flags);
     __publicField(this, "toSort");
     __publicField(this, "key");
     __publicField(this, "varProps");
@@ -23603,9 +23627,9 @@ var SSRRaw = () => null;
 var SSRComment = () => null;
 
 // packages/qwik/src/core/client/vnode-namespace.ts
-import { isDev as isDev13 } from "@qwik.dev/core/build";
+import { isDev as isDev12 } from "@qwik.dev/core/build";
 var isForeignObjectElement = (elementName) => {
-  return isDev13 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
+  return isDev12 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
 };
 var isSvgElement = (elementName) => elementName === "svg" || isForeignObjectElement(elementName);
 var isMathElement = (elementName) => elementName === "math";
@@ -24010,6 +24034,12 @@ var VNodeDataChar = {
     /* ** */
     "<"
   ),
+  RENDER_HASH_PREFIX: (
+    /* **/
+    95
+  ),
+  // `_` after `<` identifies a component hash.
+  RENDER_HASH_PREFIX_CHAR: "_",
   ID: (
     /* ***************** */
     61
@@ -24399,34 +24429,34 @@ function isAriaAttribute(prop) {
 // packages/qwik/src/core/shared/vnode/types/dom-vnode-operation.ts
 var DeleteOperation = class {
   constructor(target) {
-    this.target = target;
+    __publicField(this, "target", target);
   }
 };
 var RemoveAllChildrenOperation = class {
   constructor(target) {
-    this.target = target;
+    __publicField(this, "target", target);
   }
 };
 var SetTextOperation = class {
   constructor(target, text) {
-    this.target = target;
-    this.text = text;
+    __publicField(this, "target", target);
+    __publicField(this, "text", text);
   }
 };
 var InsertOrMoveOperation = class {
   constructor(target, parent, beforeTarget) {
-    this.target = target;
-    this.parent = parent;
-    this.beforeTarget = beforeTarget;
+    __publicField(this, "target", target);
+    __publicField(this, "parent", parent);
+    __publicField(this, "beforeTarget", beforeTarget);
   }
 };
 var SetAttributeOperation = class {
   constructor(target, attrName, attrValue, scopedStyleIdPrefix, isSvg2) {
-    this.target = target;
-    this.attrName = attrName;
-    this.attrValue = attrValue;
-    this.scopedStyleIdPrefix = scopedStyleIdPrefix;
-    this.isSvg = isSvg2;
+    __publicField(this, "target", target);
+    __publicField(this, "attrName", attrName);
+    __publicField(this, "attrValue", attrValue);
+    __publicField(this, "scopedStyleIdPrefix", scopedStyleIdPrefix);
+    __publicField(this, "isSvg", isSvg2);
   }
 };
 var createDeleteOperation = (target) => new DeleteOperation(target);
@@ -24440,14 +24470,14 @@ function addCursorBoundary(cursorData, vNode) {
   if (!__EXPERIMENTAL__.suspense) {
     return;
   }
-  const boundary = getNearestCursorBoundary(cursorData.container, vNode);
+  const boundary = getNearestCursorBoundary(vNode);
   if (!boundary) {
     return;
   }
   const boundaries = cursorData.boundaries || (cursorData.boundaries = []);
   if (!boundaries.includes(boundary)) {
     boundaries.push(boundary);
-    boundary.pending.value++;
+    boundary.value++;
   }
 }
 function resolveCursorBoundaries(cursorData) {
@@ -24461,38 +24491,33 @@ function resolveCursorBoundaries(cursorData) {
   cursorData.boundaries = null;
   for (let i2 = 0; i2 < boundaries.length; i2++) {
     const boundary = boundaries[i2];
-    boundary.pending.value = Math.max(0, boundary.pending.value - 1);
-    boundary.version.value++;
+    boundary.value = Math.max(0, boundary.value - 1);
   }
 }
-function getOwnCursorBoundary(container, vNode) {
+function getOwnCursorBoundary(vNode) {
   if (!__EXPERIMENTAL__.suspense) {
     return null;
   }
-  return container.getHostProp(vNode, QCursorBoundary);
-}
-function getNearestCursorBoundaryProp(vNode) {
-  if (!__EXPERIMENTAL__.suspense) {
-    return null;
-  }
-  return vnode_getProp(vNode, NEAREST_CURSOR_BOUNDARY, null) || null;
+  return vnode_getProp(vNode, QCursorBoundary, null) || null;
 }
 function clearNearestCursorBoundary(vNode) {
-  if (!__EXPERIMENTAL__.suspense) {
-    return;
-  }
-  vnode_setProp(vNode, NEAREST_CURSOR_BOUNDARY, null);
+  setNearestCursorBoundary(vNode, null);
 }
-function getNearestCursorBoundary(container, vNode) {
+function getNearestCursorBoundary(vNode) {
   if (!__EXPERIMENTAL__.suspense) {
     return null;
   }
-  return getNearestCursorBoundaryProp(vNode) || getOwnCursorBoundary(container, vNode);
+  return vnode_getProp(vNode, NEAREST_CURSOR_BOUNDARY, null) || getOwnCursorBoundary(vNode);
 }
 function setNearestCursorBoundary(vNode, boundary) {
   __EXPERIMENTAL__.suspense && vnode_setProp(vNode, NEAREST_CURSOR_BOUNDARY, boundary);
 }
-function updateDirtySubtreeCursorBoundary(container, vNode, boundary) {
+function clearCursorBoundary(vNode) {
+  if (__EXPERIMENTAL__.suspense && vNode.props && QCursorBoundary in vNode.props) {
+    vnode_setProp(vNode, QCursorBoundary, null);
+  }
+}
+function updateDirtySubtreeCursorBoundary(vNode, boundary) {
   if (!__EXPERIMENTAL__.suspense) {
     return;
   }
@@ -24503,11 +24528,7 @@ function updateDirtySubtreeCursorBoundary(container, vNode, boundary) {
   }
   for (let i2 = 0; i2 < dirtyChildren.length; i2++) {
     const child = dirtyChildren[i2];
-    updateDirtySubtreeCursorBoundary(
-      container,
-      child,
-      getOwnCursorBoundary(container, child) || boundary
-    );
+    updateDirtySubtreeCursorBoundary(child, getOwnCursorBoundary(child) || boundary);
   }
 }
 
@@ -24664,8 +24685,8 @@ function runDiff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChil
 }
 function diff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(vStartNode), vEnd = null, forceCreationMode = false) {
   const previousCreationMode = diffContext.$isCreationMode$;
-  isDev14 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
-  isDev14 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
+  isDev13 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
+  isDev13 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
   diffContext.$isCreationMode$ = forceCreationMode || previousCreationMode;
   diffContext.$vParent$ = vStartNode;
   diffContext.$vNewNode$ = null;
@@ -24679,7 +24700,7 @@ function diff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(v
     }
     while (diffContext.$stack$.length) {
       while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
-        isDev14 && assertFalse(
+        isDev13 && assertFalse(
           diffContext.$vParent$ === diffContext.$vCurrent$,
           "Parent and current can't be the same"
         );
@@ -24720,9 +24741,8 @@ function diff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(v
                   diffContext,
                   diffContext.$jsxValue$.children,
                   true,
-                  // special case for projection, we don't want to expect no children
-                  // because the projection's children are not removed
-                  false
+                  /* isProjection */
+                  true
                 );
               } else if (type === SSRComment) {
                 expectNoMore(diffContext);
@@ -24811,18 +24831,22 @@ function advance(diffContext) {
     diffContext.$vCurrent$ = peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$);
   }
 }
-function descend(diffContext, children, descendVNode, shouldExpectNoChildren = true) {
-  if (shouldExpectNoChildren && (children == null || descendVNode && isArray(children) && children.length === 0)) {
+function descend(diffContext, children, descendVNode, isProjection = false) {
+  if (!isProjection && (children == null || descendVNode && isArray(children) && children.length === 0)) {
     expectNoChildren(diffContext);
     return;
   }
   stackPush(diffContext, children, descendVNode);
   if (descendVNode) {
-    isDev14 && assertDefined(
+    isDev13 && assertDefined(
       diffContext.$vCurrent$ || diffContext.$vNewNode$,
       "Expecting vCurrent to be defined."
     );
-    const creationMode = diffContext.$isCreationMode$ || !!diffContext.$vNewNode$ || !vnode_getFirstChild(diffContext.$vCurrent$);
+    const creationMode = (
+      // a projection keeps its children across re-renders, so it never inherits
+      // creation mode from a not-yet-rendered host; create only if new or empty
+      !isProjection && diffContext.$isCreationMode$ || !!diffContext.$vNewNode$ || !vnode_getFirstChild(diffContext.$vCurrent$)
+    );
     diffContext.$isCreationMode$ = creationMode;
     diffContext.$vSideBuffer$ = null;
     diffContext.$vSiblings$ = null;
@@ -24945,8 +24969,8 @@ function expectProjection(diffContext) {
   diffContext.$vCurrent$ = diffContext.$vCurrent$ && diffContext.$vCurrent$.flags & 32 /* Deleted */ ? null : diffContext.$vCurrent$;
   if (diffContext.$vCurrent$ == null) {
     diffContext.$vNewNode$ = vnode_newVirtual();
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, "q:code", "expectProjection");
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, "q:code", "expectProjection");
     vnode_setProp(diffContext.$vNewNode$, QSlot, slotName);
     diffContext.$vNewNode$.slotParent = diffContext.$vParent$;
     vnode_setProp(diffContext.$vParent$, slotName, diffContext.$vNewNode$);
@@ -24969,13 +24993,9 @@ function expectSlot(diffContext) {
     diffContext.$vNewNode$ = vnode_newVirtual();
     vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
     vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
-    updateDirtySubtreeCursorBoundary(
-      diffContext.$container$,
-      diffContext.$vNewNode$,
-      cursorBoundary
-    );
+    updateDirtySubtreeCursorBoundary(diffContext.$vNewNode$, cursorBoundary);
     vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
       diffContext.$journal$,
       diffContext.$vParent$,
@@ -24989,13 +25009,9 @@ function expectSlot(diffContext) {
     diffContext.$vNewNode$ = vProjectedNode;
     vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
     vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
-    updateDirtySubtreeCursorBoundary(
-      diffContext.$container$,
-      diffContext.$vNewNode$,
-      cursorBoundary
-    );
+    updateDirtySubtreeCursorBoundary(diffContext.$vNewNode$, cursorBoundary);
     vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* Projection */);
     vnode_inflateProjectionTrailingText(
       diffContext.$journal$,
       diffContext.$vNewNode$
@@ -25077,7 +25093,7 @@ function expectNoChildren(diffContext, removeDOM = true) {
 }
 function expectNoMore(diffContext) {
   const boundary = getLevelBoundary(diffContext);
-  isDev14 && assertFalse(
+  isDev13 && assertFalse(
     diffContext.$vParent$ === diffContext.$vCurrent$,
     "Parent and current can't be the same"
   );
@@ -25138,7 +25154,7 @@ function applyConstInnerHtml(element, value) {
 }
 function applyConstTextareaValue(element, value, currentFile) {
   if (value && typeof value !== "string") {
-    if (isDev14) {
+    if (isDev13) {
       throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
     }
     return true;
@@ -25273,7 +25289,7 @@ function expectElement(diffContext, jsx2, elementName) {
   const jsxProps = jsx2.varProps;
   const vNode = diffContext.$vNewNode$ || diffContext.$vCurrent$;
   if (jsxProps) {
-    diffProps(diffContext, vNode, jsxProps, isDev14 && getFileLocationFromJsx(jsx2.dev) || null);
+    diffProps(diffContext, vNode, jsxProps, isDev13 && getFileLocationFromJsx(jsx2.dev) || null);
   }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
@@ -25281,14 +25297,17 @@ function diffProps(diffContext, vnode, newAttrs, currentFile) {
     vnode_ensureElementInflated(diffContext.$container$, vnode);
   }
   const oldAttrs = vnode.props;
+  const isHtml = (vnode.flags & 1536 /* NAMESPACE_MASK */) === 0 /* NS_html */;
   for (const key in newAttrs) {
     const newValue = newAttrs[key];
-    if (oldAttrs && _hasOwnProperty3.call(oldAttrs, key)) {
-      const oldValue = oldAttrs[key];
-      if (newValue !== oldValue) {
-        if (newValue instanceof WrappedSignalImpl && oldValue instanceof WrappedSignalImpl && areWrappedSignalsEqual(newValue, oldValue)) {
-          continue;
-        }
+    const oldKey = oldAttrs && isHtml && !_hasOwnProperty3.call(oldAttrs, key) ? key.toLowerCase() : key;
+    if (oldAttrs && _hasOwnProperty3.call(oldAttrs, oldKey)) {
+      const oldValue = oldAttrs[oldKey];
+      if (oldKey !== key) {
+        vnode_setProp(vnode, oldKey, null);
+        vnode_setProp(vnode, key, oldValue);
+      }
+      if (!areDiffValuesEqual(newValue, oldValue)) {
         patchProperty(diffContext, vnode, key, newValue, currentFile);
       }
     } else if (newValue != null) {
@@ -25533,7 +25552,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       getInsertBefore(diffContext)
     );
     diffContext.$vNewNode$.key = jsxKey;
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
     return;
   }
   if (moveOrCreateKeyedNode(
@@ -25551,7 +25570,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       getInsertBefore(diffContext)
     );
     diffContext.$vNewNode$.key = jsxKey;
-    isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
+    isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
   }
 }
 function expectComponent(diffContext, component) {
@@ -25663,7 +25682,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.$jsxValue$;
-  isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* Component */);
+  isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* Component */);
   vnode_setProp(diffContext.$vNewNode$, OnRenderProp, componentQRL);
   vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxProps);
   diffContext.$vNewNode$.key = jsxNode.key;
@@ -25676,7 +25695,7 @@ function insertNewInlineComponent(diffContext) {
     getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.$jsxValue$;
-  isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* InlineComponent */);
+  isDev13 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* InlineComponent */);
   vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxNode.props);
   if (jsxNode.key) {
     diffContext.$vNewNode$.key = jsxNode.key;
@@ -25714,7 +25733,7 @@ function getComponentHash(vNode, getObject) {
     return null;
   }
   const qrl = vnode_getProp(vNode, OnRenderProp, getObject);
-  return qrl ? qrl.$hash$ : null;
+  return qrl ? qrl.$hash$ : vnode_getProp(vNode, QComponentHash, null);
 }
 function Projection() {
 }
@@ -25755,10 +25774,21 @@ function handleChangedProps(src, dst, propsHandler, container, triggerEffects =
       if (key === "children" || key === QBackRefs) {
         continue;
       }
-      if (!dst || src[key] !== dst[key]) {
+      const newValue = src[key];
+      const oldValue = dst?.[key];
+      if (!dst || !(areDiffValuesEqual(newValue, oldValue) || areSignalValuesEqual(newValue, oldValue))) {
+        if (key === "class") {
+          if (areClassValuesEqual(newValue, oldValue)) {
+            continue;
+          }
+        } else if (key === "style") {
+          if (areStyleValuesEqual(newValue, oldValue)) {
+            continue;
+          }
+        }
         if (triggerEffects) {
           if (dst) {
-            dst[key] = src[key];
+            dst[key] = newValue;
           }
           const didTigger = triggerPropsProxyEffect(propsHandler, key);
           if (!didTigger) {
@@ -25822,10 +25852,12 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
                 obj.$flags$ |= 16 /* NEEDS_CLEANUP */;
                 markVNodeDirty(container, vCursor, 128 /* CLEANUP */, cursorRoot);
                 continue;
-              } else if (obj instanceof SignalImpl || isStore(obj)) {
-                clearAllEffects(container, obj);
+              } else if (obj instanceof ComputedSignalImpl || obj instanceof WrappedSignalImpl) {
+                if (!(obj.$flags$ & 4 /* PRESERVE_ON_SEQ_CLEANUP */)) {
+                  clearAllEffects(container, obj);
+                }
               }
-              if (objIsTask || obj instanceof AsyncSignalImpl) {
+              if (objIsTask || obj instanceof ComputedSignalImpl && (obj.$flags$ & 512 /* ASYNC_MODE */ || obj.$current$)) {
                 cleanupDestroyable(obj);
               }
             }
@@ -25917,6 +25949,35 @@ function cleanupStaleUnclaimedProjection(container, journal, projection) {
 function markVNodeAsDeleted(vCursor) {
   vCursor.flags |= 32 /* Deleted */;
 }
+function areDiffValuesEqual(newValue, oldValue) {
+  if (newValue === oldValue) {
+    return true;
+  }
+  return newValue instanceof WrappedSignalImpl && oldValue instanceof WrappedSignalImpl && areWrappedSignalsEqual(oldValue, newValue);
+}
+function areSignalValuesEqual(newValue, oldValue) {
+  if (newValue === oldValue) {
+    return true;
+  }
+  if (isSignal(newValue) && isSignal(oldValue)) {
+    const unwrappedNew = newValue instanceof WrappedSignalImpl ? newValue.$unwrapIfSignal$() : newValue;
+    const unwrappedOld = oldValue instanceof WrappedSignalImpl ? oldValue.$unwrapIfSignal$() : oldValue;
+    return untrack(() => unwrappedNew.value === unwrappedOld.value);
+  }
+  return false;
+}
+function areStyleValuesEqual(newValue, oldValue) {
+  if (newValue === oldValue) {
+    return true;
+  }
+  return stringifyStyle(newValue) === stringifyStyle(oldValue);
+}
+function areClassValuesEqual(newValue, oldValue) {
+  if (newValue === oldValue) {
+    return true;
+  }
+  return serializeClass(newValue) === serializeClass(oldValue);
+}
 function areWrappedSignalsEqual(oldSignal, newSignal) {
   if (oldSignal === newSignal) {
     return true;
@@ -25951,7 +26012,7 @@ function containsWrappedSignal(data, signal) {
 }
 
 // packages/qwik/src/core/shared/component-execution.ts
-import { isDev as isDev15, isServer as isServer6 } from "@qwik.dev/core/build";
+import { isDev as isDev14, isServer as isServer6 } from "@qwik.dev/core/build";
 var executeComponent = (container, renderHost, subscriptionHost, componentQRL, props) => {
   const iCtx = newRenderInvokeContext(
     container.$locale$,
@@ -25967,7 +26028,7 @@ var executeComponent = (container, renderHost, subscriptionHost, componentQRL, p
   let isInlineComponent = false;
   if (componentQRL === null) {
     componentQRL = container.getHostProp(renderHost, OnRenderProp);
-    isDev15 && assertDefined(componentQRL, "No Component found at this location");
+    isDev14 && assertDefined(componentQRL, "No Component found at this location");
   }
   if (isQrl(componentQRL)) {
     props = props || container.getHostProp(renderHost, ELEMENT_PROPS) || EMPTY_OBJ;
@@ -26048,7 +26109,7 @@ function addUseOnEvents(container, jsx2, useOnEvents) {
             }
             targetElement = placeholderElement;
           } else {
-            if (isDev15) {
+            if (isDev14) {
               const sourceLocation = getUseOnSourceLocation(useOnEvents[key].qrls);
               logWarn(
                 'You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component outputs a DOM element.' + (sourceLocation ? ` Offending \`useOn\`: ${sourceLocation}.` : "")
@@ -26060,7 +26121,7 @@ function addUseOnEvents(container, jsx2, useOnEvents) {
         if (targetElement) {
           if (targetElement.type === "script" && key === qVisibleEvent) {
             eventKey = "q-d:qinit";
-            if (isDev15) {
+            if (isDev14) {
               const sourceLocation = getUseOnSourceLocation(useOnEvents[key].qrls);
               logWarn(
                 `You are trying to add the event "${key}" using the \`useVisibleTask$\` hook with the "intersection-observer" strategy, but this only works when the component outputs a DOM element. Falling back to "document-ready" instead.` + (sourceLocation ? ` Offending \`useVisibleTask$\`: ${sourceLocation}.` : "")
@@ -26147,7 +26208,7 @@ function findFirstElementNode(jsx2) {
 }
 function injectPlaceholderElement(jsx2, placeholder) {
   if (isJSXNode(jsx2)) {
-    if (jsx2.type !== Fragment && !isQwikComponent(jsx2.type)) {
+    if (jsx2.type !== Fragment) {
       return _jsxSorted(Fragment, null, null, [jsx2, placeholder], 0, null);
     }
     if (jsx2.children == null) {
@@ -26173,7 +26234,7 @@ function createPlaceholderScriptNode() {
 }
 
 // packages/qwik/src/core/client/reconcile-keyed-loop.ts
-import { isDev as isDev16 } from "@qwik.dev/core/build";
+import { isDev as isDev15 } from "@qwik.dev/core/build";
 function collectChildren(first, last = null) {
   const children = [];
   let child = first;
@@ -26188,7 +26249,7 @@ function collectChildren(first, last = null) {
 }
 function renderKeyedRow(item, index, key, renderItem) {
   const jsx2 = renderItem(item, index);
-  if (isDev16 && !isJSXNode(jsx2)) {
+  if (isDev15 && !isJSXNode(jsx2)) {
     throw new Error("Each item$ must return a single JSX node");
   }
   jsx2.key = key;
@@ -26414,7 +26475,7 @@ function reconcileKeyedLoopToParent(container, journal, parent, cursor, items, k
       );
       return maybeThen(result, () => {
         const firstInserted = firstInsertedBeforeAnchor(parent, anchor, blockLength);
-        if (isDev16 && !firstInserted) {
+        if (isDev15 && !firstInserted) {
           throw new Error("Failed to insert keyed loop block");
         }
         anchor = firstInserted;
@@ -26712,7 +26773,7 @@ function executeReconcile(vNode, container, journal, cursor) {
 }
 
 // packages/qwik/src/core/shared/cursor/cursor-flush.ts
-var DEBUG5 = false;
+var DEBUG4 = false;
 function executeFlushPhase(cursor, container) {
   const cursorData = getCursorData(cursor);
   const journal = cursorData.journal;
@@ -26730,7 +26791,7 @@ var fastInsertBefore = (insertBeforeParent, target, insertBefore) => {
   _insertBefore.call(insertBeforeParent, target, insertBefore);
 };
 function _flushJournal(journal) {
-  DEBUG5 && console.warn("walkCursor: flushing journal", vnode_journalToString(journal));
+  DEBUG4 && console.warn("walkCursor: flushing journal", vnode_journalToString(journal));
   let batchParent = null;
   let batchBefore = null;
   let batchNodes = null;
@@ -26839,7 +26900,7 @@ function executeAfterFlush(container, cursorData) {
     cursorData.afterFlushTasks = null;
     return;
   }
-  DEBUG5 && console.warn(
+  DEBUG4 && console.warn(
     "walkCursor: executeAfterFlush",
     visibleTasks.map((t) => t.$qrl$.$symbol$)
   );
@@ -26868,8 +26929,21 @@ var createMacroTask = (fn) => {
   let macroTask;
   if (typeof MessageChannel !== "undefined") {
     const channel = new MessageChannel();
+    let active = true;
     channel.port1.onmessage = () => fn();
-    macroTask = () => channel.port2.postMessage(null);
+    macroTask = () => {
+      if (active) {
+        channel.port2.postMessage(null);
+      }
+    };
+    macroTask.$destroy$ = () => {
+      if (active) {
+        active = false;
+        channel.port1.onmessage = null;
+        channel.port1.close();
+        channel.port2.close();
+      }
+    };
   } else {
     macroTask = () => setTimeout(fn);
   }
@@ -26877,8 +26951,8 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isDev as isDev17, isServer as isServer7 } from "@qwik.dev/core/build";
-var DEBUG6 = false;
+import { isDev as isDev16, isServer as isServer7 } from "@qwik.dev/core/build";
+var DEBUG5 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
 var isNextTickScheduled = false;
@@ -26914,7 +26988,7 @@ function walkCursor(cursor, until) {
     return;
   }
   const container = cursorData.container;
-  isDev17 && assertDefined(container, "Cursor container not found");
+  isDev16 && assertDefined(container, "Cursor container not found");
   if (!cursor.dirty) {
     finishWalk(container, cursor, cursorData, isRunningOnServer);
     return;
@@ -26923,8 +26997,8 @@ function walkCursor(cursor, until) {
   let currentVNode = null;
   let count = 0;
   while (currentVNode = cursorData.position) {
-    DEBUG6 && console.warn("walkCursor", currentVNode.toString());
-    if (DEBUG6 && count++ > 1e3) {
+    DEBUG5 && console.warn("walkCursor", currentVNode.toString());
+    if (DEBUG5 && count++ > 1e3) {
       throw new Error("Infinite loop detected in cursor walker");
     }
     if (cursorData.promise) {
@@ -26978,7 +27052,7 @@ function walkCursor(cursor, until) {
       container.handleError(error, currentVNode);
     }
     if (result && isPromise(result)) {
-      DEBUG6 && console.warn("walkCursor: blocking promise", currentVNode.toString());
+      DEBUG5 && console.warn("walkCursor: blocking promise", currentVNode.toString());
       addCursorBoundary(cursorData, currentVNode);
       const blockingPromise2 = result;
       cursorData.promise = blockingPromise2;
@@ -27002,20 +27076,21 @@ function walkCursor(cursor, until) {
       return true;
     }
   }
-  isDev17 && assertFalse(
+  isDev16 && assertFalse(
     !!(cursor.dirty & 1023 /* DIRTY_MASK */ && !cursorData.position),
     "Cursor is still dirty and position is not set after walking"
   );
   finishWalk(container, cursor, cursorData, isRunningOnServer);
 }
-function finishWalk(container, cursor, cursorData, isServer12) {
+function finishWalk(container, cursor, cursorData, isServer13) {
   if (!(cursor.dirty & 1023 /* DIRTY_MASK */)) {
     removeCursorFromQueue(cursor, container);
-    DEBUG6 && console.warn("walkCursor: cursor done", cursor.toString());
-    if (!isServer12) {
+    DEBUG5 && console.warn("walkCursor: cursor done", cursor.toString());
+    if (!isServer13) {
       executeFlushPhase(cursor, container);
     }
     resolveCursorBoundaries(cursorData);
+    clearCursorBoundary(cursor);
     if (cursorData.extraPromises) {
       Promise.all(cursorData.extraPromises).then(() => {
         resolveCursor(container);
@@ -27026,7 +27101,7 @@ function finishWalk(container, cursor, cursorData, isServer12) {
   }
 }
 function resolveCursor(container) {
-  DEBUG6 && console.warn(`walkCursor: cursor resolved, ${container.$pendingCount$} remaining`);
+  DEBUG5 && console.warn(`walkCursor: cursor resolved, ${container.$pendingCount$} remaining`);
   container.$checkPendingCount$();
 }
 function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
@@ -27104,10 +27179,7 @@ function getNextVNode(vNode, cursor, container) {
   return getNextVNode(parent, cursor, container);
 }
 function splitCursorBoundary(container, vNode) {
-  if (!__EXPERIMENTAL__.suspense) {
-    return false;
-  }
-  if (!vNode.props || !(QCursorBoundary in vNode.props) || !container.getHostProp(vNode, QCursorBoundary)) {
+  if (!getOwnCursorBoundary(vNode)) {
     return false;
   }
   if (!isCursor(vNode)) {
@@ -27118,6 +27190,10 @@ function splitCursorBoundary(container, vNode) {
 
 // packages/qwik/src/core/shared/cursor/cursor.ts
 function addCursor(container, root, priority) {
+  if (isCursor(root)) {
+    triggerCursors();
+    return root;
+  }
   const cursorData = {
     afterFlushTasks: null,
     extraPromises: null,
@@ -27161,15 +27237,15 @@ function propagatePath(target) {
     }
   }
 }
-function propagateToCursorRoot(container, vNode, cursorRoot) {
+function propagateToCursorRoot(vNode, cursorRoot) {
   reusablePath.push(vNode);
-  let cursorBoundary = getOwnCursorBoundary(container, vNode);
+  let cursorBoundary = getOwnCursorBoundary(vNode);
   let current = vNode.slotParent || vNode.parent;
   while (current) {
     const isDirty = current.dirty & 1023 /* DIRTY_MASK */;
     const currentIsCursor = isCursor(current);
     if (__EXPERIMENTAL__.suspense) {
-      cursorBoundary || (cursorBoundary = getOwnCursorBoundary(container, current) || (isDirty ? getNearestCursorBoundary(container, current) : null));
+      cursorBoundary || (cursorBoundary = getOwnCursorBoundary(current) || (isDirty ? getNearestCursorBoundary(current) : null));
     }
     if (current === cursorRoot || isDirty) {
       setNearestCursorBoundary(vNode, cursorBoundary);
@@ -27195,14 +27271,14 @@ function propagateToCursorRoot(container, vNode, cursorRoot) {
   reusablePath.length = 0;
   throwErrorAndStop("Cursor root not found in current path!");
 }
-function findAndPropagateToBlockingCursor(container, vNode) {
+function findAndPropagateToBlockingCursor(vNode) {
   reusablePath.push(vNode);
-  let cursorBoundary = __EXPERIMENTAL__.suspense ? getOwnCursorBoundary(container, vNode) : null;
+  let cursorBoundary = getOwnCursorBoundary(vNode);
   let current = vNode.slotParent || vNode.parent;
   while (current) {
     const currentIsCursor = isCursor(current);
     if (__EXPERIMENTAL__.suspense) {
-      cursorBoundary || (cursorBoundary = getOwnCursorBoundary(container, current) || (currentIsCursor ? getNearestCursorBoundary(container, current) : null));
+      cursorBoundary || (cursorBoundary = getOwnCursorBoundary(current) || (currentIsCursor ? getNearestCursorBoundary(current) : null));
     }
     if (currentIsCursor) {
       setNearestCursorBoundary(vNode, cursorBoundary);
@@ -27228,7 +27304,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if (isPromise(result)) {
       container.$renderPromise$ = container.$renderPromise$ ? container.$renderPromise$.then(() => result) : result;
     }
-    return;
+    return result;
   }
   const isRealDirty = bits & 1023 /* DIRTY_MASK */;
   if ((isRealDirty ? prevDirty & 1023 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
@@ -27236,13 +27312,13 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
   }
   const parent = vNode.slotParent || vNode.parent;
   if (cursorRoot && isRealDirty && parent && !parent.dirty) {
-    propagateToCursorRoot(container, vNode, cursorRoot);
+    propagateToCursorRoot(vNode, cursorRoot);
     return;
   }
   if (parent && parent.dirty & 1023 /* DIRTY_MASK */) {
     setNearestCursorBoundary(
       vNode,
-      getOwnCursorBoundary(container, vNode) || getNearestCursorBoundary(container, parent)
+      getOwnCursorBoundary(vNode) || getNearestCursorBoundary(parent)
     );
     if (isRealDirty) {
       parent.dirty |= 64 /* CHILDREN */;
@@ -27268,11 +27344,11 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
       }
     }
   } else if (!isCursor(vNode)) {
-    if (!findAndPropagateToBlockingCursor(container, vNode)) {
+    if (!findAndPropagateToBlockingCursor(vNode)) {
       addCursor(container, vNode, 0);
     }
   } else {
-    setNearestCursorBoundary(vNode, getOwnCursorBoundary(container, vNode));
+    setNearestCursorBoundary(vNode, getOwnCursorBoundary(vNode));
   }
 }
 function addVNodeOperation(journal, operation) {
@@ -27280,10 +27356,10 @@ function addVNodeOperation(journal, operation) {
 }
 
 // packages/qwik/src/core/reactive-primitives/impl/wrapped-signal-impl.ts
-import { isDev as isDev18 } from "@qwik.dev/core/build";
-var _a4, _b3;
-var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a4 = _EFFECT_BACK_REF, _b3) {
-  constructor(container, fn, args, fnStr, flags = 1 /* INVALID */ | 4 /* UNWRAP */) {
+import { isDev as isDev17 } from "@qwik.dev/core/build";
+var _a3, _b2;
+var WrappedSignalImpl = class extends (_b2 = SignalImpl, _a3 = _EFFECT_BACK_REF, _b2) {
+  constructor(container, fn, args, fnStr, flags = 1 /* INVALID */) {
     super(container, NEEDS_COMPUTATION);
     __publicField(this, "$args$");
     __publicField(this, "$func$");
@@ -27292,7 +27368,7 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a4 = _EFFECT_BACK_REF,
     __publicField(this, "$hostElement$");
     // important: don't use implemnets BackRef here
     // it causes v8 optimizations eager bailouts, because of not consistent class shape
-    __publicField(this, _a4);
+    __publicField(this, _a3);
     this.$args$ = args;
     this.$func$ = fn;
     this.$funcStr$ = fnStr;
@@ -27315,7 +27391,7 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a4 = _EFFECT_BACK_REF,
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev18 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev17 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -27368,10 +27444,11 @@ function clearEffectSubscription(container, effect) {
     return;
   }
   for (const producer of backRefs) {
-    if (producer instanceof AsyncSignalImpl) {
-      clearAsyncSignal(producer, effect);
-    } else if (producer instanceof SignalImpl) {
+    if (producer instanceof SignalImpl) {
       clearSignal(container, producer, effect);
+      if (producer instanceof ComputedSignalImpl) {
+        clearAsyncSignalEffects(producer, effect);
+      }
     } else if (isPropsProxy(producer)) {
       const propsHandler = producer[_PROPS_HANDLER];
       clearStoreOrProps(propsHandler, effect);
@@ -27393,11 +27470,7 @@ function clearSignal(container, producer, effect) {
     clearAllEffects(container, producer);
   }
 }
-function clearAsyncSignal(producer, effect) {
-  const effects = producer.$effects$;
-  if (effects && effects.has(effect)) {
-    effects.delete(effect);
-  }
+function clearAsyncSignalEffects(producer, effect) {
   const pendingEffects = producer.$loadingEffects$;
   if (pendingEffects && pendingEffects.has(effect)) {
     pendingEffects.delete(effect);
@@ -27467,14 +27540,13 @@ var runTask = (task, container, host) => {
   return result;
 };
 var Task = class extends BackRef {
-  constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+  constructor($flags$, $index$, $el$, $qrl$, $destroy$) {
     super();
-    this.$flags$ = $flags$;
-    this.$index$ = $index$;
-    this.$el$ = $el$;
-    this.$qrl$ = $qrl$;
-    this.$state$ = $state$;
-    this.$destroy$ = $destroy$;
+    __publicField(this, "$flags$", $flags$);
+    __publicField(this, "$index$", $index$);
+    __publicField(this, "$el$", $el$);
+    __publicField(this, "$qrl$", $qrl$);
+    __publicField(this, "$destroy$", $destroy$);
     __publicField(this, "$destroyPromise$");
     __publicField(this, "$taskPromise$", null);
   }
@@ -27484,7 +27556,7 @@ var isTask = (value) => {
 };
 
 // packages/qwik/src/core/shared/cursor/ssr-chore-execution.ts
-import { isDev as isDev19 } from "@qwik.dev/core/build";
+import { isDev as isDev18 } from "@qwik.dev/core/build";
 function _executeSsrChores(container, ssrNode) {
   if (!(ssrNode.flags & 1 /* Updatable */)) {
     if (ssrNode.dirty & 16 /* NODE_PROPS */) {
@@ -27493,7 +27565,8 @@ function _executeSsrChores(container, ssrNode) {
     if (ssrNode.dirty & 32 /* COMPUTE */) {
       executeCompute(ssrNode, container);
     }
-    if (isDev19 && ssrNode.dirty & 1023 /* DIRTY_MASK */) {
+    if (isDev18 && ssrNode.dirty & 1023 /* DIRTY_MASK */ && !(ssrNode.flags & 2 /* WarnedStreamedChore */)) {
+      ssrNode.flags |= 2 /* WarnedStreamedChore */;
       const warningMessage = `A chore was scheduled on a host element that has already been streamed to the client.
         This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).
         
@@ -27592,29 +27665,34 @@ var getAsyncLocalStorage = () => {
 };
 
 // packages/qwik/src/core/shared/jsx/bind-handlers.ts
-var maybeScopeFromQL = (captureIds, element) => {
-  if (typeof captureIds === "string") {
+var withScopeFromQL = (captureDeltas, element, callback) => {
+  if (typeof captureDeltas === "string") {
     const container = getDomContainer(element);
-    setCaptures(deserializeCaptures(container, captureIds));
+    return whenContainerDataReady(container, () => {
+      setCaptures(deserializeCaptureDeltas(container, captureDeltas));
+      return callback();
+    });
   }
-  return null;
+  return callback();
 };
 function _val(_, element) {
-  maybeScopeFromQL(this, element);
-  const signal = _captures[0];
-  signal.value = element.type === "number" ? element.valueAsNumber : element.value;
+  return withScopeFromQL(this, element, () => {
+    const signal = _captures[0];
+    signal.value = element.type === "number" ? element.valueAsNumber : element.value;
+  });
 }
 function _chk(_, element) {
-  maybeScopeFromQL(this, element);
-  const signal = _captures[0];
-  signal.value = element.checked;
+  return withScopeFromQL(this, element, () => {
+    const signal = _captures[0];
+    signal.value = element.checked;
+  });
 }
 
 // packages/qwik/src/core/shared/serdes/subscription-patch.ts
 var SubscriptionPatch = class {
   constructor(rootId = 0, subscriptions = /* @__PURE__ */ new Set()) {
-    this.rootId = rootId;
-    this.subscriptions = subscriptions;
+    __publicField(this, "rootId", rootId);
+    __publicField(this, "subscriptions", subscriptions);
   }
 };
 
@@ -27631,6 +27709,7 @@ var stringifyRootRefPath = (path) => {
 };
 var writeStringRootRef = (writer, id) => writer.write(String(id));
 var writeStringRootRefPath = (writer, path) => writer.write(stringifyRootRefPath(path));
+var writeStringRootRefDelta = (writer, id, base2) => writer.write(String(id - base2));
 var createStringStreamWriter = (write) => ({
   write,
   writeRootRef(id) {
@@ -27638,11 +27717,14 @@ var createStringStreamWriter = (write) => ({
   },
   writeRootRefPath(path) {
     return writeStringRootRefPath(this, path);
+  },
+  writeRootRefDelta(id, base2) {
+    return writeStringRootRefDelta(this, id, base2);
   }
 });
 
 // packages/qwik/src/core/shared/serdes/serialize.ts
-import { isDev as isDev20 } from "@qwik.dev/core/build";
+import { isDev as isDev19 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/ssr-const.ts
 var LT = "<";
@@ -27661,7 +27743,7 @@ var COMMA = ",";
 // packages/qwik/src/core/shared/serdes/serialize.ts
 var Serializer = class {
   constructor($serializationContext$) {
-    this.$serializationContext$ = $serializationContext$;
+    __publicField(this, "$serializationContext$", $serializationContext$);
     __publicField(this, "$rootIdx$", 0);
     __publicField(this, "$forwardRefs$", []);
     __publicField(this, "$forwardRefsId$", 0);
@@ -27782,6 +27864,36 @@ var Serializer = class {
     }
     return Number(key);
   }
+  rebaseQrlCaptureDeltas$(baseRootId, captureDeltas) {
+    let previousCaptureId = 0;
+    let previousOutputBase = baseRootId;
+    const deltaList = captureDeltas.split(" ");
+    for (let i2 = 0; i2 < deltaList.length; i2++) {
+      const captureId = previousCaptureId + Number(deltaList[i2]);
+      deltaList[i2] = String(captureId - previousOutputBase);
+      previousCaptureId = captureId;
+      previousOutputBase = captureId;
+    }
+    return deltaList.join(" ");
+  }
+  outputShortStringConstant$(value) {
+    switch (value) {
+      case ":":
+        this.output(3 /* Constant */, 18 /* Colon */);
+        return true;
+      case ".":
+        this.output(3 /* Constant */, 19 /* Dot */);
+        return true;
+      case "id":
+        this.output(3 /* Constant */, 20 /* Id */);
+        return true;
+      case "ref":
+        this.output(3 /* Constant */, 21 /* Ref */);
+        return true;
+      default:
+        return false;
+    }
+  }
   outputString(value) {
     const s = this.stringNeedsJsonEscape$(value) ? JSON.stringify(value) : QUOTE + value + QUOTE;
     let angleBracketIdx = -1;
@@ -27799,6 +27911,9 @@ var Serializer = class {
   writeRootRefPath(path) {
     this.$writer$.writeRootRefPath(path);
   }
+  writeRootRefDelta(id, base2) {
+    this.$writer$.writeRootRefDelta(id, base2);
+  }
   outputStringChunks(chunks) {
     this.$writer$.write(QUOTE);
     for (let i2 = 0; i2 < chunks.length; i2++) {
@@ -27807,6 +27922,8 @@ var Serializer = class {
         this.$writer$.write(chunk);
       } else if (typeof chunk === "number") {
         this.writeRootRef(chunk);
+      } else if ("base" in chunk) {
+        this.writeRootRefDelta(chunk.id, chunk.base);
       } else {
         this.writeRootRefPath(chunk.path);
       }
@@ -27914,6 +28031,8 @@ var Serializer = class {
         case "string":
           if (value.length === 0) {
             this.output(3 /* Constant */, 4 /* EmptyString */);
+          } else if (this.outputShortStringConstant$(value)) {
+            break;
           } else {
             if (value.length < 4 || this.getSeenRefOrOutput(value, index)) {
               this.output(0 /* Plain */, value);
@@ -27945,29 +28064,38 @@ var Serializer = class {
             this.output(3 /* Constant */, 11 /* Fragment */);
           } else if (isQrl(value)) {
             if (this.getSeenRefOrOutput(value, index)) {
-              const [chunk, symbol, captures] = qrlToString(
+              const [chunk, symbol, captureDeltasFromZero] = qrlToString(
                 this.$serializationContext$,
                 value,
                 true
               );
               let data;
               if (chunk !== "") {
-                data = [
-                  this.$serializationContext$.$addRoot$(chunk),
-                  "#",
-                  this.$serializationContext$.$addRoot$(symbol)
-                ];
-                if (captures) {
-                  const captureIds = captures.split(" ");
+                const chunkRootId = this.$serializationContext$.$addRoot$(chunk);
+                const symbolRootId = this.$serializationContext$.$addRoot$(symbol);
+                const captureDeltas = captureDeltasFromZero ? this.rebaseQrlCaptureDeltas$(symbolRootId, captureDeltasFromZero) : null;
+                data = [chunkRootId, "#", { id: symbolRootId, base: chunkRootId }];
+                if (captureDeltasFromZero) {
+                  let previousRootId = 0;
+                  let previousOutputBase = symbolRootId;
+                  let start = 0;
                   data.push("#");
-                  for (let i2 = 0; i2 < captureIds.length; i2++) {
-                    if (i2 > 0) {
-                      data.push(" ");
+                  for (let i2 = 0; i2 <= captureDeltasFromZero.length; i2++) {
+                    if (i2 === captureDeltasFromZero.length || captureDeltasFromZero[i2] === " ") {
+                      if (i2 > start) {
+                        const captureId = previousRootId + Number(captureDeltasFromZero.slice(start, i2));
+                        if (start > 0) {
+                          data.push(" ");
+                        }
+                        data.push({ id: captureId, base: previousOutputBase });
+                        previousRootId = captureId;
+                        previousOutputBase = captureId;
+                      }
+                      start = i2 + 1;
                     }
-                    data.push(Number(captureIds[i2]));
                   }
                 }
-                const qrlKey = data.join("");
+                const qrlKey = `${chunkRootId}#${symbolRootId - chunkRootId}${captureDeltas ? "#" + captureDeltas : ""}`;
                 const existing = this.$qrlMap$.get(qrlKey);
                 if (existing) {
                   const ref = this.$serializationContext$.$addRoot$(existing);
@@ -28023,12 +28151,21 @@ var Serializer = class {
         value[_PROPS_HANDLER].$effects$
       ]);
     } else if (value instanceof SubscriptionData) {
-      this.output(39 /* SubscriptionData */, [
-        value.data.$scopedStyleIdPrefix$,
-        value.data.$isConst$
-      ]);
+      const { $scopedStyleIdPrefix$, $isConst$ } = value.data;
+      if ($scopedStyleIdPrefix$ === null) {
+        this.output(
+          $isConst$ ? 42 /* SubscriptionDataConstTrue */ : 43 /* SubscriptionDataConstFalse */,
+          0
+        );
+      } else {
+        this.output(39 /* SubscriptionData */, [$scopedStyleIdPrefix$, $isConst$]);
+      }
     } else if (value instanceof EffectSubscription) {
-      this.output(40 /* EffectSubscription */, [value.consumer, value.property, value.data]);
+      if (value.data === null) {
+        this.output(44 /* EffectSubscriptionNoData */, [value.consumer, value.property]);
+      } else {
+        this.output(40 /* EffectSubscription */, [value.consumer, value.property, value.data]);
+      }
     } else if (value instanceof SubscriptionPatch) {
       this.output(41 /* SubscriptionPatch */, [value.rootId, value.subscriptions]);
     } else if (isStore(value)) {
@@ -28080,7 +28217,7 @@ var Serializer = class {
             }
           }
         }
-        this.output(5 /* Object */, out.length ? out : 0);
+        this.output(5 /* Object */, out.length ? out : EMPTY_OBJECT_PAYLOAD);
       }
     } else if (this.$serializationContext$.$isDomRef$(value)) {
       this.$serializationContext$.$markSsrNodeForSerialization$(
@@ -28120,12 +28257,12 @@ var Serializer = class {
         const shouldNeverSerialize = value.$flags$ & 8 /* SERIALIZATION_STRATEGY_NEVER */;
         const isInvalid = value.$flags$ & 1 /* INVALID */;
         const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-        const isAsync = value instanceof AsyncSignalImpl;
-        const expires = isAsync && value.$expires$ !== 0 ? value.$expires$ : void 0;
+        const isAsync = !!(value.$flags$ & 512 /* ASYNC_MODE */);
+        const isErrored = isAsync && !!value.$untrackedError$;
         const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : void 0;
         const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : void 0;
         const asyncFlags = isAsync && value.$flags$ & ~24 /* SERIALIZATION_ALL_STRATEGIES */ || void 0;
-        if (isInvalid || isSkippable) {
+        if (isInvalid || isSkippable || isErrored) {
           v = NEEDS_COMPUTATION;
         } else if (shouldAlwaysSerialize) {
           v = value.$untrackedValue$;
@@ -28137,11 +28274,10 @@ var Serializer = class {
           out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
           out.push(asyncFlags || void 0);
         }
-        if (v !== NEEDS_COMPUTATION || expires !== void 0 || concurrency !== void 0 || timeout !== void 0) {
+        if (v !== NEEDS_COMPUTATION || concurrency !== void 0 || timeout !== void 0) {
           out.push(v === void 0 ? explicitUndefined : v);
         }
         if (isAsync) {
-          out.push(expires);
           out.push(concurrency);
           out.push(timeout);
         }
@@ -28158,28 +28294,12 @@ var Serializer = class {
       this.output(6 /* URL */, value.href);
     } else if (value instanceof Date) {
       this.output(7 /* Date */, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.Duration) {
-      this.output(15 /* TemporalDuration */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.Instant) {
-      this.output(16 /* TemporalInstant */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDate) {
-      this.output(17 /* TemporalPlainDate */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDateTime) {
-      this.output(18 /* TemporalPlainDateTime */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainMonthDay) {
-      this.output(19 /* TemporalPlainMonthDay */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainTime) {
-      this.output(20 /* TemporalPlainTime */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainYearMonth) {
-      this.output(21 /* TemporalPlainYearMonth */, value.toJSON());
-    } else if (this.$hasTemporal$ && value instanceof Temporal.ZonedDateTime) {
-      this.output(22 /* TemporalZonedDateTime */, value.toJSON());
     } else if (value instanceof RegExp) {
       this.output(8 /* Regex */, value.toString());
     } else if (value instanceof Error) {
       const out = [value.message];
       out.push(...Object.entries(value).flat());
-      if (isDev20) {
+      if (isDev19) {
         out.push("stack", value.stack);
       }
       this.output(23 /* Error */, out);
@@ -28233,7 +28353,7 @@ var Serializer = class {
       }
       this.output(37 /* JSXNode */, out);
     } else if (value instanceof Task) {
-      const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$state$];
+      const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$];
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
@@ -28277,6 +28397,22 @@ var Serializer = class {
         }
         this.output(2 /* ForwardRef */, this.getForwardRefId(forwardRefId));
       }
+    } else if (this.$hasTemporal$ && value instanceof Temporal.Duration) {
+      this.output(15 /* TemporalDuration */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.Instant) {
+      this.output(16 /* TemporalInstant */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDate) {
+      this.output(17 /* TemporalPlainDate */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDateTime) {
+      this.output(18 /* TemporalPlainDateTime */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainMonthDay) {
+      this.output(19 /* TemporalPlainMonthDay */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainTime) {
+      this.output(20 /* TemporalPlainTime */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainYearMonth) {
+      this.output(21 /* TemporalPlainYearMonth */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.ZonedDateTime) {
+      this.output(22 /* TemporalZonedDateTime */, value.toJSON());
     } else if (vnode_isVNode(value)) {
       this.output(3 /* Constant */, 0 /* Undefined */);
     } else {
@@ -28389,11 +28525,11 @@ var Serializer = class {
 };
 var PromiseResult = class {
   constructor($type$, $resolved$, $value$, $effects$ = void 0, $qrl$ = void 0) {
-    this.$type$ = $type$;
-    this.$resolved$ = $resolved$;
-    this.$value$ = $value$;
-    this.$effects$ = $effects$;
-    this.$qrl$ = $qrl$;
+    __publicField(this, "$type$", $type$);
+    __publicField(this, "$resolved$", $resolved$);
+    __publicField(this, "$value$", $value$);
+    __publicField(this, "$effects$", $effects$);
+    __publicField(this, "$qrl$", $qrl$);
   }
 };
 function getCustomSerializerPromise(signal, value) {
@@ -28426,7 +28562,7 @@ var discoverValuesForVNodeData = (vnodeData, callback) => {
     if (isSsrAttrs(value)) {
       for (const key in value) {
         const attrValue = value[key];
-        if (attrValue == null || typeof attrValue === "string" || typeof attrValue === "number" && key === ELEMENT_ID || key === ELEMENT_PROPS && isObjectEmpty(attrValue)) {
+        if (attrValue == null || typeof attrValue === "string" || typeof attrValue === "number" && key === ELEMENT_ID || key === ELEMENT_PROPS && (isObjectEmpty(attrValue) || shouldSkipComponentProps(value, attrValue))) {
           continue;
         }
         callback(attrValue);
@@ -28435,6 +28571,19 @@ var discoverValuesForVNodeData = (vnodeData, callback) => {
   }
 };
 var isSsrAttrs = (value) => typeof value === "object" && value !== null && !isObjectEmpty(value);
+var shouldSkipComponentProps = (attrs, value, isDevMode = isDev19) => {
+  if (isDevMode || !Object.prototype.hasOwnProperty.call(attrs, OnRenderProp)) {
+    return false;
+  }
+  const owner = value[_OWNER];
+  return isObjectEmpty(owner.varProps) && !hasPropsEffects(value) && !hasComponentBackRef(attrs[QBackRefs]);
+};
+var hasPropsEffects = (propsProxy) => {
+  return !!propsProxy[_PROPS_HANDLER].$effects$?.size;
+};
+var hasComponentBackRef = (backRefs) => {
+  return backRefs instanceof Map && backRefs.has(":" /* COMPONENT */);
+};
 function isObjectLiteral(obj) {
   const prototype = Object.getPrototypeOf(obj);
   return prototype == null || prototype === Object.prototype || prototype === Array.prototype;
@@ -28452,7 +28601,7 @@ function serializeWrappingFn(serializationContext, value) {
 }
 var SerializationWeakRef = class {
   constructor($obj$) {
-    this.$obj$ = $obj$;
+    __publicField(this, "$obj$", $obj$);
   }
 };
 var _serializationWeakRef = (obj) => new SerializationWeakRef(obj);
@@ -28461,17 +28610,17 @@ var _serializationWeakRef = (obj) => new SerializationWeakRef(obj);
 var isDomRef = (obj) => false;
 var SerializationBackRef = class {
   constructor($path$) {
-    this.$path$ = $path$;
+    __publicField(this, "$path$", $path$);
   }
 };
 var SerializationContextImpl = class {
   constructor(NodeConstructor, DomRefConstructor, $symbolToChunkResolver$, $setProp$, $storeProxyMap$, $writer$) {
-    this.NodeConstructor = NodeConstructor;
-    this.DomRefConstructor = DomRefConstructor;
-    this.$symbolToChunkResolver$ = $symbolToChunkResolver$;
-    this.$setProp$ = $setProp$;
-    this.$storeProxyMap$ = $storeProxyMap$;
-    this.$writer$ = $writer$;
+    __publicField(this, "NodeConstructor", NodeConstructor);
+    __publicField(this, "DomRefConstructor", DomRefConstructor);
+    __publicField(this, "$symbolToChunkResolver$", $symbolToChunkResolver$);
+    __publicField(this, "$setProp$", $setProp$);
+    __publicField(this, "$storeProxyMap$", $storeProxyMap$);
+    __publicField(this, "$writer$", $writer$);
     __publicField(this, "$seenObjsMap$", /* @__PURE__ */ new Map());
     __publicField(this, "$syncFnMap$", /* @__PURE__ */ new Map());
     __publicField(this, "$syncFnOffset$", 0);
@@ -28692,7 +28841,7 @@ var _SharedContainer = class {
 };
 
 // packages/qwik/src/core/shared/serdes/preprocess-state.ts
-function preprocessState(data, container, segmentId, startIndex = 0) {
+function* preprocessStateIterator(data, container, startIndex = 0) {
   const isRootDeepRef = (type, value) => {
     return type === 1 /* RootRef */ && typeof value === "string" && value.indexOf(" ") !== -1;
   };
@@ -28734,23 +28883,103 @@ function preprocessState(data, container, segmentId, startIndex = 0) {
     } else if (isForwardRefsMap(data[i2])) {
       container.$forwardRefs$ = data[i2 + 1];
     }
+    yield;
   }
 }
 
 // packages/qwik/src/core/shared/serdes/serdes.public.ts
-import { isDev as isDev21 } from "@qwik.dev/core/build";
+import { isDev as isDev20 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/client/yielding-iterator.ts
+var YIELD_INTERVAL = 10;
+var scheduleYieldingIterator = (state) => {
+  if (!state.$scheduled$) {
+    state.$scheduled$ = true;
+    state.$schedule$();
+  }
+};
+var runYieldingIterator = (state, onDone, onError) => {
+  state.$scheduled$ = false;
+  const deadline = performance.now() + YIELD_INTERVAL;
+  let count = 0;
+  try {
+    while (true) {
+      const result = state.$iterator$.next();
+      if (result.done) {
+        onDone(result.value);
+        return;
+      }
+      if ((++count & 31) === 0 && performance.now() >= deadline) {
+        scheduleYieldingIterator(state);
+        return;
+      }
+    }
+  } catch (error) {
+    onError(error);
+  }
+};
+var createYieldingIteratorState = (iterator, onDone, onError) => {
+  const state = {
+    $iterator$: iterator,
+    $schedule$: void 0,
+    $scheduled$: false
+  };
+  const schedule = createMacroTask(() => {
+    runYieldingIterator(
+      state,
+      (value) => {
+        schedule.$destroy$?.();
+        onDone(value);
+      },
+      (error) => {
+        schedule.$destroy$?.();
+        onError(error);
+      }
+    );
+  });
+  state.$schedule$ = schedule;
+  return state;
+};
+
+// packages/qwik/src/core/shared/serdes/serdes.public.ts
 function getObjectById(id, stateData) {
   if (typeof id === "string") {
     id = parseInt(id, 10);
     return stateData[id];
   }
-  isDev21 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
+  isDev20 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
   return stateData[id];
 }
 
 // packages/qwik/src/core/shared/serdes/allocate.ts
 var resolvers = /* @__PURE__ */ new WeakMap();
-var pendingStoreTargets = /* @__PURE__ */ new Map();
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_REGEXP = /^[A-Za-z0-9+/]*$/;
+var isCanonicalBase64 = (value) => {
+  if (typeof value !== "string" || !BASE64_REGEXP.test(value)) {
+    return false;
+  }
+  const rest = value.length % 4;
+  if (rest === 0) {
+    return true;
+  }
+  if (rest === 1) {
+    return false;
+  }
+  const lastValue = BASE64_ALPHABET.indexOf(value[value.length - 1]);
+  return (lastValue & (rest === 2 ? 15 : 3)) === 0;
+};
+var beginDeserialization = (container) => {
+  const ownsPendingStoreTargets = container.$pendingStoreTargets$ === void 0;
+  container.$pendingStoreTargets$ ?? (container.$pendingStoreTargets$ = /* @__PURE__ */ new Map());
+  return ownsPendingStoreTargets;
+};
+var endDeserialization = (container, ownsPendingStoreTargets) => {
+  if (ownsPendingStoreTargets) {
+    container.$pendingStoreTargets$.clear();
+    container.$pendingStoreTargets$ = void 0;
+  }
+};
 var allocate = (container, typeId, value) => {
   switch (typeId) {
     case 0 /* Plain */:
@@ -28775,13 +29004,18 @@ var allocate = (container, typeId, value) => {
     case 9 /* QRL */: {
       let qrl;
       if (typeof value === "string") {
-        const [chunkId, symbolId, captureIds] = value.split("#");
-        const chunk = container.$getObjectById$(chunkId);
-        const symbol = container.$getObjectById$(symbolId);
+        const serializedQrl = value;
+        const firstHash = serializedQrl.indexOf("#");
+        const secondHash = serializedQrl.indexOf("#", firstHash + 1);
+        const chunkRootId = Number(serializedQrl.slice(0, firstHash));
+        const symbolDelta = secondHash === -1 ? Number(serializedQrl.slice(firstHash + 1)) : Number(serializedQrl.slice(firstHash + 1, secondHash));
+        const symbolRootId = chunkRootId + symbolDelta;
+        const chunk = container.$getObjectById$(chunkRootId);
+        const symbol = container.$getObjectById$(symbolRootId);
         qrl = createQRLWithBackChannel(
           chunk,
           symbol,
-          captureIds || null,
+          secondHash !== -1 ? serializedQrl : null,
           container
         );
       } else {
@@ -28790,7 +29024,7 @@ var allocate = (container, typeId, value) => {
       return qrl;
     }
     case 28 /* Task */:
-      return new Task(-1, -1, null, null, null, null);
+      return new Task(-1, -1, null, null, null);
     case 6 /* URL */:
       return new URL(value);
     case 7 /* Date */:
@@ -28835,7 +29069,7 @@ var allocate = (container, typeId, value) => {
       const storeValue = allocate(container, t, v);
       const store = getOrCreateStore(storeValue, 0 /* NONE */, container);
       if (needsInflation(t)) {
-        pendingStoreTargets.set(storeValue, { t, v });
+        container.$pendingStoreTargets$.set(storeValue, { t, v });
       }
       data[0] = 0 /* Plain */;
       data[1] = storeValue;
@@ -28864,12 +29098,16 @@ var allocate = (container, typeId, value) => {
       promise.catch(() => {
       });
       return promise;
-    case 27 /* Uint8Array */:
+    case 27 /* Uint8Array */: {
+      if (!isCanonicalBase64(value)) {
+        throw qError(38 /* invalidUint8ArrayPayload */);
+      }
       const encodedLength = value.length;
-      const blocks = encodedLength >>> 2;
-      const rest = encodedLength & 3;
+      const blocks = Math.floor(encodedLength / 4);
+      const rest = encodedLength % 4;
       const decodedLength = blocks * 3 + (rest ? rest - 1 : 0);
       return new Uint8Array(decodedLength);
+    }
     case 38 /* PropsProxy */:
       return createPropsProxy(null);
     case 10 /* VNode */:
@@ -28884,7 +29122,12 @@ var allocate = (container, typeId, value) => {
       }
     case 39 /* SubscriptionData */:
       return new SubscriptionData({});
+    case 42 /* SubscriptionDataConstTrue */:
+      return new SubscriptionData({ $scopedStyleIdPrefix$: null, $isConst$: true });
+    case 43 /* SubscriptionDataConstFalse */:
+      return new SubscriptionData({ $scopedStyleIdPrefix$: null, $isConst$: false });
     case 40 /* EffectSubscription */:
+    case 44 /* EffectSubscriptionNoData */:
       return new EffectSubscription(null, null, null, null);
     case 41 /* SubscriptionPatch */:
       return new SubscriptionPatch();
@@ -28913,114 +29156,209 @@ var isSafeObjectKV = (key, value) => {
   return typeof key === "string" && key !== "__proto__" && (typeof value !== "function" || !dangerousObjectKeys.has(key));
 };
 var inflate = (container, target, typeId, data) => {
+  const ownsPendingStoreTargets = beginDeserialization(container);
+  try {
+    const iterator = inflateIterator(container, target, typeId, data);
+    while (!iterator.next().done) {
+    }
+  } finally {
+    endDeserialization(container, ownsPendingStoreTargets);
+  }
+};
+function* eagerDeserializeArrayIterator(container, data, output = Array(data.length / 2)) {
+  for (let i2 = 0; i2 < data.length; i2 += 2) {
+    output[i2 / 2] = yield* deserializeDataIterator(container, data[i2], data[i2 + 1]);
+    yield;
+  }
+  return output;
+}
+function* eagerDeserializeStateIterator(container, data, output = Array(data.length / 2)) {
+  const ownsPendingStoreTargets = beginDeserialization(container);
+  const length = data.length / 2;
+  const allocated = new Uint8Array(length);
+  const previousGetObjectById = container.$getObjectById$;
+  const allocateRoot = (index) => {
+    if (!allocated[index]) {
+      allocated[index] = 1;
+      const typeIndex = index * 2;
+      const typeId = data[typeIndex];
+      const value = data[typeIndex + 1];
+      output[index] = typeId === 0 /* Plain */ ? value : allocate(container, typeId, value);
+    }
+    return output[index];
+  };
+  container.$getObjectById$ = (id) => allocateRoot(typeof id === "string" ? parseInt(id, 10) : id);
+  try {
+    for (let i2 = 0; i2 < length; i2++) {
+      allocateRoot(i2);
+      yield;
+    }
+    for (let i2 = 0; i2 < length; i2++) {
+      const typeIndex = i2 * 2;
+      const typeId = data[typeIndex];
+      const value = data[typeIndex + 1];
+      const propValue = output[i2];
+      data[typeIndex] = 0 /* Plain */;
+      data[typeIndex + 1] = propValue;
+      if (needsInflation(typeId)) {
+        yield* inflateIterator(container, propValue, typeId, value);
+      }
+      yield;
+    }
+  } finally {
+    container.$getObjectById$ = previousGetObjectById;
+    endDeserialization(container, ownsPendingStoreTargets);
+  }
+  return output;
+}
+function* deserializeDataIterator(container, typeId, value) {
+  if (typeId === 0 /* Plain */) {
+    return value;
+  }
+  const propValue = allocate(container, typeId, value);
+  if (needsInflation(typeId)) {
+    yield* inflateIterator(container, propValue, typeId, value);
+  }
+  return propValue;
+}
+function* inflateIterator(container, target, typeId, data) {
   if (typeId === 0 /* Plain */) {
     return;
   }
+  if (typeId === 5 /* Object */ && data !== EMPTY_OBJECT_PAYLOAD && !Array.isArray(data)) {
+    throw new Error("Invalid Object payload");
+  }
   if (typeId !== 4 /* Array */ && Array.isArray(data)) {
-    data = _eagerDeserializeArray(container, data);
+    data = yield* eagerDeserializeArrayIterator(container, data);
   }
   switch (typeId) {
     case 4 /* Array */:
-      _eagerDeserializeArray(container, data, target);
+      yield* eagerDeserializeArrayIterator(container, data, target);
       break;
     case 5 /* Object */:
-      if (data === 0) {
+      if (data === EMPTY_OBJECT_PAYLOAD) {
         break;
       }
-      for (let i3 = 0; i3 < data.length; i3 += 2) {
-        const key = data[i3];
-        const value = data[i3 + 1];
+      for (let i2 = 0; i2 < data.length; i2 += 2) {
+        const key = data[i2];
+        const value = data[i2 + 1];
         if (!isSafeObjectKV(key, value)) {
           continue;
         }
         target[key] = value;
       }
       break;
-    case 28 /* Task */:
+    case 25 /* Set */: {
+      const set = target;
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        set.add(d[i2]);
+        yield;
+      }
+      break;
+    }
+    case 26 /* Map */: {
+      const map = target;
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        map.set(d[i2++], d[i2]);
+        yield;
+      }
+      break;
+    }
+    case 24 /* Promise */: {
+      const promise = target;
+      const [resolved, result] = data;
+      const [resolve, reject] = resolvers.get(promise);
+      if (resolved) {
+        if (resolvers.has(result)) {
+          throw qError(37 /* invalidPromiseDependency */);
+        }
+        resolve(result);
+      } else {
+        reject(result);
+      }
+      break;
+    }
+    case 23 /* Error */: {
+      const d = data;
+      target.message = d[0];
+      for (let i2 = 1; i2 < d.length; i2 += 2) {
+        const key = d[i2];
+        const value = d[i2 + 1];
+        if (isSafeObjectKV(key, value)) {
+          target[key] = value;
+        }
+        yield;
+      }
+      break;
+    }
+    case 28 /* Task */: {
       const task = target;
       const v = data;
       task.$qrl$ = v[0];
       task.$flags$ = v[1];
       task.$index$ = v[2];
       task.$el$ = v[3];
-      task.$state$ = v[4];
       break;
+    }
     case 29 /* Component */:
       target[SERIALIZABLE_STATE][0] = data[0];
       break;
-    case 35 /* Store */: {
-      const store = unwrapStore(target);
-      const storeTarget = pendingStoreTargets.get(store);
-      if (storeTarget) {
-        pendingStoreTargets.delete(store);
-        inflate(container, store, storeTarget.t, storeTarget.v);
-      }
-      const [, flags, effects] = data;
-      const storeHandler = getStoreHandler(target);
-      storeHandler.$flags$ = flags;
-      storeHandler.$effects$ = effects;
-      restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
-      break;
-    }
     case 30 /* Signal */: {
       const signal = target;
-      const d2 = data;
-      signal.$untrackedValue$ = d2[0];
-      signal.$effects$ = new Set(d2.slice(1));
+      const d = data;
+      signal.$untrackedValue$ = d[0];
+      signal.$effects$ = new Set(d.slice(1));
       restoreEffectBackRefForEffects(signal.$effects$, signal);
       break;
     }
     case 31 /* WrappedSignal */: {
       const signal = target;
-      const d2 = data;
-      signal.$func$ = container.getSyncFn(d2[0]);
-      signal.$args$ = d2[1];
+      const d = data;
+      signal.$func$ = container.getSyncFn(d[0]);
+      signal.$args$ = d[1];
       signal.$untrackedValue$ = NEEDS_COMPUTATION;
-      signal.$flags$ = d2[2];
+      signal.$flags$ = d[2];
       signal.$flags$ |= 1 /* INVALID */;
-      signal.$hostElement$ = d2[3];
-      signal.$effects$ = new Set(d2.slice(4));
+      signal.$hostElement$ = d[3];
+      signal.$effects$ = new Set(d.slice(4));
       inflateWrappedSignalValue(signal);
       restoreEffectBackRefForEffects(signal.$effects$, signal);
       break;
     }
     case 33 /* AsyncSignal */: {
       const asyncSignal = target;
-      const d2 = data;
-      asyncSignal.$computeQrl$ = d2[0];
-      if (d2[1]) {
-        asyncSignal.$effects$ = new Set(d2[1]);
+      const d = data;
+      asyncSignal.$computeQrl$ = d[0];
+      if (d[1]) {
+        asyncSignal.$effects$ = new Set(d[1]);
       }
-      if (d2[2]) {
-        asyncSignal.$loadingEffects$ = new Set(d2[2]);
+      if (d[2]) {
+        asyncSignal.$loadingEffects$ = new Set(d[2]);
       }
-      if (d2[3]) {
-        asyncSignal.$errorEffects$ = new Set(d2[3]);
+      if (d[3]) {
+        asyncSignal.$errorEffects$ = new Set(d[3]);
       }
-      if (d2[4]) {
-        asyncSignal.$untrackedError$ = d2[4];
+      if (d[4]) {
+        asyncSignal.$untrackedError$ = d[4];
       }
-      asyncSignal.$flags$ = d2[5] ?? 0;
+      asyncSignal.$flags$ = d[5] ?? 0;
       if (asyncSignal.$flags$ & 64 /* CLIENT_ONLY */) {
-        asyncSignal.$untrackedLoading$ = true;
+        asyncSignal.$untrackedPending$ = true;
       }
-      const hasValue = d2.length > 6;
+      const hasValue = d.length > 6;
       if (hasValue) {
-        asyncSignal.$untrackedValue$ = d2[6];
+        asyncSignal.$untrackedValue$ = d[6];
       }
       if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
         asyncSignal.$flags$ |= 1 /* INVALID */;
       }
-      const rawExpires = d2[7] ?? 0;
-      asyncSignal.expires = Math.abs(rawExpires);
-      if (rawExpires < 0) {
-        asyncSignal.$flags$ |= 256 /* NO_POLL */;
-      }
-      if (d2[8] !== void 0 && d2[8] !== 1) {
-        asyncSignal.$concurrency$ = d2[8] ?? 1;
+      if (d[7] !== void 0 && d[7] !== 1) {
+        asyncSignal.$concurrency$ = d[7] ?? 1;
         asyncSignal.$jobs$ = [];
       }
-      asyncSignal.$timeoutMs$ = d2[9] ?? 0;
+      asyncSignal.$timeoutMs$ = d[8] ?? 0;
       restoreEffectBackRefForEffects(asyncSignal.$effects$, asyncSignal);
       restoreEffectBackRefForEffects(asyncSignal.$loadingEffects$, asyncSignal);
       restoreEffectBackRefForEffects(asyncSignal.$errorEffects$, asyncSignal);
@@ -29030,17 +29368,17 @@ var inflate = (container, target, typeId, data) => {
     case 34 /* SerializerSignal */:
     case 32 /* ComputedSignal */: {
       const computed = target;
-      const d2 = data;
-      computed.$computeQrl$ = d2[0];
+      const d = data;
+      computed.$computeQrl$ = d[0];
       const p = computed.$computeQrl$.resolve(container).catch(() => {
       });
       loading = loading.finally(() => p);
-      if (d2[1]) {
-        computed.$effects$ = new Set(d2[1]);
+      if (d[1]) {
+        computed.$effects$ = new Set(d[1]);
       }
-      const hasValue = d2.length > 2;
+      const hasValue = d.length > 2;
       if (hasValue) {
-        computed.$untrackedValue$ = d2[2];
+        computed.$untrackedValue$ = d[2];
       }
       if (typeId !== 34 /* SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
         computed.$flags$ &= ~1 /* INVALID */;
@@ -29048,19 +29386,12 @@ var inflate = (container, target, typeId, data) => {
       restoreEffectBackRefForEffects(computed.$effects$, computed);
       break;
     }
-    case 23 /* Error */: {
-      const d2 = data;
-      target.message = d2[0];
-      for (let i3 = 1; i3 < d2.length; i3 += 2) {
-        target[d2[i3]] = d2[i3 + 1];
-      }
-      break;
-    }
     case 36 /* FormData */: {
       const formData = target;
-      const d2 = data;
-      for (let i3 = 0; i3 < d2.length; i3++) {
-        formData.append(d2[i3++], d2[i3]);
+      const d = data;
+      for (let i2 = 0; i2 < d.length; i2++) {
+        formData.append(d[i2++], d[i2]);
+        yield;
       }
       break;
     }
@@ -29075,48 +29406,14 @@ var inflate = (container, target, typeId, data) => {
       jsx2.toSort = !!toSort;
       break;
     }
-    case 25 /* Set */: {
-      const set = target;
-      const d2 = data;
-      for (let i3 = 0; i3 < d2.length; i3++) {
-        set.add(d2[i3]);
-      }
-      break;
-    }
-    case 26 /* Map */: {
-      const map = target;
-      const d2 = data;
-      for (let i3 = 0; i3 < d2.length; i3++) {
-        map.set(d2[i3++], d2[i3]);
-      }
-      break;
-    }
-    case 24 /* Promise */: {
-      const promise = target;
-      const [resolved, result] = data;
-      const [resolve, reject] = resolvers.get(promise);
-      if (resolved) {
-        resolve(result);
-      } else {
-        reject(result);
-      }
-      break;
-    }
-    case 27 /* Uint8Array */:
-      const bytes = target;
-      const buf = atob(data);
-      let i2 = 0;
-      for (let j = 0; j < buf.length; j++) {
-        const s = buf[j];
-        bytes[i2++] = s.charCodeAt(0);
-      }
-      break;
-    case 38 /* PropsProxy */:
+    case 38 /* PropsProxy */: {
       const propsProxy = target;
       const d = data;
       let owner = d[0];
       if (owner === _UNINITIALIZED) {
-        owner = new JSXNodeImpl(Fragment, d[1], d[2], null, 0, null);
+        owner = new JSXNodeImpl(Fragment, null, null, null, 0, null);
+        owner.varProps = d[1];
+        owner.constProps = d[2];
         owner._proxy = propsProxy;
       }
       propsProxy[_OWNER] = owner;
@@ -29124,47 +29421,69 @@ var inflate = (container, target, typeId, data) => {
       propsHandler.$effects$ = d[3];
       restoreEffectBackRefForEffectsMap(propsHandler.$effects$, propsProxy);
       break;
+    }
     case 39 /* SubscriptionData */: {
       const effectData = target;
       effectData.data.$scopedStyleIdPrefix$ = data[0];
       effectData.data.$isConst$ = data[1];
       break;
     }
+    case 42 /* SubscriptionDataConstTrue */:
+    case 43 /* SubscriptionDataConstFalse */:
+      break;
     case 40 /* EffectSubscription */: {
       const effectSub = target;
-      const d2 = data;
-      effectSub.consumer = d2[0];
-      effectSub.property = d2[1];
-      effectSub.data = d2[2];
+      const d = data;
+      effectSub.consumer = d[0];
+      effectSub.property = d[1];
+      effectSub.data = d[2];
       restoreEffectBackRefForConsumer(effectSub);
       break;
     }
     case 41 /* SubscriptionPatch */: {
       const patch = target;
-      const d2 = data;
-      patch.rootId = d2[0];
-      patch.subscriptions = d2[1];
+      const d = data;
+      patch.rootId = d[0];
+      patch.subscriptions = d[1];
+      break;
+    }
+    case 44 /* EffectSubscriptionNoData */: {
+      const effectSub = target;
+      const d = data;
+      effectSub.consumer = d[0];
+      effectSub.property = d[1];
+      effectSub.data = null;
+      restoreEffectBackRefForConsumer(effectSub);
+      break;
+    }
+    case 27 /* Uint8Array */: {
+      const bytes = target;
+      const buf = atob(data);
+      for (let j = 0; j < buf.length; j++) {
+        bytes[j] = buf.charCodeAt(j);
+        if ((j & 31) === 31) {
+          yield;
+        }
+      }
+      break;
+    }
+    case 35 /* Store */: {
+      const store = unwrapStore(target);
+      const storeTarget = container.$pendingStoreTargets$.get(store);
+      if (storeTarget) {
+        container.$pendingStoreTargets$.delete(store);
+        yield* inflateIterator(container, store, storeTarget.t, storeTarget.v);
+      }
+      const [, flags, effects] = data;
+      const storeHandler = getStoreHandler(target);
+      storeHandler.$flags$ = flags;
+      storeHandler.$effects$ = effects;
+      restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
       break;
     }
     default:
       throw qError(16 /* serializeErrorNotImplemented */, [typeId]);
   }
-};
-var _eagerDeserializeArray = (container, data, output = Array(data.length / 2)) => {
-  for (let i2 = 0; i2 < data.length; i2 += 2) {
-    output[i2 / 2] = deserializeData(container, data[i2], data[i2 + 1]);
-  }
-  return output;
-};
-function deserializeData(container, typeId, value) {
-  if (typeId === 0 /* Plain */) {
-    return value;
-  }
-  const propValue = allocate(container, typeId, value);
-  if (needsInflation(typeId)) {
-    inflate(container, propValue, typeId, value);
-  }
-  return propValue;
 }
 function inflateWrappedSignalValue(signal) {
   if (signal.$hostElement$ !== null && vnode_isVNode(signal.$hostElement$)) {
@@ -29193,13 +29512,13 @@ function inflateWrappedSignalValue(signal) {
   }
 }
 function restoreEffectBackRefForConsumer(effect) {
-  var _a6;
+  var _a5;
   const isServerSide = qTest ? isServerPlatform() : isServer9;
   const consumerBackRef = effect.consumer;
   if (isServerSide && !consumerBackRef) {
     return;
   }
-  consumerBackRef[_a6 = _EFFECT_BACK_REF] || (consumerBackRef[_a6] = /* @__PURE__ */ new Map());
+  consumerBackRef[_a5 = _EFFECT_BACK_REF] || (consumerBackRef[_a5] = /* @__PURE__ */ new Map());
   consumerBackRef[_EFFECT_BACK_REF].set(effect.property, effect);
 }
 function restoreEffectBackRefForEffects(effects, consumer) {
@@ -29219,17 +29538,17 @@ function restoreEffectBackRefForEffectsMap(effectsMap, consumer) {
 }
 
 // packages/qwik/src/core/shared/vnode/vnode.ts
-import { isDev as isDev22 } from "@qwik.dev/core/build";
-var _a5;
-_a5 = _EFFECT_BACK_REF;
+import { isDev as isDev21 } from "@qwik.dev/core/build";
+var _a4;
+_a4 = _EFFECT_BACK_REF;
 var VNode = class {
   constructor(flags, parent, previousSibling, nextSibling, props) {
-    this.flags = flags;
-    this.parent = parent;
-    this.previousSibling = previousSibling;
-    this.nextSibling = nextSibling;
-    this.props = props;
-    __publicField(this, _a5);
+    __publicField(this, "flags", flags);
+    __publicField(this, "parent", parent);
+    __publicField(this, "previousSibling", previousSibling);
+    __publicField(this, "nextSibling", nextSibling);
+    __publicField(this, "props", props);
+    __publicField(this, _a4);
     __publicField(this, "slotParent", null);
     __publicField(this, "dirty", 0 /* NONE */);
     __publicField(this, "dirtyChildren", null);
@@ -29237,7 +29556,7 @@ var VNode = class {
   }
   // TODO: this creates debug issues
   toString() {
-    if (isDev22) {
+    if (isDev21) {
       return vnode_toString.call(this);
     }
     return Object.prototype.toString.call(this);
@@ -29248,9 +29567,9 @@ var VNode = class {
 var VirtualVNode = class extends VNode {
   constructor(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild) {
     super(flags, parent, previousSibling, nextSibling, props);
-    this.key = key;
-    this.firstChild = firstChild;
-    this.lastChild = lastChild;
+    __publicField(this, "key", key);
+    __publicField(this, "firstChild", firstChild);
+    __publicField(this, "lastChild", lastChild);
   }
 };
 
@@ -29258,21 +29577,22 @@ var VirtualVNode = class extends VNode {
 var ElementVNode = class extends VirtualVNode {
   constructor(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild, node, elementName) {
     super(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild);
-    this.node = node;
-    this.elementName = elementName;
+    __publicField(this, "node", node);
+    __publicField(this, "elementName", elementName);
   }
 };
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
+var reportedChunkFailures;
 var getLazyRef = (chunk, symbol, symbolFn, ref, container) => {
   return new LazyRef(chunk, symbol, symbolFn, ref, container);
 };
 var LazyRef = class {
   constructor($chunk$, $symbol$, $symbolFn$, $ref$, container) {
-    this.$chunk$ = $chunk$;
-    this.$symbol$ = $symbol$;
-    this.$symbolFn$ = $symbolFn$;
-    this.$ref$ = $ref$;
+    __publicField(this, "$chunk$", $chunk$);
+    __publicField(this, "$symbol$", $symbol$);
+    __publicField(this, "$symbolFn$", $symbolFn$);
+    __publicField(this, "$ref$", $ref$);
     __publicField(this, "$container$");
     if ($ref$) {
       this.$setRef$($ref$);
@@ -29295,7 +29615,24 @@ var LazyRef = class {
       ref.then(
         (r) => this.$ref$ = r,
         (err) => {
-          console.error(`qrl ${this.$symbol$} failed to load`, err);
+          const errorMessage = `qrl ${this.$symbol$} failed to load`;
+          if (qTest ? isServerPlatform() : isServer10) {
+            console.error(errorMessage, err);
+          } else if (qTest ? !isServerPlatform() : isBrowser3) {
+            const failureKey = this.$chunk$ === null ? `symbol:${this.$symbol$}` : `chunk:${this.$chunk$}`;
+            const container = this.$container$;
+            let containerFailures = container && reportedChunkFailures?.get(container);
+            if (!containerFailures?.has(failureKey)) {
+              if (container) {
+                if (!containerFailures) {
+                  containerFailures = /* @__PURE__ */ new Set();
+                  (reportedChunkFailures || (reportedChunkFailures = /* @__PURE__ */ new WeakMap())).set(container, containerFailures);
+                }
+                containerFailures.add(failureKey);
+              }
+              console.error(errorMessage, err);
+            }
+          }
           this.$ref$ = null;
         }
       );
@@ -29307,7 +29644,7 @@ var LazyRef = class {
       return this.$ref$;
     }
     if (this.$chunk$ === "") {
-      isDev23 && assertDefined(this.$container$, "Sync QRL must have container element");
+      isDev22 && assertDefined(this.$container$, "Sync QRL must have container element");
       const hash = this.$container$.$instanceHash$;
       const doc = this.$container$.element?.ownerDocument || document;
       const qFuncs2 = getQFuncs(doc, hash);
@@ -29335,7 +29672,7 @@ var getInstance = (instance) => {
 };
 var QRLClass = class {
   constructor($lazy$, $captures$, container) {
-    this.$lazy$ = $lazy$;
+    __publicField(this, "$lazy$", $lazy$);
     __publicField(this, "resolved");
     // This is defined or undefined for the lifetime of the QRL, so we set it lazily
     __publicField(this, "$captures$");
@@ -29349,7 +29686,7 @@ var QRLClass = class {
         this.$container$ = container;
       }
     }
-    if ($lazy$.$ref$ != null && typeof this.$captures$ !== "string" && !isPromise($lazy$.$ref$)) {
+    if ($lazy$.$ref$ != null && (!this.$captures$ || typeof this.$captures$ !== "string") && !isPromise($lazy$.$ref$)) {
       this.resolved = bindCaptures(this, $lazy$.$ref$);
     }
   }
@@ -29371,6 +29708,10 @@ var qrlWithCaptures = function(captures) {
   );
   return makeQrlFn(newQrl);
 };
+var qrlWithMovedCaptures = function() {
+  this[QRL_STATE].$lazy$.$hasMovedCaptures$ = true;
+  return this;
+};
 var qrlSetRef = function(ref) {
   const qrl = getInstance(this);
   qrl.$lazy$.$setRef$(ref);
@@ -29426,6 +29767,11 @@ var QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
       this[QRL_STATE].$captures$ = value;
     }
   },
+  $hasMovedCaptures$: {
+    get() {
+      return this[QRL_STATE].$lazy$.$hasMovedCaptures$;
+    }
+  },
   $container$: {
     get() {
       return this[QRL_STATE].$container$;
@@ -29472,6 +29818,9 @@ var QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
   w: {
     value: qrlWithCaptures
   },
+  m: {
+    value: qrlWithMovedCaptures
+  },
   s: {
     value: qrlSetRef
   },
@@ -29495,27 +29844,45 @@ var _captures = null;
 var setCaptures = (captures) => {
   _captures = captures;
 };
-var deserializeCaptures = (container, captures) => {
+var deserializeCaptureDeltas = (container, deltaString, startIndex = 0, previousRootId) => {
   const refs = [];
-  const captureIds = captures.split(" ");
-  for (let i2 = 0; i2 < captureIds.length; i2++) {
-    const id = captureIds[i2];
-    refs.push(container.$getObjectById$(id));
+  let previous = previousRootId;
+  let start = startIndex;
+  for (let i2 = startIndex; i2 <= deltaString.length; i2++) {
+    if (i2 === deltaString.length || deltaString.charCodeAt(i2) === 32) {
+      if (i2 > start) {
+        const delta = Number(deltaString.slice(start, i2));
+        previous = previous === void 0 ? delta : previous + delta;
+        refs.push(container.$getObjectById$(previous));
+      }
+      start = i2 + 1;
+    }
   }
   return refs;
 };
+var deserializeQrlCaptureDeltas = (container, qrlString) => {
+  const firstHash = qrlString.indexOf("#");
+  if (firstHash === -1) {
+    return deserializeCaptureDeltas(container, qrlString);
+  }
+  const secondHash = qrlString.indexOf("#", firstHash + 1);
+  const previousRootId = Number(qrlString.slice(0, firstHash)) + Number(qrlString.slice(firstHash + 1, secondHash));
+  return deserializeCaptureDeltas(container, qrlString, secondHash + 1, previousRootId);
+};
 var ensureQrlCaptures = (qrl) => {
-  _captures = qrl.$captures$;
+  const serializedCaptures = qrl.$captures$;
   const container = qrl.$container$;
-  if (typeof _captures === "string") {
+  if (typeof serializedCaptures === "string") {
     if (!container) {
       throw qError(13 /* qrlMissingContainer */);
     }
     const prevLoading = loading;
-    _captures = qrl.$captures$ = deserializeCaptures(container, _captures);
+    _captures = qrl.$captures$ = deserializeQrlCaptureDeltas(container, serializedCaptures);
     if (loading !== prevLoading) {
       return loading;
     }
+  } else {
+    _captures = serializedCaptures || null;
   }
 };
 var bindCaptures = (qrl, ref) => {
@@ -29888,6 +30255,7 @@ var Slot = (props) => {
 
 // packages/qwik/src/core/shared/serdes/constants.ts
 var explicitUndefined = /* @__PURE__ */ Symbol("undefined");
+var EMPTY_OBJECT_PAYLOAD = 0;
 var _constants = [
   void 0,
   null,
@@ -29906,7 +30274,11 @@ var _constants = [
   -Infinity,
   Number.MAX_SAFE_INTEGER,
   Number.MAX_SAFE_INTEGER - 1,
-  Number.MIN_SAFE_INTEGER
+  Number.MIN_SAFE_INTEGER,
+  ":",
+  ".",
+  "id",
+  "ref"
 ];
 
 // packages/qwik/src/core/shared/serdes/deser-proxy.ts
@@ -29932,8 +30304,8 @@ var wrapDeserializerProxy = (container, data) => {
 };
 var DeserializationHandler = class {
   constructor($container$, $data$) {
-    this.$container$ = $container$;
-    this.$data$ = $data$;
+    __publicField(this, "$container$", $container$);
+    __publicField(this, "$data$", $data$);
   }
   get(target, property, receiver) {
     if (property === SERIALIZER_PROXY_UNWRAP) {
@@ -29950,14 +30322,19 @@ var DeserializationHandler = class {
       return value;
     }
     const container = this.$container$;
-    const propValue = allocate(container, typeId, value);
-    Reflect.set(target, property, propValue);
-    this.$data$[idx] = 0 /* Plain */;
-    this.$data$[idx + 1] = propValue;
-    if (needsInflation(typeId)) {
-      inflate(container, propValue, typeId, value);
+    const ownsPendingStoreTargets = beginDeserialization(container);
+    try {
+      const propValue = allocate(container, typeId, value);
+      Reflect.set(target, property, propValue);
+      this.$data$[idx] = 0 /* Plain */;
+      this.$data$[idx + 1] = propValue;
+      if (needsInflation(typeId)) {
+        inflate(container, propValue, typeId, value);
+      }
+      return propValue;
+    } finally {
+      endDeserialization(container, ownsPendingStoreTargets);
     }
-    return propValue;
   }
   has(target, property) {
     if (property === SERIALIZER_PROXY_UNWRAP) {
@@ -30031,13 +30408,13 @@ var mergeSubscriptionSet = (container, producer, backRef, rootEffects, patchEffe
 
 // packages/qwik/src/core/client/process-segment-state.ts
 var processedStatePatchScripts = /* @__PURE__ */ new WeakMap();
-var processSegmentStateScripts = (container, segmentId) => {
+function* processSegmentStateScriptsIterator(container, segmentId) {
   if (!__EXPERIMENTAL__.suspense) {
     return;
   }
   const stateContainer = container;
   const qwikStates = stateContainer.element.querySelectorAll(
-    `${stateScriptSelector(stateContainer.$instanceHash$)}${QStatePatchAttrSelector}`
+    `script[type="qwik/state"][q\\:instance="${stateContainer.$instanceHash$}"]${QStatePatchAttrSelector}`
   );
   const processedScripts = getProcessedStatePatchScripts(container);
   for (let i2 = 0; i2 < qwikStates.length; i2++) {
@@ -30049,9 +30426,10 @@ var processSegmentStateScripts = (container, segmentId) => {
       continue;
     }
     processedScripts.add(stateScript);
-    processStatePatch(container, stateContainer, stateScript.textContent);
+    yield* processStatePatch(container, stateContainer, stateScript.textContent);
+    yield;
   }
-};
+}
 var getProcessedStatePatchScripts = (container) => {
   let processedScripts = processedStatePatchScripts.get(container);
   if (!processedScripts) {
@@ -30060,23 +30438,21 @@ var getProcessedStatePatchScripts = (container) => {
   }
   return processedScripts;
 };
-var stateScriptSelector = (instanceHash) => {
-  return `script[type="qwik/state"][q\\:instance="${instanceHash}"]`;
-};
-var processStatePatch = (container, stateContainer, textContent) => {
-  if (textContent) {
-    const [rootStart, rawStateData, forwardRefs, subscriptionPatchRootId] = JSON.parse(
-      textContent
-    );
-    appendStatePatchRoots(container, stateContainer, rootStart, rawStateData);
-    mergeForwardRefs(stateContainer, forwardRefs || void 0);
-    applySubscriptionPatches(
-      container,
-      subscriptionPatchRootId === void 0 ? void 0 : stateContainer.$getObjectById$(subscriptionPatchRootId)
-    );
+function* processStatePatch(container, stateContainer, textContent) {
+  if (!textContent) {
+    return;
   }
-};
-var appendStatePatchRoots = (container, stateContainer, rootStart, rawStateData) => {
+  const [rootStart, rawStateData, forwardRefs, subscriptionPatchRootId] = JSON.parse(
+    textContent
+  );
+  yield* appendStatePatchRoots(container, stateContainer, rootStart, rawStateData);
+  mergeForwardRefs(stateContainer, forwardRefs || void 0);
+  applySubscriptionPatches(
+    container,
+    subscriptionPatchRootId === void 0 ? void 0 : stateContainer.$getObjectById$(subscriptionPatchRootId)
+  );
+}
+function* appendStatePatchRoots(container, stateContainer, rootStart, rawStateData) {
   const currentRootCount = stateContainer.$rawStateData$.length / 2;
   if (rootStart !== currentRootCount) {
     if (qDev) {
@@ -30088,15 +30464,16 @@ var appendStatePatchRoots = (container, stateContainer, rootStart, rawStateData)
   }
   for (let i2 = 0; i2 < rawStateData.length; i2++) {
     stateContainer.$rawStateData$[rootStart * 2 + i2] = rawStateData[i2];
+    yield;
   }
-  preprocessState(stateContainer.$rawStateData$, container, void 0, rootStart * 2);
+  yield* preprocessStateIterator(stateContainer.$rawStateData$, container, rootStart * 2);
   stateContainer.$stateData$ = wrapDeserializerProxy(
     container,
     stateContainer.$rawStateData$
   );
   stateContainer.$stateData$.length = stateContainer.$rawStateData$.length / 2;
   stateContainer.$rootForwardRefs$ = stateContainer.$forwardRefs$;
-};
+}
 var mergeForwardRefs = (stateContainer, forwardRefs) => {
   if (!forwardRefs) {
     return;
@@ -30112,33 +30489,144 @@ var mergeForwardRefs = (stateContainer, forwardRefs) => {
 };
 
 // packages/qwik/src/core/client/process-vnode-data.ts
+var Q_SUSPENSE_RESOLVED = "q:r";
+var Q_PATCH = "q:patch";
+function processVNodeData(document2, containerElement) {
+  const qDocument = document2;
+  if (containerElement?.qVNodeRefs) {
+    return;
+  }
+  if (qDocument.qVNodeDataStarted && !qDocument.qVNodeDataProcessed) {
+    return;
+  }
+  qDocument.qVNodeDataStarted = true;
+  qDocument.qVNodeData || (qDocument.qVNodeData = /* @__PURE__ */ new WeakMap());
+  enqueueProcessVNodeDataJob(qDocument, processRootVNodeData(document2));
+}
 function processOutOfOrderSegmentVNodeData(document2, segmentId, contentNode) {
   if (!__EXPERIMENTAL__.suspense || !contentNode) {
     return;
   }
   const qContainerElement = contentNode.closest("[q\\:container]");
-  const script = qContainerElement?.querySelector(
+  if (!qContainerElement) {
+    return;
+  }
+  const script = qContainerElement.querySelector(
     `script[type="qwik/vnode"][q\\:r="${segmentId}"]:not([q\\:patch])`
   );
-  processVNodeDataImpl(
+  const patches = qContainerElement.querySelectorAll(
+    `script[type="qwik/vnode"][q\\:r="${segmentId}"][q\\:patch]`
+  );
+  enqueueProcessVNodeDataJob(
     document2,
-    segmentId,
-    qContainerElement,
-    contentNode,
-    script?.textContent || void 0
+    processOutOfOrderSegmentVNodeDataIterator(
+      document2,
+      segmentId,
+      qContainerElement,
+      contentNode,
+      script?.textContent || void 0,
+      patches
+    )
   );
-  const patches = qContainerElement?.querySelectorAll(
-    `script[type="qwik/vnode"][q\\:r="${segmentId}"][q\\:patch]`
+}
+var onVNodeDataReady = (document2, callback) => {
+  const qDocument = document2;
+  if (qDocument.qVNodeDataReady) {
+    callback();
+  } else {
+    (qDocument.qVNodeDataCallbacks || (qDocument.qVNodeDataCallbacks = [])).push(callback);
+  }
+};
+function enqueueProcessVNodeDataJob(qDocument, iterator) {
+  const state = qDocument.qVNodeDataState || (qDocument.qVNodeDataState = {
+    $queue$: [],
+    $active$: null
+  });
+  qDocument.qProcessVNodeDataPatch || (qDocument.qProcessVNodeDataPatch = (script) => enqueueProcessVNodeDataJob(qDocument, processVNodeDataPatch(qDocument, script)));
+  qDocument.qVNodeDataReady = false;
+  state.$queue$.push(iterator);
+  scheduleProcessVNodeData(qDocument, state);
+}
+function scheduleProcessVNodeData(qDocument, state) {
+  if (state.$active$) {
+    return;
+  }
+  const iterator = state.$queue$.shift();
+  if (!iterator) {
+    markVNodeDataReady(qDocument);
+    return;
+  }
+  state.$active$ = createYieldingIteratorState(
+    runProcessVNodeData(qDocument, state, iterator),
+    () => {
+      if (qDocument.qVNodeDataState === state) {
+        state.$active$ = null;
+        scheduleProcessVNodeData(qDocument, state);
+      }
+    },
+    (error) => {
+      state.$active$ = null;
+      logError(error);
+      markVNodeDataReady(qDocument);
+    }
+  );
+  scheduleYieldingIterator(state.$active$);
+}
+function* runProcessVNodeData(qDocument, state, iterator) {
+  while (qDocument.qVNodeDataState === state) {
+    if (iterator.next().done) {
+      return;
+    }
+    yield;
+  }
+}
+function markVNodeDataReady(document2) {
+  if (document2.qVNodeDataReady) {
+    return;
+  }
+  document2.qVNodeDataReady = true;
+  document2.qVNodeDataState = void 0;
+  const callbacks = document2.qVNodeDataCallbacks;
+  document2.qVNodeDataCallbacks = void 0;
+  if (callbacks) {
+    for (let i2 = 0; i2 < callbacks.length; i2++) {
+      callbacks[i2]();
+    }
+  }
+}
+function* processRootVNodeData(document2) {
+  yield* processVNodeDataImpl(document2);
+  const qDocument = document2;
+  qDocument.qVNodeDataProcessed = true;
+  qDocument.qVNodeDataStarted = false;
+}
+function* processOutOfOrderSegmentVNodeDataIterator(document2, segmentId, segmentContainer, segmentContent, segmentVNodeData, patches) {
+  yield* processVNodeDataImpl(
+    document2,
+    segmentId,
+    segmentContainer,
+    segmentContent,
+    segmentVNodeData
   );
-  for (let i2 = 0; patches && i2 < patches.length; i2++) {
-    document2.qProcessVNodeDataPatch?.(patches[i2]);
+  for (let i2 = 0; i2 < patches.length; i2++) {
+    yield* processVNodeDataPatch(document2, patches[i2]);
   }
 }
-function processVNodeData(document2) {
-  processVNodeDataImpl(document2);
-  document2.qVNodeDataProcessed = true;
+function* processVNodeDataPatch(document2, script) {
+  const qContainerElement = script?.closest("[q\\:container]");
+  const patchSegment = script?.getAttribute(Q_SUSPENSE_RESOLVED);
+  const contentNode = qContainerElement && (patchSegment ? qContainerElement.querySelector(`[q\\:rp="${patchSegment}"]`) : qContainerElement);
+  if (qContainerElement && contentNode) {
+    yield* processVNodeDataImpl(
+      document2,
+      patchSegment || void 0,
+      qContainerElement,
+      contentNode,
+      script.textContent
+    );
+  }
 }
-function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentContent, segmentVNodeData) {
+function* processVNodeDataImpl(document2, segmentId, segmentContainer, segmentContent, segmentVNodeData) {
   const Q_CONTAINER = "q:container";
   const Q_CONTAINER_END = "/" + Q_CONTAINER;
   const Q_PROPS_SEPARATOR2 = ":";
@@ -30147,9 +30635,22 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
   const Q_IGNORE_END = "/" + Q_IGNORE;
   const Q_CONTAINER_ISLAND = "q:container-island";
   const Q_CONTAINER_ISLAND_END = "/" + Q_CONTAINER_ISLAND;
-  const Q_SUSPENSE_RESOLVED = "q:r";
   const Q_SUSPENSE_RESULT_PARENT = "q:rp";
-  const Q_PATCH = "q:patch";
+  let NodeType;
+  ((NodeType2) => {
+    NodeType2[NodeType2["CONTAINER_MASK"] = 1] = "CONTAINER_MASK";
+    NodeType2[NodeType2["ELEMENT"] = 2] = "ELEMENT";
+    NodeType2[NodeType2["ELEMENT_CONTAINER"] = 3] = "ELEMENT_CONTAINER";
+    NodeType2[NodeType2["ELEMENT_SHADOW_ROOT_WRAPPER"] = 6] = "ELEMENT_SHADOW_ROOT_WRAPPER";
+    NodeType2[NodeType2["ELEMENT_SUSPENSE_RESULT_PARENT"] = 130] = "ELEMENT_SUSPENSE_RESULT_PARENT";
+    NodeType2[NodeType2["COMMENT_SKIP_START"] = 9] = "COMMENT_SKIP_START";
+    NodeType2[NodeType2["COMMENT_SKIP_END"] = 8] = "COMMENT_SKIP_END";
+    NodeType2[NodeType2["COMMENT_IGNORE_START"] = 16] = "COMMENT_IGNORE_START";
+    NodeType2[NodeType2["COMMENT_IGNORE_END"] = 32] = "COMMENT_IGNORE_END";
+    NodeType2[NodeType2["COMMENT_ISLAND_START"] = 65] = "COMMENT_ISLAND_START";
+    NodeType2[NodeType2["COMMENT_ISLAND_END"] = 64] = "COMMENT_ISLAND_END";
+    NodeType2[NodeType2["OTHER"] = 0] = "OTHER";
+  })(NodeType || (NodeType = {}));
   const qDocument = document2;
   const vNodeDataMap = qDocument.qVNodeData || (qDocument.qVNodeData = /* @__PURE__ */ new WeakMap());
   const prototype = document2.body;
@@ -30165,7 +30666,7 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
   const getAttribute = prototype.getAttribute;
   const hasAttribute = prototype.hasAttribute;
   const getNodeType = getter(prototype, "nodeType");
-  const attachVnodeDataAndRefs = (element) => {
+  const attachVnodeDataAndRefs = function* (element) {
     const scripts = element.querySelectorAll('script[type="qwik/vnode"]');
     for (let i2 = 0; i2 < scripts.length; i2++) {
       const script = scripts[i2];
@@ -30173,6 +30674,7 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
       qContainer.qVNodeRefs || (qContainer.qVNodeRefs = /* @__PURE__ */ new Map());
       if (script.hasAttribute(Q_PATCH)) {
         qDocument.qProcessVNodeDataPatch?.(script);
+        yield;
         continue;
       }
       const scriptContent = script.textContent;
@@ -30182,29 +30684,18 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
       } else {
         qContainer.qVnodeData = scriptContent;
       }
+      yield;
     }
     const shadowRoots = element.querySelectorAll("[q\\:shadowroot]");
     for (let i2 = 0; i2 < shadowRoots.length; i2++) {
       const parent = shadowRoots[i2];
       const shadowRoot = parent.shadowRoot;
-      shadowRoot && attachVnodeDataAndRefs(shadowRoot);
+      if (shadowRoot) {
+        yield* attachVnodeDataAndRefs(shadowRoot);
+      }
+      yield;
     }
   };
-  let NodeType;
-  ((NodeType2) => {
-    NodeType2[NodeType2["CONTAINER_MASK"] = 1] = "CONTAINER_MASK";
-    NodeType2[NodeType2["ELEMENT"] = 2] = "ELEMENT";
-    NodeType2[NodeType2["ELEMENT_CONTAINER"] = 3] = "ELEMENT_CONTAINER";
-    NodeType2[NodeType2["ELEMENT_SHADOW_ROOT_WRAPPER"] = 6] = "ELEMENT_SHADOW_ROOT_WRAPPER";
-    NodeType2[NodeType2["ELEMENT_SUSPENSE_RESULT_PARENT"] = 130] = "ELEMENT_SUSPENSE_RESULT_PARENT";
-    NodeType2[NodeType2["COMMENT_SKIP_START"] = 9] = "COMMENT_SKIP_START";
-    NodeType2[NodeType2["COMMENT_SKIP_END"] = 8] = "COMMENT_SKIP_END";
-    NodeType2[NodeType2["COMMENT_IGNORE_START"] = 16] = "COMMENT_IGNORE_START";
-    NodeType2[NodeType2["COMMENT_IGNORE_END"] = 32] = "COMMENT_IGNORE_END";
-    NodeType2[NodeType2["COMMENT_ISLAND_START"] = 65] = "COMMENT_ISLAND_START";
-    NodeType2[NodeType2["COMMENT_ISLAND_END"] = 64] = "COMMENT_ISLAND_END";
-    NodeType2[NodeType2["OTHER"] = 0] = "OTHER";
-  })(NodeType || (NodeType = {}));
   const getFastNodeType = (node) => {
     const nodeType = getNodeType.call(node);
     if (nodeType === 1) {
@@ -30241,7 +30732,7 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
     }
     return node;
   };
-  const walkContainer = (walker2, containerNode, node, exitNode, vData, qVNodeRefs, qContainerElement, segmentId2) => {
+  const walkContainer = function* (walker2, containerNode, node, exitNode, vData, qVNodeRefs, qContainerElement, segmentId2) {
     const isSegment = __EXPERIMENTAL__.suspense && segmentId2 !== void 0;
     const vData_length = vData.length;
     let elementIdx = 0;
@@ -30262,6 +30753,9 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
       }
       return elementsToSkip;
     };
+    if (!node) {
+      return;
+    }
     do {
       if (node === exitNode) {
         return;
@@ -30274,7 +30768,7 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
         while (cursor && !(nextNode = nextSibling(cursor))) {
           cursor = cursor.parentNode;
         }
-        walkContainer(
+        yield* walkContainer(
           walker2,
           container,
           node,
@@ -30310,13 +30804,13 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
             throw new Error(`<!--${node?.nodeValue}--> not closed!`);
           }
         } while (getFastNodeType(nextNode) !== 8 /* COMMENT_SKIP_END */);
-        walkContainer(walker2, node, node, nextNode, "", null, qContainerElement);
+        yield* walkContainer(walker2, node, node, nextNode, "", null, qContainerElement);
       } else if (nodeType === 6 /* ELEMENT_SHADOW_ROOT_WRAPPER */) {
         nextNode = nextSibling(node);
         const shadowRootContainer = node;
         const shadowRoot = shadowRootContainer?.shadowRoot;
         if (shadowRoot) {
-          walkContainer(
+          yield* walkContainer(
             // we need to create a new walker for the shadow root
             document2.createTreeWalker(
               shadowRoot,
@@ -30380,16 +30874,21 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
         }
         elementIdx++;
         if (__EXPERIMENTAL__.suspense && contentBoundaryId !== null) {
-          processSuspenseContentSegment(qContainerElement, node, contentBoundaryId);
+          yield* processSuspenseContentSegment(
+            qContainerElement,
+            node,
+            contentBoundaryId
+          );
           nextNode = nextSibling(node);
           if (nextNode) {
             walker2.currentNode = nextNode;
           }
         }
       }
+      yield;
     } while (node = nextNode || walker2.nextNode());
   };
-  const processVNodeDataScope = (qContainerElement, contentNode, vData, scopeSegmentId) => {
+  const processVNodeDataScope = function* (qContainerElement, contentNode, vData, scopeSegmentId) {
     qContainerElement.qVNodeRefs || (qContainerElement.qVNodeRefs = /* @__PURE__ */ new Map());
     const scopeWalker = document2.createTreeWalker(
       document2,
@@ -30397,7 +30896,7 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
       /*  NodeFilter.SHOW_COMMENT */
     );
     scopeWalker.currentNode = contentNode;
-    walkContainer(
+    yield* walkContainer(
       scopeWalker,
       contentNode,
       contentNode,
@@ -30408,39 +30907,33 @@ function processVNodeDataImpl(document2, segmentId, segmentContainer, segmentCon
       scopeSegmentId
     );
   };
-  const processSuspenseContentSegment = __EXPERIMENTAL__.suspense ? (qContainerElement, contentNode, boundaryId, vData) => {
+  const processSuspenseContentSegment = function* (qContainerElement, contentNode, boundaryId, vData) {
     vData || (vData = qContainerElement?.qSegmentVnodeData?.get(boundaryId));
     if (qContainerElement && vData) {
-      processVNodeDataScope(qContainerElement, contentNode, vData, boundaryId);
-    }
-  } : null;
-  qDocument.qProcessVNodeDataPatch = (script) => {
-    const qContainerElement = script?.closest("[q\\:container]");
-    const patchSegment = script?.getAttribute(Q_SUSPENSE_RESOLVED);
-    const contentNode = qContainerElement && (patchSegment ? qContainerElement.querySelector(`[q\\:rp="${patchSegment}"]`) : qContainerElement);
-    if (qContainerElement && contentNode) {
-      processVNodeDataScope(
-        qContainerElement,
-        contentNode,
-        script.textContent,
-        patchSegment || void 0
-      );
+      yield* processVNodeDataScope(qContainerElement, contentNode, vData, boundaryId);
     }
   };
-  if (__EXPERIMENTAL__.suspense && segmentId !== void 0) {
-    if (segmentContainer && segmentContent && segmentVNodeData) {
-      segmentContainer.qVNodeRefs || (segmentContainer.qVNodeRefs = /* @__PURE__ */ new Map());
-      processSuspenseContentSegment(segmentContainer, segmentContent, segmentId, segmentVNodeData);
+  if (segmentContainer && segmentContent && segmentVNodeData !== void 0) {
+    segmentContainer.qVNodeRefs || (segmentContainer.qVNodeRefs = /* @__PURE__ */ new Map());
+    if (__EXPERIMENTAL__.suspense && segmentId !== void 0) {
+      yield* processSuspenseContentSegment(
+        segmentContainer,
+        segmentContent,
+        segmentId,
+        segmentVNodeData
+      );
+    } else {
+      yield* processVNodeDataScope(segmentContainer, segmentContent, segmentVNodeData);
     }
     return;
   }
-  attachVnodeDataAndRefs(document2);
+  yield* attachVnodeDataAndRefs(document2);
   const walker = document2.createTreeWalker(
     document2,
     1 | 128
     /*  NodeFilter.SHOW_COMMENT */
   );
-  walkContainer(walker, null, walker.firstChild(), null, "", null, null);
+  yield* walkContainer(walker, null, walker.firstChild(), null, "", null, null);
 }
 var isSeparator = (ch) => (
   /* `!` */
@@ -30470,6 +30963,90 @@ var findVDataSectionEnd = (vData, start, end) => {
   return start;
 };
 
+// packages/qwik/src/core/client/process-state-data.ts
+function isContainerReady(container) {
+  return container.$containerDataProcessState$ === 3 /* ProcessingStateDone */;
+}
+function processContainerStateData(container, iterator) {
+  const state = container.$containerStateDataState$ || (container.$containerStateDataState$ = {
+    $queue$: [],
+    $active$: null
+  });
+  container.$containerDataProcessState$ = 2 /* ProcessingState */;
+  state.$queue$.push(iterator);
+  scheduleProcessContainerStateData(container, state);
+}
+var onContainerDataReady = (container, callback) => {
+  const domContainer = container;
+  const checkReady = () => {
+    if (!isContainerReady(domContainer)) {
+      (domContainer.$containerStateReadyCallbacks$ || (domContainer.$containerStateReadyCallbacks$ = [])).push(checkReady);
+      return;
+    }
+    onVNodeDataReady(domContainer.document, () => {
+      if (isContainerReady(domContainer)) {
+        callback();
+      } else {
+        checkReady();
+      }
+    });
+  };
+  checkReady();
+};
+var whenContainerDataReady = (container, callback) => {
+  const domContainer = container;
+  if (isContainerReady(domContainer) && domContainer.document.qVNodeDataReady) {
+    return callback();
+  }
+  return new Promise((resolve, reject) => {
+    onContainerDataReady(domContainer, () => {
+      try {
+        resolve(callback());
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+};
+function scheduleProcessContainerStateData(container, state) {
+  if (state.$active$) {
+    return;
+  }
+  const iterator = state.$queue$.shift();
+  if (!iterator) {
+    markContainerDataReady(container);
+    return;
+  }
+  state.$active$ = createYieldingIteratorState(
+    iterator,
+    () => {
+      state.$active$ = null;
+      scheduleProcessContainerStateData(container, state);
+    },
+    (error) => {
+      state.$active$ = null;
+      logError(error);
+      markContainerDataReady(container);
+    }
+  );
+  scheduleYieldingIterator(state.$active$);
+}
+function markContainerDataReady(container) {
+  const state = container.$containerDataProcessState$;
+  if (state !== 2 /* ProcessingState */) {
+    return;
+  }
+  container.$containerDataProcessState$ = 3 /* ProcessingStateDone */;
+  container.$containerStateDataState$ = void 0;
+  const callbacks = container.$containerStateReadyCallbacks$;
+  container.$containerStateReadyCallbacks$ = void 0;
+  if (callbacks) {
+    for (let i2 = 0; i2 < callbacks.length; i2++) {
+      callbacks[i2]();
+    }
+  }
+}
+
 // packages/qwik/src/core/client/dom-container.ts
 function getDomContainer(element) {
   const qContainerElement = _getQContainerElement(element);
@@ -30490,8 +31067,14 @@ function getOutOfOrderStreamingScript(boundaryId, content) {
   const qContainerElement = content?.closest(QContainerSelector);
   const qContainer = qContainerElement?.qContainer;
   if (qContainer) {
-    processOutOfOrderSegmentVNodeData(qContainer.element.ownerDocument, segmentId, content);
-    processSegmentStateScripts(qContainer, segmentId);
+    const document2 = qContainer.element.ownerDocument;
+    processOutOfOrderSegmentVNodeData(document2, segmentId, content);
+    onVNodeDataReady(document2, () => {
+      qContainer.element.qContainer === qContainer && processContainerStateData(
+        qContainer,
+        processSegmentStateScriptsIterator(qContainer, segmentId)
+      );
+    });
   }
 }
 var DomContainer = class extends _SharedContainer {
@@ -30507,6 +31090,9 @@ var DomContainer = class extends _SharedContainer {
     __publicField(this, "$instanceHash$");
     __publicField(this, "$forwardRefs$", null);
     __publicField(this, "vNodeLocate", (id) => vnode_locate(this.rootVNode, id));
+    __publicField(this, "$containerDataProcessState$", 0 /* NotStarted */);
+    __publicField(this, "$containerStateReadyCallbacks$");
+    __publicField(this, "$containerStateDataState$");
     __publicField(this, "$rawStateData$");
     __publicField(this, "$stateData$");
     __publicField(this, "$rootForwardRefs$", null);
@@ -30518,7 +31104,8 @@ var DomContainer = class extends _SharedContainer {
     if (!this.qContainer) {
       throw qError(25 /* elementWithoutContainer */);
     }
-    this.document = element.ownerDocument;
+    const document2 = element.ownerDocument;
+    this.document = document2;
     this.element = element;
     this.$buildBase$ = element.getAttribute(QBaseAttr);
     this.$instanceHash$ = element.getAttribute(QInstanceAttr);
@@ -30526,23 +31113,48 @@ var DomContainer = class extends _SharedContainer {
     this.rootVNode = vnode_newUnMaterializedElement(this.element);
     this.$rawStateData$ = [];
     this.$stateData$ = [];
-    const document2 = this.element.ownerDocument;
-    if (!document2.qVNodeDataProcessed) {
-      processVNodeData(document2);
-    }
     if (__EXPERIMENTAL__.suspense && document2.querySelector("template[q\\:r]")) {
       document2.qProcessOOOS || (document2.qProcessOOOS = getOutOfOrderStreamingScript);
     }
     this.$qFuncs$ = getQFuncs(document2, this.$instanceHash$) || EMPTY_ARRAY;
     this.$setServerData$();
-    element.setAttribute(QContainerAttr, "resumed" /* RESUMED */);
     element.qContainer = this;
     element.qDestroy = () => this.$destroy$();
-    this.$processRootStateScript$();
+    this.$containerDataProcessState$ = 1 /* ProcessingVNode */;
+    processVNodeData(document2, element);
+    onVNodeDataReady(document2, () => {
+      if (this.$containerDataProcessState$ === 1 /* ProcessingVNode */) {
+        processContainerStateData(this, this.$processContainerData$());
+      }
+    });
+  }
+  *$processContainerData$() {
+    const element = this.element;
+    if (element.qContainer !== this) {
+      return;
+    }
+    const rootState = element.querySelector(
+      `script[type="qwik/state"][q\\:instance="${this.$instanceHash$}"]:not(${QStatePatchAttrSelector})`
+    ) || element.querySelector(
+      `script[type="qwik/state"]:not([q\\:instance]):not(${QStatePatchAttrSelector})`
+    );
+    if (rootState) {
+      this.$rawStateData$ = JSON.parse(rootState.textContent);
+      yield* preprocessStateIterator(this.$rawStateData$, this);
+      this.$rootForwardRefs$ = this.$forwardRefs$;
+      const rootCount = this.$rawStateData$.length / 2;
+      const statePrewarm = element.getAttribute(QStatePrewarmAttr);
+      if (statePrewarm !== null && rootCount > 0 && rootCount >= Number(statePrewarm)) {
+        this.$stateData$ = yield* eagerDeserializeStateIterator(this, this.$rawStateData$);
+      } else {
+        this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
+      }
+    }
     if (__EXPERIMENTAL__.suspense) {
-      processSegmentStateScripts(this);
+      yield* processSegmentStateScriptsIterator(this);
     }
     this.$hoistStyles$();
+    element.setAttribute(QContainerAttr, "resumed" /* RESUMED */);
     if (!qTest && element.isConnected) {
       element.dispatchEvent(new CustomEvent("qresume", { bubbles: true }));
     }
@@ -30562,9 +31174,15 @@ var DomContainer = class extends _SharedContainer {
     }
     el.removeAttribute(QContainerAttr);
     const document2 = el.ownerDocument;
+    this.$containerStateDataState$ = void 0;
+    this.$containerDataProcessState$ = 0 /* NotStarted */;
     const hasContainers = document2.querySelector(QContainerSelector) !== null;
     if (!hasContainers) {
       document2.qVNodeData = void 0;
+      document2.qVNodeDataStarted = void 0;
+      document2.qVNodeDataReady = void 0;
+      document2.qVNodeDataState = void 0;
+      document2.qVNodeDataCallbacks = void 0;
       document2.qVNodeDataProcessed = void 0;
       document2.qProcessVNodeDataPatch = void 0;
     }
@@ -30574,20 +31192,6 @@ var DomContainer = class extends _SharedContainer {
       }
     }
   }
-  $processRootStateScript$() {
-    const rootState = this.element.querySelector(
-      `${this.$stateScriptSelector$()}:not(${QStatePatchAttrSelector})`
-    );
-    if (rootState) {
-      this.$rawStateData$ = JSON.parse(rootState.textContent);
-      preprocessState(this.$rawStateData$, this);
-      this.$rootForwardRefs$ = this.$forwardRefs$;
-      this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
-    }
-  }
-  $stateScriptSelector$() {
-    return `script[type="qwik/state"][q\\:instance="${this.$instanceHash$}"]`;
-  }
   /**
    * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
    * component inline to <head>)
@@ -30682,7 +31286,6 @@ var DomContainer = class extends _SharedContainer {
       case OnRenderProp:
       case QCtxAttr:
       case QBackRefs:
-      case QCursorBoundary:
         getObjectById2 = this.$getObjectById$;
         break;
       case ELEMENT_SEQ_IDX:
@@ -30716,7 +31319,7 @@ var DomContainer = class extends _SharedContainer {
   }
   getSyncFn(id) {
     const fn = this.$qFuncs$[id];
-    isDev24 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
+    isDev23 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
     return fn;
   }
   $appendStyle$(content, styleId, host, scoped) {
@@ -30761,10 +31364,10 @@ var DomContainer = class extends _SharedContainer {
 };
 
 // packages/qwik/src/core/use/use-locale.ts
-import { isServer as isServer10 } from "@qwik.dev/core/build";
+import { isServer as isServer11 } from "@qwik.dev/core/build";
 var _locale = void 0;
 var localAsyncStore;
-if (isServer10) {
+if (isServer11) {
   const AsyncLocalStorage = getAsyncLocalStorage();
   if (AsyncLocalStorage) {
     localAsyncStore = new AsyncLocalStorage();
@@ -30795,8 +31398,7 @@ function invokeApply(context, fn, args) {
     _context = previousContext;
   }
 }
-var newInvokeContextFromDOM = (event, element) => {
-  const domContainer = getDomContainer(element);
+var newInvokeContextFromDOM = (event, element, domContainer = getDomContainer(element)) => {
   const hostElement = vnode_locate(domContainer.rootVNode, element);
   const locale = domContainer.$locale$;
   locale && setLocale(locale);
@@ -30868,9 +31470,9 @@ var trackSignalAndAssignHost = (value, host, property, container, data) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/store.ts
-import { isDev as isDev25, isServer as isServer11 } from "@qwik.dev/core/build";
-var DEBUG7 = false;
-var log5 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
+import { isDev as isDev24, isServer as isServer12 } from "@qwik.dev/core/build";
+var DEBUG6 = false;
+var log4 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
 var getStoreHandler = (value) => {
   return value[STORE_HANDLER];
 };
@@ -30899,8 +31501,8 @@ var getOrCreateStore = (obj, flags, container) => {
 };
 var StoreHandler2 = class {
   constructor($flags$, $container$) {
-    this.$flags$ = $flags$;
-    this.$container$ = $container$;
+    __publicField(this, "$flags$", $flags$);
+    __publicField(this, "$container$", $container$);
     __publicField(this, "$effects$");
   }
   toString() {
@@ -30929,7 +31531,7 @@ var StoreHandler2 = class {
         }
         this.$container$ = ctx.$container$;
       } else {
-        isDev25 && assertTrue(
+        isDev24 && assertTrue(
           !ctx.$container$ || isSameContainer(ctx.$container$, this.$container$),
           "Do not use signals across containers"
         );
@@ -30964,11 +31566,11 @@ var StoreHandler2 = class {
     if (prop in target) {
       const oldValue = target[prop];
       if (newValue !== oldValue) {
-        DEBUG7 && log5("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
+        DEBUG6 && log4("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
         setNewValueAndTriggerEffects(prop, newValue, target, this);
       }
     } else {
-      DEBUG7 && log5("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
+      DEBUG6 && log4("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
       setNewValueAndTriggerEffects(prop, newValue, target, this);
     }
     return true;
@@ -31032,7 +31634,7 @@ function addStoreEffect(target, prop, store, effectSubscription, renderContainer
     effects = /* @__PURE__ */ new Set();
     effectsMap.set(prop, effects);
   }
-  const isOnServer = qTest ? isServerPlatform() : isServer11;
+  const isOnServer = qTest ? isServerPlatform() : isServer12;
   const shouldRecordExternalRootEffect = __EXPERIMENTAL__.suspense && store instanceof StoreHandler2 && isOnServer;
   ensureContainsSubscription(effects, effectSubscription);
   ensureContainsBackRef(effectSubscription, target);
@@ -31051,7 +31653,7 @@ function addStoreEffect(target, prop, store, effectSubscription, renderContainer
     }
     addQrlToSerializationCtx(effectSubscription, serializationContainer);
   }
-  DEBUG7 && log5(
+  DEBUG6 && log4(
     "sub",
     pad(
       "\n" + [...store.$effects$?.entries() || []].map(([key, value]) => `${String(key)}: ${String(value)}`).join(","),
@@ -31281,9 +31883,9 @@ var NoSerializeSymbol = /* @__PURE__ */ Symbol("noSerialize");
 var SerializerSymbol = /* @__PURE__ */ Symbol("serialize");
 
 // packages/qwik/src/core/reactive-primitives/utils.ts
-import { isBrowser as isBrowser4, isDev as isDev26 } from "@qwik.dev/core/build";
-var DEBUG8 = false;
-var log6 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
+import { isBrowser as isBrowser4, isDev as isDev25 } from "@qwik.dev/core/build";
+var DEBUG7 = false;
+var log5 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var throwIfQRLNotResolved = (qrl) => {
   const resolved = qrl.resolved;
   if (!resolved) {
@@ -31328,7 +31930,7 @@ var scheduleEffects = (container, signal, effects) => {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
       const property = effectSubscription.property;
-      isDev26 && assertDefined(container, "Container must be defined.");
+      isDev25 && assertDefined(container, "Container must be defined.");
       if (isTask(consumer)) {
         consumer.$flags$ |= 4 /* DIRTY */;
         markVNodeDirty(container, consumer.$el$, 1 /* TASKS */);
@@ -31370,7 +31972,7 @@ var scheduleEffects = (container, signal, effects) => {
       scheduleEffect(effectsSnapshot[i2]);
     }
   }
-  DEBUG8 && log6("done scheduling");
+  DEBUG7 && log5("done scheduling");
 };
 var isSerializerObj = (obj) => {
   return isObject(obj) && typeof obj[SerializerSymbol] === "function";
@@ -31485,8 +32087,8 @@ var mergeMaps = (map1, map2) => {
 var TextVNode = class extends VNode {
   constructor(flags, parent, previousSibling, nextSibling, props, node, text) {
     super(flags, parent, previousSibling, nextSibling, props);
-    this.node = node;
-    this.text = text;
+    __publicField(this, "node", node);
+    __publicField(this, "text", text);
   }
 };
 
@@ -31512,7 +32114,7 @@ var createFastGetter = (propName) => {
 
 // packages/qwik/src/core/client/vnode-utils.ts
 var vnode_newElement = (element, elementName, key = null) => {
-  isDev27 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev26 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     key,
     1 /* Element */ | 8 /* Inflated */ | -1 << 12 /* shift */,
@@ -31530,7 +32132,7 @@ var vnode_newElement = (element, elementName, key = null) => {
   return vnode;
 };
 var vnode_newUnMaterializedElement = (element) => {
-  isDev27 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev26 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     null,
     1 /* Element */ | -1 << 12 /* shift */,
@@ -31548,7 +32150,7 @@ var vnode_newUnMaterializedElement = (element) => {
   return vnode;
 };
 var vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-  isDev27 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+  isDev26 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
   const vnode = new TextVNode(
     4 /* Text */ | -1 << 12 /* shift */,
     // Flag
@@ -31580,10 +32182,10 @@ var vnode_newText = (textNode, textContent) => {
     textContent
     // Text Content
   );
-  isDev27 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
-  isDev27 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev27 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev27 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
+  isDev26 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_newVirtual = () => {
@@ -31598,9 +32200,9 @@ var vnode_newVirtual = () => {
     null,
     null
   );
-  isDev27 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev27 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev27 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_isVNode = (vNode) => {
@@ -31610,12 +32212,12 @@ var vnode_isElementVNode = (vNode) => {
   return (vNode.flags & 1 /* Element */) === 1 /* Element */;
 };
 var vnode_isElementOrTextVNode = (vNode) => {
-  isDev27 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 5 /* ELEMENT_OR_TEXT_MASK */) !== 0;
 };
 var vnode_isMaterialized = (vNode) => {
-  isDev27 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 1 /* Element */) === 1 /* Element */ && vNode.firstChild !== void 0 && vNode.lastChild !== void 0;
 };
@@ -31626,26 +32228,26 @@ var vnode_isVirtualVNode = (vNode) => {
   return (vNode.flags & 2 /* Virtual */) === 2 /* Virtual */;
 };
 var vnode_isProjection = (vNode) => {
-  isDev27 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 2 /* Virtual */) === 2 /* Virtual */ && vnode_getProp(vNode, QSlot, null) !== null;
 };
 var ensureTextVNode = (vNode) => {
-  isDev27 && assertTrue(
+  isDev26 && assertTrue(
     vnode_isTextVNode(vNode),
     "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)
   );
   return vNode;
 };
 var ensureElementOrVirtualVNode = (vNode) => {
-  isDev27 && assertDefined(vNode, "Missing vNode");
-  isDev27 && assertTrue(
+  isDev26 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertTrue(
     (vNode.flags & 3 /* ELEMENT_OR_VIRTUAL_MASK */) !== 0,
     "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode)
   );
 };
 var ensureElementVNode = (vNode) => {
-  isDev27 && assertTrue(
+  isDev26 && assertTrue(
     vnode_isElementVNode(vNode),
     "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)
   );
@@ -31886,7 +32488,7 @@ var vnode_ensureTextInflated = (journal, vnode) => {
   const flags = textVNode.flags;
   if ((flags & 8 /* Inflated */) === 0) {
     const parentNode = vnode_getDomParent(vnode, true);
-    isDev27 && assertDefined(parentNode, "Missing parent node.");
+    isDev26 && assertDefined(parentNode, "Missing parent node.");
     const sharedTextNode = textVNode.node;
     const doc = fastOwnerDocument(parentNode);
     let vCursor = vnode_getDomSibling(vnode, false, true);
@@ -31936,7 +32538,7 @@ var vnode_locate = (rootVNode, id) => {
   let refElement;
   const localId = typeof id === "string" ? id : "";
   if (typeof id === "string") {
-    isDev27 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
+    isDev26 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
     elementOffset = parseInt(localId);
     refElement = qVNodeRefs.get(elementOffset);
   } else {
@@ -31953,12 +32555,12 @@ var vnode_locate = (rootVNode, id) => {
       return vNode;
     }
   }
-  isDev27 && assertDefined(
+  isDev26 && assertDefined(
     refElement,
     "Missing refElement " + (typeof id === "string" ? `for id ${id}` : "")
   );
   if (!vnode_isVNode(refElement)) {
-    isDev27 && assertTrue(
+    isDev26 && assertTrue(
       containerElement.contains(refElement),
       `Couldn't find the element inside the container while locating the VNode.`
     );
@@ -32007,10 +32609,10 @@ var vnode_locate = (rootVNode, id) => {
 };
 var vnode_getChildWithIdx = (vNode, childIdx) => {
   let child = vnode_getFirstChild(vNode);
-  isDev27 && assertDefined(child, "Missing child.");
+  isDev26 && assertDefined(child, "Missing child.");
   while (child.flags >>> 12 /* shift */ !== childIdx) {
     child = child.nextSibling;
-    isDev27 && assertDefined(child, "Missing child.");
+    isDev26 && assertDefined(child, "Missing child.");
   }
   return child;
 };
@@ -32018,7 +32620,7 @@ var vNodeStack = [];
 var vnode_getVNodeForChildNode = (vNode, childElement) => {
   ensureElementVNode(vNode);
   let child = vnode_getFirstChild(vNode);
-  isDev27 && assertDefined(child, "Missing child.");
+  isDev26 && assertDefined(child, "Missing child.");
   while (child && (child instanceof ElementVNode ? child.node !== childElement : true)) {
     if (vnode_isVirtualVNode(child)) {
       const next = child.nextSibling;
@@ -32037,13 +32639,13 @@ var vnode_getVNodeForChildNode = (vNode, childElement) => {
         child = next || vNodeStack.pop();
       }
     }
-    isDev27 && assertDefined(child, "Missing child.");
+    isDev26 && assertDefined(child, "Missing child.");
   }
   while (vNodeStack.length) {
     vNodeStack.pop();
   }
   ensureElementVNode(child);
-  isDev27 && assertEqual(child.node, childElement, "Child not found.");
+  isDev26 && assertEqual(child.node, childElement, "Child not found.");
   return child;
 };
 var indexOfAlphanumeric = (id, length) => {
@@ -32301,7 +32903,7 @@ var vnode_getDomParentVNode = (vnode, includeProjection) => {
   return vnode;
 };
 var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-  isDev27 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
+  isDev26 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
   if (vnode_isTextVNode(vToRemove)) {
     vnode_ensureTextInflated(journal, vToRemove);
   }
@@ -32334,7 +32936,7 @@ var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
   vToRemove.nextSibling = null;
 };
 var vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
-  isDev27 && assertDefined(vDelete, "Missing vDelete.");
+  isDev26 && assertDefined(vDelete, "Missing vDelete.");
   const parent = vnode_getDomParent(vParent, true);
   if (parent && removeDOM) {
     if (vnode_isElementOrTextVNode(vParent)) {
@@ -32437,8 +33039,8 @@ var ensureMaterialized = (vnode) => {
       vFirstChild = vnode_materialize(vParent);
     }
   }
-  isDev27 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
-  isDev27 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
+  isDev26 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
+  isDev26 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
   return vFirstChild;
 };
 var _fastHasAttribute = null;
@@ -32610,7 +33212,7 @@ var materializeFromDOM = (vParent, firstChild, vData, segmentId) => {
         }
         const id = consumeValue();
         container.$setRawState$(parseInt(id, 10), vParent);
-        isDev27 && vnode_setProp(vParent, ELEMENT_ID, id);
+        isDev26 && vnode_setProp(vParent, ELEMENT_ID, id);
       } else if (peek() === VNodeDataChar.BACK_REFS) {
         if (!container) {
           container = getDomContainer(vParent.node);
@@ -32675,8 +33277,17 @@ var processVNodeData2 = (vData, callback) => {
     }
     return vData.substring(start, nextToConsumeIdx);
   };
+  const consumeEncodedValue = () => {
+    if (getChar(nextToConsumeIdx + 1) !== VNodeDataChar.SEPARATOR) {
+      return consumeValue();
+    }
+    consume();
+    const value = decodeURIComponent(decodeVNodeDataString(consumeValue()));
+    consume();
+    return value;
+  };
   while (peek() !== 0) {
-    callback(peek, consumeValue, consume, getChar, nextToConsumeIdx);
+    callback(peek, consumeValue, consume, getChar, nextToConsumeIdx, consumeEncodedValue);
   }
 };
 var vnode_getAttrKeys = (container, vnode) => {
@@ -32861,12 +33472,12 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
     return !nodeIsElement || nodeIsElement && shouldSkipElement(node);
   };
   let components = null;
-  processVNodeData2(vData, (peek, consumeValue, consume, getChar, nextToConsumeIdx) => {
+  processVNodeData2(vData, (peek, consumeValue, consume, getChar, dataIdx, consumeEncodedValue) => {
     if (isNumber(peek())) {
       while (shouldSkipNode(child)) {
         child = fastNextSibling(child);
         if (!child) {
-          throw qError(27 /* materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+          throw qError(27 /* materializeVNodeDataError */, [vData, peek(), dataIdx]);
         }
       }
       combinedText = null;
@@ -32887,35 +33498,35 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
         ) {
           child = fastNextSibling(child);
           if (!child && value > 0) {
-            throw qError(27 /* materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+            throw qError(27 /* materializeVNodeDataError */, [vData, peek(), dataIdx]);
           }
         }
       }
     } else if (peek() === VNodeDataChar.SCOPED_STYLE) {
       vnode_setProp(vParent, QScopedStyle, consumeValue());
     } else if (peek() === VNodeDataChar.RENDER_FN) {
-      (components || (components = [])).push(vParent);
-      vnode_setProp(vParent, OnRenderProp, consumeValue());
+      const renderRef = consumeValue();
+      if (renderRef.charCodeAt(0) === VNodeDataChar.RENDER_HASH_PREFIX) {
+        vnode_setProp(
+          vParent,
+          QComponentHash,
+          decodeURIComponent(decodeVNodeDataString(renderRef.slice(1)))
+        );
+      } else {
+        (components || (components = [])).push(vParent);
+        vnode_setProp(vParent, OnRenderProp, renderRef);
+      }
     } else if (peek() === VNodeDataChar.ID) {
       if (!container) {
         container = getDomContainer(element);
       }
       const id = consumeValue();
       container.$setRawState$(parseInt(id, 10), vParent);
-      isDev27 && vnode_setProp(vParent, ELEMENT_ID, id);
+      isDev26 && vnode_setProp(vParent, ELEMENT_ID, id);
     } else if (peek() === VNodeDataChar.PROPS) {
       vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
     } else if (peek() === VNodeDataChar.KEY) {
-      const isEscapedValue = getChar(nextToConsumeIdx + 1) === VNodeDataChar.SEPARATOR;
-      let value;
-      if (isEscapedValue) {
-        consume();
-        value = decodeURIComponent(decodeVNodeDataString(consumeValue()));
-        consume();
-      } else {
-        value = consumeValue();
-      }
-      vParent.key = value;
+      vParent.key = consumeEncodedValue();
     } else if (peek() === VNodeDataChar.SEQ) {
       vnode_setProp(vParent, ELEMENT_SEQ, consumeValue());
     } else if (peek() === VNodeDataChar.SEQ_IDX) {
@@ -32941,8 +33552,8 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
       vFirst = vLast = null;
     } else if (peek() === VNodeDataChar.SEPARATOR) {
       const keyValue = consumeValue();
-      const key = decodeVNodeDataString(keyValue);
-      const valueSeparatorIdx = nextToConsumeIdx + keyValue.length + 1;
+      const key = decodeURIComponent(decodeVNodeDataString(keyValue));
+      const valueSeparatorIdx = dataIdx + keyValue.length + 1;
       const isEscapedValue = getChar(valueSeparatorIdx + 1) === VNodeDataChar.SEPARATOR;
       let value;
       if (isEscapedValue) {
@@ -32962,8 +33573,7 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
       vFirst = stack.pop();
       vParent = stack.pop();
     } else if (peek() === VNodeDataChar.SLOT) {
-      const value = decodeVNodeDataString(consumeValue());
-      vnode_setProp(vParent, QSlot, value);
+      vnode_setProp(vParent, QSlot, consumeEncodedValue());
     } else {
       while (isElement(child) && shouldSkipElement(child)) {
         child = fastNextSibling(child);
@@ -34536,7 +35146,7 @@ import {
   _vnode_toString
 } from "@qwik.dev/core/internal";
 import { expect as expect2 } from "vitest";
-import { _dumpState, _preprocessState as preprocessState2 } from "@qwik.dev/core/internal";
+import { _dumpState, _preprocessState as preprocessState } from "@qwik.dev/core/internal";
 import { useContextProvider } from "../core.mjs";
 
 // packages/qwik/src/core/preloader/bundle-graph.ts
@@ -34579,7 +35189,7 @@ import { getClientManifest } from "../core.mjs";
 
 // packages/qwik/src/server/platform.ts
 import { setPlatform } from "../core.mjs";
-import { isDev as isDev28 } from "@qwik.dev/core/build";
+import { isDev as isDev27 } from "@qwik.dev/core/build";
 var getDevSegmentPath = (mapper, hash, symbolName, parent) => {
   const existing = mapper?.[hash];
   if (existing) {
@@ -34601,9 +35211,9 @@ var getDevSegmentPath = (mapper, hash, symbolName, parent) => {
 function createPlatform3(opts, resolvedManifest) {
   const mapper = resolvedManifest?.mapper;
   const mapperFn = opts.symbolMapper ? opts.symbolMapper : (symbolName, _chunk, parent) => {
-    if (mapper || isDev28 && import.meta.env?.MODE !== "test") {
+    if (mapper || isDev27 && import.meta.env?.MODE !== "test") {
       const hash = getSymbolHash2(symbolName);
-      const result = !isDev28 ? mapper[hash] : getDevSegmentPath(mapper, hash, symbolName, parent);
+      const result = !isDev27 ? mapper[hash] : getDevSegmentPath(mapper, hash, symbolName, parent);
       if (!result) {
         if (hash === SYNC_QRL) {
           return [hash, ""];
@@ -34650,7 +35260,7 @@ var getSymbolHash2 = (symbolName) => {
 };
 
 // packages/qwik/src/server/ssr-container.ts
-import { isDev as isDev30 } from "@qwik.dev/core/build";
+import { isDev as isDev29 } from "@qwik.dev/core/build";
 import {
   _SubscriptionData as SubscriptionData2,
   _SharedContainer as _SharedContainer2,
@@ -34915,14 +35525,14 @@ import {
   _EMPTY_OBJ,
   _EFFECT_BACK_REF as _EFFECT_BACK_REF2
 } from "@qwik.dev/core/internal";
-import { isDev as isDev29 } from "@qwik.dev/core/build";
+import { isDev as isDev28 } from "@qwik.dev/core/build";
 var SsrNode = class {
   constructor(parentComponent, id, attributesIndex, cleanupQueue, vnodeData, currentFile) {
-    this.parentComponent = parentComponent;
-    this.attributesIndex = attributesIndex;
-    this.cleanupQueue = cleanupQueue;
-    this.vnodeData = vnodeData;
-    this.currentFile = currentFile;
+    __publicField(this, "parentComponent", parentComponent);
+    __publicField(this, "attributesIndex", attributesIndex);
+    __publicField(this, "cleanupQueue", cleanupQueue);
+    __publicField(this, "vnodeData", vnodeData);
+    __publicField(this, "currentFile", currentFile);
     __publicField(this, "__brand__", "SsrNode");
     /**
      * ID which the deserialize will use to retrieve the node.
@@ -34940,7 +35550,7 @@ var SsrNode = class {
     this.flags = 1 /* Updatable */;
     this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_OBJ;
     this.parentComponent?.addChild(this);
-    if (isDev29 && id.indexOf("undefined") != -1) {
+    if (isDev28 && id.indexOf("undefined") != -1) {
       throw new Error(`Invalid SSR node id: ${id}`);
     }
   }
@@ -35005,7 +35615,7 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev29) {
+    if (isDev28) {
       let stringifiedAttrs = "";
       for (const key in this.attrs) {
         const value = this.attrs[key];
@@ -35021,13 +35631,13 @@ var SsrNode = class {
 };
 var DomRef = class {
   constructor($ssrNode$) {
-    this.$ssrNode$ = $ssrNode$;
+    __publicField(this, "$ssrNode$", $ssrNode$);
     __publicField(this, "__brand__", "DomRef");
   }
 };
 var SsrComponentFrame = class {
   constructor(componentNode) {
-    this.componentNode = componentNode;
+    __publicField(this, "componentNode", componentNode);
     __publicField(this, "slots", []);
     __publicField(this, "projectionDepth", 0);
     __publicField(this, "scopedStyleIds", /* @__PURE__ */ new Set());
@@ -35098,6 +35708,10 @@ var renderSSRChunks = (chunks, remap) => {
     const chunk = chunks[i2];
     if (typeof chunk === "string") {
       out += chunk;
+    } else if (chunk.type === "root-ref-delta") {
+      const id = remap ? remap[chunk.localId] ?? chunk.localId : chunk.localId;
+      const base2 = remap ? remap[chunk.localBaseId] ?? chunk.localBaseId : chunk.localBaseId;
+      out += String(id - base2);
     } else {
       const localId = chunk.type === "root-ref" ? chunk.localId : chunk.localPath[0];
       out += String(remap ? remap[localId] ?? localId : localId);
@@ -35125,6 +35739,9 @@ var StringSSRWriter = class {
   writeRootRefPath(path) {
     writeStringRootRefPath(this, path);
   }
+  writeRootRefDelta(id, base2) {
+    writeStringRootRefDelta(this, id, base2);
+  }
   clear() {
     this.buffer.length = 0;
   }
@@ -35145,6 +35762,9 @@ var StringBufferSegmentWriter = class {
   writeRootRefPath(path) {
     this.chunks.push({ type: "root-ref-path", localPath: path });
   }
+  writeRootRefDelta(id, base2) {
+    this.chunks.push({ type: "root-ref-delta", localId: id, localBaseId: base2 });
+  }
   clear() {
     this.chunks.length = 0;
   }
@@ -35284,6 +35904,7 @@ function encodeAsAlphanumeric(value) {
 }
 
 // packages/qwik/src/server/ssr-container.ts
+var VALID_ELEMENT_NAME = /^[A-Za-z][A-Za-z0-9._:-]*$/;
 var NO_SCRIPT_HERE_ELEMENTS = /* @__PURE__ */ new Set([
   "script",
   "style",
@@ -35669,11 +36290,17 @@ var SSRContainer = class extends _SharedContainer2 {
     containerAttributes[QContainerAttr] = "paused" /* PAUSED */;
     containerAttributes[QRuntimeAttr] = "2";
     containerAttributes[QVersionAttr] = this.$version$ ?? "dev";
-    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev30 ? "ssr-dev" : "ssr");
+    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev29 ? "ssr-dev" : "ssr");
     containerAttributes[QBaseAttr] = this.$buildBase$ || "";
     containerAttributes[QLocaleAttr] = this.$locale$;
     containerAttributes[QManifestHashAttr] = this.resolvedManifest.manifest.manifestHash;
     containerAttributes[QInstanceAttr] = this.$instanceHash$;
+    const statePrewarm = this.renderOptions.statePrewarm;
+    if (typeof statePrewarm === "number") {
+      containerAttributes[QStatePrewarmAttr] = String(statePrewarm);
+    } else {
+      delete containerAttributes[QStatePrewarmAttr];
+    }
     this.$serverData$.containerAttributes = containerAttributes;
     this.openElement(this.tag, null, containerAttributes);
     if (!this.isHtml) {
@@ -35686,6 +36313,9 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   /** Renders opening tag for DOM element */
   openElement(elementName, key, varAttrs, constAttrs = null, styleScopedId = null, currentFile = null, hasMovedCaptures = true) {
+    if (!VALID_ELEMENT_NAME.test(elementName)) {
+      throw qError(36 /* invalidElementName */, [JSON.stringify(elementName)]);
+    }
     const isQwikStyle = isQwikStyleElement(elementName, varAttrs) || isQwikStyleElement(elementName, constAttrs);
     if (NO_SCRIPT_HERE_ELEMENTS.has(elementName)) {
       this.$noScriptHere$++;
@@ -35724,7 +36354,9 @@ var SSRContainer = class extends _SharedContainer2 {
     }
     this.write(" " + Q_PROPS_SEPARATOR);
     if (key !== null) {
-      this.write(`="${key}"`);
+      this.write(ATTR_EQUALS_QUOTE);
+      this.write(escapeHTML(key));
+      this.write(QUOTE);
     } else if (qTest) {
       this.write(EMPTY_ATTR);
     }
@@ -35866,7 +36498,7 @@ var SSRContainer = class extends _SharedContainer2 {
         this.markVNodeRefForSerialization(componentFrame.componentNode);
       }
       this.openFragment(
-        isDev30 ? {
+        isDev29 ? {
           [DEBUG_TYPE]: "P" /* Projection */,
           [QSlotParent]: componentFrame.componentNode.id,
           [QSlot]: slotName
@@ -35995,7 +36627,7 @@ var SSRContainer = class extends _SharedContainer2 {
   emitRestStateData() {
     this.emitVNodeData();
     this.emitDelayedOutOfOrderSegmentVNodeData();
-    if (!isDev30) {
+    if (!isDev29) {
       preloaderPost(this, this.renderOptions, this.$serverData$?.nonce);
     }
     this.emitSyncFnsData();
@@ -36159,6 +36791,11 @@ var SSRContainer = class extends _SharedContainer2 {
       } else if (typeof rawValue !== "string") {
         rootId = this.addRoot(rawValue);
         if (rootId === void 0) {
+          if (key === OnRenderProp) {
+            this.write(VNodeDataChar.RENDER_FN_CHAR);
+            this.write(VNodeDataChar.RENDER_HASH_PREFIX_CHAR);
+            this.write(encodeVNodeDataString(encodeVNodeDataKey(rawValue.$hash$)));
+          }
           continue;
         }
         value = String(rootId);
@@ -36197,12 +36834,13 @@ var SSRContainer = class extends _SharedContainer2 {
           this.write(VNodeDataChar.CONTEXT_CHAR);
           break;
         case QSlot:
+          encodeValue = encodeVNodeDataKey;
           this.write(VNodeDataChar.SLOT_CHAR);
           break;
         default: {
           encodeValue = encodeURI;
           this.write(VNodeDataChar.SEPARATOR_CHAR);
-          this.write(encodeVNodeDataString(key));
+          this.write(encodeVNodeDataString(encodeVNodeDataKey(key)));
           this.write(VNodeDataChar.SEPARATOR_CHAR);
         }
       }
@@ -36220,7 +36858,7 @@ var SSRContainer = class extends _SharedContainer2 {
     }
   }
   emitStateData() {
-    if (!this.serializationCtx.$roots$.length) {
+    if (!this.serializationCtx.$roots$.length && !this.serializationCtx.$eagerResume$.size) {
       return;
     }
     const attrs = this.stateScriptAttrs();
@@ -36287,7 +36925,7 @@ var SSRContainer = class extends _SharedContainer2 {
       if (this.renderOptions.serverData?.nonce) {
         scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
       }
-      this.writeScript(scriptAttrs, JSON.stringify(patches));
+      this.writeScript(scriptAttrs, JSON.stringify(patches).replaceAll("<", "\\u003C"));
     }
   }
   emitBackpatchDataAndExecutorIfNeeded() {
@@ -36306,7 +36944,7 @@ var SSRContainer = class extends _SharedContainer2 {
     if (this.renderOptions.serverData?.nonce) {
       scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
     }
-    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev30 });
+    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev29 });
     this.writeScript(scriptAttrs, backpatchScript);
   }
   emitOutOfOrderExecutorIfNeeded() {
@@ -36316,7 +36954,7 @@ var SSRContainer = class extends _SharedContainer2 {
     this.isOutOfOrderExecutorEmitted = true;
     this.writeScript(
       { type: "text/javascript", nonce: this.renderOptions.serverData?.nonce },
-      getQwikOutOfOrderExecutorScript({ debug: isDev30 })
+      getQwikOutOfOrderExecutorScript({ debug: isDev29 })
     );
   }
   emitInlineScript(script) {
@@ -36342,7 +36980,7 @@ var SSRContainer = class extends _SharedContainer2 {
     this.write("</script>");
   }
   emitPreloaderPre() {
-    if (!isDev30) {
+    if (!isDev29) {
       preloaderPre(this, this.renderOptions.preloader, this.renderOptions.serverData?.nonce);
     }
   }
@@ -36447,7 +37085,7 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   createAndPushFrame(elementName, depthFirstElementIdx, currentFile) {
     let tagNesting = 10 /* ANYTHING */;
-    if (isDev30) {
+    if (isDev29) {
       if (!this.currentElementFrame) {
         tagNesting = initialTag(elementName);
       } else {
@@ -36494,7 +37132,7 @@ var SSRContainer = class extends _SharedContainer2 {
       elementName,
       depthFirstElementIdx,
       vNodeData: [0 /* NONE */],
-      currentFile: isDev30 ? currentFile || null : null,
+      currentFile: isDev29 ? currentFile || null : null,
       refBase: null
     };
     this.currentElementFrame = frame;
@@ -36521,6 +37159,11 @@ var SSRContainer = class extends _SharedContainer2 {
       this.size += 1 + String(path[i2]).length;
     }
   }
+  writeRootRefDelta(id, base2) {
+    const delta = id - base2;
+    this.size += String(delta).length;
+    this.writer.writeRootRefDelta(id, base2);
+  }
   writeArray(array, separator) {
     for (let i2 = 0; i2 < array.length; i2++) {
       const element = array[i2];
@@ -36535,7 +37178,7 @@ var SSRContainer = class extends _SharedContainer2 {
     for (let key in attrs) {
       let value = attrs[key];
       if (isSSRUnsafeAttr(key)) {
-        if (isDev30) {
+        if (isDev29) {
           throw qError(32 /* unsafeAttr */, [key]);
         }
         continue;
@@ -36598,7 +37241,7 @@ var SSRContainer = class extends _SharedContainer2 {
       }
       if (tag === "textarea" && key === "value") {
         if (value && typeof value !== "string") {
-          if (isDev30) {
+          if (isDev29) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -36632,6 +37275,8 @@ var SSRContainer = class extends _SharedContainer2 {
         this.write(escapeHTML(chunk));
       } else if (typeof chunk === "number") {
         this.writeRootRef(chunk);
+      } else if ("base" in chunk) {
+        this.writeRootRefDelta(chunk.id, chunk.base);
       } else {
         this.writeRootRefPath(chunk.path);
       }
@@ -36651,27 +37296,12 @@ var SSRContainer = class extends _SharedContainer2 {
 var SSRSegmentContainer = class extends SSRContainer {
   constructor(opts, $rootContainer$) {
     super(opts);
-    this.$rootContainer$ = $rootContainer$;
+    __publicField(this, "$rootContainer$", $rootContainer$);
     __publicField(this, "$outOfOrderState$", 0 /* Rendering */);
     __publicField(this, "$outOfOrderRootIdMap$", null);
     __publicField(this, "subscriptionPatchRecords", []);
     __publicField(this, "pendingVNodeDataPatches", null);
   }
-  nextOutOfOrderId() {
-    return this.$rootContainer$.nextOutOfOrderId();
-  }
-  $runQueuedRender$(render2) {
-    return this.$rootContainer$.$runQueuedRender$(render2);
-  }
-  queueOutOfOrderSegment(segment) {
-    this.$rootContainer$.queueOutOfOrderSegment(segment);
-  }
-  emitOutOfOrderSegmentScripts(scripts) {
-    this.$rootContainer$.emitOutOfOrderSegmentScripts(scripts);
-  }
-  emitOutOfOrderExecutorIfNeeded() {
-    this.$rootContainer$.emitOutOfOrderExecutorIfNeeded();
-  }
   $recordExternalRootEffect$(producer, effect, prop, sourceEffects) {
     recordExternalRootEffect(
       this.$rootContainer$.serializationCtx,
@@ -36691,7 +37321,6 @@ var SSRSegmentContainer = class extends SSRContainer {
     try {
       const commit = this.$commitRoots$(rootContainer, segmentSerializationCtx);
       this.$mergeSegmentEventData$(rootContainer, segmentSerializationCtx);
-      this.$mergeSegmentSyncFns$(rootContainer, segmentSerializationCtx);
       const subscriptionPatchRootId = this.$addSubscriptionsToRoots$(
         rootContainer,
         rootReadyAtSegment,
@@ -36763,7 +37392,7 @@ var SSRSegmentContainer = class extends SSRContainer {
     }
   }
   queueLateVNodeDataPatch(node, addedFlags) {
-    if (!__EXPERIMENTAL__.suspense || !this.outOfOrderStreaming || !(addedFlags & (16 /* SERIALIZE */ | 8 /* REFERENCE */))) {
+    if (!(addedFlags & (16 /* SERIALIZE */ | 8 /* REFERENCE */))) {
       return;
     }
     const owner = this.getVNodeDataOwnerFromNodeId(node.id);
@@ -36885,13 +37514,7 @@ var SSRSegmentContainer = class extends SSRContainer {
       rootContainer.serializationCtx.$eventQrls$.add(qrl);
     }
   }
-  $mergeSegmentSyncFns$(rootContainer, segmentSerializationCtx) {
-    rootContainer.serializationCtx.$syncFns$.push(...segmentSerializationCtx.$syncFns$);
-  }
   collectSubscriptionPatches(rootContainer, rootLimit) {
-    if (!__EXPERIMENTAL__.suspense || !this.outOfOrderStreaming) {
-      return;
-    }
     return collectSubscriptionPatches(
       rootContainer.serializationCtx,
       this.subscriptionPatchRecords,
@@ -36953,8 +37576,8 @@ function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
 // packages/qwik/src/server/ssr-stream-handler.ts
 var StreamHandler = class {
   constructor(opts, timing) {
-    this.opts = opts;
-    this.timing = timing;
+    __publicField(this, "opts", opts);
+    __publicField(this, "timing", timing);
     __publicField(this, "bufferSize", 0);
     __publicField(this, "buffer", "");
     __publicField(this, "networkFlushes", 0);
@@ -37265,7 +37888,8 @@ async function ssrRenderToDom(jsx2, opts = {}) {
     ];
     const renderOptions = {
       containerTagName: opts.containerTagName,
-      qwikLoader: opts.qwikLoader ? "inline" : "never"
+      qwikLoader: opts.qwikLoader ? "inline" : "never",
+      statePrewarm: opts.statePrewarm
     };
     if (opts.stream || opts.streaming) {
       const stream = {
@@ -37307,6 +37931,7 @@ async function ssrRenderToDom(jsx2, opts = {}) {
   if (!isStreaming) {
     emulateExecutionOfOutOfOrderScripts(document2);
   }
+  await whenContainerDataReady(container, () => void 0);
   if (opts.debug) {
     console.log("========================================================");
     console.log("------------------------- SSR --------------------------");
@@ -37362,12 +37987,12 @@ async function ssrRenderToDom(jsx2, opts = {}) {
   return { container, document: document2, vNode, getStyles };
 }
 function getDebugSerializedState(container) {
-  const stateScriptSelector2 = `script[type="qwik/state"][q\\:instance="${container.$instanceHash$}"]`;
+  const stateScriptSelector = `script[type="qwik/state"][q\\:instance="${container.$instanceHash$}"]`;
   const rootStateScript = container.element.querySelector(
-    `${stateScriptSelector2}:not(${QStatePatchAttrSelector})`
+    `${stateScriptSelector}:not(${QStatePatchAttrSelector})`
   );
   const patchStateScripts = container.element.querySelectorAll(
-    `${stateScriptSelector2}${QStatePatchAttrSelector}`
+    `${stateScriptSelector}${QStatePatchAttrSelector}`
   );
   if (!rootStateScript && patchStateScripts.length === 0) {
     return null;
@@ -37388,7 +38013,7 @@ function getDebugSerializedState(container) {
     }
   }
   const debugContainer = { $forwardRefs$: null };
-  preprocessState2(state, debugContainer);
+  preprocessState(state, debugContainer);
   for (let i2 = 0; i2 < patchForwardRefs.length; i2++) {
     const rootForwardRefs = debugContainer.$forwardRefs$ || (debugContainer.$forwardRefs$ = []);
     const forwardRefs = patchForwardRefs[i2];
@@ -37487,6 +38112,7 @@ function renderStyles(getStyles) {
 }
 async function rerenderComponent(element) {
   const container = _getDomContainer2(element);
+  await whenContainerDataReady(container, () => void 0);
   const vElement = container.vNodeLocate(element);
   const host = getHostVNode(vElement);
   markVNodeDirty(container, host, 4 /* COMPONENT */);