@qwik.dev/core 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.21-dev+c008e88
+ * @qwik.dev/core/testing 2.0.0-beta.23-dev+03de42d
  * 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
@@ -4018,16 +4018,16 @@ var require_CharacterData = __commonJS({
       //     Return a DOMString whose value is the UTF-16 code
       //     units from the offsetth UTF-16 code unit to the
       //     offset+countth UTF-16 code unit in data.
-      substringData: { value: function substringData(offset, count2) {
+      substringData: { value: function substringData(offset, count) {
         if (arguments.length < 2) {
           throw new TypeError("Not enough arguments");
         }
         offset = offset >>> 0;
-        count2 = count2 >>> 0;
-        if (offset > this.data.length || offset < 0 || count2 < 0) {
+        count = count >>> 0;
+        if (offset > this.data.length || offset < 0 || count < 0) {
           utils.IndexSizeError();
         }
-        return this.data.substring(offset, offset + count2);
+        return this.data.substring(offset, offset + count);
       } },
       // void appendData(DOMString data);
       // The appendData(data) method must append data to the context
@@ -4063,8 +4063,8 @@ var require_CharacterData = __commonJS({
       //
       //     Starting from offset UTF-16 code units remove count
       //     UTF-16 code units from the context object's data.
-      deleteData: { value: function deleteData(offset, count2) {
-        return this.replaceData(offset, count2, "");
+      deleteData: { value: function deleteData(offset, count) {
+        return this.replaceData(offset, count, "");
       } },
       // void replaceData(unsigned long offset, unsigned long count,
       //          DOMString data);
@@ -4074,15 +4074,15 @@ var require_CharacterData = __commonJS({
       // count as arguments followed by the insertData() method
       // with offset and data as arguments and re-throw any
       // exceptions these methods might have thrown.
-      replaceData: { value: function replaceData(offset, count2, data) {
+      replaceData: { value: function replaceData(offset, count, data) {
         var curtext = this.data, len = curtext.length;
         offset = offset >>> 0;
-        count2 = count2 >>> 0;
+        count = count >>> 0;
         data = String(data);
         if (offset > len || offset < 0) utils.IndexSizeError();
-        if (offset + count2 > len)
-          count2 = len - offset;
-        var prefix = curtext.substring(0, offset), suffix = curtext.substring(offset + count2);
+        if (offset + count > len)
+          count = len - offset;
+        var prefix = curtext.substring(0, offset), suffix = curtext.substring(offset + count);
         this.data = prefix + data + suffix;
       } },
       // Utility method that Node.isEqualNode() calls to test Text and
@@ -5195,11 +5195,11 @@ var require_cssparser = __commonJS({
          * @return {String} The next character or null if there is no next character.
          * @method peek
          */
-        peek: function(count2) {
+        peek: function(count) {
           var c = null;
-          count2 = typeof count2 === "undefined" ? 1 : count2;
+          count = typeof count === "undefined" ? 1 : count;
           if (this._cursor < this._input.length) {
-            c = this._input.charAt(this._cursor + count2 - 1);
+            c = this._input.charAt(this._cursor + count - 1);
           }
           return c;
         },
@@ -5318,9 +5318,9 @@ var require_cssparser = __commonJS({
          * @return {String} The string made up the read characters.
          * @method readCount
          */
-        readCount: function(count2) {
+        readCount: function(count) {
           var buffer = "";
-          while (count2--) {
+          while (count--) {
             buffer += this.read();
           }
           return buffer;
@@ -5868,7 +5868,7 @@ var require_cssparser = __commonJS({
           // Grammar
           //-----------------------------------------------------------------
           _stylesheet: function() {
-            var tokenStream = this._tokenStream, count2, token, tt;
+            var tokenStream = this._tokenStream, count, token, tt;
             this.fire("startstylesheet");
             this._charset();
             this._skipCruft();
@@ -5918,13 +5918,13 @@ var require_cssparser = __commonJS({
                         line: tokenStream.LT(0).startLine,
                         col: tokenStream.LT(0).startCol
                       });
-                      count2 = 0;
+                      count = 0;
                       while (tokenStream.advance([Tokens.LBRACE, Tokens.RBRACE]) === Tokens.LBRACE) {
-                        count2++;
+                        count++;
                       }
-                      while (count2) {
+                      while (count) {
                         tokenStream.advance([Tokens.RBRACE]);
-                        count2--;
+                        count--;
                       }
                     } else {
                       throw new SyntaxError2("Unknown @ rule.", tokenStream.LT(0).startLine, tokenStream.LT(0).startCol);
@@ -7310,17 +7310,17 @@ var require_cssparser = __commonJS({
         "border-image-outset": { multi: "<length> | <number>", max: 4 },
         "border-image-repeat": { multi: "stretch | repeat | round", max: 2 },
         "border-image-slice": function(expression) {
-          var valid = false, numeric = "<number> | <percentage>", fill = false, count2 = 0, max = 4, part;
+          var valid = false, numeric = "<number> | <percentage>", fill = false, count = 0, max = 4, part;
           if (ValidationTypes.isAny(expression, "fill")) {
             fill = true;
             valid = true;
           }
-          while (expression.hasNext() && count2 < max) {
+          while (expression.hasNext() && count < max) {
             valid = ValidationTypes.isAny(expression, numeric);
             if (!valid) {
               break;
             }
-            count2++;
+            count++;
           }
           if (!fill) {
             ValidationTypes.isAny(expression, "fill");
@@ -7343,19 +7343,19 @@ var require_cssparser = __commonJS({
         "border-left-style": "<border-style>",
         "border-left-width": "<border-width>",
         "border-radius": function(expression) {
-          var valid = false, simple = "<length> | <percentage> | inherit", slash = false, count2 = 0, max = 8, part;
-          while (expression.hasNext() && count2 < max) {
+          var valid = false, simple = "<length> | <percentage> | inherit", slash = false, count = 0, max = 8, part;
+          while (expression.hasNext() && count < max) {
             valid = ValidationTypes.isAny(expression, simple);
             if (!valid) {
-              if (String(expression.peek()) === "/" && count2 > 0 && !slash) {
+              if (String(expression.peek()) === "/" && count > 0 && !slash) {
                 slash = true;
-                max = count2 + 5;
+                max = count + 5;
                 expression.next();
               } else {
                 break;
               }
             }
-            count2++;
+            count++;
           }
           if (expression.hasNext()) {
             part = expression.next();
@@ -7737,8 +7737,8 @@ var require_cssparser = __commonJS({
       PropertyValueIterator.prototype.mark = function() {
         this._marks.push(this._i);
       };
-      PropertyValueIterator.prototype.peek = function(count2) {
-        return this.hasNext() ? this._parts[this._i + (count2 || 0)] : null;
+      PropertyValueIterator.prototype.peek = function(count) {
+        return this.hasNext() ? this._parts[this._i + (count || 0)] : null;
       };
       PropertyValueIterator.prototype.next = function() {
         return this.hasNext() ? this._parts[this._i++] : null;
@@ -8949,13 +8949,13 @@ var require_cssparser = __commonJS({
           }
         },
         singleProperty: function(types, expression, max, partial) {
-          var result2 = false, value = expression.value, count2 = 0, part;
-          while (expression.hasNext() && count2 < max) {
+          var result2 = false, value = expression.value, count = 0, part;
+          while (expression.hasNext() && count < max) {
             result2 = ValidationTypes.isAny(expression, types);
             if (!result2) {
               break;
             }
-            count2++;
+            count++;
           }
           if (!result2) {
             if (expression.hasNext() && !expression.isFirst()) {
@@ -8970,10 +8970,10 @@ var require_cssparser = __commonJS({
           }
         },
         multiProperty: function(types, expression, comma, max) {
-          var result2 = false, value = expression.value, count2 = 0, part;
-          while (expression.hasNext() && !result2 && count2 < max) {
+          var result2 = false, value = expression.value, count = 0, part;
+          while (expression.hasNext() && !result2 && count < max) {
             if (ValidationTypes.isAny(expression, types)) {
-              count2++;
+              count++;
               if (!expression.hasNext()) {
                 result2 = true;
               } else if (comma) {
@@ -9208,11 +9208,11 @@ var require_cssparser = __commonJS({
         complex: {
           __proto__: null,
           "<bg-position>": function(expression) {
-            var result2 = false, numeric = "<percentage> | <length>", xDir = "left | right", yDir = "top | bottom", count2 = 0;
-            while (expression.peek(count2) && expression.peek(count2).text !== ",") {
-              count2++;
+            var result2 = false, numeric = "<percentage> | <length>", xDir = "left | right", yDir = "top | bottom", count = 0;
+            while (expression.peek(count) && expression.peek(count).text !== ",") {
+              count++;
             }
-            if (count2 < 3) {
+            if (count < 3) {
               if (ValidationTypes.isAny(expression, xDir + " | center | " + numeric)) {
                 result2 = true;
                 ValidationTypes.isAny(expression, yDir + " | center | " + numeric);
@@ -9280,7 +9280,7 @@ var require_cssparser = __commonJS({
             return result2;
           },
           "<shadow>": function(expression) {
-            var result2 = false, count2 = 0, inset = false, color = false;
+            var result2 = false, count = 0, inset = false, color = false;
             if (expression.hasNext()) {
               if (ValidationTypes.isAny(expression, "inset")) {
                 inset = true;
@@ -9288,8 +9288,8 @@ var require_cssparser = __commonJS({
               if (ValidationTypes.isAny(expression, "<color>")) {
                 color = true;
               }
-              while (ValidationTypes.isAny(expression, "<length>") && count2 < 4) {
-                count2++;
+              while (ValidationTypes.isAny(expression, "<length>") && count < 4) {
+                count++;
               }
               if (expression.hasNext()) {
                 if (!color) {
@@ -9299,7 +9299,7 @@ var require_cssparser = __commonJS({
                   ValidationTypes.isAny(expression, "inset");
                 }
               }
-              result2 = count2 >= 2 && count2 <= 4;
+              result2 = count >= 2 && count <= 4;
             }
             return result2;
           },
@@ -15806,12 +15806,12 @@ var require_HTMLParser = __commonJS({
       this.attrs.push(this.MARKER);
     };
     HTMLParser.ActiveFormattingElements.prototype.push = function(elt, attrs) {
-      var count2 = 0;
+      var count = 0;
       for (var i = this.list.length - 1; i >= 0; i--) {
         if (this.list[i] === this.MARKER) break;
         if (equal(elt, this.list[i], this.attrs[i])) {
-          count2++;
-          if (count2 === 3) {
+          count++;
+          if (count === 3) {
             this.list.splice(i, 1);
             this.attrs.splice(i, 1);
             break;
@@ -21517,17 +21517,17 @@ var require_main = __commonJS({
           case 4:
             return bb.read();
           case 5: {
-            let count2 = bb.read32();
+            let count = bb.read32();
             let value2 = [];
-            for (let i = 0; i < count2; i++) {
+            for (let i = 0; i < count; i++) {
               value2.push(visit());
             }
             return value2;
           }
           case 6: {
-            let count2 = bb.read32();
+            let count = bb.read32();
             let value2 = {};
-            for (let i = 0; i < count2; i++) {
+            for (let i = 0; i < count; i++) {
               value2[decodeUTF8(bb.read())] = visit();
             }
             return value2;
@@ -22401,13 +22401,13 @@ is not a problem with esbuild. You need to fix your environment instead.
             watch: (options2 = {}) => new Promise((resolve, reject) => {
               if (!streamIn.hasFS) throw new Error(`Cannot use the "watch" API in this environment`);
               const keys = {};
-              const delay2 = getFlag(options2, keys, "delay", mustBeInteger);
+              const delay = getFlag(options2, keys, "delay", mustBeInteger);
               checkForInvalidFlags(options2, keys, `in watch() call`);
               const request2 = {
                 command: "watch",
                 key: buildKey
               };
-              if (delay2) request2.delay = delay2;
+              if (delay) request2.delay = delay;
               sendRequest(refs, request2, (error2) => {
                 if (error2) reject(new Error(error2));
                 else resolve(void 0);
@@ -23645,7 +23645,7 @@ import { _isJSXNode, _isStringifiable } from "@qwik.dev/core/internal";
 import { expect } from "vitest";
 
 // packages/qwik/src/core/client/vnode-utils.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/qdev.ts
 var qDev = globalThis.qDev !== false;
@@ -23966,7 +23966,6 @@ var SVG_NS = "http://www.w3.org/2000/svg";
 var MATH_NS = "http://www.w3.org/1998/Math/MathML";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
 var XML_NS = "http://www.w3.org/XML/1998/namespace";
-var ResourceEvent = "qResource";
 var RenderEvent = "qRender";
 var TaskEvent = "qTask";
 var QDefaultSlot = "";
@@ -24076,11 +24075,6 @@ var safeCall = (call, thenFn, rejectFn) => {
 var maybeThen = (valueOrPromise, thenFn) => {
   return isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
 };
-var delay = (timeout) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-};
 var checkError = (e) => {
   if (isServer2 && e instanceof ReferenceError && e.message.includes("window")) {
     e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
@@ -24132,10 +24126,10 @@ function retryOnPromise(fn, onError = justThrow) {
 }
 
 // packages/qwik/src/core/use/use-core.ts
-import { isDev as isDev20 } from "@qwik.dev/core/build";
+import { isDev as isDev19 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/client/dom-container.ts
-import { isDev as isDev19 } from "@qwik.dev/core/build";
+import { isDev as isDev18 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/use/use-sequential-scope.ts
 var useSequentialScope = () => {
@@ -24289,7 +24283,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser, isDev as isDev18 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser2, isDev as isDev17 } from "@qwik.dev/core/build";
 import { p as preload } from "@qwik.dev/core/preloader";
 
 // packages/qwik/src/core/reactive-primitives/backref.ts
@@ -24347,6 +24341,74 @@ var ElementVNode = class extends VirtualVNode {
   }
 };
 
+// packages/qwik/src/core/shared/serdes/qrl-to-string.ts
+import { isDev as isDev5 } from "@qwik.dev/core/build";
+function qrlToString(serializationContext, qrl, raw) {
+  let symbol = qrl.$symbol$;
+  let chunk = qrl.$chunk$;
+  const platform = getPlatform();
+  if (platform) {
+    const result2 = isDev5 ? platform.chunkForSymbol(symbol, chunk, qrl.dev?.file) : platform.chunkForSymbol(symbol, chunk);
+    if (result2) {
+      chunk = result2[1];
+      symbol = result2[0];
+    }
+  }
+  const isSync = isSyncQrl(qrl);
+  if (!isSync) {
+    if (!chunk) {
+      chunk = serializationContext.$symbolToChunkResolver$(qrl.$hash$);
+    }
+    if (isDev5) {
+      const backChannel = globalThis.__qrl_back_channel__ || (globalThis.__qrl_back_channel__ = /* @__PURE__ */ new Map());
+      backChannel.set(qrl.$symbol$, qrl.$symbolRef$);
+      if (!chunk) {
+        chunk = QRL_RUNTIME_CHUNK;
+      }
+    }
+    if (!chunk) {
+      throw qError(14 /* qrlMissingChunk */, [qrl.$symbol$]);
+    }
+    if (chunk.startsWith("./")) {
+      chunk = chunk.slice(2);
+    }
+  } else {
+    const fn = qrl.resolved;
+    chunk = "";
+    symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
+  }
+  const captures = qrl.getCaptured();
+  let captureIds = null;
+  if (captures && captures.length > 0) {
+    captureIds = captures.map((ref) => `${serializationContext.$addRoot$(ref)}`).join(" ");
+  }
+  if (raw) {
+    return [chunk, symbol, captureIds];
+  }
+  let qrlStringInline = `${chunk}#${symbol}`;
+  if (captureIds) {
+    qrlStringInline += `#${captureIds}`;
+  }
+  return qrlStringInline;
+}
+function createQRLWithBackChannel(chunk, symbol, captures) {
+  let qrlImporter = null;
+  if (isDev5 && chunk === QRL_RUNTIME_CHUNK) {
+    const backChannel = globalThis.__qrl_back_channel__;
+    isDev5 && assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK");
+    const fn = backChannel.get(symbol);
+    if (fn) {
+      qrlImporter = () => Promise.resolve({ [symbol]: fn });
+    }
+  }
+  return createQRL(chunk, symbol, null, qrlImporter, captures);
+}
+function parseQRL(qrl) {
+  const [chunk, symbol, captures] = qrl.split("#");
+  return createQRLWithBackChannel(chunk, symbol, captures || null);
+}
+var QRL_RUNTIME_CHUNK = "mock-chunk";
+
 // packages/qwik/src/core/client/run-qrl.ts
 function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
   const container = ctx.$container$;
@@ -24381,9 +24443,9 @@ function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromD
 }
 
 // packages/qwik/src/core/client/util-mapArray.ts
-import { isDev as isDev5 } from "@qwik.dev/core/build";
+import { isDev as isDev6 } from "@qwik.dev/core/build";
 var mapApp_findIndx = (array, key, start) => {
-  isDev5 && assertTrue(start % 2 === 0, "Expecting even number.");
+  isDev6 && assertTrue(start % 2 === 0, "Expecting even number.");
   let bottom = start >> 1;
   let top = array.length - 2 >> 1;
   while (bottom <= top) {
@@ -24434,11 +24496,8 @@ var mapArray_has = (array, key, start) => {
   return mapApp_findIndx(array, key, start) >= 0;
 };
 
-// packages/qwik/src/core/use/use-resource.ts
-import { isDev as isDev15 } from "@qwik.dev/core/build";
-
 // packages/qwik/src/core/reactive-primitives/impl/signal-impl.ts
-import { isDev as isDev6, isServer as isServer3 } from "@qwik.dev/core/build";
+import { isDev as isDev7, isServer as isServer3 } from "@qwik.dev/core/build";
 var DEBUG = false;
 var log = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var SignalImpl = class {
@@ -24448,7 +24507,7 @@ var SignalImpl = class {
     __publicField(this, "$effects$");
     __publicField(this, "$container$", null);
     __publicField(this, "$wrappedSignal$", null);
-    this.$container$ = container;
+    this.$container$ = container || tryGetInvokeContext()?.$container$ || null;
     this.$untrackedValue$ = value;
     DEBUG && log("new", this);
   }
@@ -24467,17 +24526,16 @@ var SignalImpl = class {
     this.$untrackedValue$ = value;
   }
   get value() {
+    const val = this.untrackedValue;
     const ctx = tryGetInvokeContext();
     if (!ctx) {
-      return this.untrackedValue;
+      DEBUG && log("read->no-ctx", pad("\n" + this.toString(), "  "));
+      return val;
     }
     if (this.$container$ === null) {
-      if (!ctx.$container$) {
-        return this.untrackedValue;
-      }
       this.$container$ = ctx.$container$;
     } else {
-      isDev6 && assertTrue(
+      isDev7 && assertTrue(
         !ctx.$container$ || ctx.$container$ === this.$container$,
         "Do not use signals across containers"
       );
@@ -24488,12 +24546,21 @@ var SignalImpl = class {
       ensureContainsBackRef(effectSubscriber, this);
       (import.meta.env.TEST ? !isDomContainer(this.$container$) : isServer3) && addQrlToSerializationCtx(effectSubscriber, this.$container$);
       DEBUG && log("read->sub", pad("\n" + this.toString(), "  "));
+    } else {
+      DEBUG && log("read no sub", pad("\n" + this.toString(), "  "));
     }
-    return this.untrackedValue;
+    return val;
   }
   set value(value) {
     if (value !== this.$untrackedValue$) {
-      DEBUG && log("Signal.set", this.$untrackedValue$, "->", value, pad("\n" + this.toString(), "  "));
+      DEBUG && log(
+        "Signal.set",
+        this.$untrackedValue$,
+        "->",
+        value,
+        pad("\n" + this.toString(), "  "),
+        this.$effects$ ? "subs: " + this.$effects$.size : "no subs"
+      );
       this.$untrackedValue$ = value;
       scheduleEffects(this.$container$, this, this.$effects$);
     }
@@ -24505,8 +24572,12 @@ var SignalImpl = class {
     }
   }
   toString() {
-    if (isDev6) {
-      return `[${this.constructor.name}${this.$flags$ & 1 /* INVALID */ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map((e) => "\n -> " + pad(qwikDebugToString(e.consumer), "    ")).join("\n") || "");
+    if (isDev7) {
+      try {
+        return `[${this.constructor.name}${this.$flags$ & 1 /* INVALID */ ? " INVALID" : ""} ${this.$untrackedValue$}]` + (Array.from(this.$effects$ || []).map((e) => "\n -> " + pad(qwikDebugToString(e.consumer), "    ")).join("\n") || "");
+      } catch (e) {
+        return `[${this.constructor.name} <cannot stringify>]`;
+      }
     } else {
       return this.constructor.name;
     }
@@ -24515,34 +24586,29 @@ var SignalImpl = class {
     return { value: this.$untrackedValue$ };
   }
 };
-var setupSignalValueAccess = (target, effectsFn, returnValueFn) => {
+var setupSignalValueAccess = (target, effectsProp, valueProp) => {
   const ctx = tryGetInvokeContext();
-  if (!ctx) {
-    return returnValueFn();
-  }
-  if (target.$container$ === null) {
-    if (!ctx.$container$) {
-      return returnValueFn();
-    }
-    target.$container$ = ctx.$container$;
-  } else {
-    isDev6 && assertTrue(
+  if (ctx && (target.$container$ || (target.$container$ = ctx.$container$ || null))) {
+    isDev7 && assertTrue(
       !ctx.$container$ || ctx.$container$ === target.$container$,
       "Do not use signals across containers"
     );
+    const effectSubscriber = ctx.$effectSubscriber$;
+    if (effectSubscriber) {
+      ensureContainsSubscription(
+        target[effectsProp] || (target[effectsProp] = /* @__PURE__ */ new Set()),
+        effectSubscriber
+      );
+      ensureContainsBackRef(effectSubscriber, target);
+      addQrlToSerializationCtx(effectSubscriber, target.$container$);
+      DEBUG && log("read->sub", pad("\n" + target.toString(), "  "));
+    }
   }
-  const effectSubscriber = ctx.$effectSubscriber$;
-  if (effectSubscriber) {
-    ensureContainsSubscription(effectsFn(), effectSubscriber);
-    ensureContainsBackRef(effectSubscriber, target);
-    addQrlToSerializationCtx(effectSubscriber, target.$container$);
-    DEBUG && log("read->sub", pad("\n" + target.toString(), "  "));
-  }
-  return returnValueFn();
+  return target[valueProp];
 };
 
 // packages/qwik/src/core/shared/jsx/props-proxy.ts
-import { isDev as isDev7 } from "@qwik.dev/core/build";
+import { isDev as isDev8 } from "@qwik.dev/core/build";
 function createPropsProxy(owner) {
   return new Proxy({}, new PropsProxyHandler(owner));
 }
@@ -24675,7 +24741,7 @@ var addPropsProxyEffect = (propsProxy, prop) => {
         propsProxy.$container$ = ctx.$container$;
       }
     } else {
-      isDev7 && assertTrue(
+      isDev8 && assertTrue(
         !ctx.$container$ || ctx.$container$ === propsProxy.$container$,
         "Do not use props across containers"
       );
@@ -24703,18 +24769,8 @@ var isPropsProxy = (obj) => {
   return obj && _VAR_PROPS in obj;
 };
 
-// packages/qwik/src/core/use/utils/destroyable.ts
-var cleanupDestroyable = (destroyable) => {
-  const destroy = destroyable.$destroy$;
-  if (destroy) {
-    destroyable.$destroy$ = null;
-    try {
-      destroy();
-    } catch (err) {
-      logError(err);
-    }
-  }
-};
+// packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
+import { isBrowser, 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";
@@ -24773,7 +24829,7 @@ var cleanupFn = (target, handleError) => {
     if (typeof fn == "function") {
       if (!cleanupFns) {
         cleanupFns = [];
-        target.$destroy$ = noSerialize(() => {
+        target.$destroy$ = () => {
           target.$destroy$ = null;
           for (const fn2 of cleanupFns) {
             try {
@@ -24782,7 +24838,7 @@ var cleanupFn = (target, handleError) => {
               handleError(err);
             }
           }
-        });
+        };
       }
       cleanupFns.push(fn);
     }
@@ -24791,13 +24847,13 @@ var cleanupFn = (target, handleError) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/computed-signal-impl.ts
-import { isDev as isDev8 } from "@qwik.dev/core/build";
+import { isDev as isDev9 } from "@qwik.dev/core/build";
 var DEBUG2 = false;
 var log2 = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToString));
 var _a3, _b;
 var ComputedSignalImpl = class extends (_b = SignalImpl, _a3 = _EFFECT_BACK_REF, _b) {
   constructor(container, fn, flags = 1 /* INVALID */ | 16 /* SERIALIZATION_STRATEGY_ALWAYS */) {
-    super(container, NEEDS_COMPUTATION);
+    super(container || fn.$container$, NEEDS_COMPUTATION);
     /**
      * The compute function is stored here.
      *
@@ -24814,27 +24870,20 @@ var ComputedSignalImpl = class extends (_b = SignalImpl, _a3 = _EFFECT_BACK_REF,
     this.$flags$ |= 1 /* INVALID */;
     const ctx = newInvokeContext();
     ctx.$container$ = this.$container$ || void 0;
-    maybeThen(
-      retryOnPromise(() => invoke.call(this, ctx, this.$computeIfNeeded$)),
-      () => {
-        if (this.$flags$ & 2 /* RUN_EFFECTS */) {
-          this.$flags$ &= ~2 /* RUN_EFFECTS */;
-          scheduleEffects(this.$container$, this, this.$effects$);
+    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);
         }
-      }
-    );
-  }
-  /**
-   * Use this to force running subscribers, for example when the calculated value has mutated but
-   * remained the same object
-   */
-  force() {
-    this.$flags$ |= 2 /* RUN_EFFECTS */;
-    super.force();
+      });
+    }
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev8 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev9 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -24860,13 +24909,7 @@ var ComputedSignalImpl = class extends (_b = SignalImpl, _a3 = _EFFECT_BACK_REF,
       }
       DEBUG2 && log2("Signal.$compute$", untrackedValue);
       this.$flags$ &= ~1 /* INVALID */;
-      const didChange = untrackedValue !== this.$untrackedValue$;
-      if (didChange) {
-        if (this.$untrackedValue$ !== NEEDS_COMPUTATION) {
-          this.$flags$ |= 2 /* RUN_EFFECTS */;
-        }
-        this.$untrackedValue$ = untrackedValue;
-      }
+      super.value = untrackedValue;
     } finally {
       if (ctx) {
         ctx.$effectSubscriber$ = previousEffectSubscription;
@@ -24881,29 +24924,83 @@ var log3 = (...args) => (
   // eslint-disable-next-line no-console
   console.log("ASYNC COMPUTED SIGNAL", ...args.map(qwikDebugToString))
 );
+var AsyncJob = class {
+  constructor($signal$) {
+    this.$signal$ = $signal$;
+    /** First holds the compute promise and then the cleanup promise */
+    __publicField(this, "$promise$", null);
+    __publicField(this, "$cleanupRequested$", false);
+    __publicField(this, "$canWrite$", true);
+    __publicField(this, "$track$");
+    __publicField(this, "$cleanups$");
+    __publicField(this, "$abortController$");
+  }
+  get track() {
+    return this.$track$ || (this.$track$ = trackFn(this.$signal$, this.$signal$.$container$));
+  }
+  get abortSignal() {
+    return (this.$abortController$ || (this.$abortController$ = new AbortController())).signal;
+  }
+  /** Backward compatible cache method for resource */
+  cache() {
+    console.error(
+      "useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior."
+    );
+  }
+  get previous() {
+    const val = this.$signal$.$untrackedValue$;
+    if (val !== NEEDS_COMPUTATION) {
+      return val;
+    }
+  }
+  cleanup(callback) {
+    if (typeof callback === "function") {
+      (this.$cleanups$ || (this.$cleanups$ = [])).push(callback);
+    }
+  }
+};
 var _a4, _b2;
 var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BACK_REF, _b2) {
-  constructor(container, fn, flags = 1 /* INVALID */) {
+  constructor(container, fn, flags = 1 /* INVALID */ | 16 /* SERIALIZATION_STRATEGY_ALWAYS */, options) {
     super(container, fn, flags);
     __publicField(this, "$untrackedLoading$", false);
     __publicField(this, "$untrackedError$");
     __publicField(this, "$loadingEffects$");
     __publicField(this, "$errorEffects$");
-    __publicField(this, "$destroy$");
-    __publicField(this, "$promiseValue$", NEEDS_COMPUTATION);
-    __publicField(this, "$promise$", null);
+    __publicField(this, "$current$", null);
+    // TODO only create the array if concurrency > 1
+    __publicField(this, "$jobs$", []);
+    __publicField(this, "$concurrency$", 1);
+    __publicField(this, "$interval$", 0);
+    __publicField(this, "$pollTimeoutId$");
+    __publicField(this, "$timeoutMs$");
+    __publicField(this, "$computationTimeoutId$");
     __publicField(this, _a4);
+    const interval = options?.interval || 0;
+    const concurrency = options?.concurrency ?? 1;
+    const initial = options?.initial;
+    const timeout = options?.timeout;
+    const eagerCleanup = options?.eagerCleanup;
+    if (initial !== void 0) {
+      const initialValue = typeof initial === "function" ? initial() : initial;
+      this.$untrackedValue$ = initialValue;
+    }
+    this.$concurrency$ = concurrency;
+    this.$timeoutMs$ = timeout;
+    if (eagerCleanup) {
+      this.$flags$ |= 32 /* EAGER_CLEANUP */;
+    }
+    this.interval = interval;
   }
   /**
    * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
    * has resolved or rejected.
+   *
+   * Accessing .loading will trigger computation if needed, since it's often used like
+   * `signal.loading ? <Loading /> : signal.value`.
    */
   get loading() {
-    return setupSignalValueAccess(
-      this,
-      () => this.$loadingEffects$ || (this.$loadingEffects$ = /* @__PURE__ */ new Set()),
-      () => this.untrackedLoading
-    );
+    return setupSignalValueAccess(this, "$loadingEffects$", "untrackedLoading");
   }
   set untrackedLoading(value) {
     if (value !== this.$untrackedLoading$) {
@@ -24913,15 +25010,16 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
     }
   }
   get untrackedLoading() {
+    this.$computeIfNeeded$();
+    if ((import.meta.env.TEST ? isServerPlatform() : isServer5) && this.$current$?.$promise$) {
+      DEBUG3 && log3("Throwing loading promise for SSR");
+      throw this.$current$?.$promise$;
+    }
     return this.$untrackedLoading$;
   }
   /** The error that occurred when the signal was resolved. */
   get error() {
-    return setupSignalValueAccess(
-      this,
-      () => this.$errorEffects$ || (this.$errorEffects$ = /* @__PURE__ */ new Set()),
-      () => this.untrackedError
-    );
+    return setupSignalValueAccess(this, "$errorEffects$", "untrackedError");
   }
   set untrackedError(value) {
     if (value !== this.$untrackedError$) {
@@ -24932,78 +25030,206 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
   get untrackedError() {
     return this.$untrackedError$;
   }
-  invalidate() {
-    this.$promise$ = null;
-    super.invalidate();
+  get interval() {
+    return this.$interval$;
   }
+  set interval(value) {
+    this.$clearNextPoll$();
+    this.$interval$ = value;
+    if (this.$interval$ > 0 && this.$effects$?.size) {
+      this.$scheduleNextPoll$();
+    }
+  }
+  /** Invalidates the signal, causing it to re-compute its value. */
+  async invalidate() {
+    this.$flags$ |= 1 /* INVALID */;
+    this.$clearNextPoll$();
+    if (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) {
+      await true;
+      this.$computeIfNeeded$();
+    }
+  }
+  /** Abort the current computation and run cleanups if needed. */
+  abort(reason) {
+    if (this.$current$) {
+      this.$requestCleanups$(this.$current$, reason);
+    }
+  }
+  /** Schedule eager cleanup on next macro task if no subscribers remain. */
+  $scheduleEagerCleanup$() {
+    if (!(this.$flags$ & 32 /* EAGER_CLEANUP */) || this.$hasSubscribers$()) {
+      return;
+    }
+    if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser)) {
+      return;
+    }
+    setTimeout(() => {
+      if (!this.$hasSubscribers$()) {
+        this.abort();
+      }
+    });
+  }
+  /** Returns a promise resolves when the signal finished computing. */
   async promise() {
-    this.$promise$ = null;
-    await retryOnPromise(this.$computeIfNeeded$.bind(this));
-    return this.$untrackedValue$;
+    this.$computeIfNeeded$();
+    while (this.$current$?.$promise$) {
+      await this.$current$?.$promise$;
+    }
   }
+  /** Run the computation if needed */
   $computeIfNeeded$() {
     if (!(this.$flags$ & 1 /* INVALID */)) {
       return;
     }
-    const untrackedValue = (
-      // first time
-      this.$promiseValue$ === NEEDS_COMPUTATION || // or after invalidation
-      this.$promise$ === null ? this.$promiseComputation$() : this.$promiseValue$
-    );
-    if (isPromise(untrackedValue)) {
-      const isFirstComputation = this.$promiseValue$ === NEEDS_COMPUTATION;
-      this.untrackedLoading = true;
-      this.untrackedError = void 0;
-      if (this.$promiseValue$ !== NEEDS_COMPUTATION) {
-        cleanupDestroyable(this);
-      }
-      const promise = untrackedValue.then((promiseValue) => {
-        DEBUG3 && log3("Promise resolved", promiseValue);
-        this.$promiseValue$ = promiseValue;
-        this.untrackedLoading = false;
+    this.$clearNextPoll$();
+    if (this.$current$) {
+      this.$requestCleanups$(this.$current$);
+    }
+    const limit = this.$concurrency$ === 0 ? Number.POSITIVE_INFINITY : this.$concurrency$;
+    if (this.$jobs$.length >= limit) {
+      DEBUG3 && log3(`Concurrency limit ${limit} reached, not starting new computation`);
+      return;
+    }
+    DEBUG3 && log3("Starting new async computation");
+    this.$flags$ &= ~1 /* INVALID */;
+    const running = new AsyncJob(this);
+    this.$current$ = running;
+    this.$jobs$.push(running);
+    running.$promise$ = this.$runComputation$(running);
+  }
+  async $runComputation$(running) {
+    const isCurrent = () => running === this.$current$;
+    this.untrackedLoading = true;
+    const fn = this.$computeQrl$.resolved || await this.$computeQrl$.resolve();
+    try {
+      if (this.$timeoutMs$) {
+        this.$computationTimeoutId$ = setTimeout(() => {
+          running.$abortController$?.abort();
+          const error = new Error(`timeout`);
+          if (isCurrent()) {
+            this.untrackedError = error;
+            running.$canWrite$ = false;
+          }
+        }, this.$timeoutMs$);
+      }
+      const value = await retryOnPromise(fn.bind(null, running));
+      running.$promise$ = null;
+      if (running.$canWrite$) {
+        const index = this.$jobs$.indexOf(running);
+        if (index !== -1) {
+          for (let i = 0; i < index; i++) {
+            this.$jobs$[i].$canWrite$ = false;
+          }
+        }
+        DEBUG3 && log3("Promise resolved", value);
         this.untrackedError = void 0;
-        if (this.setValue(promiseValue)) {
-          DEBUG3 && log3("Scheduling effects for subscribers", this.$effects$?.size);
-          this.$flags$ &= ~2 /* RUN_EFFECTS */;
-          scheduleEffects(this.$container$, this, this.$effects$);
-        }
-      }).catch((err) => {
-        if (isPromise(err)) {
-          return;
-        }
-        DEBUG3 && log3("Error caught in promise.catch", err);
-        this.$promiseValue$ = err;
-        this.untrackedLoading = false;
+        this.value = value;
+      }
+    } catch (err) {
+      running.$promise$ = null;
+      DEBUG3 && log3("Error caught in promise.catch", err);
+      if (isCurrent()) {
         this.untrackedError = err;
-      });
-      if (isFirstComputation) {
-        throw promise;
+      }
+    }
+    if (isCurrent()) {
+      clearTimeout(this.$computationTimeoutId$);
+      if (this.$flags$ & 1 /* INVALID */) {
+        DEBUG3 && log3("Computation finished but signal is invalid, re-running");
+        this.$computeIfNeeded$();
       } else {
-        DEBUG3 && log3("Returning stale value", this.$untrackedValue$, "while computing", untrackedValue);
-        return promise;
+        this.untrackedLoading = false;
+        this.$scheduleNextPoll$();
       }
-    } else {
-      this.setValue(untrackedValue);
     }
   }
-  async $promiseComputation$() {
-    if (!this.$promise$) {
-      const [cleanup2] = cleanupFn(this, (err) => this.$container$?.handleError(err, null));
-      this.$promise$ = this.$computeQrl$.getFn()({
-        track: trackFn(this, this.$container$),
-        cleanup: cleanup2
-      });
+  /** Called after SSR/unmount */
+  async $destroy$() {
+    this.$clearNextPoll$();
+    clearTimeout(this.$computationTimeoutId$);
+    if (this.$current$) {
+      await this.$requestCleanups$(this.$current$);
     }
-    return this.$promise$;
+    await Promise.all(this.$jobs$.map((job) => job.$promise$));
   }
-  setValue(value) {
-    this.$flags$ &= ~1 /* INVALID */;
-    const didChange = value !== this.$untrackedValue$;
-    if (didChange) {
-      this.$untrackedValue$ = value;
-      this.$flags$ |= 2 /* RUN_EFFECTS */;
+  get untrackedValue() {
+    this.$computeIfNeeded$();
+    if (this.$current$?.$promise$) {
+      if (this.$untrackedValue$ === NEEDS_COMPUTATION || (import.meta.env.TEST ? 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$;
+    }
+    if (this.$untrackedError$) {
+      DEBUG3 && log3("Throwing error while reading value", this);
+      throw this.$untrackedError$;
+    }
+    return this.$untrackedValue$;
+  }
+  $clearNextPoll$() {
+    if (this.$pollTimeoutId$ !== void 0) {
+      clearTimeout(this.$pollTimeoutId$);
+      this.$pollTimeoutId$ = void 0;
+    }
+  }
+  $scheduleNextPoll$() {
+    if ((import.meta.env.TEST ? !isServerPlatform() : isBrowser) && this.$interval$ > 0) {
+      this.$clearNextPoll$();
+      this.$pollTimeoutId$ = setTimeout(this.invalidate.bind(this), this.$interval$);
+      this.$pollTimeoutId$?.unref?.();
     }
-    return didChange;
+  }
+  $hasSubscribers$() {
+    return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
+  }
+  async $requestCleanups$(job, reason) {
+    if (job.$cleanupRequested$) {
+      return job.$promise$;
+    }
+    DEBUG3 && log3("Requesting cleanups for job", job);
+    job.$cleanupRequested$ = true;
+    job.$abortController$?.abort(reason);
+    job.$promise$ = Promise.resolve(job.$promise$).then(
+      () => job.$promise$ = this.$runCleanups$(job)
+    );
+  }
+  /** Clean up and trigger signal compute once complete */
+  async $runCleanups$(job) {
+    const cleanups = job.$cleanups$;
+    if (cleanups?.length) {
+      DEBUG3 && log3("cleanup start", job);
+      const onError = (err) => {
+        const handleError = this.$container$?.handleError;
+        if (handleError) {
+          handleError(err, null);
+        } else {
+          console.error("Error in async signal cleanup", err);
+        }
+      };
+      DEBUG3 && log3("cleanup start for real", job);
+      await Promise.all(
+        cleanups.map((fn) => {
+          try {
+            const result2 = fn();
+            if (isPromise(result2)) {
+              return result2.catch(onError);
+            }
+          } catch (err) {
+            onError(err);
+          }
+        })
+      );
+      cleanups.length = 0;
+      DEBUG3 && log3("cleanup finished", job);
+    }
+    const jobs = this.$jobs$;
+    const idx = jobs.indexOf(job);
+    if (idx !== -1) {
+      jobs.splice(idx, 1);
+    }
+    this.$computeIfNeeded$();
   }
 };
 
@@ -25043,6 +25269,7 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
       return;
     }
     throwIfQRLNotResolved(this.$computeQrl$);
+    this.$flags$ &= ~1 /* INVALID */;
     let arg = this.$computeQrl$.resolved;
     if (typeof arg === "function") {
       arg = arg();
@@ -25056,13 +25283,12 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
       "." /* VNODE */,
       this.$container$
     );
+    this.$didInitialize$ = true;
     DEBUG4 && log4("SerializerSignal.$compute$", untrackedValue);
     const didChange = this.$didInitialize$ && untrackedValue !== "undefined" || untrackedValue !== this.$untrackedValue$;
-    this.$flags$ &= ~1 /* INVALID */;
-    this.$didInitialize$ = true;
     if (didChange) {
-      this.$flags$ |= 2 /* RUN_EFFECTS */;
       this.$untrackedValue$ = untrackedValue;
+      scheduleEffects(this.$container$, this, this.$effects$);
     }
   }
 };
@@ -25081,7 +25307,7 @@ var createSerializer$ = implicit$FirstArg(
 var getValueProp = (p0) => p0.value;
 
 // packages/qwik/src/core/shared/vnode/vnode-dirty.ts
-import { isServer as isServer7 } from "@qwik.dev/core/build";
+import { isServer as isServer8 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/cursor/cursor-queue.ts
 var globalCursorQueue = [];
@@ -25097,7 +25323,7 @@ function addCursorToQueue(container, cursor) {
     }
   }
   globalCursorQueue.splice(insertIndex, 0, cursor);
-  container.$cursorCount$++;
+  container.$pendingCount$++;
   container.$renderPromise$ || (container.$renderPromise$ = new Promise((r) => container.$resolveRenderPromise$ = r));
 }
 function getHighestPriorityCursor() {
@@ -25120,7 +25346,7 @@ function getHighestPriorityCursor() {
 function pauseCursor(cursor, container) {
   pausedCursorQueue.push(cursor);
   removeCursorFromQueue(cursor, container, true);
-  container.$pausedCursorCount$++;
+  container.$pendingCount$++;
 }
 function resumeCursor(cursor, container) {
   const index = pausedCursorQueue.indexOf(cursor);
@@ -25130,7 +25356,7 @@ function resumeCursor(cursor, container) {
       pausedCursorQueue[index] = pausedCursorQueue[lastIndex];
     }
     pausedCursorQueue.pop();
-    container.$pausedCursorCount$--;
+    container.$pendingCount$--;
   }
   addCursorToQueue(container, cursor);
 }
@@ -25141,7 +25367,7 @@ function removeCursorFromQueue(cursor, container, keepCursorFlag) {
   const index = globalCursorQueue.indexOf(cursor);
   if (index !== -1) {
     globalCursorQueue.splice(index, 1);
-    container.$cursorCount$--;
+    container.$pendingCount$--;
   }
 }
 
@@ -25198,7 +25424,7 @@ function setCursorData(vNode, cursorData) {
 }
 
 // packages/qwik/src/core/client/vnode-diff.ts
-import { isDev as isDev12 } 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 {
@@ -25209,14 +25435,14 @@ var SubscriptionData = class {
 };
 
 // packages/qwik/src/core/shared/component-execution.ts
-import { isDev as isDev10, isServer as isServer5 } from "@qwik.dev/core/build";
+import { isDev as isDev11, isServer as isServer6 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/component.public.ts
-import { isDev as isDev9 } from "@qwik.dev/core/build";
+import { isDev as isDev10 } from "@qwik.dev/core/build";
 var componentQrl = (componentQrl2) => {
   function QwikComponent(props, key, flags = 0) {
-    isDev9 && assertQrl(componentQrl2);
-    isDev9 && assertNumber(flags, "The Qwik Component was not invoked correctly");
+    isDev10 && assertQrl(componentQrl2);
+    isDev10 && assertNumber(flags, "The Qwik Component was not invoked correctly");
     const hash3 = qTest ? "sX" : componentQrl2.$hash$.slice(0, 4);
     const finalKey = hash3 + ":" + (key ? key : "");
     const InnerCmp = () => {
@@ -25232,6 +25458,16 @@ var isQwikComponent = (component) => {
   return typeof component == "function" && component[SERIALIZABLE_STATE] !== void 0;
 };
 
+// packages/qwik/src/core/shared/utils/objects.ts
+var isObjectEmpty = (obj) => {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      return false;
+    }
+  }
+  return true;
+};
+
 // packages/qwik/src/core/shared/jsx/jsx-node.ts
 var _hasOwnProperty = Object.prototype.hasOwnProperty;
 var JSXNodeImpl = class {
@@ -25246,8 +25482,8 @@ var JSXNodeImpl = class {
     __publicField(this, "_proxy", null);
     this.toSort = !!toSort;
     this.key = key === null || key === void 0 ? null : typeof key === "string" ? key : "" + key;
-    this.varProps = !varProps || isEmpty(varProps) ? EMPTY_OBJ : varProps;
-    this.constProps = !constProps || isEmpty(constProps) ? null : constProps;
+    this.varProps = !varProps || isObjectEmpty(varProps) ? EMPTY_OBJ : varProps;
+    this.constProps = !constProps || isObjectEmpty(constProps) ? null : constProps;
     if (qDev && dev) {
       this.dev = {
         ...dev,
@@ -25287,9 +25523,6 @@ var isJSXNode = (n) => {
     return n instanceof JSXNodeImpl;
   }
 };
-var isEmpty = (obj) => {
-  return Object.keys(obj).length === 0;
-};
 
 // packages/qwik/src/core/shared/jsx/jsx-runtime.ts
 var Fragment = (props) => props.children;
@@ -25310,7 +25543,7 @@ var executeComponent = (container, renderHost, subscriptionHost, componentQRL, p
   let isInlineComponent = false;
   if (componentQRL === null) {
     componentQRL = container.getHostProp(renderHost, OnRenderProp);
-    isDev10 && assertDefined(componentQRL, "No Component found at this location");
+    isDev11 && assertDefined(componentQRL, "No Component found at this location");
   }
   if (isQrl(componentQRL)) {
     props = props || container.getHostProp(renderHost, ELEMENT_PROPS) || EMPTY_OBJ;
@@ -25326,7 +25559,7 @@ var executeComponent = (container, renderHost, subscriptionHost, componentQRL, p
     const inlineComponent = componentQRL;
     componentFn = () => invokeApply(iCtx, inlineComponent, [props || EMPTY_OBJ]);
   }
-  const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer5;
+  const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer6;
   const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall(
     () => {
       if (!isInlineComponent) {
@@ -25389,7 +25622,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
             }
             targetElement = placeholderElement;
           } else {
-            if (isDev10) {
+            if (isDev11) {
               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 has a valid element node. '
               );
@@ -25400,7 +25633,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
         if (targetElement) {
           if (targetElement.type === "script" && key === qVisibleEvent) {
             eventKey = "q-d:qinit";
-            if (isDev10) {
+            if (isDev11) {
               logWarn(
                 'You are trying to add an event "' + key + '" using the `useVisibleTask$` hook with the "intersection-observer" strategy, but a node to which you can add an event is not found. Using "document-ready" or "document-idle" instead.'
               );
@@ -25488,9 +25721,9 @@ var SSRRaw = () => null;
 var SSRComment = () => null;
 
 // packages/qwik/src/core/client/vnode-namespace.ts
-import { isDev as isDev11 } from "@qwik.dev/core/build";
+import { isDev as isDev12 } from "@qwik.dev/core/build";
 var isForeignObjectElement = (elementName) => {
-  return isDev11 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
+  return isDev12 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
 };
 var isSvgElement = (elementName) => elementName === "svg" || isForeignObjectElement(elementName);
 var isMathElement = (elementName) => elementName === "math";
@@ -25509,40 +25742,6 @@ var vnode_getElementNamespaceFlags = (element) => {
       return 0 /* NS_html */;
   }
 };
-function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild) {
-  const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(
-    domParentVNode,
-    newChild
-  );
-  let domChildren = [];
-  if (elementNamespace === HTML_NS) {
-    domChildren = vnode_getDOMChildNodes(journal, newChild, true);
-  } else {
-    const children = vnode_getDOMChildNodes(journal, newChild, true);
-    for (let i = 0; i < children.length; i++) {
-      const childVNode = children[i];
-      if (vnode_isTextVNode(childVNode)) {
-        domChildren.push(childVNode);
-        continue;
-      }
-      if ((childVNode.flags & 1536 /* NAMESPACE_MASK */) === (domParentVNode.flags & 1536 /* NAMESPACE_MASK */)) {
-        domChildren.push(childVNode);
-        continue;
-      }
-      const newChildElement = vnode_cloneElementWithNamespace(
-        childVNode,
-        domParentVNode,
-        elementNamespace,
-        elementNamespaceFlag
-      );
-      if (newChildElement) {
-        childVNode.node = newChildElement;
-        domChildren.push(childVNode);
-      }
-    }
-  }
-  return domChildren;
-}
 function cloneDomTreeWithNamespace(element, elementName, namespace, deep = false) {
   const newElement = element.ownerDocument.createElementNS(namespace, elementName);
   for (const attr of element.attributes) {
@@ -26305,42 +26504,17 @@ var createSetTextOperation = (target, text) => new SetTextOperation(target, text
 var createInsertOrMoveOperation = (target, parent, beforeTarget) => new InsertOrMoveOperation(target, parent, beforeTarget);
 var createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg2 = false) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg2);
 
-// packages/qwik/src/core/use/use-task.ts
-var runTask = (task, container, host) => {
-  task.$flags$ &= ~8 /* DIRTY */;
-  cleanupDestroyable(task);
-  const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
-  iCtx.$container$ = container;
-  const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
-  const track = trackFn(task, container);
-  const [cleanup2] = cleanupFn(task, (reason) => container.handleError(reason, host));
-  const taskApi = { track, cleanup: cleanup2 };
-  return safeCall(
-    () => taskFn(taskApi),
-    cleanup2,
-    (err) => {
-      if (isPromise(err)) {
-        return err.then(() => runTask(task, container, host));
-      } else {
-        container.handleError(err, host);
-      }
+// packages/qwik/src/core/use/utils/destroyable.ts
+var cleanupDestroyable = (destroyable) => {
+  if (destroyable.$destroy$) {
+    try {
+      destroyable.$destroy$();
+    } catch (err) {
+      logError(err);
     }
-  );
-};
-var Task = class extends BackRef {
-  constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
-    super();
-    this.$flags$ = $flags$;
-    this.$index$ = $index$;
-    this.$el$ = $el$;
-    this.$qrl$ = $qrl$;
-    this.$state$ = $state$;
-    this.$destroy$ = $destroy$;
+    destroyable.$destroy$ = null;
   }
 };
-var isTask = (value) => {
-  return value instanceof Task;
-};
 
 // packages/qwik/src/core/client/vnode-diff.ts
 function peekNextSibling(vCurrent) {
@@ -26404,8 +26578,8 @@ var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleId
   }
 };
 function diff(diffContext, jsxNode, vStartNode) {
-  isDev12 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
-  isDev12 && 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.vParent = vStartNode;
   diffContext.vNewNode = null;
   diffContext.vCurrent = vnode_getFirstChild(vStartNode);
@@ -26415,7 +26589,7 @@ function diff(diffContext, jsxNode, vStartNode) {
   }
   while (diffContext.stack.length) {
     while (diffContext.jsxIdx < diffContext.jsxCount) {
-      isDev12 && assertFalse(
+      isDev13 && assertFalse(
         diffContext.vParent === diffContext.vCurrent,
         "Parent and current can't be the same"
       );
@@ -26546,7 +26720,7 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
   }
   stackPush(diffContext, children, descendVNode);
   if (descendVNode) {
-    isDev12 && assertDefined(
+    isDev13 && assertDefined(
       diffContext.vCurrent || diffContext.vNewNode,
       "Expecting vCurrent to be defined."
     );
@@ -26675,8 +26849,8 @@ function expectProjection(diffContext) {
   diffContext.vCurrent = diffContext.vCurrent && diffContext.vCurrent.flags & 32 /* Deleted */ ? null : diffContext.vCurrent;
   if (diffContext.vCurrent == null) {
     diffContext.vNewNode = vnode_newVirtual();
-    isDev12 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    isDev12 && 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);
@@ -26694,30 +26868,30 @@ function expectSlot(diffContext) {
     //(id) => vnode_locate(container.rootVNode, id)
   ) : null;
   if (vProjectedNode == null) {
+    diffContext.vNewNode = vnode_newVirtual();
+    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
+    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
       diffContext.journal,
       diffContext.vParent,
-      diffContext.vNewNode = vnode_newVirtual(),
+      diffContext.vNewNode,
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
-    isDev12 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    isDev12 && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++);
     return false;
   } else if (vProjectedNode === diffContext.vCurrent) {
   } else {
     const oldParent = vProjectedNode.parent;
+    diffContext.vNewNode = vProjectedNode;
+    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
+    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
       diffContext.journal,
       diffContext.vParent,
-      diffContext.vNewNode = vProjectedNode,
+      diffContext.vNewNode,
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-    vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
-    isDev12 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    isDev12 && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++);
     if (oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === QTemplate) {
       vnode_remove(
         diffContext.journal,
@@ -26803,7 +26977,7 @@ function expectNoChildren(diffContext, removeDOM = true) {
   }
 }
 function expectNoMore(diffContext) {
-  isDev12 && assertFalse(
+  isDev13 && assertFalse(
     diffContext.vParent === diffContext.vCurrent,
     "Parent and current can't be the same"
   );
@@ -26890,7 +27064,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
       }
       if (elementName === "textarea" && key2 === "value") {
         if (value && typeof value !== "string") {
-          if (isDev12) {
+          if (isDev13) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -26916,7 +27090,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
       element.setAttribute("class", diffContext.scopedStyleIdPrefix);
     }
   }
-  vnode_insertBefore(
+  vnode_insertElementBefore(
     diffContext.journal,
     diffContext.vParent,
     diffContext.vNewNode,
@@ -26925,16 +27099,28 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
   const scopedKebabName = key.slice(2);
-  if (!Array.isArray(value)) {
-    value = [value];
-  }
-  const handlers = [];
-  for (const handler of value.flat(2)) {
-    if (handler) {
-      handlers.push(runEventHandlerQRL.bind(null, handler));
-    }
+  if (Array.isArray(value)) {
+    const arr = value;
+    const handlers = [];
+    for (let i = 0; i < arr.length; i++) {
+      const item = arr[i];
+      if (Array.isArray(item)) {
+        for (let j = 0; j < item.length; j++) {
+          const handler = item[j];
+          if (handler) {
+            handlers.push(runEventHandlerQRL.bind(null, handler));
+          }
+        }
+      } else if (item) {
+        handlers.push(runEventHandlerQRL.bind(null, item));
+      }
+    }
+    (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
+  } else if (value) {
+    (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = [
+      runEventHandlerQRL.bind(null, value)
+    ];
   }
-  (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
   if (key.charAt(2) !== "e") {
     vnode_setAttr(diffContext.journal, vnode, key, "");
   }
@@ -26975,7 +27161,7 @@ function expectElement(diffContext, jsx2, elementName) {
   const jsxProps = jsx2.varProps;
   const vNode = diffContext.vNewNode || diffContext.vCurrent;
   if (jsxProps) {
-    diffProps(diffContext, vNode, jsxProps, isDev12 && getFileLocationFromJsx(jsx2.dev) || null);
+    diffProps(diffContext, vNode, jsxProps, isDev13 && getFileLocationFromJsx(jsx2.dev) || null);
   }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
@@ -27232,14 +27418,14 @@ function expectVirtual(diffContext, type, jsxKey) {
     return;
   }
   if (jsxKey === null || diffContext.isCreationMode) {
-    vnode_insertBefore(
+    vnode_insertVirtualBefore(
       diffContext.journal,
       diffContext.vParent,
       diffContext.vNewNode = vnode_newVirtual(),
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
     diffContext.vNewNode.key = jsxKey;
-    isDev12 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
     return;
   }
   if (moveOrCreateKeyedNode(
@@ -27250,14 +27436,14 @@ function expectVirtual(diffContext, type, jsxKey) {
     diffContext.vParent,
     true
   )) {
-    vnode_insertBefore(
+    vnode_insertVirtualBefore(
       diffContext.journal,
       diffContext.vParent,
       diffContext.vNewNode = vnode_newVirtual(),
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
     diffContext.vNewNode.key = jsxKey;
-    isDev12 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
   }
 }
 function expectComponent(diffContext, component) {
@@ -27361,27 +27547,27 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
   if (host) {
     clearAllEffects(diffContext.container, host);
   }
-  vnode_insertBefore(
+  vnode_insertVirtualBefore(
     diffContext.journal,
     diffContext.vParent,
     diffContext.vNewNode = vnode_newVirtual(),
     diffContext.vCurrent && getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.jsxValue;
-  isDev12 && 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;
 }
 function insertNewInlineComponent(diffContext) {
-  vnode_insertBefore(
+  vnode_insertVirtualBefore(
     diffContext.journal,
     diffContext.vParent,
     diffContext.vNewNode = vnode_newVirtual(),
     diffContext.vCurrent && getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.jsxValue;
-  isDev12 && 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;
@@ -27398,7 +27584,7 @@ function expectText(diffContext, text) {
       return;
     }
   }
-  vnode_insertBefore(
+  vnode_insertElementBefore(
     diffContext.journal,
     diffContext.vParent,
     diffContext.vNewNode = vnode_newText(
@@ -27497,7 +27683,7 @@ function isPropsEmpty(props) {
   if (!props) {
     return true;
   }
-  return Object.keys(props).length === 0;
+  return isObjectEmpty(props);
 }
 function cleanup(container, journal, vNode, cursorRoot = null) {
   let vCursor = vNode;
@@ -27520,7 +27706,7 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
             if (isObject(obj)) {
               const objIsTask = isTask(obj);
               if (objIsTask && obj.$flags$ & 1 /* VISIBLE_TASK */) {
-                obj.$flags$ |= 32 /* NEEDS_CLEANUP */;
+                obj.$flags$ |= 16 /* NEEDS_CLEANUP */;
                 markVNodeDirty(container, vCursor, 64 /* CLEANUP */, cursorRoot);
                 continue;
               } else if (obj instanceof SignalImpl || isStore(obj)) {
@@ -27640,7 +27826,6 @@ function containsWrappedSignal(data, signal) {
   }
   return false;
 }
-var count = 0;
 
 // packages/qwik/src/core/shared/cursor/chore-execution.ts
 function executeTasks(vNode, container, cursorData) {
@@ -27653,15 +27838,13 @@ function executeTasks(vNode, container, cursorData) {
   for (const item of elementSeq) {
     if (item instanceof Task) {
       const task = item;
-      if (!(task.$flags$ & 8 /* DIRTY */)) {
+      if (!(task.$flags$ & 4 /* DIRTY */)) {
         continue;
       }
-      if (task.$flags$ & 4 /* RESOURCE */) {
-        runResource(task, container, vNode);
-      } else if (task.$flags$ & 1 /* VISIBLE_TASK */) {
+      if (task.$flags$ & 1 /* VISIBLE_TASK */) {
         (cursorData.afterFlushTasks || (cursorData.afterFlushTasks = [])).push(task);
       } else {
-        const isRenderBlocking = !!(task.$flags$ & 16 /* RENDER_BLOCKING */);
+        const isRenderBlocking = !!(task.$flags$ & 8 /* RENDER_BLOCKING */);
         const result2 = runTask(task, container, vNode);
         if (isPromise(result2)) {
           if (isRenderBlocking) {
@@ -27793,8 +27976,8 @@ function executeCleanup(vNode, container) {
   }
   for (const item of elementSeq) {
     if (item instanceof Task) {
-      if (item.$flags$ & 32 /* NEEDS_CLEANUP */) {
-        item.$flags$ &= ~32 /* NEEDS_CLEANUP */;
+      if (item.$flags$ & 16 /* NEEDS_CLEANUP */) {
+        item.$flags$ &= ~16 /* NEEDS_CLEANUP */;
         const task = item;
         cleanupDestroyable(task);
       }
@@ -27854,8 +28037,8 @@ function _flushJournal(journal) {
       } else {
         const doc2 = batchParent.ownerDocument || batchParent;
         const fragment = doc2.createDocumentFragment();
-        for (const node of batchNodes) {
-          fragment.appendChild(node);
+        for (let i = 0; i < batchNodes.length; i++) {
+          fragment.appendChild(batchNodes[i]);
         }
         fastInsertBefore(batchParent, fragment, batchBefore);
       }
@@ -27865,7 +28048,8 @@ function _flushJournal(journal) {
       batchSet.clear();
     }
   };
-  for (const operation of journal) {
+  for (let i = 0; i < journal.length; i++) {
+    const operation = journal[i];
     if (operation instanceof InsertOrMoveOperation) {
       if (batchParent === operation.parent && batchBefore === operation.beforeTarget) {
         if (!batchNodes) {
@@ -27995,7 +28179,7 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isDev as isDev13, isServer as isServer6 } from "@qwik.dev/core/build";
+import { isDev as isDev14, isServer as isServer7 } from "@qwik.dev/core/build";
 var DEBUG6 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
@@ -28024,7 +28208,7 @@ function processCursorQueue(options = {
 }
 function walkCursor(cursor, options) {
   const { timeBudget } = options;
-  const isRunningOnServer = import.meta.env.TEST ? isServerPlatform() : isServer6;
+  const isRunningOnServer = import.meta.env.TEST ? isServerPlatform() : isServer7;
   const startTime = performance.now();
   const cursorData = getCursorData(cursor);
   const blockingPromise = cursorData.promise;
@@ -28032,17 +28216,17 @@ function walkCursor(cursor, options) {
     return;
   }
   const container = cursorData.container;
-  isDev13 && assertDefined(container, "Cursor container not found");
+  isDev14 && assertDefined(container, "Cursor container not found");
   if (!cursor.dirty) {
     finishWalk(container, cursor, cursorData, isRunningOnServer);
     return;
   }
   const journal = cursorData.journal || (cursorData.journal = []);
   let currentVNode = null;
-  let count2 = 0;
+  let count = 0;
   while (currentVNode = cursorData.position) {
     DEBUG6 && console.warn("walkCursor", currentVNode.toString());
-    if (DEBUG6 && count2++ > 1e3) {
+    if (DEBUG6 && count++ > 1e3) {
       throw new Error("Infinite loop detected in cursor walker");
     }
     if (cursorData.promise) {
@@ -28109,17 +28293,17 @@ function walkCursor(cursor, options) {
       }
     }
   }
-  isDev13 && assertFalse(
+  isDev14 && assertFalse(
     !!(cursor.dirty & 127 /* 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, isServer11) {
+function finishWalk(container, cursor, cursorData, isServer12) {
   if (!(cursor.dirty & 127 /* DIRTY_MASK */)) {
     removeCursorFromQueue(cursor, container);
     DEBUG6 && console.warn("walkCursor: cursor done", cursor.toString());
-    if (!isServer11) {
+    if (!isServer12) {
       executeFlushPhase(cursor, container);
     }
     if (cursorData.extraPromises) {
@@ -28132,13 +28316,8 @@ function finishWalk(container, cursor, cursorData, isServer11) {
   }
 }
 function resolveCursor(container) {
-  DEBUG6 && console.warn(
-    `walkCursor: cursor resolved, ${container.$cursorCount$} remaining, ${container.$pausedCursorCount$} paused`
-  );
-  if (container.$cursorCount$ === 0 && container.$pausedCursorCount$ === 0) {
-    container.$resolveRenderPromise$();
-    container.$renderPromise$ = null;
-  }
+  DEBUG6 && console.warn(`walkCursor: cursor resolved, ${container.$pendingCount$} remaining`);
+  container.$checkPendingCount$();
 }
 function partitionDirtyChildren(dirtyChildren, parent) {
   let writeIndex = 0;
@@ -28176,8 +28355,8 @@ function getNextVNode(vNode, cursor) {
   const dirtyChildren = parent.dirtyChildren;
   let index = parent.nextDirtyChildIndex;
   const len = dirtyChildren.length;
-  let count2 = len;
-  while (count2-- > 0) {
+  let count = len;
+  while (count-- > 0) {
     const nextVNode = dirtyChildren[index];
     if (nextVNode.dirty & 127 /* DIRTY_MASK */) {
       parent.nextDirtyChildIndex = (index + 1) % len;
@@ -28282,7 +28461,7 @@ function findAndPropagateToBlockingCursor(vNode) {
   return false;
 }
 function isSsrNodeGuard(_vNode) {
-  return import.meta.env.TEST ? isServerPlatform() : isServer7;
+  return import.meta.env.TEST ? isServerPlatform() : isServer8;
 }
 function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
   const prevDirty = vNode.dirty;
@@ -28336,7 +28515,7 @@ function addVNodeOperation(journal, operation) {
 }
 
 // packages/qwik/src/core/reactive-primitives/impl/wrapped-signal-impl.ts
-import { isDev as isDev14 } from "@qwik.dev/core/build";
+import { isDev as isDev15 } from "@qwik.dev/core/build";
 var _a5, _b3;
 var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF, _b3) {
   constructor(container, fn, args, fnStr, flags = 1 /* INVALID */ | 4 /* UNWRAP */) {
@@ -28367,20 +28546,9 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF,
       scheduleEffects(this.$container$, this, this.$effects$);
     }
   }
-  /**
-   * Use this to force running subscribers, for example when the calculated value has mutated but
-   * remained the same object.
-   */
-  force() {
-    this.$flags$ |= 2 /* RUN_EFFECTS */;
-    if (this.$container$ && this.$hostElement$) {
-      this.$container$.setHostProp(this.$hostElement$, HOST_SIGNAL, this);
-      markVNodeDirty(this.$container$, this.$hostElement$, 16 /* COMPUTE */);
-    }
-  }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev14 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev15 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -28467,6 +28635,11 @@ function clearAsyncSignal(producer, effect) {
   if (pendingEffects && pendingEffects.has(effect)) {
     pendingEffects.delete(effect);
   }
+  const errorEffects = producer.$errorEffects$;
+  if (errorEffects && errorEffects.has(effect)) {
+    errorEffects.delete(effect);
+  }
+  producer.$scheduleEagerCleanup$();
 }
 function clearStoreOrProps(producer, effect) {
   const effects = producer?.$effects$;
@@ -28482,125 +28655,41 @@ function clearStoreOrProps(producer, effect) {
   }
 }
 
-// packages/qwik/src/core/use/use-resource.ts
-var getResolved = (resource) => resource._resolved;
-var getLoading = (resource) => resource.loading;
-var _createResourceReturn = (opts) => {
-  const resource = {
-    __brand: "resource",
-    value: void 0,
-    loading: !isServerPlatform(),
-    _resolved: void 0,
-    _error: void 0,
-    _state: "pending",
-    _timeout: opts?.timeout ?? -1,
-    _cache: 0,
-    _generation: 0
-  };
-  return resource;
-};
-var createResourceReturn = (container, opts, initialPromise) => {
-  const result2 = _createResourceReturn(opts);
-  result2.value = initialPromise;
-  return createStore(container, result2, 1 /* RECURSIVE */);
-};
-var runResource = (task, container, host) => {
-  task.$flags$ &= ~8 /* DIRTY */;
+// packages/qwik/src/core/use/use-task.ts
+var runTask = (task, container, host) => {
+  task.$flags$ &= ~4 /* DIRTY */;
   cleanupDestroyable(task);
-  const iCtx = newInvokeContext(container.$locale$, host, ResourceEvent);
+  const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
   iCtx.$container$ = container;
   const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
-  const resource = task.$state$;
-  isDev15 && assertDefined(
-    resource,
-    'useResource: when running a resource, "task.resource" must be a defined.',
-    task
-  );
   const track = trackFn(task, container);
-  const [cleanup2, cleanups] = cleanupFn(
-    task,
-    (reason) => container.handleError(reason, host)
-  );
-  const resourceTarget = unwrapStore(resource);
-  const opts = {
-    track,
-    cleanup: cleanup2,
-    cache(policy) {
-      let milliseconds = 0;
-      if (policy === "immutable") {
-        milliseconds = Infinity;
-      } else {
-        milliseconds = policy;
-      }
-      resource._cache = milliseconds;
-    },
-    previous: resourceTarget._resolved
-  };
-  let resolve;
-  let reject;
-  let done = false;
-  const currentGeneration = ++resourceTarget._generation;
-  const setState = (resolved, value) => {
-    if (done || resourceTarget._generation !== currentGeneration) {
-      return false;
-    }
-    done = true;
-    if (resolved) {
-      resourceTarget.loading = false;
-      resourceTarget._state = "resolved";
-      resourceTarget._resolved = value;
-      resourceTarget._error = void 0;
-      resolve(value);
-    } else {
-      resourceTarget.loading = false;
-      resourceTarget._state = "rejected";
-      resourceTarget._error = value;
-      reject(value);
-    }
-    if (!isServerPlatform()) {
-      forceStoreEffects(resource, "_state");
-    }
-    return true;
-  };
-  cleanups.push(() => {
-    if (untrack(getLoading, resource) === true) {
-      const value = untrack(getResolved, resource);
-      setState(true, value);
-    }
-  });
-  invoke(iCtx, () => {
-    resource._state = "pending";
-    resource.loading = !isServerPlatform();
-    resource.value = new Promise((r, re) => {
-      resolve = r;
-      reject = re;
-    });
-  });
-  const promise = safeCall(
-    () => taskFn(opts),
-    (value) => {
-      setState(true, value);
-    },
+  const [cleanup2] = cleanupFn(task, (reason) => container.handleError(reason, host));
+  const taskApi = { track, cleanup: cleanup2 };
+  return safeCall(
+    () => taskFn(taskApi),
+    cleanup2,
     (err) => {
       if (isPromise(err)) {
-        return err.then(() => runResource(task, container, host));
+        return err.then(() => runTask(task, container, host));
       } else {
-        setState(false, err);
+        container.handleError(err, host);
       }
     }
   );
-  const timeout = resourceTarget._timeout;
-  if (timeout > 0) {
-    return Promise.race([
-      promise,
-      delay(timeout).then(() => {
-        if (setState(false, new Error("timeout"))) {
-          cleanupDestroyable(task);
-        }
-      })
-    ]);
+};
+var Task = class extends BackRef {
+  constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+    super();
+    this.$flags$ = $flags$;
+    this.$index$ = $index$;
+    this.$el$ = $el$;
+    this.$qrl$ = $qrl$;
+    this.$state$ = $state$;
+    this.$destroy$ = $destroy$;
   }
-  return promise;
+};
+var isTask = (value) => {
+  return value instanceof Task;
 };
 
 // packages/qwik/src/core/shared/cursor/ssr-chore-execution.ts
@@ -28648,15 +28737,10 @@ function executeTasksChore(container, ssrNode) {
   for (const item of elementSeq) {
     if (item instanceof Task) {
       const task = item;
-      if (!(task.$flags$ & 8 /* DIRTY */)) {
+      if (!(task.$flags$ & 4 /* DIRTY */)) {
         continue;
       }
-      let result2;
-      if (task.$flags$ & 4 /* RESOURCE */) {
-        result2 = runResource(task, container, ssrNode);
-      } else {
-        result2 = runTask(task, container, ssrNode);
-      }
+      const result2 = runTask(task, container, ssrNode);
       promise = promise ? promise.then(() => result2) : result2;
     }
   }
@@ -28701,77 +28785,7 @@ function _chk(_, element) {
 var version = globalThis.QWIK_VERSION;
 
 // packages/qwik/src/core/shared/serdes/serialize.ts
-import { isDev as isDev17 } from "@qwik.dev/core/build";
-
-// packages/qwik/src/core/shared/serdes/qrl-to-string.ts
 import { isDev as isDev16 } from "@qwik.dev/core/build";
-function qrlToString(serializationContext, qrl, raw) {
-  let symbol = qrl.$symbol$;
-  let chunk = qrl.$chunk$;
-  const platform = getPlatform();
-  if (platform) {
-    const result2 = isDev16 ? platform.chunkForSymbol(symbol, chunk, qrl.dev?.file) : platform.chunkForSymbol(symbol, chunk);
-    if (result2) {
-      chunk = result2[1];
-      symbol = result2[0];
-    }
-  }
-  const isSync = isSyncQrl(qrl);
-  if (!isSync) {
-    if (!chunk) {
-      chunk = serializationContext.$symbolToChunkResolver$(qrl.$hash$);
-    }
-    if (isDev16) {
-      const backChannel = globalThis.__qrl_back_channel__ || (globalThis.__qrl_back_channel__ = /* @__PURE__ */ new Map());
-      backChannel.set(qrl.$symbol$, qrl.$symbolRef$);
-      if (!chunk) {
-        chunk = QRL_RUNTIME_CHUNK;
-      }
-    }
-    if (!chunk) {
-      throw qError(14 /* qrlMissingChunk */, [qrl.$symbol$]);
-    }
-    if (chunk.startsWith("./")) {
-      chunk = chunk.slice(2);
-    }
-  } else {
-    const fn = qrl.resolved;
-    chunk = "";
-    symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
-  }
-  const captures = qrl.getCaptured();
-  let captureIds = null;
-  if (captures && captures.length > 0) {
-    captureIds = captures.map((ref) => `${serializationContext.$addRoot$(ref)}`).join(" ");
-  }
-  if (raw) {
-    return [chunk, symbol, captureIds];
-  }
-  let qrlStringInline = `${chunk}#${symbol}`;
-  if (captureIds) {
-    qrlStringInline += `#${captureIds}`;
-  }
-  return qrlStringInline;
-}
-function createQRLWithBackChannel(chunk, symbol, captures) {
-  let qrlImporter = null;
-  if (isDev16 && chunk === QRL_RUNTIME_CHUNK) {
-    const backChannel = globalThis.__qrl_back_channel__;
-    isDev16 && assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK");
-    const fn = backChannel.get(symbol);
-    if (fn) {
-      qrlImporter = () => Promise.resolve({ [symbol]: fn });
-    }
-  }
-  return createQRL(chunk, symbol, null, qrlImporter, captures);
-}
-function parseQRL(qrl) {
-  const [chunk, symbol, captures] = qrl.split("#");
-  return createQRLWithBackChannel(chunk, symbol, captures || null);
-}
-var QRL_RUNTIME_CHUNK = "mock-chunk";
-
-// packages/qwik/src/core/shared/serdes/serialize.ts
 async function serialize(serializationContext) {
   const {
     $writer$,
@@ -28943,7 +28957,7 @@ async function serialize(serializationContext) {
           } else if (isQwikComponent(value)) {
             const [qrl] = value[SERIALIZABLE_STATE];
             serializationContext.$renderSymbols$.add(qrl.$symbol$);
-            output(22 /* Component */, [qrl]);
+            output(21 /* Component */, [qrl]);
           } else {
             throw qError(34 /* serializeErrorCannotSerializeFunction */, [value.toString()]);
           }
@@ -28975,58 +28989,45 @@ async function serialize(serializationContext) {
   const writeObjectValue = (value) => {
     if (isPropsProxy(value)) {
       const owner = value[_OWNER];
-      output(31 /* PropsProxy */, [
+      output(30 /* PropsProxy */, [
         _serializationWeakRef(owner),
         owner.varProps,
         owner.constProps,
         value[_PROPS_HANDLER].$effects$
       ]);
     } else if (value instanceof SubscriptionData) {
-      output(32 /* SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+      output(31 /* SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
     } else if (value instanceof EffectSubscription) {
-      output(33 /* EffectSubscription */, [
+      output(32 /* EffectSubscription */, [
         value.consumer,
         value.property,
         value.backRef,
         value.data
       ]);
     } else if (isStore(value)) {
-      if (isResource(value)) {
-        serializationContext.$resources$.add(value);
-        const forwardRefId = resolvePromise(value.value, $addRoot$, (resolved, resolvedValue) => {
-          return new PromiseResult(
-            21 /* Resource */,
-            resolved,
-            resolvedValue,
-            getStoreHandler(value).$effects$
-          );
-        });
-        output(2 /* ForwardRef */, forwardRefId);
-      } else {
-        const storeHandler = getStoreHandler(value);
-        const storeTarget = getStoreTarget(value);
-        const flags = storeHandler.$flags$;
-        const effects = storeHandler.$effects$;
-        const innerStores = [];
-        for (const prop in storeTarget) {
-          const propValue = storeTarget[prop];
-          const innerStore = $storeProxyMap$.get(propValue);
-          if (innerStore) {
-            innerStores.push(innerStore);
-          }
-        }
-        const out = [storeTarget, flags, effects, ...innerStores];
-        while (out[out.length - 1] === void 0) {
-          out.pop();
-        }
-        output(28 /* Store */, out);
+      const storeHandler = getStoreHandler(value);
+      const storeTarget = getStoreTarget(value);
+      const flags = storeHandler.$flags$;
+      const effects = storeHandler.$effects$;
+      const innerStores = [];
+      for (const prop in storeTarget) {
+        const propValue = storeTarget[prop];
+        const innerStore = $storeProxyMap$.get(propValue);
+        if (innerStore) {
+          innerStores.push(innerStore);
+        }
+      }
+      const out = [storeTarget, flags, effects, ...innerStores];
+      while (out[out.length - 1] === void 0) {
+        out.pop();
       }
+      output(27 /* Store */, out);
     } else if (isSerializerObj(value)) {
       const result2 = value[SerializerSymbol](value);
       if (isPromise(result2)) {
         const forwardRef = resolvePromise(result2, $addRoot$, (resolved, resolvedValue) => {
           return new PromiseResult(
-            27 /* SerializerSignal */,
+            26 /* SerializerSignal */,
             resolved,
             resolvedValue,
             void 0,
@@ -29063,7 +29064,7 @@ async function serialize(serializationContext) {
         if (isPromise(maybeValue)) {
           const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => {
             return new PromiseResult(
-              27 /* SerializerSignal */,
+              26 /* SerializerSignal */,
               resolved,
               resolvedValue,
               value.$effects$,
@@ -29072,7 +29073,7 @@ async function serialize(serializationContext) {
           });
           output(2 /* ForwardRef */, forwardRefId);
         } else {
-          output(27 /* SerializerSignal */, [
+          output(26 /* SerializerSignal */, [
             value.$computeQrl$,
             filterEffectBackRefs(value[_EFFECT_BACK_REF]),
             value.$effects$,
@@ -29082,7 +29083,7 @@ async function serialize(serializationContext) {
         return;
       }
       if (value instanceof WrappedSignalImpl) {
-        output(24 /* WrappedSignal */, [
+        output(23 /* WrappedSignal */, [
           ...serializeWrappingFn(serializationContext, value),
           filterEffectBackRefs(value[_EFFECT_BACK_REF]),
           value.$flags$,
@@ -29095,35 +29096,40 @@ async function serialize(serializationContext) {
         const shouldNeverSerialize = value.$flags$ & 8 /* SERIALIZATION_STRATEGY_NEVER */;
         const isInvalid = value.$flags$ & 1 /* INVALID */;
         const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-        if (shouldAlwaysSerialize) {
+        const isAsync = value instanceof AsyncSignalImpl;
+        const interval = isAsync && value.$interval$ > 0 ? value.$interval$ : void 0;
+        const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : void 0;
+        const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : void 0;
+        const eagerCleanup = isAsync && value.$flags$ & 32 /* EAGER_CLEANUP */ ? true : void 0;
+        if (isInvalid || isSkippable) {
+          v = NEEDS_COMPUTATION;
+        } else if (shouldAlwaysSerialize) {
           v = value.$untrackedValue$;
         } else if (shouldNeverSerialize) {
           v = NEEDS_COMPUTATION;
-        } else if (isInvalid || isSkippable) {
-          v = NEEDS_COMPUTATION;
         }
         const out = [
           value.$computeQrl$,
           filterEffectBackRefs(value[_EFFECT_BACK_REF]),
           value.$effects$
         ];
-        const isAsync = value instanceof AsyncSignalImpl;
         if (isAsync) {
-          out.push(
-            value.$loadingEffects$,
-            value.$errorEffects$,
-            value.$untrackedLoading$,
-            value.$untrackedError$
-          );
+          out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
         }
         let keepUndefined = false;
-        if (v !== NEEDS_COMPUTATION) {
+        if (v !== NEEDS_COMPUTATION || interval !== void 0 || concurrency !== void 0 || timeout !== void 0) {
           out.push(v);
-          if (!isAsync && v === void 0) {
+          if (v === void 0) {
             keepUndefined = true;
           }
         }
-        output(isAsync ? 26 /* AsyncSignal */ : 25 /* ComputedSignal */, out, keepUndefined);
+        if (isAsync) {
+          out.push(interval);
+          out.push(concurrency);
+          out.push(timeout);
+          out.push(eagerCleanup);
+        }
+        output(isAsync ? 25 /* AsyncSignal */ : 24 /* ComputedSignal */, out, keepUndefined);
       } else {
         const v = value.$untrackedValue$;
         const keepUndefined = v === void 0;
@@ -29131,7 +29137,7 @@ async function serialize(serializationContext) {
         if (value.$effects$) {
           out.push(...value.$effects$);
         }
-        output(23 /* Signal */, out, keepUndefined);
+        output(22 /* Signal */, out, keepUndefined);
       }
     } else if (value instanceof URL) {
       output(6 /* URL */, value.href);
@@ -29142,7 +29148,7 @@ async function serialize(serializationContext) {
     } else if (value instanceof Error) {
       const out = [value.message];
       out.push(...Object.entries(value).flat());
-      if (isDev17) {
+      if (isDev16) {
         out.push("stack", value.stack);
       }
       output(15 /* Error */, out);
@@ -29180,7 +29186,7 @@ async function serialize(serializationContext) {
           array.push(key, value2.name);
         }
       });
-      output(29 /* FormData */, array);
+      output(28 /* FormData */, array);
     } else if (value instanceof URLSearchParams) {
       output(13 /* URLSearchParams */, value.toString());
     } else if (value instanceof Set) {
@@ -29203,7 +29209,7 @@ async function serialize(serializationContext) {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      output(30 /* JSXNode */, out);
+      output(29 /* JSXNode */, out);
     } else if (value instanceof Task) {
       const out = [
         value.$qrl$,
@@ -29223,11 +29229,9 @@ async function serialize(serializationContext) {
       });
       output(2 /* ForwardRef */, forwardRefId);
     } else if (value instanceof PromiseResult) {
-      if (value.$type$ === 21 /* Resource */) {
-        output(21 /* Resource */, [value.$resolved$, value.$value$, value.$effects$]);
-      } else if (value.$type$ === 27 /* SerializerSignal */) {
+      if (value.$type$ === 26 /* SerializerSignal */) {
         if (value.$qrl$) {
-          output(27 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
+          output(26 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
         } else if (value.$resolved$) {
           const index = parent.$index$;
           parent = parent.$parent$;
@@ -29368,9 +29372,6 @@ function isObjectLiteral(obj) {
   const prototype = Object.getPrototypeOf(obj);
   return prototype == null || prototype === Object.prototype || prototype === Array.prototype;
 }
-function isResource(value) {
-  return "__brand" in value && value.__brand === "resource";
-}
 function serializeWrappingFn(serializationContext, value) {
   if (value.$funcStr$ && value.$funcStr$[0] === "{") {
     value.$funcStr$ = `(${value.$funcStr$})`;
@@ -29420,6 +29421,7 @@ var createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToCh
   const syncFnMap = /* @__PURE__ */ new Map();
   const syncFns = [];
   const roots = [];
+  const eagerResume = /* @__PURE__ */ new Set();
   const getSeenRef = (obj) => seenObjsMap.get(obj);
   const $markSeen$ = (obj, parent, index) => {
     const ref = { $index$: index, $parent$: parent };
@@ -29507,9 +29509,10 @@ var createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToCh
     $writer$: writer,
     $eventQrls$: /* @__PURE__ */ new Set(),
     $eventNames$: /* @__PURE__ */ new Set(),
-    $resources$: /* @__PURE__ */ new Set(),
     $renderSymbols$: /* @__PURE__ */ new Set(),
     $storeProxyMap$: storeProxyMap,
+    $eagerResume$: eagerResume,
+    $resources$: /* @__PURE__ */ new Set(),
     $getProp$: getProp,
     $setProp$: setProp
   };
@@ -29530,8 +29533,7 @@ var _SharedContainer = class {
     __publicField(this, "$buildBase$", null);
     __publicField(this, "$renderPromise$", null);
     __publicField(this, "$resolveRenderPromise$", null);
-    __publicField(this, "$cursorCount$", 0);
-    __publicField(this, "$pausedCursorCount$", 0);
+    __publicField(this, "$pendingCount$", 0);
     this.$serverData$ = serverData;
     this.$locale$ = locale;
     this.$version$ = version;
@@ -29554,6 +29556,12 @@ var _SharedContainer = class {
       writer
     );
   }
+  $checkPendingCount$() {
+    if (this.$pendingCount$ === 0) {
+      this.$resolveRenderPromise$?.();
+      this.$renderPromise$ = null;
+    }
+  }
 };
 
 // packages/qwik/src/core/shared/serdes/allocate.ts
@@ -29598,16 +29606,6 @@ var allocate = (container, typeId, value) => {
     }
     case 20 /* Task */:
       return new Task(-1, -1, null, null, null, null);
-    case 21 /* Resource */: {
-      const res = createResourceReturn(
-        container,
-        // we don't care about the timeout value
-        void 0,
-        void 0
-      );
-      res.loading = false;
-      return res;
-    }
     case 6 /* URL */:
       return new URL(value);
     case 7 /* Date */:
@@ -29617,19 +29615,19 @@ var allocate = (container, typeId, value) => {
       return new RegExp(value.slice(1, idx), value.slice(idx + 1));
     case 15 /* Error */:
       return new Error();
-    case 22 /* Component */:
+    case 21 /* Component */:
       return componentQrl(null);
-    case 23 /* Signal */:
+    case 22 /* Signal */:
       return new SignalImpl(container, 0);
-    case 24 /* WrappedSignal */:
+    case 23 /* WrappedSignal */:
       return new WrappedSignalImpl(container, null, null, null);
-    case 25 /* ComputedSignal */:
+    case 24 /* ComputedSignal */:
       return new ComputedSignalImpl(container, null);
-    case 26 /* AsyncSignal */:
-      return new AsyncSignalImpl(container, null);
-    case 27 /* SerializerSignal */:
+    case 25 /* AsyncSignal */:
+      return new AsyncSignalImpl(container, null, void 0, { interval: 0 });
+    case 26 /* SerializerSignal */:
       return new SerializerSignalImpl(container, null);
-    case 28 /* Store */: {
+    case 27 /* Store */: {
       const data = value;
       const t = data[0];
       const v = data[1];
@@ -29644,9 +29642,9 @@ var allocate = (container, typeId, value) => {
     }
     case 13 /* URLSearchParams */:
       return new URLSearchParams(value);
-    case 29 /* FormData */:
+    case 28 /* FormData */:
       return new FormData();
-    case 30 /* JSXNode */:
+    case 29 /* JSXNode */:
       return new JSXNodeImpl(null, null, null, null, null);
     case 12 /* BigInt */:
       return BigInt(value);
@@ -29671,7 +29669,7 @@ var allocate = (container, typeId, value) => {
       const rest = encodedLength & 3;
       const decodedLength = blocks * 3 + (rest ? rest - 1 : 0);
       return new Uint8Array(decodedLength);
-    case 31 /* PropsProxy */:
+    case 30 /* PropsProxy */:
       return createPropsProxy(null);
     case 10 /* VNode */:
       return retrieveVNodeOrDocument(container, value);
@@ -29683,9 +29681,9 @@ var allocate = (container, typeId, value) => {
       } else {
         throw qError(17 /* serializeErrorExpectedVNode */, [typeof vNode]);
       }
-    case 32 /* SubscriptionData */:
+    case 31 /* SubscriptionData */:
       return new SubscriptionData({});
-    case 33 /* EffectSubscription */:
+    case 32 /* EffectSubscription */:
       return new EffectSubscription(null, null, null, null);
     default:
       throw qError(18 /* serializeErrorCannotAllocate */, [typeId]);
@@ -29728,44 +29726,30 @@ var inflate = (container, target, typeId, data) => {
       task[_EFFECT_BACK_REF] = v[4];
       task.$state$ = v[5];
       break;
-    case 21 /* Resource */:
-      const [resolved, result2, effects] = data;
-      const resource = target;
-      if (resolved) {
-        resource.value = Promise.resolve(result2);
-        resource._resolved = result2;
-        resource._state = "resolved";
-      } else {
-        resource.value = Promise.reject(result2);
-        resource._error = result2;
-        resource._state = "rejected";
-      }
-      getStoreHandler(target).$effects$ = effects;
-      break;
-    case 22 /* Component */:
+    case 21 /* Component */:
       target[SERIALIZABLE_STATE][0] = data[0];
       break;
-    case 28 /* Store */: {
+    case 27 /* Store */: {
       const store = unwrapStore(target);
       const storeTarget = pendingStoreTargets.get(store);
       if (storeTarget) {
         pendingStoreTargets.delete(store);
         inflate(container, store, storeTarget.t, storeTarget.v);
       }
-      const [, flags, effects2] = data;
+      const [, flags, effects] = data;
       const storeHandler = getStoreHandler(target);
       storeHandler.$flags$ = flags;
-      storeHandler.$effects$ = effects2;
+      storeHandler.$effects$ = effects;
       break;
     }
-    case 23 /* Signal */: {
+    case 22 /* Signal */: {
       const signal = target;
       const d2 = data;
       signal.$untrackedValue$ = d2[0];
       signal.$effects$ = new Set(d2.slice(1));
       break;
     }
-    case 24 /* WrappedSignal */: {
+    case 23 /* WrappedSignal */: {
       const signal = target;
       const d2 = data;
       signal.$func$ = container.getSyncFn(d2[0]);
@@ -29779,7 +29763,7 @@ var inflate = (container, target, typeId, data) => {
       inflateWrappedSignalValue(signal);
       break;
     }
-    case 26 /* AsyncSignal */: {
+    case 25 /* AsyncSignal */: {
       const asyncSignal = target;
       const d2 = data;
       asyncSignal.$computeQrl$ = d2[0];
@@ -29787,19 +29771,25 @@ var inflate = (container, target, typeId, data) => {
       asyncSignal.$effects$ = new Set(d2[2]);
       asyncSignal.$loadingEffects$ = new Set(d2[3]);
       asyncSignal.$errorEffects$ = new Set(d2[4]);
-      asyncSignal.$untrackedLoading$ = d2[5];
-      asyncSignal.$untrackedError$ = d2[6];
-      const hasValue = d2.length > 7;
+      asyncSignal.$untrackedError$ = d2[5];
+      const hasValue = d2.length > 6;
       if (hasValue) {
-        asyncSignal.$untrackedValue$ = d2[7];
-        asyncSignal.$promiseValue$ = d2[7];
+        asyncSignal.$untrackedValue$ = d2[6];
+      }
+      if (asyncSignal.$untrackedValue$ !== NEEDS_COMPUTATION) {
+        asyncSignal.$flags$ &= ~1 /* INVALID */;
+      }
+      asyncSignal.interval = d2[7] ?? 0;
+      asyncSignal.$concurrency$ = d2[8] ?? 1;
+      asyncSignal.$timeoutMs$ = d2[9] ?? 0;
+      if (d2[10]) {
+        asyncSignal.$flags$ |= 32 /* EAGER_CLEANUP */;
       }
-      asyncSignal.$flags$ |= 1 /* INVALID */;
       break;
     }
     // Inflating a SerializerSignal is the same as inflating a ComputedSignal
-    case 27 /* SerializerSignal */:
-    case 25 /* ComputedSignal */: {
+    case 26 /* SerializerSignal */:
+    case 24 /* ComputedSignal */: {
       const computed = target;
       const d2 = data;
       computed.$computeQrl$ = d2[0];
@@ -29813,11 +29803,9 @@ var inflate = (container, target, typeId, data) => {
       const hasValue = d2.length > 3;
       if (hasValue) {
         computed.$untrackedValue$ = d2[3];
-        if (typeId === 27 /* SerializerSignal */) {
-          computed.$flags$ |= 1 /* INVALID */;
-        }
-      } else {
-        computed.$flags$ |= 1 /* INVALID */;
+      }
+      if (typeId !== 26 /* SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
+        computed.$flags$ &= ~1 /* INVALID */;
       }
       break;
     }
@@ -29829,7 +29817,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 29 /* FormData */: {
+    case 28 /* FormData */: {
       const formData = target;
       const d2 = data;
       for (let i2 = 0; i2 < d2.length; i2++) {
@@ -29837,7 +29825,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 30 /* JSXNode */: {
+    case 29 /* JSXNode */: {
       const jsx2 = target;
       const [type, key, varProps, constProps, children, toSort] = data;
       jsx2.type = type;
@@ -29866,12 +29854,12 @@ var inflate = (container, target, typeId, data) => {
     }
     case 16 /* Promise */: {
       const promise = target;
-      const [resolved2, result3] = data;
+      const [resolved, result2] = data;
       const [resolve, reject] = resolvers.get(promise);
-      if (resolved2) {
-        resolve(result3);
+      if (resolved) {
+        resolve(result2);
       } else {
-        reject(result3);
+        reject(result2);
       }
       break;
     }
@@ -29883,7 +29871,7 @@ var inflate = (container, target, typeId, data) => {
         bytes[i++] = s.charCodeAt(0);
       }
       break;
-    case 31 /* PropsProxy */:
+    case 30 /* PropsProxy */:
       const propsProxy = target;
       const d = data;
       let owner = d[0];
@@ -29894,13 +29882,13 @@ var inflate = (container, target, typeId, data) => {
       propsProxy[_OWNER] = owner;
       propsProxy[_PROPS_HANDLER].$effects$ = d[3];
       break;
-    case 32 /* SubscriptionData */: {
+    case 31 /* SubscriptionData */: {
       const effectData = target;
       effectData.data.$scopedStyleIdPrefix$ = data[0];
       effectData.data.$isConst$ = data[1];
       break;
     }
-    case 33 /* EffectSubscription */: {
+    case 32 /* EffectSubscription */: {
       const effectSub = target;
       const d2 = data;
       effectSub.consumer = d2[0];
@@ -30022,13 +30010,13 @@ var makeResolveFunction = (qrl, symbolFn) => {
       }
     }
     if (qrl.$chunk$ === "") {
-      isDev18 && assertDefined(qrl.$container$, "Sync QRL must have container element");
+      isDev17 && assertDefined(qrl.$container$, "Sync QRL must have container element");
       const hash3 = qrl.$container$.$instanceHash$;
       const doc2 = qrl.$container$.element?.ownerDocument || document;
       const qFuncs2 = getQFuncs(doc2, hash3);
       return qrl.resolved = symbolRef = qFuncs2[Number(qrl.$symbol$)];
     }
-    if (isBrowser && qrl.$chunk$) {
+    if (isBrowser2 && qrl.$chunk$) {
       preload(qrl.$chunk$, 1);
     }
     const start = now();
@@ -30126,7 +30114,7 @@ var createQRL = (chunk, symbol, symbolRef, symbolFn, captures) => {
       })
     );
   }
-  if (isBrowser && symbol) {
+  if (isBrowser2 && symbol) {
     preload(symbol, 0.8);
   }
   return qrl;
@@ -30381,7 +30369,6 @@ var _typeIdNames = [
   "Map",
   "Uint8Array",
   "Task",
-  "Resource",
   "Component",
   "Signal",
   "WrappedSignal",
@@ -30820,7 +30807,7 @@ var DomContainer = class extends _SharedContainer {
           const vErrorDiv = vnode_createErrorDiv(journal, document, vHost, err);
           const insertHost = vnode_isElementVNode(vHost) ? vHostParent || vHost : vHost;
           const insertBefore = insertHost === vHost ? null : vHostNextSibling;
-          vnode_insertBefore(
+          vnode_insertElementBefore(
             journal,
             insertHost,
             vErrorDiv,
@@ -30917,7 +30904,7 @@ var DomContainer = class extends _SharedContainer {
   }
   getSyncFn(id) {
     const fn = this.$qFuncs$[id];
-    isDev19 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
+    isDev18 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
     return fn;
   }
   $appendStyle$(content, styleId, host, scoped) {
@@ -30960,10 +30947,10 @@ var DomContainer = class extends _SharedContainer {
 };
 
 // packages/qwik/src/core/use/use-locale.ts
-import { isServer as isServer8 } from "@qwik.dev/core/build";
+import { isServer as isServer9 } from "@qwik.dev/core/build";
 var _locale = void 0;
 var localAsyncStore;
-if (isServer8) {
+if (isServer9) {
   import("node:async_hooks").then((module) => {
     localAsyncStore = new module.AsyncLocalStorage();
   }).catch(() => {
@@ -31005,8 +30992,8 @@ var useInvokeContext = () => {
   if (!ctx || ctx.$event$ !== RenderEvent) {
     throw qError(10 /* useInvokeContext */);
   }
-  isDev20 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
-  isDev20 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
+  isDev19 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
+  isDev19 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
   return ctx;
 };
 function invoke(context, fn, ...args) {
@@ -31080,7 +31067,7 @@ var trackSignal = (fn, subscriber, property, container, data) => {
   try {
     trackInvocation.$effectSubscriber$ = getSubscriber(subscriber, property, data);
     trackInvocation.$container$ = container;
-    return invoke(trackInvocation, fn);
+    return invokeApply(trackInvocation, fn);
   } finally {
     trackInvocation.$effectSubscriber$ = previousSubscriber;
     trackInvocation.$container$ = previousContainer;
@@ -31094,7 +31081,7 @@ var trackSignalAndAssignHost = (value, host, property, container, data) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/store.ts
-import { isDev as isDev21, isServer as isServer9 } from "@qwik.dev/core/build";
+import { isDev as isDev20, isServer as isServer10 } from "@qwik.dev/core/build";
 var DEBUG7 = false;
 var log5 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
 var getStoreHandler = (value) => {
@@ -31103,12 +31090,6 @@ var getStoreHandler = (value) => {
 var getStoreTarget = (value) => {
   return value?.[STORE_TARGET] || null;
 };
-var forceStoreEffects = (value, prop) => {
-  const handler = getStoreHandler(value);
-  if (handler) {
-    handler.force(prop);
-  }
-};
 var unwrapStore = (value) => {
   return getStoreTarget(value) || value;
 };
@@ -31161,7 +31142,7 @@ var StoreHandler2 = class {
         }
         this.$container$ = ctx.$container$;
       } else {
-        isDev21 && assertTrue(
+        isDev20 && assertTrue(
           !ctx.$container$ || ctx.$container$ === this.$container$,
           "Do not use signals across containers"
         );
@@ -31264,7 +31245,7 @@ function addStoreEffect(target, prop, store, effectSubscription) {
   }
   ensureContainsSubscription(effects, effectSubscription);
   ensureContainsBackRef(effectSubscription, target);
-  (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer9) && addQrlToSerializationCtx(effectSubscription, store.$container$);
+  (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer10) && addQrlToSerializationCtx(effectSubscription, store.$container$);
   DEBUG7 && log5(
     "sub",
     pad(
@@ -31442,11 +31423,11 @@ ${prefix}]` : "[]";
   }
   const result2 = out.map((v, i) => `${prefix}${isRoot ? `${i} ` : ""}${v}`).join("\n");
   if (isRoot) {
-    const count2 = hasRaw ? "" : `(${JSON.stringify(state).length} chars)`;
+    const count = hasRaw ? "" : `(${JSON.stringify(state).length} chars)`;
     hasRaw = false;
     return `
 ${result2}
-${count2}`;
+${count}`;
   }
   return result2;
 };
@@ -31502,13 +31483,13 @@ function preprocessState(data, container) {
 }
 
 // packages/qwik/src/core/shared/serdes/serdes.public.ts
-import { isDev as isDev22 } from "@qwik.dev/core/build";
+import { isDev as isDev21 } from "@qwik.dev/core/build";
 function getObjectById(id, stateData) {
   if (typeof id === "string") {
     id = parseInt(id, 10);
     return stateData[id];
   }
-  isDev22 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
+  isDev21 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
   return stateData[id];
 }
 
@@ -31555,6 +31536,9 @@ var _verifySerializable = (value, seen, ctx, preMessage) => {
           });
           return value;
         }
+        if (unwrapped.__brand) {
+          return value;
+        }
         if (isSerializableObject(unwrapped)) {
           for (const [key, item] of Object.entries(unwrapped)) {
             _verifySerializable(item, seen, ctx + "." + key);
@@ -31598,17 +31582,11 @@ var shouldSerialize = (obj) => {
 var fastSkipSerialize = (obj) => {
   return !!obj && (isObject(obj) || typeof obj === "function") && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
 };
-var noSerialize = (input) => {
-  if (isObject(input) && input !== null || typeof input === "function") {
-    noSerializeSet.add(input);
-  }
-  return input;
-};
 var NoSerializeSymbol = /* @__PURE__ */ Symbol("noSerialize");
 var SerializerSymbol = /* @__PURE__ */ Symbol("serialize");
 
 // packages/qwik/src/core/reactive-primitives/utils.ts
-import { isDev as isDev23, isServer as isServer10 } from "@qwik.dev/core/build";
+import { isDev as isDev22, isServer as isServer11 } from "@qwik.dev/core/build";
 var DEBUG8 = false;
 var log6 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var throwIfQRLNotResolved = (qrl) => {
@@ -31627,7 +31605,7 @@ var ensureContainsBackRef = (array, value) => {
   (array.backRef || (array.backRef = /* @__PURE__ */ new Set())).add(value);
 };
 var addQrlToSerializationCtx = (effectSubscriber, container) => {
-  if (container) {
+  if (container?.serializationCtx) {
     const effect = effectSubscriber.consumer;
     const property = effectSubscriber.property;
     let qrl = null;
@@ -31644,21 +31622,21 @@ var addQrlToSerializationCtx = (effectSubscriber, container) => {
   }
 };
 var scheduleEffects = (container, signal, effects) => {
-  const isBrowser4 = import.meta.env.TEST ? !isServerPlatform() : !isServer10;
+  const isBrowser5 = import.meta.env.TEST ? !isServerPlatform() : !isServer11;
   if (effects) {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
       const property = effectSubscription.property;
-      isDev23 && assertDefined(container, "Container must be defined.");
+      isDev22 && assertDefined(container, "Container must be defined.");
       if (isTask(consumer)) {
-        consumer.$flags$ |= 8 /* DIRTY */;
+        consumer.$flags$ |= 4 /* DIRTY */;
         markVNodeDirty(container, consumer.$el$, 1 /* TASKS */);
       } else if (consumer instanceof SignalImpl) {
         consumer.invalidate();
       } else if (property === ":" /* COMPONENT */) {
         markVNodeDirty(container, consumer, 4 /* COMPONENT */);
       } else if (property === "." /* VNODE */) {
-        if (isBrowser4) {
+        if (isBrowser5) {
           setNodeDiffPayload(consumer, signal);
           markVNodeDirty(container, consumer, 2 /* NODE_DIFF */);
         }
@@ -31671,7 +31649,7 @@ var scheduleEffects = (container, signal, effects) => {
             scopedStyleIdPrefix: data.$scopedStyleIdPrefix$,
             value: signal
           };
-          if (isBrowser4) {
+          if (isBrowser5) {
             setNodePropData(consumer, property, payload);
           } else {
             const node = consumer;
@@ -31821,7 +31799,7 @@ var fastGetter = (prototype, name) => {
 
 // packages/qwik/src/core/client/vnode-utils.ts
 var vnode_newElement = (element, elementName, key = null) => {
-  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev23 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     key,
     1 /* Element */ | 8 /* Inflated */ | -1 << 11 /* shift */,
@@ -31839,7 +31817,7 @@ var vnode_newElement = (element, elementName, key = null) => {
   return vnode;
 };
 var vnode_newUnMaterializedElement = (element) => {
-  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev23 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     null,
     1 /* Element */ | -1 << 11 /* shift */,
@@ -31857,7 +31835,7 @@ var vnode_newUnMaterializedElement = (element) => {
   return vnode;
 };
 var vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-  isDev24 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+  isDev23 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
   const vnode = new TextVNode(
     4 /* Text */ | -1 << 11 /* shift */,
     // Flag
@@ -31889,10 +31867,10 @@ var vnode_newText = (textNode, textContent) => {
     textContent
     // Text Content
   );
-  isDev24 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
-  isDev24 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
+  isDev23 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_newVirtual = () => {
@@ -31907,9 +31885,9 @@ var vnode_newVirtual = () => {
     null,
     null
   );
-  isDev24 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev24 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev23 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_isVNode = (vNode) => {
@@ -31919,12 +31897,12 @@ var vnode_isElementVNode = (vNode) => {
   return (vNode.flags & 1 /* Element */) === 1 /* Element */;
 };
 var vnode_isElementOrTextVNode = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev23 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 5 /* ELEMENT_OR_TEXT_MASK */) !== 0;
 };
 var vnode_isMaterialized = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev23 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 1 /* Element */) === 1 /* Element */ && vNode.firstChild !== void 0 && vNode.lastChild !== void 0;
 };
@@ -31935,26 +31913,26 @@ var vnode_isVirtualVNode = (vNode) => {
   return (vNode.flags & 2 /* Virtual */) === 2 /* Virtual */;
 };
 var vnode_isProjection = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev23 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 2 /* Virtual */) === 2 /* Virtual */ && vnode_getProp(vNode, QSlot, null) !== null;
 };
 var ensureTextVNode = (vNode) => {
-  isDev24 && assertTrue(
+  isDev23 && assertTrue(
     vnode_isTextVNode(vNode),
     "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)
   );
   return vNode;
 };
 var ensureElementOrVirtualVNode = (vNode) => {
-  isDev24 && assertDefined(vNode, "Missing vNode");
-  isDev24 && assertTrue(
+  isDev23 && assertDefined(vNode, "Missing vNode");
+  isDev23 && assertTrue(
     (vNode.flags & 3 /* ELEMENT_OR_VIRTUAL_MASK */) !== 0,
     "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode)
   );
 };
 var ensureElementVNode = (vNode) => {
-  isDev24 && assertTrue(
+  isDev23 && assertTrue(
     vnode_isElementVNode(vNode),
     "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)
   );
@@ -32068,6 +32046,20 @@ function registerQrlHandlers(attr, key, container, element) {
   });
   (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
 }
+function vnode_walkDirectChildren(journal, vParent, callback) {
+  let vNode = vnode_getFirstChild(vParent);
+  while (vNode) {
+    if (vnode_isTextVNode(vNode)) {
+      vnode_ensureTextInflated(journal, vNode);
+      callback(vNode, vParent);
+    } else if (vnode_isElementVNode(vNode)) {
+      callback(vNode, vParent);
+    } else {
+      vnode_walkDirectChildren(journal, vNode, callback);
+    }
+    vNode = vNode.nextSibling;
+  }
+}
 function vnode_walkVNode(vNode, callback) {
   let vCursor = vNode;
   if (vnode_isTextVNode(vNode)) {
@@ -32108,37 +32100,15 @@ function vnode_walkVNode(vNode, callback) {
     }
   } while (true);
 }
-function vnode_getDOMChildNodes(journal, root, isVNode = false, childNodes = []) {
-  if (vnode_isElementOrTextVNode(root)) {
-    if (vnode_isTextVNode(root)) {
-      vnode_ensureTextInflated(journal, root);
-    }
-    childNodes.push(isVNode ? root : vnode_getNode(root));
-    return childNodes;
-  }
-  let vNode = vnode_getFirstChild(root);
-  while (vNode) {
-    if (vnode_isElementVNode(vNode)) {
-      childNodes.push(isVNode ? vNode : vnode_getNode(vNode));
-    } else if (vnode_isTextVNode(vNode)) {
-      vnode_ensureTextInflated(journal, vNode);
-      childNodes.push(isVNode ? vNode : vnode_getNode(vNode));
-    } else {
-      isVNode ? vnode_getDOMChildNodes(journal, vNode, true, childNodes) : vnode_getDOMChildNodes(journal, vNode, false, childNodes);
-    }
-    vNode = vNode.nextSibling;
-  }
-  return childNodes;
-}
 function vnode_getDOMContainer(vNode) {
   let cursor = vNode;
   while (cursor) {
     if (vnode_isElementVNode(cursor)) {
-      try {
-        return getDomContainer(cursor.node);
-      } catch {
+      const qContainerElement = _getQContainerElement(cursor.node);
+      if (!qContainerElement) {
         return null;
       }
+      return getDomContainerFromQContainerElement(qContainerElement);
     }
     cursor = cursor.parent;
   }
@@ -32198,7 +32168,7 @@ var vnode_ensureTextInflated = (journal, vnode) => {
   const flags = textVNode.flags;
   if ((flags & 8 /* Inflated */) === 0) {
     const parentNode = vnode_getDomParent(vnode, true);
-    isDev24 && assertDefined(parentNode, "Missing parent node.");
+    isDev23 && assertDefined(parentNode, "Missing parent node.");
     const sharedTextNode = textVNode.node;
     const doc2 = fastOwnerDocument(parentNode);
     let vCursor = vnode_getDomSibling(vnode, false, true);
@@ -32247,7 +32217,7 @@ var vnode_locate = (rootVNode, id) => {
   let elementOffset = -1;
   let refElement;
   if (typeof id === "string") {
-    isDev24 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
+    isDev23 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
     elementOffset = parseInt(id);
     refElement = qVNodeRefs.get(elementOffset);
   } else {
@@ -32257,9 +32227,9 @@ var vnode_locate = (rootVNode, id) => {
       return vNode2;
     }
   }
-  isDev24 && assertDefined(refElement, "Missing refElement.");
+  isDev23 && assertDefined(refElement, "Missing refElement.");
   if (!vnode_isVNode(refElement)) {
-    isDev24 && assertTrue(
+    isDev23 && assertTrue(
       containerElement2.contains(refElement),
       `Couldn't find the element inside the container while locating the VNode.`
     );
@@ -32303,10 +32273,10 @@ var vnode_locate = (rootVNode, id) => {
 };
 var vnode_getChildWithIdx = (vNode, childIdx) => {
   let child = vnode_getFirstChild(vNode);
-  isDev24 && assertDefined(child, "Missing child.");
+  isDev23 && assertDefined(child, "Missing child.");
   while (child.flags >>> 11 /* shift */ !== childIdx) {
     child = child.nextSibling;
-    isDev24 && assertDefined(child, "Missing child.");
+    isDev23 && assertDefined(child, "Missing child.");
   }
   return child;
 };
@@ -32314,7 +32284,7 @@ var vNodeStack = [];
 var vnode_getVNodeForChildNode = (vNode, childElement) => {
   ensureElementVNode(vNode);
   let child = vnode_getFirstChild(vNode);
-  isDev24 && assertDefined(child, "Missing child.");
+  isDev23 && assertDefined(child, "Missing child.");
   while (child && (child instanceof ElementVNode ? child.node !== childElement : true)) {
     if (vnode_isVirtualVNode(child)) {
       const next = child.nextSibling;
@@ -32333,13 +32303,13 @@ var vnode_getVNodeForChildNode = (vNode, childElement) => {
         child = next || vNodeStack.pop();
       }
     }
-    isDev24 && assertDefined(child, "Missing child.");
+    isDev23 && assertDefined(child, "Missing child.");
   }
   while (vNodeStack.length) {
     vNodeStack.pop();
   }
   ensureElementVNode(child);
-  isDev24 && assertEqual(child.node, childElement, "Child not found.");
+  isDev23 && assertEqual(child.node, childElement, "Child not found.");
   return child;
 };
 var indexOfAlphanumeric = (id, length) => {
@@ -32360,9 +32330,17 @@ var vnode_createErrorDiv = (journal, document2, host, err) => {
   }
   errorDiv.setAttribute("q:key", "_error_");
   const vErrorDiv = vnode_newElement(errorDiv, "errored-host");
-  vnode_getDOMChildNodes(journal, host, true).forEach((child) => {
-    vnode_insertBefore(journal, vErrorDiv, child, null);
-  });
+  if (vnode_isElementOrTextVNode(host)) {
+    vnode_insertBefore(journal, vErrorDiv, host, null);
+  } else {
+    const children = [];
+    vnode_walkDirectChildren(journal, host, (vNode) => {
+      children.push(vNode);
+    });
+    for (let i = 0; i < children.length; i++) {
+      vnode_insertBefore(journal, vErrorDiv, children[i], null);
+    }
+  }
   return vErrorDiv;
 };
 var vnode_journalToString = (journal) => {
@@ -32419,9 +32397,10 @@ var vnode_journalToString = (journal) => {
   lines.push("END JOURNAL");
   return lines.join("\n");
 };
-var vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+var vnode_insertElementBefore = (journal, parent, newChild, insertBefore) => {
   ensureElementOrVirtualVNode(parent);
-  if (vnode_isElementVNode(parent)) {
+  const parentIsElement = vnode_isElementVNode(parent);
+  if (parentIsElement) {
     ensureMaterialized(parent);
   }
   const newChildCurrentParent = newChild.parent;
@@ -32432,58 +32411,133 @@ var vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
       insertBefore = null;
     }
   }
-  const domParentVNode = vnode_getDomParentVNode(parent, false);
-  const parentNode = domParentVNode && domParentVNode.node;
-  let domChildren = null;
-  if (domParentVNode) {
-    domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(
+  vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+  const childNode = newChild.node;
+  const parentIsDeleted = parent.flags & 32 /* Deleted */;
+  const parentNode = parentIsElement ? parent.node : vnode_getDomParent(parent, false);
+  if (parentNode && !parentIsDeleted) {
+    addVNodeOperation(
       journal,
-      domParentVNode,
-      newChild
+      createInsertOrMoveOperation(
+        childNode,
+        parentNode,
+        vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null
+      )
     );
   }
-  if (newChildCurrentParent && (newChild.previousSibling || newChild.nextSibling || newChildCurrentParent !== parent)) {
-    vnode_remove(journal, newChildCurrentParent, newChild, false);
+  vnode_connectSiblings(parent, newChild, insertBefore);
+  if (parentIsDeleted) {
+    newChild.flags |= 32 /* Deleted */;
   }
-  const parentIsDeleted = parent.flags & 32 /* Deleted */;
-  let adjustedInsertBefore = null;
-  if (!parentIsDeleted) {
-    if (insertBefore == null) {
-      if (vnode_isVirtualVNode(parent)) {
-        adjustedInsertBefore = vnode_getDomSibling(parent, true, false);
-      }
-    } else if (vnode_isVirtualVNode(insertBefore)) {
-      adjustedInsertBefore = vnode_getDomSibling(insertBefore, true, true);
+};
+var vnode_insertVirtualBefore = (journal, parent, newChild, insertBefore) => {
+  ensureElementOrVirtualVNode(parent);
+  const parentIsElement = vnode_isElementVNode(parent);
+  if (parentIsElement) {
+    ensureMaterialized(parent);
+  }
+  const newChildCurrentParent = newChild.parent;
+  if (newChild === insertBefore) {
+    if (newChildCurrentParent) {
+      return;
     } else {
-      adjustedInsertBefore = insertBefore;
+      insertBefore = null;
     }
-    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
-    if (domChildren && domChildren.length) {
-      for (const child of domChildren) {
+  }
+  vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+  const parentIsDeleted = parent.flags & 32 /* Deleted */;
+  const domParentVNode = parentIsElement ? parent : vnode_getDomParentVNode(parent, false);
+  const parentNode = domParentVNode?.node;
+  const adjustedInsertBefore = vnode_findInsertBefore(journal, parent, insertBefore);
+  const adjustedInsertBeforeNode = adjustedInsertBefore?.node ?? null;
+  const isProjection = vnode_isProjection(newChild);
+  if (isProjection && domParentVNode && (domParentVNode.flags & 1536 /* NAMESPACE_MASK */) !== 0) {
+    const domParentVNode2 = vnode_getDomParentVNode(parent, false);
+    const adjustedInsertBeforeNode2 = vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null;
+    const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(
+      domParentVNode2,
+      newChild
+    );
+    vnode_walkDirectChildren(journal, newChild, (vNode) => {
+      if (vnode_isTextVNode(vNode)) {
         addVNodeOperation(
           journal,
-          createInsertOrMoveOperation(child.node, parentNode, vnode_getNode(adjustedInsertBefore))
+          createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode2)
+        );
+      } else {
+        if ((vNode.flags & 1536 /* NAMESPACE_MASK */) !== elementNamespaceFlag) {
+          const newChildElement = vnode_cloneElementWithNamespace(
+            vNode,
+            domParentVNode2,
+            elementNamespace,
+            elementNamespaceFlag
+          );
+          if (newChildElement) {
+            vNode.node = newChildElement;
+          }
+        }
+        addVNodeOperation(
+          journal,
+          createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode2)
         );
       }
+    });
+  } else if (
+    // for projection there can be no parent node
+    parentNode && !parentIsDeleted
+  ) {
+    vnode_walkDirectChildren(journal, newChild, (vNode) => {
+      addVNodeOperation(
+        journal,
+        createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode)
+      );
+    });
+  }
+  vnode_connectSiblings(parent, newChild, insertBefore);
+  if (parentIsDeleted) {
+    newChild.flags |= 32 /* Deleted */;
+  }
+};
+var vnode_findInsertBefore = (journal, parent, insertBefore) => {
+  let adjustedInsertBefore = null;
+  if (insertBefore == null) {
+    if (vnode_isVirtualVNode(parent)) {
+      adjustedInsertBefore = vnode_getDomSibling(parent, true, false);
     }
+  } else if (vnode_isVirtualVNode(insertBefore)) {
+    adjustedInsertBefore = vnode_getDomSibling(insertBefore, true, true);
+  } else {
+    adjustedInsertBefore = insertBefore;
   }
-  const vNext = insertBefore;
+  adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+  return adjustedInsertBefore;
+};
+var vnode_connectSiblings = (parent, vNode, vNext) => {
   const vPrevious = vNext ? vNext.previousSibling : parent.lastChild;
   if (vNext) {
-    vNext.previousSibling = newChild;
+    vNext.previousSibling = vNode;
   } else {
-    parent.lastChild = newChild;
+    parent.lastChild = vNode;
   }
   if (vPrevious) {
-    vPrevious.nextSibling = newChild;
+    vPrevious.nextSibling = vNode;
   } else {
-    parent.firstChild = newChild;
+    parent.firstChild = vNode;
   }
-  newChild.previousSibling = vPrevious;
-  newChild.nextSibling = vNext;
-  newChild.parent = parent;
-  if (parentIsDeleted) {
-    newChild.flags |= 32 /* Deleted */;
+  vNode.previousSibling = vPrevious;
+  vNode.nextSibling = vNext;
+  vNode.parent = parent;
+};
+var vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild) => {
+  if (currentParent && (newChild.previousSibling || newChild.nextSibling || currentParent !== newParent)) {
+    vnode_remove(journal, currentParent, newChild, false);
+  }
+};
+var vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+  if (vnode_isElementOrTextVNode(newChild)) {
+    vnode_insertElementBefore(journal, parent, newChild, insertBefore);
+  } else {
+    vnode_insertVirtualBefore(journal, parent, newChild, insertBefore);
   }
 };
 var vnode_getDomParent = (vnode, includeProjection) => {
@@ -32497,21 +32551,21 @@ var vnode_getDomParentVNode = (vnode, includeProjection) => {
   return vnode;
 };
 var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-  isDev24 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
+  isDev23 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
   if (vnode_isTextVNode(vToRemove)) {
     vnode_ensureTextInflated(journal, vToRemove);
   }
   if (removeDOM) {
-    const domParent = vnode_getDomParent(vParent, false);
     const isInnerHTMLParent = vnode_getProp(vParent, dangerouslySetInnerHTML, null) !== null;
     if (isInnerHTMLParent) {
       return;
     }
-    const children = vnode_getDOMChildNodes(journal, vToRemove, true);
-    if (domParent && children.length) {
-      for (const child of children) {
-        addVNodeOperation(journal, createDeleteOperation(child.node));
-      }
+    if (vnode_isElementOrTextVNode(vToRemove)) {
+      addVNodeOperation(journal, createDeleteOperation(vToRemove.node));
+    } else {
+      vnode_walkDirectChildren(journal, vToRemove, (vNode) => {
+        addVNodeOperation(journal, createDeleteOperation(vNode.node));
+      });
     }
   }
   const vPrevious = vToRemove.previousSibling;
@@ -32530,18 +32584,15 @@ var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
   vToRemove.nextSibling = null;
 };
 var vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
-  isDev24 && assertDefined(vDelete, "Missing vDelete.");
+  isDev23 && assertDefined(vDelete, "Missing vDelete.");
   const parent = vnode_getDomParent(vParent, true);
   if (parent && removeDOM) {
-    if (vnode_isElementVNode(vParent)) {
+    if (vnode_isElementOrTextVNode(vParent)) {
       addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node));
     } else {
-      const children = vnode_getDOMChildNodes(journal, vParent, true);
-      if (children.length) {
-        for (const child of children) {
-          addVNodeOperation(journal, createDeleteOperation(child.node));
-        }
-      }
+      vnode_walkDirectChildren(journal, vParent, (vNode) => {
+        addVNodeOperation(journal, createDeleteOperation(vNode.node));
+      });
     }
   }
   const vPrevious = vDelete.previousSibling;
@@ -32627,8 +32678,8 @@ var ensureMaterialized = (vnode) => {
       vFirstChild = vnode_materialize(vParent);
     }
   }
-  isDev24 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
-  isDev24 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
+  isDev23 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
+  isDev23 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
   return vFirstChild;
 };
 var _fastHasAttribute = null;
@@ -32803,7 +32854,7 @@ var materializeFromDOM = (vParent, firstChild, vData) => {
         }
         const id = consumeValue();
         container.$setRawState$(parseInt(id), vParent);
-        isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
+        isDev23 && vnode_setProp(vParent, ELEMENT_ID, id);
       } else if (peek() === VNodeDataChar.BACK_REFS) {
         if (!container) {
           container = getDomContainer(vParent.node);
@@ -32879,7 +32930,7 @@ var vnode_getAttrKeys = (container, vnode) => {
     const keys = [];
     const props = vnode.props;
     if (props) {
-      for (const key of Object.keys(props)) {
+      for (const key in props) {
         if (!key.startsWith(Q_PROPS_SEPARATOR)) {
           keys.push(key);
         }
@@ -32908,7 +32959,13 @@ var vnode_getNode = (vnode) => {
   }
   return vnode.node;
 };
-function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings = false, colorize = true, container = this && vnode_getDOMContainer(this)) {
+function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings = false, colorize = true, container = null) {
+  if (this && !container) {
+    try {
+      container = vnode_getDOMContainer(this);
+    } catch {
+    }
+  }
   let vnode = this;
   if (depth === 0) {
     return "...";
@@ -32931,12 +32988,14 @@ function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings
       if (vnode.dirty) {
         attrs.push(` dirty:${vnode.dirty}`);
       }
-      vnode_getAttrKeys(container, vnode).forEach((key) => {
-        if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
-          const value = vnode_getProp(vnode, key, null);
-          attrs.push(" " + key + "=" + qwikDebugToString(value));
-        }
-      });
+      if (container) {
+        vnode_getAttrKeys(container, vnode).forEach((key) => {
+          if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
+            const value = vnode_getProp(vnode, key, null);
+            attrs.push(" " + key + "=" + qwikDebugToString(value));
+          }
+        });
+      }
       const name = (colorize ? NAME_COL_PREFIX : "") + (VirtualTypeName[vnode_getProp(vnode, DEBUG_TYPE, null) || "V" /* Virtual */] || VirtualTypeName["V" /* Virtual */]) + (colorize ? NAME_COL_SUFFIX : "");
       strings.push("<" + name + attrs.join("") + ">");
       const child = vnode_getFirstChild(vnode);
@@ -32956,7 +33015,7 @@ function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings
       if (vnode.dirtyChildren) {
         attrs.push(` dirtyChildren[${vnode.dirtyChildren.length}]`);
       }
-      const keys = vnode_getAttrKeys(container, vnode);
+      const keys = container ? vnode_getAttrKeys(container, vnode) : [];
       for (const key of keys) {
         const value = vnode_getProp(vnode, key, null);
         attrs.push(" " + key + "=" + qwikDebugToString(value));
@@ -33064,7 +33123,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
       }
       const id = consumeValue();
       container.$setRawState$(parseInt(id), vParent);
-      isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
+      isDev23 && vnode_setProp(vParent, ELEMENT_ID, id);
     } else if (peek() === VNodeDataChar.PROPS) {
       vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
     } else if (peek() === VNodeDataChar.KEY) {
@@ -33143,8 +33202,8 @@ function materializeFromVNodeData(vParent, vData, element, child) {
     if (!container) {
       container = getDomContainer(element);
     }
-    for (const component of components) {
-      container.ensureProjectionResolved(component);
+    for (let i = 0; i < components.length; i++) {
+      container.ensureProjectionResolved(components[i]);
     }
     components = null;
   }
@@ -33871,7 +33930,10 @@ function diffJsxVNodeChildren(received, expected, path, container, isSsr, diffs)
       `${path.join(" > ")} expecting ${expectedChildren.length} children but was ${receivedChildren.length}`
     );
     diffs.push("EXPECTED", jsxToHTML(expected, "  "));
-    diffs.push("RECEIVED", received.toString());
+    diffs.push(
+      "RECEIVED",
+      vnode_toString.call(received, 20, "  ", true, false, false, container)
+    );
   }
   path.pop();
 }
@@ -34373,17 +34435,17 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { expect as expect2 } from "vitest";
 
 // packages/qwik/src/core/preloader/queue.ts
-import { isBrowser as isBrowser3 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/preloader/constants.ts
-import { isBrowser as isBrowser2 } from "@qwik.dev/core/build";
-var doc = isBrowser2 ? document : void 0;
+import { isBrowser as isBrowser3 } from "@qwik.dev/core/build";
+var doc = isBrowser3 ? document : void 0;
 var config = {
   $DEBUG$: false,
   $maxIdlePreloads$: 25,
   $invPreloadProbability$: 0.65
 };
-var rel = isBrowser2 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+var rel = isBrowser3 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
 var loadStart = Date.now();
 var isJSRegex = /\.[mc]?js$/;
 
@@ -34630,11 +34692,11 @@ var preload2 = (name, probability) => {
   } else {
     handleBundle(name, inverseProbability);
   }
-  if (isBrowser3) {
+  if (isBrowser4) {
     trigger2();
   }
 };
-if (isBrowser3) {
+if (isBrowser4) {
   document.addEventListener("qsymbol", (ev) => {
     const { symbol, href } = ev.detail;
     if (href) {
@@ -34646,7 +34708,7 @@ if (isBrowser3) {
 
 // packages/qwik/src/server/platform.ts
 import { setPlatform as setPlatform2 } from "../core.mjs";
-import { isDev as isDev25 } from "@qwik.dev/core/build";
+import { isDev as isDev24 } from "@qwik.dev/core/build";
 var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
   const existing = mapper?.[hash3];
   if (existing) {
@@ -34668,9 +34730,9 @@ var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
 function createPlatform3(opts, resolvedManifest) {
   const mapper = resolvedManifest?.mapper;
   const mapperFn = opts.symbolMapper ? opts.symbolMapper : (symbolName, _chunk, parent) => {
-    if (mapper || isDev25 && import.meta.env.MODE !== "test") {
+    if (mapper || isDev24 && import.meta.env.MODE !== "test") {
       const hash3 = getSymbolHash2(symbolName);
-      const result2 = !isDev25 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
+      const result2 = !isDev24 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
       if (!result2) {
         if (hash3 === SYNC_QRL) {
           return [hash3, ""];
@@ -34755,8 +34817,11 @@ var versions = {
 };
 
 // packages/qwik/src/server/ssr-container.ts
-import { isDev as isDev27 } from "@qwik.dev/core/build";
+import { isDev as isDev26 } from "@qwik.dev/core/build";
 import {
+  _createQRL as createQRL2,
+  _qrlToString as qrlToString2,
+  _res,
   _SubscriptionData as SubscriptionData2,
   _SharedContainer as _SharedContainer2,
   _jsxSorted as _jsxSorted2,
@@ -35023,7 +35088,7 @@ function getQwikBackpatchExecutorScript(opts = {}) {
 
 // packages/qwik/src/server/ssr-node.ts
 import { _isJSXNode as isJSXNode2, _EMPTY_ARRAY, _EFFECT_BACK_REF as _EFFECT_BACK_REF2 } from "@qwik.dev/core/internal";
-import { isDev as isDev26 } from "@qwik.dev/core/build";
+import { isDev as isDev25 } from "@qwik.dev/core/build";
 var SsrNode = class {
   constructor(parentComponent, id, attributesIndex, cleanupQueue, vnodeData, currentFile) {
     this.parentComponent = parentComponent;
@@ -35048,7 +35113,7 @@ var SsrNode = class {
     this.flags = 1 /* Updatable */;
     this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_ARRAY;
     this.parentComponent?.addChild(this);
-    if (isDev26 && id.indexOf("undefined") != -1) {
+    if (isDev25 && id.indexOf("undefined") != -1) {
       throw new Error(`Invalid SSR node id: ${id}`);
     }
   }
@@ -35112,7 +35177,7 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev26) {
+    if (isDev25) {
       let stringifiedAttrs = "";
       for (let i = 0; i < this.attrs.length; i += 2) {
         const key = this.attrs[i];
@@ -35474,7 +35539,7 @@ var SSRContainer = class extends _SharedContainer2 {
     containerAttributes[QContainerAttr] = "paused" /* PAUSED */;
     containerAttributes[QRuntimeAttr] = "2";
     containerAttributes[QVersionAttr] = this.$version$ ?? "dev";
-    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev27 ? "ssr-dev" : "ssr");
+    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev26 ? "ssr-dev" : "ssr");
     containerAttributes[QBaseAttr] = this.$buildBase$ || "";
     containerAttributes[QLocaleAttr] = this.$locale$;
     containerAttributes[QManifestHashAttr] = this.resolvedManifest.manifest.manifestHash;
@@ -35523,7 +35588,7 @@ var SSRContainer = class extends _SharedContainer2 {
     this.write(" " + Q_PROPS_SEPARATOR);
     if (key !== null) {
       this.write(`="${key}"`);
-    } else if (isDev27) {
+    } else if (isDev26) {
       this.write('=""');
     }
     if (constAttrs && constAttrs.length) {
@@ -35659,7 +35724,7 @@ var SSRContainer = class extends _SharedContainer2 {
       const slotName = componentFrame.slots[i];
       const children = componentFrame.slots[i + 1];
       this.openFragment(
-        isDev27 ? [DEBUG_TYPE, "P" /* Projection */, QSlotParent, componentFrame.componentNode.id] : [QSlotParent, componentFrame.componentNode.id]
+        isDev26 ? [DEBUG_TYPE, "P" /* Projection */, QSlotParent, componentFrame.componentNode.id] : [QSlotParent, componentFrame.componentNode.id]
       );
       const lastNode = this.getOrCreateLastNode();
       if (lastNode.vnodeData) {
@@ -35917,11 +35982,24 @@ var SSRContainer = class extends _SharedContainer2 {
     if (!this.serializationCtx.$roots$.length) {
       return;
     }
-    this.openElement("script", null, ["type", "qwik/state"]);
+    const attrs = this.stateScriptAttrs();
+    this.openElement("script", null, attrs);
     return maybeThen(this.serializationCtx.$serialize$(), () => {
       this.closeElement();
     });
   }
+  /** Add q-d:qidle attribute to eagerly resume some state if needed */
+  stateScriptAttrs() {
+    const attrs = ["type", "qwik/state"];
+    const eagerResume = this.serializationCtx.$eagerResume$;
+    if (eagerResume.size > 0) {
+      const qrl = createQRL2(null, "_res", _res, null, [...eagerResume]);
+      const qrlStr = qrlToString2(this.serializationCtx, qrl);
+      attrs.push("q-d:qidle", qrlStr);
+      this.serializationCtx.$eventNames$.add("d:qidle");
+    }
+    return attrs;
+  }
   emitSyncFnsData() {
     const fns = this.serializationCtx.$syncFns$;
     if (fns.length) {
@@ -35969,7 +36047,7 @@ var SSRContainer = class extends _SharedContainer2 {
       scriptAttrs.push("nonce", this.renderOptions.serverData.nonce);
     }
     this.openElement("script", null, scriptAttrs);
-    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev27 });
+    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev26 });
     this.write(backpatchScript);
     this.closeElement();
   }
@@ -36059,7 +36137,7 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   createAndPushFrame(elementName, depthFirstElementIdx, currentFile) {
     let tagNesting = 10 /* ANYTHING */;
-    if (isDev27) {
+    if (isDev26) {
       if (!this.currentElementFrame) {
         tagNesting = initialTag(elementName);
       } else {
@@ -36105,7 +36183,7 @@ var SSRContainer = class extends _SharedContainer2 {
       elementName,
       depthFirstElementIdx,
       vNodeData: [0 /* NONE */],
-      currentFile: isDev27 ? currentFile || null : null
+      currentFile: isDev26 ? currentFile || null : null
     };
     this.currentElementFrame = frame;
     this.vNodeDatas.push(frame.vNodeData);
@@ -36137,7 +36215,7 @@ var SSRContainer = class extends _SharedContainer2 {
         let value = attrs[i];
         let styleScopedId = null;
         if (isSSRUnsafeAttr(key)) {
-          if (isDev27) {
+          if (isDev26) {
             throw qError(32 /* unsafeAttr */, [key]);
           }
           continue;
@@ -36192,7 +36270,7 @@ var SSRContainer = class extends _SharedContainer2 {
         }
         if (tag === "textarea" && key === "value") {
           if (value && typeof value !== "string") {
-            if (isDev27) {
+            if (isDev26) {
               throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
             }
             continue;
@@ -36300,13 +36378,12 @@ var renderToStream = async (jsx2, opts) => {
   await ssrContainer.$renderPromise$;
   flush();
   const snapshotResult = getSnapshotResult(ssrContainer);
-  const isDynamic = snapshotResult.resources.some((r) => r._cache !== Infinity);
   const result2 = {
     snapshotResult,
     flushes: networkFlushes,
     manifest: resolvedManifest?.manifest,
     size: ssrContainer.size,
-    isStatic: !isDynamic,
+    isStatic: false,
     timing
   };
   return result2;