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

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.23-dev+03de42d
+ * @qwik.dev/core/testing 2.0.0-beta.24-dev+314726b
  * 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
@@ -23645,7 +23645,10 @@ import { _isJSXNode, _isStringifiable } from "@qwik.dev/core/internal";
 import { expect } from "vitest";
 
 // packages/qwik/src/core/client/vnode-utils.ts
-import { isDev as isDev23 } from "@qwik.dev/core/build";
+import { isDev as isDev24 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/shared/error/assert.ts
+import { isDev } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/utils/qdev.ts
 var qDev = globalThis.qDev !== false;
@@ -23702,7 +23705,7 @@ var createAndLogError = (asyncThrow, message, ...optionalParams) => {
 // packages/qwik/src/core/shared/error/assert.ts
 var ASSERT_DISCLAIMER = "Internal assert, this is likely caused by a bug in Qwik: ";
 function assertDefined(value, text, ...parts) {
-  if (qDev) {
+  if (isDev) {
     if (value != null) {
       return;
     }
@@ -23710,7 +23713,7 @@ function assertDefined(value, text, ...parts) {
   }
 }
 function assertEqual(value1, value2, text, ...parts) {
-  if (qDev) {
+  if (isDev) {
     if (value1 === value2) {
       return;
     }
@@ -23718,7 +23721,7 @@ function assertEqual(value1, value2, text, ...parts) {
   }
 }
 function assertTrue(value1, text, ...parts) {
-  if (qDev) {
+  if (isDev) {
     if (value1 === true) {
       return;
     }
@@ -23726,7 +23729,7 @@ function assertTrue(value1, text, ...parts) {
   }
 }
 function assertFalse(value1, text, ...parts) {
-  if (qDev) {
+  if (isDev) {
     if (value1 === false) {
       return;
     }
@@ -23734,7 +23737,7 @@ function assertFalse(value1, text, ...parts) {
   }
 }
 function assertNumber(value1, text, ...parts) {
-  if (qDev) {
+  if (isDev) {
     if (typeof value1 === "number") {
       return;
     }
@@ -23834,7 +23837,12 @@ See https://qwik.dev/docs/core/tasks/#use-method-rules`,
       // 28
       "useComputed$ QRL {{0}} {{1}} cannot return a Promise",
       // 29
-      "ComputedSignal is read-only",
+      `===
+Qwik version {{0}} already imported while importing {{1}}.
+This can lead to issues due to duplicated shared structures.
+Verify that the Qwik libraries you're using are in "resolve.noExternal[]" and in "optimizeDeps.exclude".
+===
+`,
       // 30
       "WrappedSignal is read-only",
       // 31
@@ -23857,7 +23865,7 @@ See https://qwik.dev/docs/core/tasks/#use-method-rules`,
     }
     return `Code(Q${code2}): ${text}`;
   } else {
-    return `Code(Q${code2}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code2}`;
+    return `Code(Q${code2}) https://github.com/QwikDev/qwik/blob/build/v2/packages/qwik/src/core/shared/error/error.ts#${parts.join()}L${9 + code2}`;
   }
 };
 var qError = (code2, errorMessageArgs = []) => {
@@ -23866,7 +23874,7 @@ var qError = (code2, errorMessageArgs = []) => {
 };
 
 // packages/qwik/src/core/shared/qrl/qrl-utils.ts
-import { isDev } from "@qwik.dev/core/build";
+import { isDev as isDev2 } from "@qwik.dev/core/build";
 var SYNC_QRL = "<sync>";
 var isSyncQrl = (value) => {
   return isQrl(value) && value.$symbol$ == SYNC_QRL;
@@ -23875,7 +23883,7 @@ var isQrl = (value) => {
   return typeof value === "function" && typeof value.getSymbol === "function";
 };
 function assertQrl(qrl) {
-  if (isDev) {
+  if (isDev2) {
     if (!isQrl(qrl)) {
       throw new Error("Not a QRL");
     }
@@ -23981,9 +23989,6 @@ var NON_SERIALIZABLE_MARKER_PREFIX = ":";
 var USE_ON_LOCAL = NON_SERIALIZABLE_MARKER_PREFIX + "on";
 var USE_ON_LOCAL_SEQ_IDX = NON_SERIALIZABLE_MARKER_PREFIX + "onIdx";
 var USE_ON_LOCAL_FLAGS = NON_SERIALIZABLE_MARKER_PREFIX + "onFlags";
-var FLUSH_COMMENT = "qkssr-f";
-var STREAM_BLOCK_START_COMMENT = "qkssr-pu";
-var STREAM_BLOCK_END_COMMENT = "qkssr-po";
 var Q_PROPS_SEPARATOR = ":";
 var dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
 var debugStyleScopeIdPrefixAttr = "__scopedStyleIdPrefix__";
@@ -24055,7 +24060,7 @@ var isText = (value) => {
 };
 
 // packages/qwik/src/core/shared/utils/promises.ts
-import { isDev as isDev2, isServer as isServer2 } from "@qwik.dev/core/build";
+import { isDev as isDev3, isServer as isServer2 } from "@qwik.dev/core/build";
 var MAX_RETRY_ON_PROMISE_COUNT = 100;
 var isPromise = (value) => {
   return !!value && typeof value == "object" && typeof value.then === "function";
@@ -24096,7 +24101,7 @@ function retryOnPromise(fn, onError = justThrow) {
     if (ok) {
       return result2;
     }
-    isDev2 && checkError(result2);
+    isDev3 && checkError(result2);
     return onError(result2);
   }
   let retryCount = MAX_RETRY_ON_PROMISE_COUNT;
@@ -24119,17 +24124,17 @@ function retryOnPromise(fn, onError = justThrow) {
         }
       }
     }
-    isDev2 && checkError(p);
+    isDev3 && checkError(p);
     return onError(p);
   };
   return ok ? result2.catch(retry) : retry(result2);
 }
 
 // packages/qwik/src/core/use/use-core.ts
-import { isDev as isDev19 } from "@qwik.dev/core/build";
+import { isDev as isDev20 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/client/dom-container.ts
-import { isDev as isDev18 } from "@qwik.dev/core/build";
+import { isDev as isDev19 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/use/use-sequential-scope.ts
 var useSequentialScope = () => {
@@ -24217,9 +24222,9 @@ var fromCamelToKebabCase = (text) => {
 };
 
 // packages/qwik/src/core/use/use-context.ts
-import { isDev as isDev3 } from "@qwik.dev/core/build";
+import { isDev as isDev4 } from "@qwik.dev/core/build";
 var createContextId = (name) => {
-  isDev3 && assertTrue(/^[\w/.-]+$/.test(name), "Context name must only contain A-Z,a-z,0-9,_,.,-", name);
+  isDev4 && assertTrue(/^[\w/.-]+$/.test(name), "Context name must only contain A-Z,a-z,0-9,_,.,-", name);
   return /* @__PURE__ */ Object.freeze({
     id: fromCamelToKebabCase(name)
   });
@@ -24283,7 +24288,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser2, isDev as isDev17 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser2, isDev as isDev18 } from "@qwik.dev/core/build";
 import { p as preload } from "@qwik.dev/core/preloader";
 
 // packages/qwik/src/core/reactive-primitives/backref.ts
@@ -24297,7 +24302,7 @@ var BackRef = class {
 };
 
 // packages/qwik/src/core/shared/vnode/vnode.ts
-import { isDev as isDev4 } from "@qwik.dev/core/build";
+import { isDev as isDev5 } from "@qwik.dev/core/build";
 var _a2;
 _a2 = _EFFECT_BACK_REF;
 var VNode = class {
@@ -24315,7 +24320,7 @@ var VNode = class {
   }
   // TODO: this creates debug issues
   toString() {
-    if (isDev4) {
+    if (isDev5) {
       return vnode_toString.call(this);
     }
     return Object.prototype.toString.call(this);
@@ -24342,13 +24347,13 @@ var ElementVNode = class extends VirtualVNode {
 };
 
 // packages/qwik/src/core/shared/serdes/qrl-to-string.ts
-import { isDev as isDev5 } from "@qwik.dev/core/build";
+import { isDev as isDev6 } 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);
+    const result2 = isDev6 ? platform.chunkForSymbol(symbol, chunk, qrl.dev?.file) : platform.chunkForSymbol(symbol, chunk);
     if (result2) {
       chunk = result2[1];
       symbol = result2[0];
@@ -24359,7 +24364,7 @@ function qrlToString(serializationContext, qrl, raw) {
     if (!chunk) {
       chunk = serializationContext.$symbolToChunkResolver$(qrl.$hash$);
     }
-    if (isDev5) {
+    if (isDev6) {
       const backChannel = globalThis.__qrl_back_channel__ || (globalThis.__qrl_back_channel__ = /* @__PURE__ */ new Map());
       backChannel.set(qrl.$symbol$, qrl.$symbolRef$);
       if (!chunk) {
@@ -24393,9 +24398,9 @@ function qrlToString(serializationContext, qrl, raw) {
 }
 function createQRLWithBackChannel(chunk, symbol, captures) {
   let qrlImporter = null;
-  if (isDev5 && chunk === QRL_RUNTIME_CHUNK) {
+  if (isDev6 && chunk === QRL_RUNTIME_CHUNK) {
     const backChannel = globalThis.__qrl_back_channel__;
-    isDev5 && assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK");
+    isDev6 && assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK");
     const fn = backChannel.get(symbol);
     if (fn) {
       qrlImporter = () => Promise.resolve({ [symbol]: fn });
@@ -24443,9 +24448,9 @@ function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromD
 }
 
 // packages/qwik/src/core/client/util-mapArray.ts
-import { isDev as isDev6 } from "@qwik.dev/core/build";
+import { isDev as isDev7 } from "@qwik.dev/core/build";
 var mapApp_findIndx = (array, key, start) => {
-  isDev6 && assertTrue(start % 2 === 0, "Expecting even number.");
+  isDev7 && assertTrue(start % 2 === 0, "Expecting even number.");
   let bottom = start >> 1;
   let top = array.length - 2 >> 1;
   while (bottom <= top) {
@@ -24497,7 +24502,7 @@ var mapArray_has = (array, key, start) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/signal-impl.ts
-import { isDev as isDev7, isServer as isServer3 } from "@qwik.dev/core/build";
+import { isDev as isDev8, isServer as isServer3 } from "@qwik.dev/core/build";
 var DEBUG = false;
 var log = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var SignalImpl = class {
@@ -24512,16 +24517,20 @@ var SignalImpl = class {
     DEBUG && log("new", this);
   }
   /**
-   * Use this to force running subscribers, for example when the calculated value has mutated but
+   * Use this to trigger running subscribers, for example when the calculated value has mutated but
    * remained the same object
    */
+  trigger() {
+    scheduleEffects(this.$container$, this, this.$effects$);
+  }
+  /** @deprecated Use `trigger()` instead */
   force() {
     scheduleEffects(this.$container$, this, this.$effects$);
   }
+  // We need this to be getter/setter so subclasses can override them
   get untrackedValue() {
     return this.$untrackedValue$;
   }
-  // TODO: should we disallow setting the value directly?
   set untrackedValue(value) {
     this.$untrackedValue$ = value;
   }
@@ -24535,7 +24544,7 @@ var SignalImpl = class {
     if (this.$container$ === null) {
       this.$container$ = ctx.$container$;
     } else {
-      isDev7 && assertTrue(
+      isDev8 && assertTrue(
         !ctx.$container$ || ctx.$container$ === this.$container$,
         "Do not use signals across containers"
       );
@@ -24572,7 +24581,7 @@ var SignalImpl = class {
     }
   }
   toString() {
-    if (isDev7) {
+    if (isDev8) {
       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) {
@@ -24589,7 +24598,7 @@ var SignalImpl = class {
 var setupSignalValueAccess = (target, effectsProp, valueProp) => {
   const ctx = tryGetInvokeContext();
   if (ctx && (target.$container$ || (target.$container$ = ctx.$container$ || null))) {
-    isDev7 && assertTrue(
+    isDev8 && assertTrue(
       !ctx.$container$ || ctx.$container$ === target.$container$,
       "Do not use signals across containers"
     );
@@ -24608,7 +24617,7 @@ var setupSignalValueAccess = (target, effectsProp, valueProp) => {
 };
 
 // packages/qwik/src/core/shared/jsx/props-proxy.ts
-import { isDev as isDev8 } from "@qwik.dev/core/build";
+import { isDev as isDev9 } from "@qwik.dev/core/build";
 function createPropsProxy(owner) {
   return new Proxy({}, new PropsProxyHandler(owner));
 }
@@ -24741,7 +24750,7 @@ var addPropsProxyEffect = (propsProxy, prop) => {
         propsProxy.$container$ = ctx.$container$;
       }
     } else {
-      isDev8 && assertTrue(
+      isDev9 && assertTrue(
         !ctx.$container$ || ctx.$container$ === propsProxy.$container$,
         "Do not use props across containers"
       );
@@ -24847,7 +24856,7 @@ var cleanupFn = (target, handleError) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/computed-signal-impl.ts
-import { isDev as isDev9 } from "@qwik.dev/core/build";
+import { isDev as isDev10 } from "@qwik.dev/core/build";
 var DEBUG2 = false;
 var log2 = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToString));
 var _a3, _b;
@@ -24883,9 +24892,12 @@ var ComputedSignalImpl = class extends (_b = SignalImpl, _a3 = _EFFECT_BACK_REF,
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev9 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev10 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
+  set untrackedValue(value) {
+    this.$untrackedValue$ = value;
+  }
   $computeIfNeeded$() {
     if (!(this.$flags$ & 1 /* INVALID */)) {
       return;
@@ -24972,25 +24984,55 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
     __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 interval = options?.interval;
     const concurrency = options?.concurrency ?? 1;
     const initial = options?.initial;
     const timeout = options?.timeout;
     const eagerCleanup = options?.eagerCleanup;
+    const clientOnly = options?.clientOnly;
     if (initial !== void 0) {
       const initialValue = typeof initial === "function" ? initial() : initial;
       this.$untrackedValue$ = initialValue;
     }
     this.$concurrency$ = concurrency;
-    this.$timeoutMs$ = timeout;
+    if (timeout) {
+      this.$timeoutMs$ = timeout;
+    }
     if (eagerCleanup) {
       this.$flags$ |= 32 /* EAGER_CLEANUP */;
     }
-    this.interval = interval;
+    if (clientOnly) {
+      this.$flags$ |= 64 /* CLIENT_ONLY */;
+    }
+    if (interval) {
+      this.interval = interval;
+    }
+  }
+  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$;
+    }
+    if ((import.meta.env.TEST ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */ && this.$untrackedValue$ === NEEDS_COMPUTATION) {
+      throw new Error(
+        "During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value."
+      );
+    }
+    return this.$untrackedValue$;
+  }
+  set untrackedValue(value) {
+    this.$untrackedValue$ = value;
   }
   /**
    * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
@@ -25081,6 +25123,11 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
     if (!(this.$flags$ & 1 /* INVALID */)) {
       return;
     }
+    if ((import.meta.env.TEST ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */) {
+      this.$untrackedLoading$ = true;
+      this.$container$?.serializationCtx.$eagerResume$.add(this);
+      return;
+    }
     this.$clearNextPoll$();
     if (this.$current$) {
       this.$requestCleanups$(this.$current$);
@@ -25152,22 +25199,6 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a4 = _EFFECT_BAC
     }
     await Promise.all(this.$jobs$.map((job) => job.$promise$));
   }
-  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$);
@@ -25424,7 +25455,7 @@ function setCursorData(vNode, cursorData) {
 }
 
 // packages/qwik/src/core/client/vnode-diff.ts
-import { isDev as isDev13 } from "@qwik.dev/core/build";
+import { isDev as isDev14 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscription-data.ts
 var SubscriptionData = class {
@@ -25435,14 +25466,14 @@ var SubscriptionData = class {
 };
 
 // packages/qwik/src/core/shared/component-execution.ts
-import { isDev as isDev11, isServer as isServer6 } from "@qwik.dev/core/build";
+import { isDev as isDev12, isServer as isServer6 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/component.public.ts
-import { isDev as isDev10 } from "@qwik.dev/core/build";
+import { isDev as isDev11 } from "@qwik.dev/core/build";
 var componentQrl = (componentQrl2) => {
   function QwikComponent(props, key, flags = 0) {
-    isDev10 && assertQrl(componentQrl2);
-    isDev10 && assertNumber(flags, "The Qwik Component was not invoked correctly");
+    isDev11 && assertQrl(componentQrl2);
+    isDev11 && 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 = () => {
@@ -25515,6 +25546,9 @@ var isJSXNode = (n) => {
       return true;
     }
     if (isObject(n) && _hasOwnProperty.call(n, "key") && _hasOwnProperty.call(n, "props") && _hasOwnProperty.call(n, "type")) {
+      if (isPropsProxy(n)) {
+        return false;
+      }
       logWarn(`Duplicate implementations of "JSXNode" found`);
       return true;
     }
@@ -25543,7 +25577,7 @@ var executeComponent = (container, renderHost, subscriptionHost, componentQRL, p
   let isInlineComponent = false;
   if (componentQRL === null) {
     componentQRL = container.getHostProp(renderHost, OnRenderProp);
-    isDev11 && assertDefined(componentQRL, "No Component found at this location");
+    isDev12 && assertDefined(componentQRL, "No Component found at this location");
   }
   if (isQrl(componentQRL)) {
     props = props || container.getHostProp(renderHost, ELEMENT_PROPS) || EMPTY_OBJ;
@@ -25622,7 +25656,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
             }
             targetElement = placeholderElement;
           } else {
-            if (isDev11) {
+            if (isDev12) {
               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. '
               );
@@ -25633,7 +25667,7 @@ function addUseOnEvents(jsx2, useOnEvents) {
         if (targetElement) {
           if (targetElement.type === "script" && key === qVisibleEvent) {
             eventKey = "q-d:qinit";
-            if (isDev11) {
+            if (isDev12) {
               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.'
               );
@@ -25666,7 +25700,6 @@ function addUseOnEvent(jsxElement, key, value) {
     props[key] = void 0;
   }
 }
-var getValue = (o) => o.value;
 function findFirstElementNode(jsx2) {
   const queue2 = [jsx2];
   while (queue2.length) {
@@ -25681,7 +25714,7 @@ function findFirstElementNode(jsx2) {
     } else if (isPromise(jsx3)) {
       return maybeThen(jsx3, (jsx4) => findFirstElementNode(jsx4));
     } else if (isSignal(jsx3)) {
-      return findFirstElementNode(untrack(getValue, jsx3));
+      return findFirstElementNode(jsx3.untrackedValue);
     }
   }
   return null;
@@ -25721,9 +25754,9 @@ var SSRRaw = () => null;
 var SSRComment = () => null;
 
 // packages/qwik/src/core/client/vnode-namespace.ts
-import { isDev as isDev12 } from "@qwik.dev/core/build";
+import { isDev as isDev13 } from "@qwik.dev/core/build";
 var isForeignObjectElement = (elementName) => {
-  return isDev12 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
+  return isDev13 ? elementName.toLowerCase() === "foreignobject" : elementName === "foreignObject";
 };
 var isSvgElement = (elementName) => elementName === "svg" || isForeignObjectElement(elementName);
 var isMathElement = (elementName) => elementName === "math";
@@ -26479,7 +26512,6 @@ var SetTextOperation = class {
   constructor(target, text) {
     this.target = target;
     this.text = text;
-    __publicField(this, "operationType", 16 /* SetText */);
   }
 };
 var InsertOrMoveOperation = class {
@@ -26578,8 +26610,8 @@ var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleId
   }
 };
 function diff(diffContext, jsxNode, vStartNode) {
-  isDev13 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
-  isDev13 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
+  isDev14 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
+  isDev14 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
   diffContext.vParent = vStartNode;
   diffContext.vNewNode = null;
   diffContext.vCurrent = vnode_getFirstChild(vStartNode);
@@ -26589,7 +26621,7 @@ function diff(diffContext, jsxNode, vStartNode) {
   }
   while (diffContext.stack.length) {
     while (diffContext.jsxIdx < diffContext.jsxCount) {
-      isDev13 && assertFalse(
+      isDev14 && assertFalse(
         diffContext.vParent === diffContext.vCurrent,
         "Parent and current can't be the same"
       );
@@ -26601,7 +26633,7 @@ function diff(diffContext, jsxNode, vStartNode) {
         if (isJSXNode(diffContext.jsxValue)) {
           const type = diffContext.jsxValue.type;
           if (typeof type === "string") {
-            expectNoMoreTextNodes(diffContext);
+            expectNoTextNode(diffContext);
             expectElement(diffContext, diffContext.jsxValue, type);
             const hasDangerousInnerHTML = diffContext.jsxValue.constProps && _hasOwnProperty2.call(diffContext.jsxValue.constProps, dangerouslySetInnerHTML) || _hasOwnProperty2.call(diffContext.jsxValue.varProps, dangerouslySetInnerHTML);
             if (hasDangerousInnerHTML) {
@@ -26611,11 +26643,11 @@ function diff(diffContext, jsxNode, vStartNode) {
             }
           } else if (typeof type === "function") {
             if (type === Fragment) {
-              expectNoMoreTextNodes(diffContext);
+              expectNoTextNode(diffContext);
               expectVirtual(diffContext, "F" /* Fragment */, diffContext.jsxValue.key);
               descend(diffContext, diffContext.jsxValue.children, true);
             } else if (type === Slot) {
-              expectNoMoreTextNodes(diffContext);
+              expectNoTextNode(diffContext);
               if (!expectSlot(diffContext)) {
                 descend(diffContext, diffContext.jsxValue.children, true);
               }
@@ -26634,7 +26666,7 @@ function diff(diffContext, jsxNode, vStartNode) {
             } else if (type === SSRRaw) {
               expectNoMore(diffContext);
             } else {
-              expectNoMoreTextNodes(diffContext);
+              expectNoTextNode(diffContext);
               expectComponent(diffContext, type);
             }
           }
@@ -26720,7 +26752,7 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
   }
   stackPush(diffContext, children, descendVNode);
   if (descendVNode) {
-    isDev13 && assertDefined(
+    isDev14 && assertDefined(
       diffContext.vCurrent || diffContext.vNewNode,
       "Expecting vCurrent to be defined."
     );
@@ -26804,11 +26836,10 @@ function descendContentToProject(diffContext, children, host) {
   if (host) {
     const props = host.props;
     if (props) {
-      for (const prop of Object.keys(props)) {
+      for (const prop in props) {
         if (isSlotProp(prop)) {
           const slotName = prop;
-          projections.push(slotName);
-          projections.push(createProjectionJSXNode(slotName));
+          mapArray_set(projections, slotName, createProjectionJSXNode(slotName), 0);
         }
       }
     }
@@ -26849,8 +26880,8 @@ function expectProjection(diffContext) {
   diffContext.vCurrent = diffContext.vCurrent && diffContext.vCurrent.flags & 32 /* Deleted */ ? null : diffContext.vCurrent;
   if (diffContext.vCurrent == null) {
     diffContext.vNewNode = vnode_newVirtual();
-    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
-    isDev13 && vnode_setProp(diffContext.vNewNode, "q:code", "expectProjection");
+    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
+    isDev14 && 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);
@@ -26871,7 +26902,7 @@ function expectSlot(diffContext) {
     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 */);
+    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
       diffContext.journal,
       diffContext.vParent,
@@ -26885,7 +26916,7 @@ function expectSlot(diffContext) {
     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 */);
+    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* Projection */);
     vnode_insertBefore(
       diffContext.journal,
       diffContext.vParent,
@@ -26977,7 +27008,7 @@ function expectNoChildren(diffContext, removeDOM = true) {
   }
 }
 function expectNoMore(diffContext) {
-  isDev13 && assertFalse(
+  isDev14 && assertFalse(
     diffContext.vParent === diffContext.vCurrent,
     "Parent and current can't be the same"
   );
@@ -26992,9 +27023,8 @@ function expectNoMore(diffContext) {
     }
   }
 }
-function expectNoMoreTextNodes(diffContext) {
-  while (diffContext.vCurrent !== null && vnode_isTextVNode(diffContext.vCurrent)) {
-    cleanup(diffContext.container, diffContext.journal, diffContext.vCurrent, diffContext.cursor);
+function expectNoTextNode(diffContext) {
+  if (diffContext.vCurrent !== null && vnode_isTextVNode(diffContext.vCurrent)) {
     const toRemove = diffContext.vCurrent;
     diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
     vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
@@ -27064,7 +27094,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
       }
       if (elementName === "textarea" && key2 === "value") {
         if (value && typeof value !== "string") {
-          if (isDev13) {
+          if (isDev14) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -27115,7 +27145,9 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
         handlers.push(runEventHandlerQRL.bind(null, item));
       }
     }
-    (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
+    if (handlers.length > 0) {
+      (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
+    }
   } else if (value) {
     (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = [
       runEventHandlerQRL.bind(null, value)
@@ -27161,7 +27193,7 @@ function expectElement(diffContext, jsx2, elementName) {
   const jsxProps = jsx2.varProps;
   const vNode = diffContext.vNewNode || diffContext.vCurrent;
   if (jsxProps) {
-    diffProps(diffContext, vNode, jsxProps, isDev13 && getFileLocationFromJsx(jsx2.dev) || null);
+    diffProps(diffContext, vNode, jsxProps, isDev14 && getFileLocationFromJsx(jsx2.dev) || null);
   }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
@@ -27425,7 +27457,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
     diffContext.vNewNode.key = jsxKey;
-    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
     return;
   }
   if (moveOrCreateKeyedNode(
@@ -27443,7 +27475,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       diffContext.vCurrent && getInsertBefore(diffContext)
     );
     diffContext.vNewNode.key = jsxKey;
-    isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
   }
 }
 function expectComponent(diffContext, component) {
@@ -27530,7 +27562,7 @@ function expectComponent(diffContext, component) {
         OnRenderProp,
         null
       ) === null : true)) {
-        componentHost = componentHost.parent;
+        componentHost = componentHost.parent || vnode_getProjectionParentComponent(componentHost);
       }
       const jsxOutput = executeComponent(
         diffContext.container,
@@ -27554,7 +27586,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     diffContext.vCurrent && getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.jsxValue;
-  isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "C" /* Component */);
+  isDev14 && 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;
@@ -27567,7 +27599,7 @@ function insertNewInlineComponent(diffContext) {
     diffContext.vCurrent && getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.jsxValue;
-  isDev13 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "I" /* InlineComponent */);
+  isDev14 && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "I" /* InlineComponent */);
   vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxNode.props);
   if (jsxNode.key) {
     diffContext.vNewNode.key = jsxNode.key;
@@ -28179,7 +28211,7 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isDev as isDev14, isServer as isServer7 } from "@qwik.dev/core/build";
+import { isDev as isDev15, isServer as isServer7 } from "@qwik.dev/core/build";
 var DEBUG6 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
@@ -28216,7 +28248,7 @@ function walkCursor(cursor, options) {
     return;
   }
   const container = cursorData.container;
-  isDev14 && assertDefined(container, "Cursor container not found");
+  isDev15 && assertDefined(container, "Cursor container not found");
   if (!cursor.dirty) {
     finishWalk(container, cursor, cursorData, isRunningOnServer);
     return;
@@ -28239,6 +28271,12 @@ function walkCursor(cursor, options) {
     if (currentVNode.flags & 32 /* Deleted */) {
       if (currentVNode.dirty & 64 /* CLEANUP */) {
         executeCleanup(currentVNode, container);
+      } else if (currentVNode.dirty & 32 /* CHILDREN */) {
+        const next = tryDescendDirtyChildren(container, cursorData, currentVNode, cursor);
+        if (next !== null) {
+          currentVNode = next;
+          continue;
+        }
       }
       currentVNode.dirty &= ~127 /* DIRTY_MASK */;
       setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
@@ -28257,14 +28295,9 @@ function walkCursor(cursor, options) {
       } else if (currentVNode.dirty & 16 /* COMPUTE */) {
         result2 = executeCompute(currentVNode, container);
       } else if (currentVNode.dirty & 32 /* CHILDREN */) {
-        const dirtyChildren = currentVNode.dirtyChildren;
-        if (!dirtyChildren || dirtyChildren.length === 0) {
-          currentVNode.dirty &= ~32 /* CHILDREN */;
-        } else {
-          partitionDirtyChildren(dirtyChildren, currentVNode);
-          currentVNode.nextDirtyChildIndex = 0;
-          currentVNode = getNextVNode(dirtyChildren[0], cursor);
-          setCursorPosition(container, cursorData, currentVNode);
+        const next = tryDescendDirtyChildren(container, cursorData, currentVNode, cursor);
+        if (next !== null) {
+          currentVNode = next;
           continue;
         }
       }
@@ -28293,7 +28326,7 @@ function walkCursor(cursor, options) {
       }
     }
   }
-  isDev14 && assertFalse(
+  isDev15 && assertFalse(
     !!(cursor.dirty & 127 /* DIRTY_MASK */ && !cursorData.position),
     "Cursor is still dirty and position is not set after walking"
   );
@@ -28319,6 +28352,18 @@ function resolveCursor(container) {
   DEBUG6 && console.warn(`walkCursor: cursor resolved, ${container.$pendingCount$} remaining`);
   container.$checkPendingCount$();
 }
+function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
+  const dirtyChildren = currentVNode.dirtyChildren;
+  if (!dirtyChildren || dirtyChildren.length === 0) {
+    currentVNode.dirty &= ~32 /* CHILDREN */;
+    return null;
+  }
+  partitionDirtyChildren(dirtyChildren, currentVNode);
+  currentVNode.nextDirtyChildIndex = 0;
+  const next = getNextVNode(dirtyChildren[0], cursor);
+  setCursorPosition(container, cursorData, next);
+  return next;
+}
 function partitionDirtyChildren(dirtyChildren, parent) {
   let writeIndex = 0;
   for (let readIndex = 0; readIndex < dirtyChildren.length; readIndex++) {
@@ -28515,7 +28560,7 @@ function addVNodeOperation(journal, operation) {
 }
 
 // packages/qwik/src/core/reactive-primitives/impl/wrapped-signal-impl.ts
-import { isDev as isDev15 } from "@qwik.dev/core/build";
+import { isDev as isDev16 } 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 */) {
@@ -28525,6 +28570,8 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF,
     __publicField(this, "$funcStr$");
     __publicField(this, "$flags$");
     __publicField(this, "$hostElement$");
+    // important: don't use implemnets BackRef here
+    // it causes v8 optimizations eager bailouts, because of not consistent class shape
     __publicField(this, _a5);
     this.$args$ = args;
     this.$func$ = fn;
@@ -28548,7 +28595,7 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a5 = _EFFECT_BACK_REF,
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev15 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev16 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -28785,27 +28832,42 @@ function _chk(_, element) {
 var version = globalThis.QWIK_VERSION;
 
 // packages/qwik/src/core/shared/serdes/serialize.ts
-import { isDev as isDev16 } from "@qwik.dev/core/build";
-async function serialize(serializationContext) {
-  const {
-    $writer$,
-    $isSsrNode$,
-    $isDomRef$,
-    $storeProxyMap$,
-    $addRoot$,
-    $promoteToRoot$,
-    getSeenRef,
-    $markSeen$
-  } = serializationContext;
-  let rootIdx = 0;
-  const forwardRefs = [];
-  let forwardRefsId = 0;
-  const promises = /* @__PURE__ */ new Set();
-  const s11nWeakRefs = /* @__PURE__ */ new Map();
-  let parent;
-  const qrlMap = /* @__PURE__ */ new Map();
-  const outputArray = (value, keepUndefined, writeFn) => {
-    $writer$.write("[");
+import { isDev as isDev17 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/shared/ssr-const.ts
+var LT = "<";
+var GT = ">";
+var CLOSE_TAG = "</";
+var ESCAPED_CLOSE_TAG = "<\\/";
+var SPACE = " ";
+var ATTR_EQUALS_QUOTE = '="';
+var QUOTE = '"';
+var EMPTY_ATTR = '=""';
+var BRACKET_OPEN = "[";
+var BRACKET_CLOSE = "]";
+var PAREN_CLOSE = ")";
+var COMMA = ",";
+
+// packages/qwik/src/core/shared/serdes/serialize.ts
+var Serializer = class {
+  constructor($serializationContext$) {
+    this.$serializationContext$ = $serializationContext$;
+    __publicField(this, "rootIdx", 0);
+    __publicField(this, "forwardRefs", []);
+    __publicField(this, "forwardRefsId", 0);
+    __publicField(this, "promises", /* @__PURE__ */ new Set());
+    __publicField(this, "s11nWeakRefs", /* @__PURE__ */ new Map());
+    __publicField(this, "parent");
+    __publicField(this, "qrlMap", /* @__PURE__ */ new Map());
+    __publicField(this, "$writer$");
+    this.$writer$ = $serializationContext$.$writer$;
+  }
+  async serialize() {
+    await this.outputRoots();
+  }
+  /** Helper to output an array */
+  outputArray(value, keepUndefined, writeFn) {
+    this.$writer$.write(BRACKET_OPEN);
     let separator = false;
     let length;
     if (keepUndefined) {
@@ -28819,165 +28881,183 @@ async function serialize(serializationContext) {
     }
     for (let i = 0; i < length; i++) {
       if (separator) {
-        $writer$.write(",");
+        this.$writer$.write(COMMA);
       } else {
         separator = true;
       }
       writeFn(value[i], i);
     }
-    $writer$.write("]");
-  };
-  const output = (type, value, keepUndefined) => {
-    $writer$.write(`${type},`);
+    this.$writer$.write(BRACKET_CLOSE);
+  }
+  /** Whether a string needs JSON escaping (quote, backslash, or control chars). */
+  stringNeedsJsonEscape$(str) {
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 32 || c === 34 || c === 92) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Output a type,value pair. If the value is an array, it calls writeValue on each item. */
+  output(type, value, keepUndefined) {
     if (typeof value === "number") {
-      $writer$.write(value.toString());
+      this.$writer$.write(type + COMMA + value);
     } else if (typeof value === "string") {
-      const s = JSON.stringify(value);
+      const s = this.stringNeedsJsonEscape$(value) ? JSON.stringify(value) : QUOTE + value + QUOTE;
+      this.$writer$.write(type + COMMA);
       let angleBracketIdx = -1;
       let lastIdx = 0;
-      while ((angleBracketIdx = s.indexOf("</", lastIdx)) !== -1) {
-        $writer$.write(s.slice(lastIdx, angleBracketIdx));
-        $writer$.write("<\\/");
+      while ((angleBracketIdx = s.indexOf(CLOSE_TAG, lastIdx)) !== -1) {
+        this.$writer$.write(s.slice(lastIdx, angleBracketIdx));
+        this.$writer$.write(ESCAPED_CLOSE_TAG);
         lastIdx = angleBracketIdx + 2;
       }
-      $writer$.write(lastIdx === 0 ? s : s.slice(lastIdx));
+      this.$writer$.write(lastIdx === 0 ? s : s.slice(lastIdx));
     } else {
-      outputArray(value, !!keepUndefined, (valueItem, idx) => {
-        writeValue(valueItem, idx);
+      this.$writer$.write(type + COMMA);
+      this.outputArray(value, !!keepUndefined, (valueItem, idx) => {
+        this.writeValue(valueItem, idx);
       });
     }
-  };
-  const getSeenRefOrOutput = (value, index, keepWeak) => {
-    let seen = getSeenRef(value);
-    const forwardRefIdx = !keepWeak && s11nWeakRefs.get(value);
+  }
+  getSeenRefOrOutput(value, index, keepWeak) {
+    let seen = this.$serializationContext$.getSeenRef(value);
+    const forwardRefIdx = !keepWeak && this.s11nWeakRefs.get(value);
     if (!seen) {
       if (keepWeak) {
         return true;
       }
       if (typeof forwardRefIdx === "number") {
-        seen = $addRoot$(value, true);
+        seen = this.$serializationContext$.$addRoot$(value, true);
       } else {
-        return $markSeen$(value, parent, index);
+        return this.$serializationContext$.$markSeen$(value, this.parent, index);
       }
     }
     if (seen.$parent$) {
-      if (!parent) {
-        $promoteToRoot$(seen, index);
-        value = serializationContext.$roots$[index];
+      if (!this.parent) {
+        this.$serializationContext$.$promoteToRoot$(seen, index);
+        value = this.$serializationContext$.$roots$[index];
       } else {
-        $promoteToRoot$(seen);
+        this.$serializationContext$.$promoteToRoot$(seen);
       }
     }
     if (typeof forwardRefIdx === "number") {
-      forwardRefs[forwardRefIdx] = seen.$index$;
-      s11nWeakRefs.delete(value);
+      this.forwardRefs[forwardRefIdx] = seen.$index$;
+      this.s11nWeakRefs.delete(value);
     }
-    const rootIdx2 = value instanceof SerializationBackRef ? value.$path$ : seen.$index$;
-    if (!parent && rootIdx2 === index) {
+    const rootIdx = value instanceof SerializationBackRef ? value.$path$ : seen.$index$;
+    if (!this.parent && rootIdx === index) {
       return seen;
     }
-    output(1 /* RootRef */, rootIdx2);
-  };
-  const writeValue = (value, index) => {
+    this.output(1 /* RootRef */, rootIdx);
+  }
+  // First check for scalars, then do objects with seen checks
+  // Make sure to only get the SeenRef once, it's expensive
+  writeValue(value, index) {
     if (fastSkipSerialize(value)) {
-      output(3 /* Constant */, 0 /* Undefined */);
+      this.output(3 /* Constant */, 0 /* Undefined */);
     } else {
       switch (typeof value) {
         case "undefined":
-          output(3 /* Constant */, 0 /* Undefined */);
+          this.output(3 /* Constant */, 0 /* Undefined */);
           break;
         case "boolean":
-          output(3 /* Constant */, value ? 2 /* True */ : 3 /* False */);
+          this.output(3 /* Constant */, value ? 2 /* True */ : 3 /* False */);
           break;
         case "number":
           if (Number.isNaN(value)) {
-            output(3 /* Constant */, 12 /* NaN */);
+            this.output(3 /* Constant */, 12 /* NaN */);
           } else if (!Number.isFinite(value)) {
-            output(
+            this.output(
               3 /* Constant */,
               value < 0 ? 14 /* NegativeInfinity */ : 13 /* PositiveInfinity */
             );
           } else if (value === Number.MAX_SAFE_INTEGER) {
-            output(3 /* Constant */, 15 /* MaxSafeInt */);
+            this.output(3 /* Constant */, 15 /* MaxSafeInt */);
           } else if (value === Number.MAX_SAFE_INTEGER - 1) {
-            output(3 /* Constant */, 16 /* AlmostMaxSafeInt */);
+            this.output(3 /* Constant */, 16 /* AlmostMaxSafeInt */);
           } else if (value === Number.MIN_SAFE_INTEGER) {
-            output(3 /* Constant */, 17 /* MinSafeInt */);
+            this.output(3 /* Constant */, 17 /* MinSafeInt */);
           } else {
-            output(0 /* Plain */, value);
+            this.output(0 /* Plain */, value);
           }
           break;
         case "string":
           if (value.length === 0) {
-            output(3 /* Constant */, 4 /* EmptyString */);
+            this.output(3 /* Constant */, 4 /* EmptyString */);
           } else {
-            if (value.length < 4 || getSeenRefOrOutput(value, index)) {
-              output(0 /* Plain */, value);
+            if (value.length < 4 || this.getSeenRefOrOutput(value, index)) {
+              this.output(0 /* Plain */, value);
             }
           }
           break;
         case "bigint":
-          if (value < 1e4 && value > -1e3 || getSeenRefOrOutput(value, index)) {
-            output(12 /* BigInt */, value.toString());
+          if (value < 1e4 && value > -1e3 || this.getSeenRefOrOutput(value, index)) {
+            this.output(12 /* BigInt */, value.toString());
           }
           break;
         case "symbol":
           if (value === NEEDS_COMPUTATION) {
-            output(3 /* Constant */, 7 /* NEEDS_COMPUTATION */);
+            this.output(3 /* Constant */, 7 /* NEEDS_COMPUTATION */);
           } else if (value === STORE_ALL_PROPS) {
-            output(3 /* Constant */, 8 /* STORE_ALL_PROPS */);
+            this.output(3 /* Constant */, 8 /* STORE_ALL_PROPS */);
           } else if (value === _UNINITIALIZED) {
-            output(3 /* Constant */, 9 /* UNINITIALIZED */);
+            this.output(3 /* Constant */, 9 /* UNINITIALIZED */);
           }
           break;
         case "function":
           if (value === Slot) {
-            output(3 /* Constant */, 10 /* Slot */);
+            this.output(3 /* Constant */, 10 /* Slot */);
           } else if (value === Fragment) {
-            output(3 /* Constant */, 11 /* Fragment */);
+            this.output(3 /* Constant */, 11 /* Fragment */);
           } else if (isQrl(value)) {
-            if (getSeenRefOrOutput(value, index)) {
-              const [chunk, symbol, captures] = qrlToString(serializationContext, value, true);
+            if (this.getSeenRefOrOutput(value, index)) {
+              const [chunk, symbol, captures] = qrlToString(
+                this.$serializationContext$,
+                value,
+                true
+              );
               let data;
               if (chunk !== "") {
-                data = `${$addRoot$(chunk)}#${$addRoot$(symbol)}${captures ? "#" + captures : ""}`;
-                const existing = qrlMap.get(data);
+                data = `${this.$serializationContext$.$addRoot$(chunk)}#${this.$serializationContext$.$addRoot$(symbol)}${captures ? "#" + captures : ""}`;
+                const existing = this.qrlMap.get(data);
                 if (existing) {
-                  const ref = $addRoot$(existing);
-                  output(1 /* RootRef */, ref);
+                  const ref = this.$serializationContext$.$addRoot$(existing);
+                  this.output(1 /* RootRef */, ref);
                   return;
                 } else {
-                  qrlMap.set(data, value);
+                  this.qrlMap.set(data, value);
                 }
               } else {
                 data = Number(symbol);
               }
-              output(9 /* QRL */, data);
+              this.output(9 /* QRL */, data);
             }
           } else if (isQwikComponent(value)) {
             const [qrl] = value[SERIALIZABLE_STATE];
-            serializationContext.$renderSymbols$.add(qrl.$symbol$);
-            output(21 /* Component */, [qrl]);
+            this.$serializationContext$.$renderSymbols$.add(qrl.$symbol$);
+            this.output(21 /* Component */, [qrl]);
           } else {
             throw qError(34 /* serializeErrorCannotSerializeFunction */, [value.toString()]);
           }
           break;
         case "object":
           if (value === EMPTY_ARRAY) {
-            output(3 /* Constant */, 5 /* EMPTY_ARRAY */);
+            this.output(3 /* Constant */, 5 /* EMPTY_ARRAY */);
           } else if (value === EMPTY_OBJ) {
-            output(3 /* Constant */, 6 /* EMPTY_OBJ */);
+            this.output(3 /* Constant */, 6 /* EMPTY_OBJ */);
           } else if (value === null) {
-            output(3 /* Constant */, 1 /* Null */);
+            this.output(3 /* Constant */, 1 /* Null */);
           } else if (value instanceof SerializationBackRef) {
-            output(1 /* RootRef */, value.$path$);
+            this.output(1 /* RootRef */, value.$path$);
           } else {
-            const newSeenRef = getSeenRefOrOutput(value, index);
+            const newSeenRef = this.getSeenRefOrOutput(value, index);
             if (newSeenRef) {
-              const oldParent = parent;
-              parent = newSeenRef;
-              writeObjectValue(value);
-              parent = oldParent;
+              const oldParent = this.parent;
+              this.parent = newSeenRef;
+              this.writeObjectValue(value);
+              this.parent = oldParent;
             }
           }
           break;
@@ -28985,20 +29065,23 @@ async function serialize(serializationContext) {
           throw qError(20 /* serializeErrorUnknownType */, [typeof value]);
       }
     }
-  };
-  const writeObjectValue = (value) => {
+  }
+  writeObjectValue(value) {
     if (isPropsProxy(value)) {
       const owner = value[_OWNER];
-      output(30 /* PropsProxy */, [
+      this.output(30 /* PropsProxy */, [
         _serializationWeakRef(owner),
         owner.varProps,
         owner.constProps,
         value[_PROPS_HANDLER].$effects$
       ]);
     } else if (value instanceof SubscriptionData) {
-      output(31 /* SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+      this.output(31 /* SubscriptionData */, [
+        value.data.$scopedStyleIdPrefix$,
+        value.data.$isConst$
+      ]);
     } else if (value instanceof EffectSubscription) {
-      output(32 /* EffectSubscription */, [
+      this.output(32 /* EffectSubscription */, [
         value.consumer,
         value.property,
         value.backRef,
@@ -29012,7 +29095,7 @@ async function serialize(serializationContext) {
       const innerStores = [];
       for (const prop in storeTarget) {
         const propValue = storeTarget[prop];
-        const innerStore = $storeProxyMap$.get(propValue);
+        const innerStore = this.$serializationContext$.$storeProxyMap$.get(propValue);
         if (innerStore) {
           innerStores.push(innerStore);
         }
@@ -29021,11 +29104,11 @@ async function serialize(serializationContext) {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      output(27 /* Store */, out);
+      this.output(27 /* Store */, out);
     } else if (isSerializerObj(value)) {
       const result2 = value[SerializerSymbol](value);
       if (isPromise(result2)) {
-        const forwardRef = resolvePromise(result2, $addRoot$, (resolved, resolvedValue) => {
+        const forwardRef = this.resolvePromise(result2, (resolved, resolvedValue) => {
           return new PromiseResult(
             26 /* SerializerSignal */,
             resolved,
@@ -29034,15 +29117,15 @@ async function serialize(serializationContext) {
             void 0
           );
         });
-        output(2 /* ForwardRef */, forwardRef);
+        this.output(2 /* ForwardRef */, forwardRef);
       } else {
-        const index = parent.$index$;
-        parent = parent.$parent$;
-        writeValue(result2, index);
+        const index = this.parent.$index$;
+        this.parent = this.parent.$parent$;
+        this.writeValue(result2, index);
       }
     } else if (isObjectLiteral(value)) {
       if (Array.isArray(value)) {
-        output(4 /* Array */, value);
+        this.output(4 /* Array */, value);
       } else {
         const out = [];
         for (const key in value) {
@@ -29053,16 +29136,16 @@ async function serialize(serializationContext) {
             }
           }
         }
-        output(5 /* Object */, out.length ? out : 0);
+        this.output(5 /* Object */, out.length ? out : 0);
       }
-    } else if ($isDomRef$(value)) {
+    } else if (this.$serializationContext$.$isDomRef$(value)) {
       value.$ssrNode$.vnodeData[0] |= 16 /* SERIALIZE */;
-      output(11 /* RefVNode */, value.$ssrNode$.id);
+      this.output(11 /* RefVNode */, value.$ssrNode$.id);
     } else if (value instanceof SignalImpl) {
       if (value instanceof SerializerSignalImpl) {
         const maybeValue = getCustomSerializerPromise(value, value.$untrackedValue$);
         if (isPromise(maybeValue)) {
-          const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => {
+          const forwardRefId = this.resolvePromise(maybeValue, (resolved, resolvedValue) => {
             return new PromiseResult(
               26 /* SerializerSignal */,
               resolved,
@@ -29071,9 +29154,9 @@ async function serialize(serializationContext) {
               value.$computeQrl$
             );
           });
-          output(2 /* ForwardRef */, forwardRefId);
+          this.output(2 /* ForwardRef */, forwardRefId);
         } else {
-          output(26 /* SerializerSignal */, [
+          this.output(26 /* SerializerSignal */, [
             value.$computeQrl$,
             filterEffectBackRefs(value[_EFFECT_BACK_REF]),
             value.$effects$,
@@ -29083,8 +29166,8 @@ async function serialize(serializationContext) {
         return;
       }
       if (value instanceof WrappedSignalImpl) {
-        output(23 /* WrappedSignal */, [
-          ...serializeWrappingFn(serializationContext, value),
+        this.output(23 /* WrappedSignal */, [
+          ...serializeWrappingFn(this.$serializationContext$, value),
           filterEffectBackRefs(value[_EFFECT_BACK_REF]),
           value.$flags$,
           value.$hostElement$,
@@ -29100,7 +29183,7 @@ async function serialize(serializationContext) {
         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;
+        const asyncFlags = isAsync && value.$flags$ & ~24 /* SERIALIZATION_ALL_STRATEGIES */ || void 0;
         if (isInvalid || isSkippable) {
           v = NEEDS_COMPUTATION;
         } else if (shouldAlwaysSerialize) {
@@ -29115,6 +29198,7 @@ async function serialize(serializationContext) {
         ];
         if (isAsync) {
           out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
+          out.push(asyncFlags || void 0);
         }
         let keepUndefined = false;
         if (v !== NEEDS_COMPUTATION || interval !== void 0 || concurrency !== void 0 || timeout !== void 0) {
@@ -29127,9 +29211,8 @@ async function serialize(serializationContext) {
           out.push(interval);
           out.push(concurrency);
           out.push(timeout);
-          out.push(eagerCleanup);
         }
-        output(isAsync ? 25 /* AsyncSignal */ : 24 /* ComputedSignal */, out, keepUndefined);
+        this.output(isAsync ? 25 /* AsyncSignal */ : 24 /* ComputedSignal */, out, keepUndefined);
       } else {
         const v = value.$untrackedValue$;
         const keepUndefined = v === void 0;
@@ -29137,39 +29220,45 @@ async function serialize(serializationContext) {
         if (value.$effects$) {
           out.push(...value.$effects$);
         }
-        output(22 /* Signal */, out, keepUndefined);
+        this.output(22 /* Signal */, out, keepUndefined);
       }
     } else if (value instanceof URL) {
-      output(6 /* URL */, value.href);
+      this.output(6 /* URL */, value.href);
     } else if (value instanceof Date) {
-      output(7 /* Date */, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
+      this.output(7 /* Date */, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
     } else if (value instanceof RegExp) {
-      output(8 /* Regex */, value.toString());
+      this.output(8 /* Regex */, value.toString());
     } else if (value instanceof Error) {
       const out = [value.message];
       out.push(...Object.entries(value).flat());
-      if (isDev16) {
+      if (isDev17) {
         out.push("stack", value.stack);
       }
-      output(15 /* Error */, out);
-    } else if ($isSsrNode$(value)) {
-      const rootIndex = $addRoot$(value);
-      serializationContext.$setProp$(value, ELEMENT_ID, String(rootIndex));
-      output(10 /* VNode */, value.id);
+      this.output(15 /* Error */, out);
+    } else if (this.$serializationContext$.$isSsrNode$(value)) {
+      const rootIndex = this.$serializationContext$.$addRoot$(value);
+      this.$serializationContext$.$setProp$(value, ELEMENT_ID, String(rootIndex));
+      this.output(10 /* VNode */, value.id);
       const vNodeData = value.vnodeData;
       if (vNodeData) {
-        discoverValuesForVNodeData(vNodeData, (vNodeDataValue) => $addRoot$(vNodeDataValue));
+        discoverValuesForVNodeData(
+          vNodeData,
+          (vNodeDataValue) => this.$serializationContext$.$addRoot$(vNodeDataValue)
+        );
         vNodeData[0] |= 16 /* SERIALIZE */;
       }
       if (value.children) {
-        for (const child of value.children) {
+        const childrenLength = value.children.length;
+        for (let i = 0; i < childrenLength; i++) {
+          const child = value.children[i];
           const childVNodeData = child.vnodeData;
           if (childVNodeData) {
-            for (const value2 of childVNodeData) {
+            for (let i2 = 0; i2 < childVNodeData.length; i2++) {
+              const value2 = childVNodeData[i2];
               if (isSsrAttrs(value2)) {
-                const backRefKeyIndex = value2.findIndex((v) => v === QBackRefs);
-                if (backRefKeyIndex !== -1) {
-                  $addRoot$(value2[backRefKeyIndex + 1]);
+                const backRefs = tryGetBackRefs(value2);
+                if (backRefs) {
+                  this.$serializationContext$.$addRoot$(backRefs);
                 }
               }
             }
@@ -29179,24 +29268,22 @@ async function serialize(serializationContext) {
       }
     } else if (typeof FormData !== "undefined" && value instanceof FormData) {
       const array = [];
-      value.forEach((value2, key) => {
-        if (typeof value2 === "string") {
-          array.push(key, value2);
-        } else {
-          array.push(key, value2.name);
+      for (const [k, v] of value.entries()) {
+        if (typeof v === "string") {
+          array.push(k, v);
         }
-      });
-      output(28 /* FormData */, array);
+      }
+      this.output(28 /* FormData */, array);
     } else if (value instanceof URLSearchParams) {
-      output(13 /* URLSearchParams */, value.toString());
+      this.output(13 /* URLSearchParams */, value.toString());
     } else if (value instanceof Set) {
-      output(17 /* Set */, [...value.values()]);
+      this.output(17 /* Set */, [...value.values()]);
     } else if (value instanceof Map) {
       const combined = [];
       for (const [k, v] of value.entries()) {
         combined.push(k, v);
       }
-      output(18 /* Map */, combined);
+      this.output(18 /* Map */, combined);
     } else if (isJSXNode(value)) {
       const out = [
         value.type,
@@ -29209,7 +29296,7 @@ async function serialize(serializationContext) {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      output(29 /* JSXNode */, out);
+      this.output(29 /* JSXNode */, out);
     } else if (value instanceof Task) {
       const out = [
         value.$qrl$,
@@ -29222,104 +29309,108 @@ async function serialize(serializationContext) {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      output(20 /* Task */, out);
+      this.output(20 /* Task */, out);
     } else if (isPromise(value)) {
-      const forwardRefId = resolvePromise(value, $addRoot$, (resolved, resolvedValue) => {
+      const forwardRefId = this.resolvePromise(value, (resolved, resolvedValue) => {
         return new PromiseResult(16 /* Promise */, resolved, resolvedValue);
       });
-      output(2 /* ForwardRef */, forwardRefId);
+      this.output(2 /* ForwardRef */, forwardRefId);
     } else if (value instanceof PromiseResult) {
       if (value.$type$ === 26 /* SerializerSignal */) {
         if (value.$qrl$) {
-          output(26 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
+          this.output(26 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
         } else if (value.$resolved$) {
-          const index = parent.$index$;
-          parent = parent.$parent$;
-          writeValue(value.$value$, index);
+          const index = this.parent.$index$;
+          this.parent = this.parent.$parent$;
+          this.writeValue(value.$value$, index);
         } else {
           console.error(value.$value$);
           throw qError(33 /* serializerSymbolRejectedPromise */);
         }
       } else {
-        output(16 /* Promise */, [value.$resolved$, value.$value$]);
+        this.output(16 /* Promise */, [value.$resolved$, value.$value$]);
       }
     } else if (value instanceof Uint8Array) {
       let buf = "";
-      for (const c of value) {
-        buf += String.fromCharCode(c);
+      const length = value.length;
+      for (let i = 0; i < length; i++) {
+        buf += String.fromCharCode(value[i]);
       }
       const out = btoa(buf).replace(/=+$/, "");
-      output(19 /* Uint8Array */, out);
+      this.output(19 /* Uint8Array */, out);
     } else if (value instanceof SerializationWeakRef) {
       const obj = value.$obj$;
-      if (getSeenRefOrOutput(obj, parent.$index$, true)) {
-        let forwardRefId = s11nWeakRefs.get(obj);
+      if (this.getSeenRefOrOutput(obj, this.parent.$index$, true)) {
+        let forwardRefId = this.s11nWeakRefs.get(obj);
         if (forwardRefId === void 0) {
-          forwardRefId = forwardRefsId++;
-          s11nWeakRefs.set(obj, forwardRefId);
-          forwardRefs[forwardRefId] = -1;
+          forwardRefId = this.forwardRefsId++;
+          this.s11nWeakRefs.set(obj, forwardRefId);
+          this.forwardRefs[forwardRefId] = -1;
         }
-        output(2 /* ForwardRef */, forwardRefId);
+        this.output(2 /* ForwardRef */, forwardRefId);
       }
     } else if (vnode_isVNode(value)) {
-      output(3 /* Constant */, 0 /* Undefined */);
+      this.output(3 /* Constant */, 0 /* Undefined */);
     } else {
       throw qError(20 /* serializeErrorUnknownType */, [typeof value]);
     }
-  };
-  function resolvePromise(promise, $addRoot$2, classCreator) {
-    const forwardRefId = forwardRefsId++;
+  }
+  resolvePromise(promise, classCreator) {
+    const forwardRefId = this.forwardRefsId++;
     promise.then((resolvedValue) => {
-      promises.delete(promise);
-      forwardRefs[forwardRefId] = $addRoot$2(classCreator(true, resolvedValue));
+      this.promises.delete(promise);
+      this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(
+        classCreator(true, resolvedValue)
+      );
     }).catch((err) => {
-      promises.delete(promise);
-      forwardRefs[forwardRefId] = $addRoot$2(classCreator(false, err));
+      this.promises.delete(promise);
+      this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(
+        classCreator(false, err)
+      );
     });
-    promises.add(promise);
+    this.promises.add(promise);
     return forwardRefId;
   }
-  const outputRoots = async () => {
-    $writer$.write("[");
-    const { $roots$ } = serializationContext;
-    while (rootIdx < $roots$.length || promises.size) {
-      if (rootIdx !== 0) {
-        $writer$.write(",");
+  async outputRoots() {
+    this.$writer$.write(BRACKET_OPEN);
+    const { $roots$ } = this.$serializationContext$;
+    while (this.rootIdx < $roots$.length || this.promises.size) {
+      if (this.rootIdx !== 0) {
+        this.$writer$.write(COMMA);
       }
       let separator = false;
-      for (; rootIdx < $roots$.length; rootIdx++) {
+      for (; this.rootIdx < $roots$.length; this.rootIdx++) {
         if (separator) {
-          $writer$.write(",");
+          this.$writer$.write(COMMA);
         } else {
           separator = true;
         }
-        writeValue($roots$[rootIdx], rootIdx);
+        this.writeValue($roots$[this.rootIdx], this.rootIdx);
       }
-      if (promises.size) {
+      if (this.promises.size) {
         try {
-          await Promise.race(promises);
+          await Promise.race(this.promises);
         } catch {
         }
       }
     }
-    if (forwardRefs.length) {
-      let lastIdx = forwardRefs.length - 1;
-      while (lastIdx >= 0 && forwardRefs[lastIdx] === -1) {
+    if (this.forwardRefs.length) {
+      let lastIdx = this.forwardRefs.length - 1;
+      while (lastIdx >= 0 && this.forwardRefs[lastIdx] === -1) {
         lastIdx--;
       }
       if (lastIdx >= 0) {
-        $writer$.write(",");
-        $writer$.write(14 /* ForwardRefs */ + ",");
-        const out = lastIdx === forwardRefs.length - 1 ? forwardRefs : forwardRefs.slice(0, lastIdx + 1);
-        outputArray(out, true, (value) => {
-          $writer$.write(String(value));
+        this.$writer$.write(COMMA);
+        this.$writer$.write(14 /* ForwardRefs */ + COMMA);
+        const out = lastIdx === this.forwardRefs.length - 1 ? this.forwardRefs : this.forwardRefs.slice(0, lastIdx + 1);
+        this.outputArray(out, true, (value) => {
+          this.$writer$.write(String(value));
         });
       }
     }
-    $writer$.write("]");
-  };
-  await outputRoots();
-}
+    this.$writer$.write(BRACKET_CLOSE);
+  }
+};
 var PromiseResult = class {
   constructor($type$, $resolved$, $value$, $effects$ = void 0, $qrl$ = void 0) {
     this.$type$ = $type$;
@@ -29353,13 +29444,13 @@ function getCustomSerializerPromise(signal, value) {
   );
 }
 var discoverValuesForVNodeData = (vnodeData, callback) => {
-  for (const value of vnodeData) {
+  const length = vnodeData.length;
+  for (let i = 0; i < length; i++) {
+    const value = vnodeData[i];
     if (isSsrAttrs(value)) {
-      for (let i = 1; i < value.length; i += 2) {
-        const keyValue = value[i - 1];
-        const attrValue = value[i];
-        if (attrValue == null || typeof attrValue === "string" || // skip empty props
-        keyValue === ELEMENT_PROPS && Object.keys(attrValue).length === 0) {
+      for (const key in value) {
+        const attrValue = value[key];
+        if (attrValue == null || typeof attrValue === "string" || key === ELEMENT_PROPS && isObjectEmpty(attrValue)) {
           continue;
         }
         callback(attrValue);
@@ -29367,7 +29458,7 @@ var discoverValuesForVNodeData = (vnodeData, callback) => {
     }
   }
 };
-var isSsrAttrs = (value) => Array.isArray(value) && value.length > 0;
+var isSsrAttrs = (value) => typeof value === "object" && value !== null && !isObjectEmpty(value);
 function isObjectLiteral(obj) {
   const prototype = Object.getPrototypeOf(obj);
   return prototype == null || prototype === Object.prototype || prototype === Array.prototype;
@@ -29395,6 +29486,9 @@ function filterEffectBackRefs(effectBackRef) {
   }
   return effectBackRefToSerialize;
 }
+function tryGetBackRefs(props) {
+  return Object.prototype.hasOwnProperty.call(props, QBackRefs) ? props[QBackRefs] : void 0;
+}
 var SerializationWeakRef = class {
   constructor($obj$) {
     this.$obj$ = $obj$;
@@ -29409,26 +29503,41 @@ var SerializationBackRef = class {
     this.$path$ = $path$;
   }
 };
-var createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToChunkResolver, getProp, setProp, storeProxyMap, writer) => {
-  if (!writer) {
-    const buffer = [];
-    writer = {
-      write: (text) => buffer.push(text),
-      toString: () => buffer.join("")
-    };
-  }
-  const seenObjsMap = /* @__PURE__ */ new Map();
-  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) => {
+var SerializationContextImpl = class {
+  constructor(NodeConstructor, DomRefConstructor, $symbolToChunkResolver$, $setProp$, $storeProxyMap$, $writer$) {
+    this.NodeConstructor = NodeConstructor;
+    this.DomRefConstructor = DomRefConstructor;
+    this.$symbolToChunkResolver$ = $symbolToChunkResolver$;
+    this.$setProp$ = $setProp$;
+    this.$storeProxyMap$ = $storeProxyMap$;
+    this.$writer$ = $writer$;
+    __publicField(this, "$seenObjsMap$", /* @__PURE__ */ new Map());
+    __publicField(this, "$syncFnMap$", /* @__PURE__ */ new Map());
+    __publicField(this, "$syncFns$", []);
+    __publicField(this, "$roots$", []);
+    __publicField(this, "$eagerResume$", /* @__PURE__ */ new Set());
+    __publicField(this, "$eventQrls$", /* @__PURE__ */ new Set());
+    __publicField(this, "$eventNames$", /* @__PURE__ */ new Set());
+    __publicField(this, "$renderSymbols$", /* @__PURE__ */ new Set());
+    __publicField(this, "$serializer$");
+    this.$serializer$ = new Serializer(this);
+  }
+  async $serialize$() {
+    return await this.$serializer$.serialize();
+  }
+  getSeenRef(obj) {
+    return this.$seenObjsMap$.get(obj);
+  }
+  $markSeen$(obj, parent, index) {
     const ref = { $index$: index, $parent$: parent };
-    seenObjsMap.set(obj, ref);
+    this.$seenObjsMap$.set(obj, ref);
     return ref;
-  };
-  const $getObjectPath$ = (ref) => {
+  }
+  /**
+   * Returns a path string representing the path from roots through all parents to the object.
+   * Format: "3 2 0" where each number is the index within its parent, from root to leaf.
+   */
+  $getObjectPath$(ref) {
     const path = [];
     while (ref.$parent$) {
       path.unshift(ref.$index$);
@@ -29436,86 +29545,85 @@ var createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToCh
     }
     path.unshift(ref.$index$);
     return path.join(" ");
-  };
-  const $promoteToRoot$ = (ref, index) => {
-    const path = $getObjectPath$(ref);
+  }
+  $promoteToRoot$(ref, index) {
+    const path = this.$getObjectPath$(ref);
     if (index === void 0) {
-      index = roots.length;
+      index = this.$roots$.length;
     }
-    roots[index] = new SerializationBackRef(path);
+    this.$roots$[index] = new SerializationBackRef(path);
     ref.$parent$ = null;
     ref.$index$ = index;
-  };
-  const $addRoot$ = ((obj, returnRef) => {
-    let seen = seenObjsMap.get(obj);
+  }
+  $addRoot$(obj, returnRef = false) {
+    let seen = this.$seenObjsMap$.get(obj);
     let index;
     if (!seen) {
-      index = roots.length;
+      index = this.$roots$.length;
       seen = {
         $index$: index
         // TODO benchmark with and without $parent$
         // $parent$: undefined
       };
-      seenObjsMap.set(obj, seen);
-      roots.push(obj);
+      this.$seenObjsMap$.set(obj, seen);
+      this.$roots$.push(obj);
     } else {
       if (seen.$parent$) {
-        $promoteToRoot$(seen);
+        this.$promoteToRoot$(seen);
       }
       index = seen.$index$;
     }
     return returnRef ? seen : index;
-  });
-  const isSsrNode2 = NodeConstructor ? (obj) => obj instanceof NodeConstructor : (() => false);
-  isDomRef = DomRefConstructor ? (obj) => obj instanceof DomRefConstructor : (() => false);
-  return {
-    async $serialize$() {
-      return await serialize(this);
-    },
-    $isSsrNode$: isSsrNode2,
-    $isDomRef$: isDomRef,
-    $symbolToChunkResolver$: symbolToChunkResolver,
-    getSeenRef,
-    $roots$: roots,
-    $markSeen$,
-    $hasRootId$: (obj) => {
-      const id = seenObjsMap.get(obj);
-      return id && (id.$parent$ ? void 0 : id.$index$);
-    },
-    $promoteToRoot$,
-    $addRoot$,
-    $syncFns$: syncFns,
-    $addSyncFn$: (funcStr, argCount, fn) => {
-      const isFullFn = funcStr == null;
+  }
+  $isSsrNode$(obj) {
+    return this.NodeConstructor ? obj instanceof this.NodeConstructor : false;
+  }
+  $isDomRef$(obj) {
+    return this.DomRefConstructor ? obj instanceof this.DomRefConstructor : false;
+  }
+  $hasRootId$(obj) {
+    const id = this.$seenObjsMap$.get(obj);
+    return id && (id.$parent$ ? void 0 : id.$index$);
+  }
+  $addSyncFn$(funcStr, argCount, fn) {
+    const isFullFn = funcStr == null;
+    if (isFullFn) {
+      funcStr = fn.serialized || fn.toString();
+    }
+    let id = this.$syncFnMap$.get(funcStr);
+    if (id === void 0) {
+      id = this.$syncFns$.length;
+      this.$syncFnMap$.set(funcStr, id);
       if (isFullFn) {
-        funcStr = fn.serialized || fn.toString();
-      }
-      let id = syncFnMap.get(funcStr);
-      if (id === void 0) {
-        id = syncFns.length;
-        syncFnMap.set(funcStr, id);
-        if (isFullFn) {
-          syncFns.push(funcStr);
-        } else {
-          let code2 = "(";
-          for (let i = 0; i < argCount; i++) {
-            code2 += (i == 0 ? "p" : ",p") + i;
-          }
-          syncFns.push(code2 += ")=>" + funcStr);
+        this.$syncFns$.push(funcStr);
+      } else {
+        let code2 = "(";
+        for (let i = 0; i < argCount; i++) {
+          code2 += (i == 0 ? "p" : ",p") + i;
         }
+        this.$syncFns$.push(code2 += ")=>" + funcStr);
       }
-      return id;
-    },
-    $writer$: writer,
-    $eventQrls$: /* @__PURE__ */ new Set(),
-    $eventNames$: /* @__PURE__ */ new Set(),
-    $renderSymbols$: /* @__PURE__ */ new Set(),
-    $storeProxyMap$: storeProxyMap,
-    $eagerResume$: eagerResume,
-    $resources$: /* @__PURE__ */ new Set(),
-    $getProp$: getProp,
-    $setProp$: setProp
-  };
+    }
+    return id;
+  }
+};
+var createSerializationContext = (NodeConstructor, DomRefConstructor, symbolToChunkResolver, setProp, storeProxyMap, writer) => {
+  if (!writer) {
+    const buffer = [];
+    writer = {
+      write: (text) => buffer.push(text),
+      toString: () => buffer.join("")
+    };
+  }
+  isDomRef = DomRefConstructor ? (obj) => obj instanceof DomRefConstructor : (() => false);
+  return new SerializationContextImpl(
+    NodeConstructor,
+    DomRefConstructor,
+    symbolToChunkResolver,
+    setProp,
+    storeProxyMap,
+    writer
+  );
 };
 
 // packages/qwik/src/core/shared/shared-container.ts
@@ -29550,7 +29658,6 @@ var _SharedContainer = class {
       NodeConstructor,
       DomRefConstructor,
       symbolToChunkResolver,
-      this.getHostProp.bind(this),
       this.setHostProp.bind(this),
       this.$storeProxyMap$,
       writer
@@ -29772,19 +29879,20 @@ var inflate = (container, target, typeId, data) => {
       asyncSignal.$loadingEffects$ = new Set(d2[3]);
       asyncSignal.$errorEffects$ = new Set(d2[4]);
       asyncSignal.$untrackedError$ = d2[5];
-      const hasValue = d2.length > 6;
-      if (hasValue) {
-        asyncSignal.$untrackedValue$ = d2[6];
+      asyncSignal.$flags$ = d2[6] ?? 0;
+      if (asyncSignal.$flags$ & 64 /* CLIENT_ONLY */) {
+        asyncSignal.$untrackedLoading$ = true;
       }
-      if (asyncSignal.$untrackedValue$ !== NEEDS_COMPUTATION) {
-        asyncSignal.$flags$ &= ~1 /* INVALID */;
+      const hasValue = d2.length > 7;
+      if (hasValue) {
+        asyncSignal.$untrackedValue$ = d2[7];
       }
-      asyncSignal.interval = d2[7] ?? 0;
-      asyncSignal.$concurrency$ = d2[8] ?? 1;
-      asyncSignal.$timeoutMs$ = d2[9] ?? 0;
-      if (d2[10]) {
-        asyncSignal.$flags$ |= 32 /* EAGER_CLEANUP */;
+      if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
+        asyncSignal.$flags$ |= 1 /* INVALID */;
       }
+      asyncSignal.interval = d2[8] ?? 0;
+      asyncSignal.$concurrency$ = d2[9] ?? 1;
+      asyncSignal.$timeoutMs$ = d2[10] ?? 0;
       break;
     }
     // Inflating a SerializerSignal is the same as inflating a ComputedSignal
@@ -30010,7 +30118,7 @@ var makeResolveFunction = (qrl, symbolFn) => {
       }
     }
     if (qrl.$chunk$ === "") {
-      isDev17 && assertDefined(qrl.$container$, "Sync QRL must have container element");
+      isDev18 && 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);
@@ -30114,8 +30222,8 @@ var createQRL = (chunk, symbol, symbolRef, symbolFn, captures) => {
       })
     );
   }
-  if (isBrowser2 && symbol) {
-    preload(symbol, 0.8);
+  if (isBrowser2 && chunk) {
+    preload(chunk, 0.8);
   }
   return qrl;
 };
@@ -30484,7 +30592,6 @@ function processVNodeData(document2) {
   const getNodeType = getter(prototype, "nodeType");
   const attachVnodeDataAndRefs = (element) => {
     Array.from(element.querySelectorAll('script[type="qwik/vnode"]')).forEach((script2) => {
-      script2.setAttribute("type", "x-qwik/vnode");
       const qContainerElement = script2.closest("[q\\:container]");
       qContainerElement.qVnodeData = script2.textContent;
       qContainerElement.qVNodeRefs = /* @__PURE__ */ new Map();
@@ -30783,9 +30890,14 @@ var DomContainer = class extends _SharedContainer {
   $hoistStyles$() {
     const document2 = this.element.ownerDocument;
     const head = document2.head;
-    const styles = document2.querySelectorAll(QStylesAllSelector);
-    for (let i = 0; i < styles.length; i++) {
-      head.appendChild(styles[i]);
+    const styles = document2.body.querySelectorAll(QStylesAllSelector);
+    const styleTagCount = styles.length;
+    if (styleTagCount) {
+      const fragment = document2.createDocumentFragment();
+      for (let i = 0; i < styleTagCount; i++) {
+        fragment.appendChild(styles[i]);
+      }
+      head.appendChild(fragment);
     }
   }
   $setRawState$(id, vParent) {
@@ -30904,7 +31016,7 @@ var DomContainer = class extends _SharedContainer {
   }
   getSyncFn(id) {
     const fn = this.$qFuncs$[id];
-    isDev18 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
+    isDev19 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
     return fn;
   }
   $appendStyle$(content, styleId, host, scoped) {
@@ -30946,6 +31058,278 @@ var DomContainer = class extends _SharedContainer {
   }
 };
 
+// packages/qwik/src/core/preloader/queue.ts
+import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/preloader/constants.ts
+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 = isBrowser3 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+var loadStart = Date.now();
+var isJSRegex = /\.[mc]?js$/;
+
+// packages/qwik/src/core/preloader/types.ts
+var BundleImportState_None = 0;
+var BundleImportState_Queued = 1;
+var BundleImportState_Preload = 2;
+var BundleImportState_Alias = 3;
+var BundleImportState_Loaded = 4;
+
+// packages/qwik/src/core/preloader/bundle-graph.ts
+var base;
+var graph;
+var makeBundle = (name, deps) => {
+  return {
+    $name$: name,
+    $state$: isJSRegex.test(name) ? BundleImportState_None : BundleImportState_Alias,
+    $deps$: shouldResetFactor ? deps?.map((d) => ({ ...d, $factor$: 1 })) : deps,
+    $inverseProbability$: 1,
+    $createdTs$: Date.now(),
+    $waitedMs$: 0,
+    $loadedMs$: 0
+  };
+};
+var parseBundleGraph = (serialized) => {
+  const graph2 = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < serialized.length) {
+    const name = serialized[i++];
+    const deps = [];
+    let idx;
+    let probability = 1;
+    while (idx = serialized[i], typeof idx === "number") {
+      if (idx < 0) {
+        probability = -idx / 10;
+      } else {
+        deps.push({
+          $name$: serialized[idx],
+          $importProbability$: probability,
+          $factor$: 1
+        });
+      }
+      i++;
+    }
+    graph2.set(name, deps);
+  }
+  return graph2;
+};
+var getBundle = (name) => {
+  let bundle = bundles.get(name);
+  if (!bundle) {
+    let deps;
+    if (graph) {
+      deps = graph.get(name);
+      if (!deps) {
+        return;
+      }
+      if (!deps.length) {
+        deps = void 0;
+      }
+    }
+    bundle = makeBundle(name, deps);
+    bundles.set(name, bundle);
+  }
+  return bundle;
+};
+var initPreloader = (serializedBundleGraph, opts) => {
+  if (opts) {
+    if ("debug" in opts) {
+      config.$DEBUG$ = !!opts.debug;
+    }
+    if (typeof opts.preloadProbability === "number") {
+      config.$invPreloadProbability$ = 1 - opts.preloadProbability;
+    }
+  }
+  if (base != null || !serializedBundleGraph) {
+    return;
+  }
+  base = "";
+  graph = parseBundleGraph(serializedBundleGraph);
+};
+
+// packages/qwik/src/core/preloader/queue.ts
+var bundles = /* @__PURE__ */ new Map();
+var shouldResetFactor;
+var queueDirty;
+var preloadCount = 0;
+var queue = [];
+var log5 = (...args) => {
+  console.log(
+    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
+    ...args
+  );
+};
+var resetQueue = () => {
+  bundles.clear();
+  queueDirty = false;
+  shouldResetFactor = true;
+  preloadCount = 0;
+  queue.length = 0;
+};
+var sortQueue = () => {
+  if (queueDirty) {
+    queue.sort((a, b) => a.$inverseProbability$ - b.$inverseProbability$);
+    queueDirty = false;
+  }
+};
+var getQueue = () => {
+  sortQueue();
+  let probability = 0.4;
+  const result2 = [];
+  for (const b of queue) {
+    const nextProbability = Math.round((1 - b.$inverseProbability$) * 10);
+    if (nextProbability !== probability) {
+      probability = nextProbability;
+      result2.push(probability);
+    }
+    result2.push(b.$name$);
+  }
+  return result2;
+};
+var trigger = () => {
+  if (!queue.length) {
+    return;
+  }
+  sortQueue();
+  while (queue.length) {
+    const bundle = queue[0];
+    const inverseProbability = bundle.$inverseProbability$;
+    const probability = 1 - inverseProbability;
+    const allowedPreloads = graph ? config.$maxIdlePreloads$ : (
+      // While the graph is not available, we limit to 5 preloads
+      5
+    );
+    if (probability >= 0.99 || preloadCount < allowedPreloads) {
+      queue.shift();
+      preloadOne(bundle);
+    } else {
+      break;
+    }
+  }
+  if (config.$DEBUG$ && !queue.length) {
+    const loaded = [...bundles.values()].filter((b) => b.$state$ > BundleImportState_None);
+    const waitTime = loaded.reduce((acc, b) => acc + b.$waitedMs$, 0);
+    const loadTime = loaded.reduce((acc, b) => acc + b.$loadedMs$, 0);
+    log5(
+      `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
+    );
+  }
+};
+var preloadOne = (bundle) => {
+  if (bundle.$state$ >= BundleImportState_Preload) {
+    return;
+  }
+  preloadCount++;
+  const start = Date.now();
+  bundle.$waitedMs$ = start - bundle.$createdTs$;
+  bundle.$state$ = BundleImportState_Preload;
+  config.$DEBUG$ && log5(
+    `<< load ${Math.round((1 - bundle.$inverseProbability$) * 100)}% after ${`${bundle.$waitedMs$}ms`}`,
+    bundle.$name$
+  );
+  const link = doc.createElement("link");
+  link.href = new URL(`${base}${bundle.$name$}`, doc.baseURI).toString();
+  link.rel = rel;
+  link.as = "script";
+  link.onload = link.onerror = () => {
+    preloadCount--;
+    const end = Date.now();
+    bundle.$loadedMs$ = end - start;
+    bundle.$state$ = BundleImportState_Loaded;
+    config.$DEBUG$ && log5(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
+    link.remove();
+    trigger();
+  };
+  doc.head.appendChild(link);
+};
+var adjustProbabilities = (bundle, newInverseProbability, seen) => {
+  if (seen?.has(bundle)) {
+    return;
+  }
+  const previousInverseProbability = bundle.$inverseProbability$;
+  bundle.$inverseProbability$ = newInverseProbability;
+  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
+    return;
+  }
+  if (
+    // don't queue until we have initialized the preloader
+    base != null && bundle.$state$ < BundleImportState_Preload
+  ) {
+    if (bundle.$state$ === BundleImportState_None) {
+      bundle.$state$ = BundleImportState_Queued;
+      queue.push(bundle);
+      config.$DEBUG$ && log5(`queued ${Math.round((1 - bundle.$inverseProbability$) * 100)}%`, bundle.$name$);
+    }
+    queueDirty = true;
+  }
+  if (bundle.$deps$) {
+    seen || (seen = /* @__PURE__ */ new Set());
+    seen.add(bundle);
+    const probability = 1 - bundle.$inverseProbability$;
+    for (const dep of bundle.$deps$) {
+      const depBundle = getBundle(dep.$name$);
+      if (depBundle.$inverseProbability$ === 0) {
+        continue;
+      }
+      let newInverseProbability2;
+      if (probability === 1 || probability >= 0.99 && depsCount < 100) {
+        depsCount++;
+        newInverseProbability2 = Math.min(0.01, 1 - dep.$importProbability$);
+      } else {
+        const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
+        const prevAdjust = dep.$factor$;
+        const factor = newInverseImportProbability / prevAdjust;
+        newInverseProbability2 = Math.max(0.02, depBundle.$inverseProbability$ * factor);
+        dep.$factor$ = factor;
+      }
+      adjustProbabilities(depBundle, newInverseProbability2, seen);
+    }
+  }
+};
+var handleBundle = (name, inverseProbability) => {
+  const bundle = getBundle(name);
+  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
+    adjustProbabilities(bundle, inverseProbability);
+  }
+};
+var depsCount;
+var preload2 = (name, probability) => {
+  if (!name?.length) {
+    return;
+  }
+  depsCount = 0;
+  let inverseProbability = probability ? 1 - probability : 0.4;
+  if (Array.isArray(name)) {
+    for (let i = name.length - 1; i >= 0; i--) {
+      const item = name[i];
+      if (typeof item === "number") {
+        inverseProbability = 1 - item / 10;
+      } else {
+        handleBundle(item, inverseProbability);
+      }
+    }
+  } else {
+    handleBundle(name, inverseProbability);
+  }
+  if (isBrowser4) {
+    trigger();
+  }
+};
+if (isBrowser4) {
+  document.addEventListener("qsymbol", (ev) => {
+    const { symbol, href } = ev.detail;
+    if (href) {
+      const hash3 = symbol.slice(symbol.lastIndexOf("_") + 1);
+      preload2(hash3, 1);
+    }
+  });
+}
+
 // packages/qwik/src/core/use/use-locale.ts
 import { isServer as isServer9 } from "@qwik.dev/core/build";
 var _locale = void 0;
@@ -30966,14 +31350,7 @@ function setLocale(locale) {
 
 // packages/qwik/src/core/index.ts
 if (globalThis.__qwik) {
-  console.error(
-    `==============================================
-Qwik version ${globalThis.__qwik} already imported while importing ${version}.
-This can lead to issues due to duplicated shared structures.
-Verify that the Qwik libraries you're using are in "resolve.noExternal[]" and in "optimizeDeps.exclude".
-==============================================
-`
-  );
+  qError(30 /* duplicateQwik */, [globalThis.__qwik, version]);
 }
 globalThis.__qwik = version;
 if (import.meta.hot) {
@@ -30992,8 +31369,8 @@ var useInvokeContext = () => {
   if (!ctx || ctx.$event$ !== RenderEvent) {
     throw qError(10 /* useInvokeContext */);
   }
-  isDev19 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
-  isDev19 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
+  isDev20 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
+  isDev20 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
   return ctx;
 };
 function invoke(context, fn, ...args) {
@@ -31081,9 +31458,9 @@ var trackSignalAndAssignHost = (value, host, property, container, data) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/store.ts
-import { isDev as isDev20, isServer as isServer10 } from "@qwik.dev/core/build";
+import { isDev as isDev21, isServer as isServer10 } from "@qwik.dev/core/build";
 var DEBUG7 = false;
-var log5 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
+var log6 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
 var getStoreHandler = (value) => {
   return value[STORE_HANDLER];
 };
@@ -31142,7 +31519,7 @@ var StoreHandler2 = class {
         }
         this.$container$ = ctx.$container$;
       } else {
-        isDev20 && assertTrue(
+        isDev21 && assertTrue(
           !ctx.$container$ || ctx.$container$ === this.$container$,
           "Do not use signals across containers"
         );
@@ -31176,11 +31553,11 @@ var StoreHandler2 = class {
     if (prop in target) {
       const oldValue = target[prop];
       if (newValue !== oldValue) {
-        DEBUG7 && log5("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
+        DEBUG7 && log6("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
         setNewValueAndTriggerEffects(prop, newValue, target, this);
       }
     } else {
-      DEBUG7 && log5("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
+      DEBUG7 && log6("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
       setNewValueAndTriggerEffects(prop, newValue, target, this);
     }
     return true;
@@ -31246,7 +31623,7 @@ function addStoreEffect(target, prop, store, effectSubscription) {
   ensureContainsSubscription(effects, effectSubscription);
   ensureContainsBackRef(effectSubscription, target);
   (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer10) && addQrlToSerializationCtx(effectSubscription, store.$container$);
-  DEBUG7 && log5(
+  DEBUG7 && log6(
     "sub",
     pad(
       "\n" + [...store.$effects$?.entries() || []].map(([key, value]) => `${String(key)}: ${String(value)}`).join(","),
@@ -31483,13 +31860,13 @@ function preprocessState(data, container) {
 }
 
 // packages/qwik/src/core/shared/serdes/serdes.public.ts
-import { isDev as isDev21 } from "@qwik.dev/core/build";
+import { isDev as isDev22 } from "@qwik.dev/core/build";
 function getObjectById(id, stateData) {
   if (typeof id === "string") {
     id = parseInt(id, 10);
     return stateData[id];
   }
-  isDev21 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
+  isDev22 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
   return stateData[id];
 }
 
@@ -31580,15 +31957,15 @@ var shouldSerialize = (obj) => {
   return true;
 };
 var fastSkipSerialize = (obj) => {
-  return !!obj && (isObject(obj) || typeof obj === "function") && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
+  return !!obj && (isObject(obj) || typeof obj === "function") && (noSerializeSet.has(obj) || NoSerializeSymbol in obj);
 };
 var NoSerializeSymbol = /* @__PURE__ */ Symbol("noSerialize");
 var SerializerSymbol = /* @__PURE__ */ Symbol("serialize");
 
 // packages/qwik/src/core/reactive-primitives/utils.ts
-import { isDev as isDev22, isServer as isServer11 } from "@qwik.dev/core/build";
+import { isDev as isDev23, isServer as isServer11 } from "@qwik.dev/core/build";
 var DEBUG8 = false;
-var log6 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
+var log7 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var throwIfQRLNotResolved = (qrl) => {
   const resolved = qrl.resolved;
   if (!resolved) {
@@ -31627,7 +32004,7 @@ var scheduleEffects = (container, signal, effects) => {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
       const property = effectSubscription.property;
-      isDev22 && assertDefined(container, "Container must be defined.");
+      isDev23 && assertDefined(container, "Container must be defined.");
       if (isTask(consumer)) {
         consumer.$flags$ |= 4 /* DIRTY */;
         markVNodeDirty(container, consumer.$el$, 1 /* TASKS */);
@@ -31669,7 +32046,7 @@ var scheduleEffects = (container, signal, effects) => {
       scheduleEffect(effect);
     }
   }
-  DEBUG8 && log6("done scheduling");
+  DEBUG8 && log7("done scheduling");
 };
 var isSerializerObj = (obj) => {
   return isObject(obj) && typeof obj[SerializerSymbol] === "function";
@@ -31799,7 +32176,7 @@ var fastGetter = (prototype, name) => {
 
 // packages/qwik/src/core/client/vnode-utils.ts
 var vnode_newElement = (element, elementName, key = null) => {
-  isDev23 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     key,
     1 /* Element */ | 8 /* Inflated */ | -1 << 11 /* shift */,
@@ -31817,7 +32194,7 @@ var vnode_newElement = (element, elementName, key = null) => {
   return vnode;
 };
 var vnode_newUnMaterializedElement = (element) => {
-  isDev23 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev24 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     null,
     1 /* Element */ | -1 << 11 /* shift */,
@@ -31835,7 +32212,7 @@ var vnode_newUnMaterializedElement = (element) => {
   return vnode;
 };
 var vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-  isDev23 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+  isDev24 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
   const vnode = new TextVNode(
     4 /* Text */ | -1 << 11 /* shift */,
     // Flag
@@ -31867,10 +32244,10 @@ var vnode_newText = (textNode, textContent) => {
     textContent
     // Text Content
   );
-  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.");
+  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.");
   return vnode;
 };
 var vnode_newVirtual = () => {
@@ -31885,9 +32262,9 @@ var vnode_newVirtual = () => {
     null,
     null
   );
-  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.");
+  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.");
   return vnode;
 };
 var vnode_isVNode = (vNode) => {
@@ -31897,12 +32274,12 @@ var vnode_isElementVNode = (vNode) => {
   return (vNode.flags & 1 /* Element */) === 1 /* Element */;
 };
 var vnode_isElementOrTextVNode = (vNode) => {
-  isDev23 && assertDefined(vNode, "Missing vNode");
+  isDev24 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 5 /* ELEMENT_OR_TEXT_MASK */) !== 0;
 };
 var vnode_isMaterialized = (vNode) => {
-  isDev23 && assertDefined(vNode, "Missing vNode");
+  isDev24 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 1 /* Element */) === 1 /* Element */ && vNode.firstChild !== void 0 && vNode.lastChild !== void 0;
 };
@@ -31913,26 +32290,26 @@ var vnode_isVirtualVNode = (vNode) => {
   return (vNode.flags & 2 /* Virtual */) === 2 /* Virtual */;
 };
 var vnode_isProjection = (vNode) => {
-  isDev23 && assertDefined(vNode, "Missing vNode");
+  isDev24 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 2 /* Virtual */) === 2 /* Virtual */ && vnode_getProp(vNode, QSlot, null) !== null;
 };
 var ensureTextVNode = (vNode) => {
-  isDev23 && assertTrue(
+  isDev24 && assertTrue(
     vnode_isTextVNode(vNode),
     "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)
   );
   return vNode;
 };
 var ensureElementOrVirtualVNode = (vNode) => {
-  isDev23 && assertDefined(vNode, "Missing vNode");
-  isDev23 && assertTrue(
+  isDev24 && assertDefined(vNode, "Missing vNode");
+  isDev24 && assertTrue(
     (vNode.flags & 3 /* ELEMENT_OR_VIRTUAL_MASK */) !== 0,
     "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode)
   );
 };
 var ensureElementVNode = (vNode) => {
-  isDev23 && assertTrue(
+  isDev24 && assertTrue(
     vnode_isElementVNode(vNode),
     "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)
   );
@@ -32168,7 +32545,7 @@ var vnode_ensureTextInflated = (journal, vnode) => {
   const flags = textVNode.flags;
   if ((flags & 8 /* Inflated */) === 0) {
     const parentNode = vnode_getDomParent(vnode, true);
-    isDev23 && assertDefined(parentNode, "Missing parent node.");
+    isDev24 && assertDefined(parentNode, "Missing parent node.");
     const sharedTextNode = textVNode.node;
     const doc2 = fastOwnerDocument(parentNode);
     let vCursor = vnode_getDomSibling(vnode, false, true);
@@ -32217,7 +32594,7 @@ var vnode_locate = (rootVNode, id) => {
   let elementOffset = -1;
   let refElement;
   if (typeof id === "string") {
-    isDev23 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
+    isDev24 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
     elementOffset = parseInt(id);
     refElement = qVNodeRefs.get(elementOffset);
   } else {
@@ -32227,9 +32604,9 @@ var vnode_locate = (rootVNode, id) => {
       return vNode2;
     }
   }
-  isDev23 && assertDefined(refElement, "Missing refElement.");
+  isDev24 && assertDefined(refElement, "Missing refElement.");
   if (!vnode_isVNode(refElement)) {
-    isDev23 && assertTrue(
+    isDev24 && assertTrue(
       containerElement2.contains(refElement),
       `Couldn't find the element inside the container while locating the VNode.`
     );
@@ -32273,10 +32650,10 @@ var vnode_locate = (rootVNode, id) => {
 };
 var vnode_getChildWithIdx = (vNode, childIdx) => {
   let child = vnode_getFirstChild(vNode);
-  isDev23 && assertDefined(child, "Missing child.");
+  isDev24 && assertDefined(child, "Missing child.");
   while (child.flags >>> 11 /* shift */ !== childIdx) {
     child = child.nextSibling;
-    isDev23 && assertDefined(child, "Missing child.");
+    isDev24 && assertDefined(child, "Missing child.");
   }
   return child;
 };
@@ -32284,7 +32661,7 @@ var vNodeStack = [];
 var vnode_getVNodeForChildNode = (vNode, childElement) => {
   ensureElementVNode(vNode);
   let child = vnode_getFirstChild(vNode);
-  isDev23 && assertDefined(child, "Missing child.");
+  isDev24 && assertDefined(child, "Missing child.");
   while (child && (child instanceof ElementVNode ? child.node !== childElement : true)) {
     if (vnode_isVirtualVNode(child)) {
       const next = child.nextSibling;
@@ -32303,13 +32680,13 @@ var vnode_getVNodeForChildNode = (vNode, childElement) => {
         child = next || vNodeStack.pop();
       }
     }
-    isDev23 && assertDefined(child, "Missing child.");
+    isDev24 && assertDefined(child, "Missing child.");
   }
   while (vNodeStack.length) {
     vNodeStack.pop();
   }
   ensureElementVNode(child);
-  isDev23 && assertEqual(child.node, childElement, "Child not found.");
+  isDev24 && assertEqual(child.node, childElement, "Child not found.");
   return child;
 };
 var indexOfAlphanumeric = (id, length) => {
@@ -32551,7 +32928,7 @@ var vnode_getDomParentVNode = (vnode, includeProjection) => {
   return vnode;
 };
 var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-  isDev23 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
+  isDev24 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
   if (vnode_isTextVNode(vToRemove)) {
     vnode_ensureTextInflated(journal, vToRemove);
   }
@@ -32584,7 +32961,7 @@ var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
   vToRemove.nextSibling = null;
 };
 var vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
-  isDev23 && assertDefined(vDelete, "Missing vDelete.");
+  isDev24 && assertDefined(vDelete, "Missing vDelete.");
   const parent = vnode_getDomParent(vParent, true);
   if (parent && removeDOM) {
     if (vnode_isElementOrTextVNode(vParent)) {
@@ -32678,8 +33055,8 @@ var ensureMaterialized = (vnode) => {
       vFirstChild = vnode_materialize(vParent);
     }
   }
-  isDev23 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
-  isDev23 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
+  isDev24 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
+  isDev24 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
   return vFirstChild;
 };
 var _fastHasAttribute = null;
@@ -32854,7 +33231,7 @@ var materializeFromDOM = (vParent, firstChild, vData) => {
         }
         const id = consumeValue();
         container.$setRawState$(parseInt(id), vParent);
-        isDev23 && vnode_setProp(vParent, ELEMENT_ID, id);
+        isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
       } else if (peek() === VNodeDataChar.BACK_REFS) {
         if (!container) {
           container = getDomContainer(vParent.node);
@@ -33123,7 +33500,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
       }
       const id = consumeValue();
       container.$setRawState$(parseInt(id), vParent);
-      isDev23 && vnode_setProp(vParent, ELEMENT_ID, id);
+      isDev24 && vnode_setProp(vParent, ELEMENT_ID, id);
     } else if (peek() === VNodeDataChar.PROPS) {
       vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
     } else if (peek() === VNodeDataChar.KEY) {
@@ -34210,7 +34587,7 @@ var ElementFixture = class {
     }
   }
 };
-async function trigger(root, queryOrElement, eventName, eventPayload = {}, options) {
+async function trigger2(root, queryOrElement, eventName, eventPayload = {}, options) {
   const waitForIdle = options?.waitForIdle ?? true;
   let scope;
   let kebabName;
@@ -34273,14 +34650,12 @@ var dispatch = async (element, event, scopedKebabName, kebabName) => {
     if ("_qDispatch" in element) {
       const handlers = element._qDispatch?.[scopedKebabName];
       if (handlers) {
-        if (Array.isArray(handlers)) {
-          for (const handler of handlers.flat(2)) {
+        if (handlers.length) {
+          for (const handler of handlers) {
             if (handler) {
               await handler(event, element);
             }
           }
-        } else {
-          await handlers(event, element);
         }
       }
     } else if (element.hasAttribute("q-" + scopedKebabName)) {
@@ -34405,7 +34780,7 @@ var createDOM = async function({ html } = {}) {
     },
     screen: host,
     userEvent: async function(queryOrElement, eventNameCamel, eventPayload = {}) {
-      return trigger(host, queryOrElement, eventNameCamel, eventPayload);
+      return trigger2(host, queryOrElement, eventNameCamel, eventPayload);
     }
   };
 };
@@ -34434,281 +34809,9 @@ import { join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { expect as expect2 } from "vitest";
 
-// packages/qwik/src/core/preloader/queue.ts
-import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
-
-// packages/qwik/src/core/preloader/constants.ts
-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 = isBrowser3 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
-var loadStart = Date.now();
-var isJSRegex = /\.[mc]?js$/;
-
-// packages/qwik/src/core/preloader/types.ts
-var BundleImportState_None = 0;
-var BundleImportState_Queued = 1;
-var BundleImportState_Preload = 2;
-var BundleImportState_Alias = 3;
-var BundleImportState_Loaded = 4;
-
-// packages/qwik/src/core/preloader/bundle-graph.ts
-var base;
-var graph;
-var makeBundle = (name, deps) => {
-  return {
-    $name$: name,
-    $state$: isJSRegex.test(name) ? BundleImportState_None : BundleImportState_Alias,
-    $deps$: shouldResetFactor ? deps?.map((d) => ({ ...d, $factor$: 1 })) : deps,
-    $inverseProbability$: 1,
-    $createdTs$: Date.now(),
-    $waitedMs$: 0,
-    $loadedMs$: 0
-  };
-};
-var parseBundleGraph = (serialized) => {
-  const graph2 = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < serialized.length) {
-    const name = serialized[i++];
-    const deps = [];
-    let idx;
-    let probability = 1;
-    while (idx = serialized[i], typeof idx === "number") {
-      if (idx < 0) {
-        probability = -idx / 10;
-      } else {
-        deps.push({
-          $name$: serialized[idx],
-          $importProbability$: probability,
-          $factor$: 1
-        });
-      }
-      i++;
-    }
-    graph2.set(name, deps);
-  }
-  return graph2;
-};
-var getBundle = (name) => {
-  let bundle = bundles.get(name);
-  if (!bundle) {
-    let deps;
-    if (graph) {
-      deps = graph.get(name);
-      if (!deps) {
-        return;
-      }
-      if (!deps.length) {
-        deps = void 0;
-      }
-    }
-    bundle = makeBundle(name, deps);
-    bundles.set(name, bundle);
-  }
-  return bundle;
-};
-var initPreloader = (serializedBundleGraph, opts) => {
-  if (opts) {
-    if ("debug" in opts) {
-      config.$DEBUG$ = !!opts.debug;
-    }
-    if (typeof opts.preloadProbability === "number") {
-      config.$invPreloadProbability$ = 1 - opts.preloadProbability;
-    }
-  }
-  if (base != null || !serializedBundleGraph) {
-    return;
-  }
-  base = "";
-  graph = parseBundleGraph(serializedBundleGraph);
-};
-
-// packages/qwik/src/core/preloader/queue.ts
-var bundles = /* @__PURE__ */ new Map();
-var shouldResetFactor;
-var queueDirty;
-var preloadCount = 0;
-var queue = [];
-var log7 = (...args) => {
-  console.log(
-    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
-    ...args
-  );
-};
-var resetQueue = () => {
-  bundles.clear();
-  queueDirty = false;
-  shouldResetFactor = true;
-  preloadCount = 0;
-  queue.length = 0;
-};
-var sortQueue = () => {
-  if (queueDirty) {
-    queue.sort((a, b) => a.$inverseProbability$ - b.$inverseProbability$);
-    queueDirty = false;
-  }
-};
-var getQueue = () => {
-  sortQueue();
-  let probability = 0.4;
-  const result2 = [];
-  for (const b of queue) {
-    const nextProbability = Math.round((1 - b.$inverseProbability$) * 10);
-    if (nextProbability !== probability) {
-      probability = nextProbability;
-      result2.push(probability);
-    }
-    result2.push(b.$name$);
-  }
-  return result2;
-};
-var trigger2 = () => {
-  if (!queue.length) {
-    return;
-  }
-  sortQueue();
-  while (queue.length) {
-    const bundle = queue[0];
-    const inverseProbability = bundle.$inverseProbability$;
-    const probability = 1 - inverseProbability;
-    const allowedPreloads = graph ? config.$maxIdlePreloads$ : (
-      // While the graph is not available, we limit to 5 preloads
-      5
-    );
-    if (probability >= 0.99 || preloadCount < allowedPreloads) {
-      queue.shift();
-      preloadOne(bundle);
-    } else {
-      break;
-    }
-  }
-  if (config.$DEBUG$ && !queue.length) {
-    const loaded = [...bundles.values()].filter((b) => b.$state$ > BundleImportState_None);
-    const waitTime = loaded.reduce((acc, b) => acc + b.$waitedMs$, 0);
-    const loadTime = loaded.reduce((acc, b) => acc + b.$loadedMs$, 0);
-    log7(
-      `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
-    );
-  }
-};
-var preloadOne = (bundle) => {
-  if (bundle.$state$ >= BundleImportState_Preload) {
-    return;
-  }
-  preloadCount++;
-  const start = Date.now();
-  bundle.$waitedMs$ = start - bundle.$createdTs$;
-  bundle.$state$ = BundleImportState_Preload;
-  config.$DEBUG$ && log7(
-    `<< load ${Math.round((1 - bundle.$inverseProbability$) * 100)}% after ${`${bundle.$waitedMs$}ms`}`,
-    bundle.$name$
-  );
-  const link = doc.createElement("link");
-  link.href = new URL(`${base}${bundle.$name$}`, doc.baseURI).toString();
-  link.rel = rel;
-  link.as = "script";
-  link.onload = link.onerror = () => {
-    preloadCount--;
-    const end = Date.now();
-    bundle.$loadedMs$ = end - start;
-    bundle.$state$ = BundleImportState_Loaded;
-    config.$DEBUG$ && log7(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
-    link.remove();
-    trigger2();
-  };
-  doc.head.appendChild(link);
-};
-var adjustProbabilities = (bundle, newInverseProbability, seen) => {
-  if (seen?.has(bundle)) {
-    return;
-  }
-  const previousInverseProbability = bundle.$inverseProbability$;
-  bundle.$inverseProbability$ = newInverseProbability;
-  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
-    return;
-  }
-  if (
-    // don't queue until we have initialized the preloader
-    base != null && bundle.$state$ < BundleImportState_Preload
-  ) {
-    if (bundle.$state$ === BundleImportState_None) {
-      bundle.$state$ = BundleImportState_Queued;
-      queue.push(bundle);
-      config.$DEBUG$ && log7(`queued ${Math.round((1 - bundle.$inverseProbability$) * 100)}%`, bundle.$name$);
-    }
-    queueDirty = true;
-  }
-  if (bundle.$deps$) {
-    seen || (seen = /* @__PURE__ */ new Set());
-    seen.add(bundle);
-    const probability = 1 - bundle.$inverseProbability$;
-    for (const dep of bundle.$deps$) {
-      const depBundle = getBundle(dep.$name$);
-      if (depBundle.$inverseProbability$ === 0) {
-        continue;
-      }
-      let newInverseProbability2;
-      if (probability === 1 || probability >= 0.99 && depsCount < 100) {
-        depsCount++;
-        newInverseProbability2 = Math.min(0.01, 1 - dep.$importProbability$);
-      } else {
-        const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
-        const prevAdjust = dep.$factor$;
-        const factor = newInverseImportProbability / prevAdjust;
-        newInverseProbability2 = Math.max(0.02, depBundle.$inverseProbability$ * factor);
-        dep.$factor$ = factor;
-      }
-      adjustProbabilities(depBundle, newInverseProbability2, seen);
-    }
-  }
-};
-var handleBundle = (name, inverseProbability) => {
-  const bundle = getBundle(name);
-  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
-    adjustProbabilities(bundle, inverseProbability);
-  }
-};
-var depsCount;
-var preload2 = (name, probability) => {
-  if (!name?.length) {
-    return;
-  }
-  depsCount = 0;
-  let inverseProbability = probability ? 1 - probability : 0.4;
-  if (Array.isArray(name)) {
-    for (let i = name.length - 1; i >= 0; i--) {
-      const item = name[i];
-      if (typeof item === "number") {
-        inverseProbability = 1 - item / 10;
-      } else {
-        handleBundle(item, inverseProbability);
-      }
-    }
-  } else {
-    handleBundle(name, inverseProbability);
-  }
-  if (isBrowser4) {
-    trigger2();
-  }
-};
-if (isBrowser4) {
-  document.addEventListener("qsymbol", (ev) => {
-    const { symbol, href } = ev.detail;
-    if (href) {
-      const hash3 = symbol.slice(symbol.lastIndexOf("_") + 1);
-      preload2(hash3, 1);
-    }
-  });
-}
-
 // packages/qwik/src/server/platform.ts
 import { setPlatform as setPlatform2 } from "../core.mjs";
-import { isDev as isDev24 } from "@qwik.dev/core/build";
+import { isDev as isDev25 } from "@qwik.dev/core/build";
 var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
   const existing = mapper?.[hash3];
   if (existing) {
@@ -34730,9 +34833,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 || isDev24 && import.meta.env.MODE !== "test") {
+    if (mapper || isDev25 && import.meta.env.MODE !== "test") {
       const hash3 = getSymbolHash2(symbolName);
-      const result2 = !isDev24 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
+      const result2 = !isDev25 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
       if (!result2) {
         if (hash3 === SYNC_QRL) {
           return [hash3, ""];
@@ -34817,16 +34920,16 @@ var versions = {
 };
 
 // packages/qwik/src/server/ssr-container.ts
-import { isDev as isDev26 } from "@qwik.dev/core/build";
+import { isDev as isDev27 } from "@qwik.dev/core/build";
 import {
-  _createQRL as createQRL2,
-  _qrlToString as qrlToString2,
-  _res,
   _SubscriptionData as SubscriptionData2,
   _SharedContainer as _SharedContainer2,
   _jsxSorted as _jsxSorted2,
   _jsxSplit as _jsxSplit2,
+  _res,
+  _setEvent,
   _walkJSX,
+  _createQRL as createQRL2,
   isSignal as isSignal3
 } from "@qwik.dev/core/internal";
 
@@ -34957,39 +35060,44 @@ var preloaderPre = (container, options, nonce) => {
       }
     }
     const optsStr = opts.length ? `,{${opts.join(",")}}` : "";
-    const preloaderLinkAttrs = ["rel", "modulepreload", "href", preloaderBundle];
+    const preloaderLinkAttrs = {
+      rel: "modulepreload",
+      href: preloaderBundle
+    };
     if (nonce) {
-      preloaderLinkAttrs.push("nonce", nonce);
+      preloaderLinkAttrs["nonce"] = nonce;
     }
-    container.openElement("link", null, preloaderLinkAttrs);
+    container.openElement("link", null, preloaderLinkAttrs, null, null, null);
     container.closeElement();
-    container.openElement("link", null, [
-      "rel",
-      "preload",
-      "href",
-      bundleGraphPath,
-      "as",
-      "fetch",
-      "crossorigin",
-      "anonymous"
-    ]);
+    container.openElement(
+      "link",
+      null,
+      { rel: "preload", href: bundleGraphPath, as: "fetch", crossorigin: "anonymous" },
+      null,
+      null,
+      null
+    );
     container.closeElement();
     const script2 = `let b=fetch("${bundleGraphPath}");import("${preloaderBundle}").then(({l})=>l(${JSON.stringify(base2)},b${optsStr}));`;
-    const scriptAttrs = ["type", "module", "async", true, "crossorigin", "anonymous"];
+    const scriptAttrs = {
+      type: "module",
+      async: true,
+      crossorigin: "anonymous"
+    };
     if (nonce) {
-      scriptAttrs.push("nonce", nonce);
+      scriptAttrs["nonce"] = nonce;
     }
-    container.openElement("script", null, scriptAttrs);
+    container.openElement("script", null, scriptAttrs, null, null, null);
     container.write(script2);
     container.closeElement();
   }
   const corePath = simplifyPath(base2, resolvedManifest?.manifest.core);
   if (corePath) {
-    const linkAttrs = ["rel", "modulepreload", "href", corePath];
+    const linkAttrs = { rel: "modulepreload", href: corePath };
     if (nonce) {
-      linkAttrs.push("nonce", nonce);
+      linkAttrs["nonce"] = nonce;
     }
-    container.openElement("link", null, linkAttrs);
+    container.openElement("link", null, linkAttrs, null, null, null);
     container.closeElement();
   }
 };
@@ -35041,11 +35149,11 @@ var includePreloader = (container, options, referencedBundles, nonce) => {
     script2 += `window.addEventListener('load',f=>{f=_=>import("${preloaderBundle}").then(({p})=>p(${JSON.stringify(referencedBundles)}));try{requestIdleCallback(f,{timeout:2000})}catch(e){setTimeout(f,200)}})`;
   }
   if (script2) {
-    const attrs = ["type", "module", "async", true, "q:type", "preload"];
+    const attrs = { type: "module", async: "true", "q:type": "preload" };
     if (nonce) {
-      attrs.push("nonce", nonce);
+      attrs["nonce"] = nonce;
     }
-    container.openElement("script", null, attrs);
+    container.openElement("script", null, attrs, null, null, null);
     container.write(script2);
     container.closeElement();
   }
@@ -35087,8 +35195,12 @@ 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 isDev25 } from "@qwik.dev/core/build";
+import {
+  _isJSXNode as isJSXNode2,
+  _EMPTY_OBJ,
+  _EFFECT_BACK_REF as _EFFECT_BACK_REF2
+} from "@qwik.dev/core/internal";
+import { isDev as isDev26 } from "@qwik.dev/core/build";
 var SsrNode = class {
   constructor(parentComponent, id, attributesIndex, cleanupQueue, vnodeData, currentFile) {
     this.parentComponent = parentComponent;
@@ -35111,9 +35223,9 @@ var SsrNode = class {
     __publicField(this, "localProps", null);
     this.id = id;
     this.flags = 1 /* Updatable */;
-    this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_ARRAY;
+    this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_OBJ;
     this.parentComponent?.addChild(this);
-    if (isDev25 && id.indexOf("undefined") != -1) {
+    if (isDev26 && id.indexOf("undefined") != -1) {
       throw new Error(`Invalid SSR node id: ${id}`);
     }
   }
@@ -35121,13 +35233,13 @@ var SsrNode = class {
     return this.getProp(QBackRefs);
   }
   setProp(name, value) {
-    if (this.attrs === _EMPTY_ARRAY) {
+    if (this.attrs === _EMPTY_OBJ) {
       this.setEmptyArrayAsVNodeDataAttributes();
     }
     if (name.startsWith(NON_SERIALIZABLE_MARKER_PREFIX)) {
-      mapArray_set(this.localProps || (this.localProps = []), name, value, 0);
+      (this.localProps || (this.localProps = {}))[name] = value;
     } else {
-      mapArray_set(this.attrs, name, value, 0);
+      this.attrs[name] = value;
     }
     if (name == ELEMENT_SEQ && value) {
       this.cleanupQueue.push(value);
@@ -35135,29 +35247,29 @@ var SsrNode = class {
   }
   setEmptyArrayAsVNodeDataAttributes() {
     if (this.attributesIndex >= 0) {
-      this.vnodeData[this.attributesIndex] = [];
+      this.vnodeData[this.attributesIndex] = {};
       this.attrs = this.vnodeData[this.attributesIndex];
     } else {
       const newAttributesIndex = this.vnodeData.length > 1 ? 1 : 0;
-      this.vnodeData.splice(newAttributesIndex, 0, []);
+      this.vnodeData.splice(newAttributesIndex, 0, {});
       this.attributesIndex = newAttributesIndex;
       this.attrs = this.vnodeData[this.attributesIndex];
     }
   }
   getProp(name) {
     if (name.startsWith(NON_SERIALIZABLE_MARKER_PREFIX)) {
-      return this.localProps ? mapArray_get(this.localProps, name, 0) : null;
+      return this.localProps ? this.localProps[name] ?? null : null;
     } else {
-      return mapArray_get(this.attrs, name, 0);
+      return this.attrs[name] ?? null;
     }
   }
   removeProp(name) {
     if (name.startsWith(NON_SERIALIZABLE_MARKER_PREFIX)) {
       if (this.localProps) {
-        mapApp_remove(this.localProps, name, 0);
+        delete this.localProps[name];
       }
     } else {
-      mapApp_remove(this.attrs, name, 0);
+      delete this.attrs[name];
     }
   }
   addChild(child) {
@@ -35177,16 +35289,13 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev25) {
+    if (isDev26) {
       let stringifiedAttrs = "";
-      for (let i = 0; i < this.attrs.length; i += 2) {
-        const key = this.attrs[i];
-        const value = this.attrs[i + 1];
+      for (const key in this.attrs) {
+        const value = this.attrs[key];
         stringifiedAttrs += `${key}=`;
         stringifiedAttrs += `${typeof value === "string" || typeof value === "number" ? JSON.stringify(value) : "*"}`;
-        if (i < this.attrs.length - 2) {
-          stringifiedAttrs += ", ";
-        }
+        stringifiedAttrs += ", ";
       }
       return `<SSRNode id="${this.id}" ${stringifiedAttrs} />`;
     } else {
@@ -35295,7 +35404,7 @@ function vNodeData_closeFragment(vNodeData) {
   vNodeData.push(CLOSE_FRAGMENT);
 }
 function vNodeData_openElement(vNodeData) {
-  vNodeData.push([], WRITE_ELEMENT_ATTRS);
+  vNodeData.push({}, WRITE_ELEMENT_ATTRS);
   vNodeData[0] |= 4 /* ELEMENT_NODE */;
 }
 function vNodeData_createSsrNodeReference(currentComponentNode, vNodeData, depthFirstElementIdx, cleanupQueue, currentFile) {
@@ -35304,7 +35413,7 @@ function vNodeData_createSsrNodeReference(currentComponentNode, vNodeData, depth
   let attributesIndex = -1;
   for (let i = 1; i < vNodeData.length; i++) {
     const value = vNodeData[i];
-    if (Array.isArray(value)) {
+    if (typeof value === "object" && value !== null) {
       attributesIndex = i;
       i++;
       if (vNodeData[i] !== WRITE_ELEMENT_ATTRS) {
@@ -35320,7 +35429,7 @@ function vNodeData_createSsrNodeReference(currentComponentNode, vNodeData, depth
       stack2[stack2.length - 1]++;
     }
   }
-  let refId = String(depthFirstElementIdx);
+  let refId = depthFirstElementIdx + "";
   if (vNodeData[0] & (2 /* VIRTUAL_NODE */ | 1 /* TEXT_DATA */)) {
     for (let i = 0; i < stack2.length; i++) {
       const childCount = stack2[i];
@@ -35364,6 +35473,7 @@ function ssrCreateContainer(opts) {
   return new SSRContainer({
     tagName: opts.tagName || "div",
     writer: opts.writer || new StringBufferWriter(),
+    streamHandler: opts.streamHandler,
     locale: opts.locale || "",
     timing: opts.timing || {
       firstFlush: 0,
@@ -35393,12 +35503,17 @@ var StringBufferWriter = class {
   }
 };
 var EMPTY_OBJ2 = {};
+var QTemplateProps = {
+  hidden: true,
+  "aria-hidden": true
+};
 var SSRContainer = class extends _SharedContainer2 {
   constructor(opts) {
     super(opts.renderOptions.serverData ?? EMPTY_OBJ2, opts.locale);
     __publicField(this, "tag");
     __publicField(this, "isHtml");
     __publicField(this, "writer");
+    __publicField(this, "streamHandler");
     __publicField(this, "timing");
     __publicField(this, "size", 0);
     __publicField(this, "resolvedManifest");
@@ -35435,6 +35550,7 @@ var SSRContainer = class extends _SharedContainer2 {
     __publicField(this, "vNodeDatas", []);
     __publicField(this, "componentStack", []);
     __publicField(this, "cleanupQueue", []);
+    __publicField(this, "emitContainerDataFrame", null);
     __publicField(this, "$instanceHash$", hash2());
     // Temporary flag to find missing roots after the state was serialized
     __publicField(this, "$noMoreRoots$", false);
@@ -35456,6 +35572,7 @@ var SSRContainer = class extends _SharedContainer2 {
     this.tag = opts.tagName;
     this.isHtml = opts.tagName === "html";
     this.writer = opts.writer;
+    this.streamHandler = opts.streamHandler;
     this.timing = opts.timing;
     this.$buildBase$ = opts.buildBase;
     this.resolvedManifest = opts.resolvedManifest;
@@ -35539,27 +35656,23 @@ var SSRContainer = class extends _SharedContainer2 {
     containerAttributes[QContainerAttr] = "paused" /* PAUSED */;
     containerAttributes[QRuntimeAttr] = "2";
     containerAttributes[QVersionAttr] = this.$version$ ?? "dev";
-    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev26 ? "ssr-dev" : "ssr");
+    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev27 ? "ssr-dev" : "ssr");
     containerAttributes[QBaseAttr] = this.$buildBase$ || "";
     containerAttributes[QLocaleAttr] = this.$locale$;
     containerAttributes[QManifestHashAttr] = this.resolvedManifest.manifest.manifestHash;
     containerAttributes[QInstanceAttr] = this.$instanceHash$;
     this.$serverData$.containerAttributes = containerAttributes;
-    const containerAttributeArray = Object.entries(containerAttributes).reduce(
-      (acc, [key, value]) => {
-        acc.push(key, value);
-        return acc;
-      },
-      []
-    );
-    this.openElement(this.tag, null, containerAttributeArray);
+    this.openElement(this.tag, null, containerAttributes);
+    if (!this.isHtml) {
+      this.emitContainerDataFrame = this.currentElementFrame;
+    }
   }
   /** Renders closing tag for current container */
   closeContainer() {
     return this.closeElement();
   }
   /** Renders opening tag for DOM element */
-  openElement(elementName, key, varAttrs, constAttrs, currentFile) {
+  openElement(elementName, key, varAttrs, constAttrs = null, styleScopedId = null, currentFile = null) {
     const isQwikStyle = isQwikStyleElement(elementName, varAttrs) || isQwikStyleElement(elementName, constAttrs);
     if (
       // don't append qwik loader before qwik style elements
@@ -35578,23 +35691,26 @@ var SSRContainer = class extends _SharedContainer2 {
       vNodeData_incrementElementCount(this.currentElementFrame.vNodeData);
     }
     this.createAndPushFrame(elementName, this.depthFirstElementCount++, currentFile);
+    if (this.isHtml && elementName === "body" && this.emitContainerDataFrame === null) {
+      this.emitContainerDataFrame = this.currentElementFrame;
+    }
     vNodeData_openElement(this.currentElementFrame.vNodeData);
-    this.write("<");
+    this.write(LT);
     this.write(elementName);
     const lastNode = this.getOrCreateLastNode();
     if (varAttrs) {
-      innerHTML = this.writeAttrs(elementName, varAttrs, false, currentFile);
+      innerHTML = this.writeAttrs(elementName, varAttrs, false, styleScopedId, currentFile);
     }
     this.write(" " + Q_PROPS_SEPARATOR);
     if (key !== null) {
       this.write(`="${key}"`);
-    } else if (isDev26) {
-      this.write('=""');
+    } else if (import.meta.env.TEST) {
+      this.write(EMPTY_ATTR);
     }
-    if (constAttrs && constAttrs.length) {
-      innerHTML = this.writeAttrs(elementName, constAttrs, true, currentFile) || innerHTML;
+    if (constAttrs && !isObjectEmpty(constAttrs)) {
+      innerHTML = this.writeAttrs(elementName, constAttrs, true, styleScopedId, currentFile) || innerHTML;
     }
-    this.write(">");
+    this.write(GT);
     if (lastNode) {
       lastNode.setTreeNonUpdatable();
     }
@@ -35602,7 +35718,8 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   /** Renders closing tag for DOM element */
   closeElement() {
-    if (this.shouldEmitDataBeforeClosingElement()) {
+    if (this.currentElementFrame === this.emitContainerDataFrame) {
+      this.emitContainerDataFrame = null;
       this.onRenderDone();
       const snapshotTimer = createTimer();
       return maybeThen(
@@ -35614,16 +35731,6 @@ var SSRContainer = class extends _SharedContainer2 {
     }
     this._closeElement();
   }
-  shouldEmitDataBeforeClosingElement() {
-    const currentFrame = this.currentElementFrame;
-    return (
-      /**
-       * - Micro-frontends don't have html tag, emit data before closing custom element
-       * - Regular applications should emit data inside body
-       */
-      currentFrame.parent === null && currentFrame.elementName !== "html" || currentFrame.elementName === "body"
-    );
-  }
   onRenderDone() {
     this.drainCleanupQueue();
     this.timing.render = this.renderTimer();
@@ -35645,9 +35752,9 @@ var SSRContainer = class extends _SharedContainer2 {
     const currentFrame = this.popFrame();
     const elementName = currentFrame.elementName;
     if (!isSelfClosingTag(elementName)) {
-      this.write("</");
+      this.write(CLOSE_TAG);
       this.write(elementName);
-      this.write(">");
+      this.write(GT);
     }
     this.lastNode = null;
     if (this.qlInclude === 1 /* Inline */) {
@@ -35718,13 +35825,13 @@ var SSRContainer = class extends _SharedContainer2 {
     if (componentFrame.slots.length === 0) {
       return;
     }
-    this.openElement(QTemplate, null, ["hidden", true, "aria-hidden", "true"], null);
+    this.openElement(QTemplate, null, QTemplateProps, null);
     const scopedStyleId = componentFrame.projectionScopedStyle;
     for (let i = 0; i < componentFrame.slots.length; i += 2) {
       const slotName = componentFrame.slots[i];
       const children = componentFrame.slots[i + 1];
       this.openFragment(
-        isDev26 ? [DEBUG_TYPE, "P" /* Projection */, QSlotParent, componentFrame.componentNode.id] : [QSlotParent, componentFrame.componentNode.id]
+        isDev27 ? { [DEBUG_TYPE]: "P" /* Projection */, [QSlotParent]: componentFrame.componentNode.id } : { [QSlotParent]: componentFrame.componentNode.id }
       );
       const lastNode = this.getOrCreateLastNode();
       if (lastNode.vnodeData) {
@@ -35814,7 +35921,9 @@ var SSRContainer = class extends _SharedContainer2 {
     }
   }
   _styleNode(styleId, content) {
-    this.openElement("style", null, [QStyle, styleId]);
+    this.openElement("style", null, {
+      [QStyle]: styleId
+    });
     this.write(content);
     this.closeElement();
   }
@@ -35855,7 +35964,7 @@ var SSRContainer = class extends _SharedContainer2 {
     if (!this.serializationCtx.$roots$.length) {
       return;
     }
-    this.openElement("script", null, ["type", "qwik/vnode"]);
+    this.openElement("script", null, { type: "qwik/vnode" });
     const vNodeAttrsStack = [];
     const vNodeData = this.vNodeDatas;
     let lastSerializedIdx = 0;
@@ -35872,7 +35981,7 @@ var SSRContainer = class extends _SharedContainer2 {
           let depth = 0;
           for (let i = 1; i < vNode.length; i++) {
             const value = vNode[i];
-            if (Array.isArray(value)) {
+            if (typeof value === "object" && value !== null) {
               vNodeAttrsStack.push(fragmentAttrs);
               fragmentAttrs = value;
             } else if (value === OPEN_FRAGMENT) {
@@ -35886,7 +35995,7 @@ var SSRContainer = class extends _SharedContainer2 {
               depth--;
               this.write(VNodeDataChar.CLOSE_CHAR);
             } else if (value === WRITE_ELEMENT_ATTRS) {
-              if (fragmentAttrs && fragmentAttrs.length) {
+              if (fragmentAttrs && !isObjectEmpty(fragmentAttrs)) {
                 this.write(VNodeDataChar.SEPARATOR_CHAR);
                 this.write(VNodeDataChar.SEPARATOR_CHAR);
                 this.writeFragmentAttrs(fragmentAttrs);
@@ -35913,9 +36022,8 @@ var SSRContainer = class extends _SharedContainer2 {
     this.closeElement();
   }
   writeFragmentAttrs(fragmentAttrs) {
-    for (let i = 0; i < fragmentAttrs.length; ) {
-      const key = fragmentAttrs[i++];
-      let value = fragmentAttrs[i++];
+    for (const key in fragmentAttrs) {
+      let value = fragmentAttrs[key];
       let encodeValue = false;
       if (typeof value !== "string") {
         const rootId = this.addRoot(value);
@@ -35990,28 +36098,25 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   /** Add q-d:qidle attribute to eagerly resume some state if needed */
   stateScriptAttrs() {
-    const attrs = ["type", "qwik/state"];
+    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");
+      attrs["q-d:qidle"] = createQRL2(null, "_res", _res, null, [...eagerResume]);
     }
     return attrs;
   }
   emitSyncFnsData() {
     const fns = this.serializationCtx.$syncFns$;
     if (fns.length) {
-      const scriptAttrs = ["q:func", "qwik/json"];
+      const scriptAttrs = { "q:func": "qwik/json" };
       if (this.renderOptions.serverData?.nonce) {
-        scriptAttrs.push("nonce", this.renderOptions.serverData.nonce);
+        scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
       }
       this.openElement("script", null, scriptAttrs);
       this.write(Q_FUNCS_PREFIX2.replace("HASH", this.$instanceHash$));
-      this.write("[");
-      this.writeArray(fns, ",");
-      this.write("]");
+      this.write(BRACKET_OPEN);
+      this.writeArray(fns, COMMA);
+      this.write(BRACKET_CLOSE);
       this.closeElement();
     }
   }
@@ -36029,9 +36134,9 @@ var SSRContainer = class extends _SharedContainer2 {
     this.backpatchMap.clear();
     if (patches.length > 0) {
       this.isBackpatchExecutorEmitted = true;
-      const scriptAttrs = ["type", ELEMENT_BACKPATCH_DATA];
+      const scriptAttrs = { type: ELEMENT_BACKPATCH_DATA };
       if (this.renderOptions.serverData?.nonce) {
-        scriptAttrs.push("nonce", this.renderOptions.serverData.nonce);
+        scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
       }
       this.openElement("script", null, scriptAttrs);
       this.write(JSON.stringify(patches));
@@ -36042,12 +36147,12 @@ var SSRContainer = class extends _SharedContainer2 {
     if (!this.isBackpatchExecutorEmitted) {
       return;
     }
-    const scriptAttrs = ["type", "text/javascript"];
+    const scriptAttrs = { type: "text/javascript" };
     if (this.renderOptions.serverData?.nonce) {
-      scriptAttrs.push("nonce", this.renderOptions.serverData.nonce);
+      scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
     }
     this.openElement("script", null, scriptAttrs);
-    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev26 });
+    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev27 });
     this.write(backpatchScript);
     this.closeElement();
   }
@@ -36061,16 +36166,20 @@ var SSRContainer = class extends _SharedContainer2 {
     if (this.qlInclude === 0 /* Module */) {
       this.qlInclude = 2 /* Done */;
       const qwikLoaderBundle = this.$buildBase$ + this.resolvedManifest.manifest.qwikLoader;
-      const linkAttrs = ["rel", "modulepreload", "href", qwikLoaderBundle];
+      const linkAttrs = { rel: "modulepreload", href: qwikLoaderBundle };
       const nonce = this.renderOptions.serverData?.nonce;
       if (nonce) {
-        linkAttrs.push("nonce", nonce);
+        linkAttrs["nonce"] = nonce;
       }
       this.openElement("link", null, linkAttrs);
       this.closeElement();
-      const scriptAttrs = ["async", true, "type", "module", "src", qwikLoaderBundle];
+      const scriptAttrs = {
+        async: true,
+        type: "module",
+        src: qwikLoaderBundle
+      };
       if (nonce) {
-        scriptAttrs.push("nonce", nonce);
+        scriptAttrs["nonce"] = nonce;
       }
       this.openElement("script", null, scriptAttrs);
       this.closeElement();
@@ -36079,9 +36188,13 @@ var SSRContainer = class extends _SharedContainer2 {
   emitQwikLoaderInline() {
     this.qlInclude = 2 /* Done */;
     const qwikLoaderScript = getQwikLoaderScript({ debug: this.renderOptions.debug });
-    const scriptAttrs = ["id", "qwikloader", "async", true, "type", "module"];
+    const scriptAttrs = {
+      id: "qwikloader",
+      async: true,
+      type: "module"
+    };
     if (this.renderOptions.serverData?.nonce) {
-      scriptAttrs.push("nonce", this.renderOptions.serverData.nonce);
+      scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
     }
     this.openElement("script", null, scriptAttrs);
     this.write(qwikLoaderScript);
@@ -36097,15 +36210,15 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   emitQwikEvents(eventNames) {
     if (eventNames.length > 0) {
-      const scriptAttrs = [];
+      const scriptAttrs = {};
       const nonce = this.renderOptions.serverData?.nonce;
       if (nonce) {
-        scriptAttrs.push("nonce", nonce);
+        scriptAttrs["nonce"] = nonce;
       }
       this.openElement("script", null, scriptAttrs);
       this.write(`(window._qwikEv||(window._qwikEv=[])).push(`);
-      this.writeArray(eventNames, ", ");
-      this.write(")");
+      this.writeArray(eventNames, COMMA);
+      this.write(PAREN_CLOSE);
       this.closeElement();
     }
   }
@@ -36137,7 +36250,7 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   createAndPushFrame(elementName, depthFirstElementIdx, currentFile) {
     let tagNesting = 10 /* ANYTHING */;
-    if (isDev26) {
+    if (isDev27) {
       if (!this.currentElementFrame) {
         tagNesting = initialTag(elementName);
       } else {
@@ -36183,7 +36296,7 @@ var SSRContainer = class extends _SharedContainer2 {
       elementName,
       depthFirstElementIdx,
       vNodeData: [0 /* NONE */],
-      currentFile: isDev26 ? currentFile || null : null
+      currentFile: isDev27 ? currentFile || null : null
     };
     this.currentElementFrame = frame;
     this.vNodeDatas.push(frame.vNodeData);
@@ -36207,88 +36320,88 @@ var SSRContainer = class extends _SharedContainer2 {
       this.write(element);
     }
   }
-  writeAttrs(tag, attrs, isConst, currentFile) {
+  writeAttrs(tag, attrs, isConst, styleScopedId, currentFile) {
     let innerHTML = void 0;
-    if (attrs.length) {
-      for (let i = 0; i < attrs.length; i++) {
-        let key = attrs[i++];
-        let value = attrs[i];
-        let styleScopedId = null;
-        if (isSSRUnsafeAttr(key)) {
-          if (isDev26) {
-            throw qError(32 /* unsafeAttr */, [key]);
-          }
-          continue;
-        }
-        if (key === "class" && Array.isArray(value)) {
-          const [signalValue, styleId] = value;
-          value = signalValue;
-          styleScopedId = styleId;
+    let isLoopElement = null;
+    for (let key in attrs) {
+      let value = attrs[key];
+      if (isSSRUnsafeAttr(key)) {
+        if (isDev27) {
+          throw qError(32 /* unsafeAttr */, [key]);
         }
-        if (key === "ref") {
-          const lastNode = this.getOrCreateLastNode();
-          if (isSignal3(value)) {
-            value.$untrackedValue$ = new DomRef(lastNode);
-            continue;
-          } else if (typeof value === "function") {
-            value(new DomRef(lastNode));
-            continue;
-          } else if (value == null) {
-            continue;
-          } else {
-            throw qError(15 /* invalidRefValue */, [currentFile]);
-          }
+        continue;
+      }
+      if (isHtmlAttributeAnEventName(key)) {
+        if (isLoopElement === null) {
+          isLoopElement = attributesContainsIterationProp(attrs);
         }
+        value = _setEvent(this.serializationCtx, key, value, isLoopElement);
+      } else if (key === "ref") {
+        const lastNode = this.getOrCreateLastNode();
         if (isSignal3(value)) {
-          const lastNode = this.getOrCreateLastNode();
-          const signalData = new SubscriptionData2({
-            $scopedStyleIdPrefix$: styleScopedId,
-            $isConst$: isConst
-          });
-          const signal = value;
-          value = retryOnPromise(
-            () => this.trackSignalValue(signal, lastNode, key, signalData)
-          );
-        }
-        if (isPromise(value)) {
-          const lastNode = this.getOrCreateLastNode();
-          this.addPromiseAttribute(value);
-          value.then((resolvedValue) => {
-            this.addBackpatchEntry(lastNode.id, key, resolvedValue);
-          });
+          value.$untrackedValue$ = new DomRef(lastNode);
           continue;
+        } else if (typeof value === "function") {
+          value(new DomRef(lastNode));
+          continue;
+        } else if (value == null) {
+          continue;
+        } else {
+          throw qError(15 /* invalidRefValue */, [currentFile]);
         }
-        if (key === dangerouslySetInnerHTML) {
-          if (value) {
-            innerHTML = String(value);
-            key = QContainerAttr;
-            value = "html" /* HTML */;
-          }
-          if (tag === "style") {
-            continue;
-          }
-        }
-        if (tag === "textarea" && key === "value") {
-          if (value && typeof value !== "string") {
-            if (isDev26) {
-              throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
-            }
-            continue;
-          }
-          innerHTML = escapeHTML(value || "");
+      } else if (key === ITERATION_ITEM_SINGLE || key === ITERATION_ITEM_MULTI) {
+        value = this.serializationCtx.$addRoot$(value);
+      } else if (isSignal3(value)) {
+        const lastNode = this.getOrCreateLastNode();
+        const signalData = new SubscriptionData2({
+          $scopedStyleIdPrefix$: styleScopedId,
+          $isConst$: isConst
+        });
+        const signal = value;
+        value = retryOnPromise(
+          () => this.trackSignalValue(signal, lastNode, key, signalData)
+        );
+      }
+      if (isPromise(value)) {
+        const lastNode = this.getOrCreateLastNode();
+        this.addPromiseAttribute(value);
+        value.then((resolvedValue) => {
+          this.addBackpatchEntry(lastNode.id, key, resolvedValue);
+        });
+        continue;
+      }
+      if (key === dangerouslySetInnerHTML) {
+        if (value) {
+          innerHTML = String(value);
           key = QContainerAttr;
-          value = "text" /* TEXT */;
+          value = "html" /* HTML */;
+        }
+        if (tag === "style") {
+          continue;
         }
-        const serializedValue = serializeAttribute(key, value, styleScopedId);
-        if (serializedValue != null && serializedValue !== false) {
-          this.write(" ");
-          this.write(key);
-          if (serializedValue !== true) {
-            this.write('="');
-            const strValue = escapeHTML(String(serializedValue));
-            this.write(strValue);
-            this.write('"');
+      } else if (isPreventDefault(key)) {
+        addPreventDefaultEventToSerializationContext(this.serializationCtx, key);
+      }
+      if (tag === "textarea" && key === "value") {
+        if (value && typeof value !== "string") {
+          if (isDev27) {
+            throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
+          continue;
+        }
+        innerHTML = escapeHTML(value || "");
+        key = QContainerAttr;
+        value = "text" /* TEXT */;
+      }
+      const serializedValue = serializeAttribute(key, value, styleScopedId);
+      if (serializedValue != null && serializedValue !== false) {
+        this.write(SPACE);
+        this.write(key);
+        if (serializedValue !== true) {
+          this.write(ATTR_EQUALS_QUOTE);
+          const strValue = escapeHTML(String(serializedValue));
+          this.write(strValue);
+          this.write(QUOTE);
         }
       }
     }
@@ -36307,15 +36420,13 @@ var SSRContainer = class extends _SharedContainer2 {
 };
 var isQwikStyleElement = (tag, attrs) => {
   if (tag === "style" && attrs != null) {
-    for (let i = 0; i < attrs.length; i = i + 2) {
-      const attr = attrs[i];
-      if (attr === QStyle || attr === QScopedStyle) {
-        return true;
-      }
-    }
+    return Object.prototype.hasOwnProperty.call(attrs, QStyle) || Object.prototype.hasOwnProperty.call(attrs, QScopedStyle);
   }
   return false;
 };
+var attributesContainsIterationProp = (attrs) => {
+  return Object.prototype.hasOwnProperty.call(attrs, ITERATION_ITEM_SINGLE) || Object.prototype.hasOwnProperty.call(attrs, ITERATION_ITEM_MULTI);
+};
 function newTagError(text) {
   return qError(12 /* tagError */, [text]);
 }
@@ -36334,9 +36445,125 @@ function isSSRUnsafeAttr(name) {
 function hash2() {
   return Math.random().toString(36).slice(2);
 }
+function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
+  const eventName = "e" + key.substring(14);
+  if (eventName) {
+    serializationCtx.$eventNames$.add(eventName);
+  }
+}
 
 // packages/qwik/src/server/ssr-render.ts
 import { manifest as builtManifest } from "@qwik-client-manifest";
+
+// packages/qwik/src/server/ssr-stream-handler.ts
+var StreamHandler = class {
+  constructor(opts, timing) {
+    this.opts = opts;
+    this.timing = timing;
+    __publicField(this, "bufferSize", 0);
+    __publicField(this, "buffer", "");
+    __publicField(this, "networkFlushes", 0);
+    __publicField(this, "inOrderStreaming");
+    __publicField(this, "streamBlockDepth", 0);
+    __publicField(this, "streamBlockBuffer", "");
+    __publicField(this, "streamBlockBufferSize", 0);
+    __publicField(this, "nativeStream");
+    __publicField(this, "firstFlushTimer", createTimer());
+    __publicField(this, "stream");
+    this.inOrderStreaming = opts.streaming?.inOrder ?? {
+      strategy: "auto",
+      maximumInitialChunk: 2e4,
+      maximumChunk: 1e4
+    };
+    this.nativeStream = opts.stream;
+    this.stream = this.setupStreamWriter();
+  }
+  setupStreamWriter() {
+    const handler = this;
+    let stream;
+    switch (this.inOrderStreaming.strategy) {
+      case "disabled":
+        stream = {
+          write(chunk) {
+            if (chunk === void 0 || chunk === null) {
+              return;
+            }
+            handler.enqueue(chunk);
+          }
+        };
+        break;
+      case "direct": {
+        const originalStream = this.nativeStream;
+        stream = {
+          write(chunk) {
+            if (chunk === void 0 || chunk === null) {
+              return;
+            }
+            originalStream.write(chunk);
+          }
+        };
+        break;
+      }
+      default:
+      case "auto": {
+        const minimumChunkSize = this.inOrderStreaming.maximumChunk ?? 0;
+        const initialChunkSize = this.inOrderStreaming.maximumInitialChunk ?? 0;
+        stream = {
+          write(chunk) {
+            if (chunk === void 0 || chunk === null) {
+              return;
+            }
+            handler.enqueue(chunk);
+            if (handler.streamBlockDepth === 0) {
+              const maxBufferSize = handler.networkFlushes === 0 ? initialChunkSize : minimumChunkSize;
+              if (handler.bufferSize >= maxBufferSize) {
+                handler.flush();
+              }
+            }
+          }
+        };
+        break;
+      }
+    }
+    return stream;
+  }
+  enqueue(chunk) {
+    const len = chunk.length;
+    if (this.streamBlockDepth > 0) {
+      this.streamBlockBuffer += chunk;
+      this.streamBlockBufferSize += len;
+    } else {
+      this.bufferSize += len;
+      this.buffer += chunk;
+    }
+  }
+  flush() {
+    if (this.buffer) {
+      this.nativeStream.write(this.buffer);
+      this.buffer = "";
+      this.bufferSize = 0;
+      this.networkFlushes++;
+      if (this.networkFlushes === 1) {
+        this.timing.firstFlush = this.firstFlushTimer();
+      }
+    }
+  }
+  streamBlockStart() {
+    this.streamBlockDepth++;
+  }
+  streamBlockEnd() {
+    this.streamBlockDepth--;
+    if (this.streamBlockDepth === 0 && this.streamBlockBuffer) {
+      this.buffer += this.streamBlockBuffer;
+      this.bufferSize += this.streamBlockBufferSize;
+      this.streamBlockBuffer = "";
+      this.streamBlockBufferSize = 0;
+      this.flush();
+    }
+  }
+};
+
+// packages/qwik/src/server/ssr-render.ts
 var renderToString = async (jsx2, opts = {}) => {
   const chunks = [];
   const stream = {
@@ -36363,11 +36590,12 @@ var renderToStream = async (jsx2, opts) => {
   const buildBase = getBuildBase(opts);
   const resolvedManifest = resolveManifest(opts.manifest);
   const locale = typeof opts.locale === "function" ? opts.locale(opts) : opts.serverData?.locale || opts.locale || opts.containerAttributes?.locale || "";
-  const { stream, flush, networkFlushes } = handleStreaming(opts, timing);
+  const streamHandler = new StreamHandler(opts, timing);
   const ssrContainer = ssrCreateContainer({
     tagName: containerTagName,
     locale,
-    writer: stream,
+    writer: streamHandler.stream,
+    streamHandler,
     timing,
     buildBase,
     resolvedManifest,
@@ -36376,11 +36604,9 @@ var renderToStream = async (jsx2, opts) => {
   await setServerPlatform(opts, resolvedManifest);
   await ssrContainer.render(jsx2);
   await ssrContainer.$renderPromise$;
-  flush();
-  const snapshotResult = getSnapshotResult(ssrContainer);
+  streamHandler.flush();
   const result2 = {
-    snapshotResult,
-    flushes: networkFlushes,
+    flushes: streamHandler.networkFlushes,
     manifest: resolvedManifest?.manifest,
     size: ssrContainer.size,
     isStatic: false,
@@ -36388,110 +36614,6 @@ var renderToStream = async (jsx2, opts) => {
   };
   return result2;
 };
-function getSnapshotResult(ssrContainer) {
-  const hasListeners = !ssrContainer.isStatic();
-  const canRender = false;
-  return hasListeners ? {
-    funcs: Array.from(ssrContainer.serializationCtx.$syncFns$),
-    mode: canRender ? "render" : "listeners",
-    qrls: Array.from(ssrContainer.serializationCtx.$eventQrls$),
-    resources: Array.from(ssrContainer.serializationCtx.$resources$)
-  } : {
-    funcs: [],
-    mode: "static",
-    qrls: [],
-    resources: Array.from(ssrContainer.serializationCtx.$resources$)
-  };
-}
-function handleStreaming(opts, timing) {
-  const firstFlushTimer = createTimer();
-  let stream = opts.stream;
-  let bufferSize = 0;
-  let buffer = "";
-  let networkFlushes = 0;
-  const inOrderStreaming = opts.streaming?.inOrder ?? {
-    strategy: "auto",
-    maximumInitialChunk: 2e4,
-    maximumChunk: 1e4
-  };
-  const nativeStream = stream;
-  function flush() {
-    if (buffer) {
-      nativeStream.write(buffer);
-      buffer = "";
-      bufferSize = 0;
-      networkFlushes++;
-      if (networkFlushes === 1) {
-        timing.firstFlush = firstFlushTimer();
-      }
-    }
-  }
-  function enqueue(chunk) {
-    const len = chunk.length;
-    bufferSize += len;
-    buffer += chunk;
-  }
-  switch (inOrderStreaming.strategy) {
-    case "disabled":
-      stream = {
-        write(chunk) {
-          if (shouldSkipChunk(chunk)) {
-            return;
-          }
-          enqueue(chunk);
-        }
-      };
-      break;
-    case "direct":
-      stream = {
-        write(chunk) {
-          if (shouldSkipChunk(chunk)) {
-            return;
-          }
-          nativeStream.write(chunk);
-        }
-      };
-      break;
-    case "auto":
-      let openedSSRStreamBlocks = 0;
-      let forceFlush = false;
-      const minimumChunkSize = inOrderStreaming.maximumChunk ?? 0;
-      const initialChunkSize = inOrderStreaming.maximumInitialChunk ?? 0;
-      stream = {
-        write(chunk) {
-          if (chunk === void 0 || chunk === null) {
-            return;
-          }
-          if (chunk === "<!--" + FLUSH_COMMENT + "-->") {
-            forceFlush = true;
-          } else if (chunk === "<!--" + STREAM_BLOCK_START_COMMENT + "-->") {
-            openedSSRStreamBlocks++;
-          } else if (chunk === "<!--" + STREAM_BLOCK_END_COMMENT + "-->") {
-            openedSSRStreamBlocks--;
-            if (openedSSRStreamBlocks === 0) {
-              forceFlush = true;
-            }
-          } else {
-            enqueue(chunk);
-          }
-          const maxBufferSize = networkFlushes === 0 ? initialChunkSize : minimumChunkSize;
-          if (openedSSRStreamBlocks === 0 && (forceFlush || bufferSize >= maxBufferSize)) {
-            forceFlush = false;
-            flush();
-          }
-        }
-      };
-      break;
-  }
-  return {
-    stream,
-    flush,
-    networkFlushes
-  };
-}
-function shouldSkipChunk(chunk) {
-  return chunk === void 0 || chunk === null || chunk === "<!--" + FLUSH_COMMENT + "-->" || chunk === "<!--" + STREAM_BLOCK_START_COMMENT + "-->" || chunk === "<!--" + STREAM_BLOCK_END_COMMENT + "-->";
-}
 function resolveManifest(manifest) {
   const mergedManifest = manifest ? { ...builtManifest, ...manifest } : builtManifest;
   if (!mergedManifest || "mapper" in mergedManifest) {
@@ -36633,7 +36755,7 @@ async function ssrRenderToDom(jsx2, opts = {}) {
 }
 function isQwikScript(node) {
   const element = node.node;
-  return vnode_getElementName(node) === "script" && (vnode_getProp(node, "type", null) === "qwik/state" || vnode_getProp(node, "type", null) === ELEMENT_BACKPATCH_DATA || vnode_getProp(node, "id", null) === "qwikloader" || element.getAttribute("type") === "qwik/state" || element.getAttribute("type") === ELEMENT_BACKPATCH_DATA || element.getAttribute("id") === "qwikloader");
+  return vnode_getElementName(node) === "script" && (vnode_getProp(node, "type", null) === "qwik/state" || vnode_getProp(node, "type", null) === ELEMENT_BACKPATCH_DATA || vnode_getProp(node, "id", null) === "qwikloader" || element.getAttribute("type") === "qwik/state" || element.getAttribute("type") === ELEMENT_BACKPATCH_DATA || element.getAttribute("id") === "qwikloader" || element.innerHTML.includes("window._qwikEv"));
 }
 function vnode_moveToVirtual(parent, newChild, insertBefore) {
   const journal = [];
@@ -36753,7 +36875,7 @@ export {
   expectDOM,
   getTestPlatform,
   ssrRenderToDom,
-  trigger,
+  trigger2 as trigger,
   vnode_fromJSX,
   waitForDrain,
   walkJSX