@qwik.dev/core 2.0.0-beta.30 → 2.0.0-beta.32

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.30-dev+5421ed4
+ * @qwik.dev/core/testing 2.0.0-beta.32-dev+0e29f8a
  * 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
@@ -23773,6 +23773,7 @@ var isPrimitiveOrNullUndefined = (v) => {
 };
 
 // packages/qwik/src/core/shared/error/error.ts
+var baseUrl = "https://qwikdev-build-v2.qwik-8nx.pages.dev/docs/errors/#Q";
 var codeToText = (code2, ...parts) => {
   if (qDev) {
     const MAP = [
@@ -23850,8 +23851,10 @@ Verify that the Qwik libraries you're using are in "resolve.noExternal[]" and in
       // 32
       "SerializerSymbol function returned rejected promise",
       // 33
-      "Serialization Error: Cannot serialize function: {{0}}"
+      "Serialization Error: Cannot serialize function: {{0}}",
       // 34
+      "Cannot read .value of a clientOnly async signal during SSR. Use .loading to check state, or provide an initial value."
+      // 35
     ];
     let text = MAP[code2] ?? "";
     if (parts.length) {
@@ -23865,7 +23868,7 @@ Verify that the Qwik libraries you're using are in "resolve.noExternal[]" and in
     }
     return `Code(Q${code2}): ${text}`;
   } else {
-    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}`;
+    return `Code(Q${code2}) ${baseUrl}${code2}`;
   }
 };
 var qError = (code2, errorMessageArgs = []) => {
@@ -24169,56 +24172,59 @@ var useSequentialScope = () => {
 
 // packages/qwik/src/core/shared/utils/event-names.ts
 var EVENT_SUFFIX = "$";
+var DOM_CONTENT_LOADED_EVENT = "DOMContentLoaded";
 var isJsxPropertyAnEventName = (name) => {
   return name.endsWith(EVENT_SUFFIX) && (name.startsWith("on" /* on */) || name.startsWith("window:on" /* window */) || name.startsWith("document:on" /* document */));
 };
 var isHtmlAttributeAnEventName = (name) => {
-  return name.charCodeAt(0) === 113 && name.charCodeAt(1) === 45 && name.charCodeAt(3) === 58;
+  return name.charCodeAt(0) === 113 && name.charCodeAt(1) === 45 && (name.charCodeAt(3) === 58 || name.charCodeAt(3) === 112 && name.charCodeAt(4) === 58);
 };
-function jsxEventToHtmlAttribute(jsxEvent) {
+function jsxEventToHtmlAttribute(jsxEvent, isPassive = false) {
   if (jsxEvent.endsWith(EVENT_SUFFIX)) {
-    const [prefix, idx] = getEventScopeDataFromJsxEvent(jsxEvent);
+    const [prefix, idx] = getEventScopeDataFromJsxEvent(jsxEvent, isPassive);
     if (idx !== -1) {
-      const name = jsxEvent.slice(idx, -1);
-      return name === "DOMContentLoaded" ? (
-        // The only DOM event that is not all lowercase
-        prefix + "-d-o-m-content-loaded"
-      ) : createEventName(
-        name.charAt(0) === "-" ? (
-          // marker for case sensitive event name
-          name.slice(1)
-        ) : name.toLowerCase(),
-        prefix
-      );
+      return prefix + normalizeJsxEventName(jsxEvent.slice(idx, -1));
     }
   }
   return null;
 }
-function createEventName(event, prefix) {
+function createEventName(event, prefix = "") {
   const eventName = fromCamelToKebabCase(event);
   return prefix + eventName;
 }
-function getEventScopeDataFromJsxEvent(eventName) {
+function getEventScopeDataFromJsxEvent(eventName, isPassive = false) {
   let prefix;
   let idx = -1;
   if (eventName.startsWith("on" /* on */)) {
-    prefix = "q-e:" /* on */;
+    prefix = isPassive ? "q-ep:" /* onPassive */ : "q-e:" /* on */;
     idx = 2;
   } else if (eventName.startsWith("window:on" /* window */)) {
-    prefix = "q-w:" /* window */;
+    prefix = isPassive ? "q-wp:" /* windowPassive */ : "q-w:" /* window */;
     idx = 9;
   } else if (eventName.startsWith("document:on" /* document */)) {
-    prefix = "q-d:" /* document */;
+    prefix = isPassive ? "q-dp:" /* documentPassive */ : "q-d:" /* document */;
     idx = 11;
   }
   return [prefix, idx];
 }
+var normalizeJsxEventName = (name) => {
+  return name === DOM_CONTENT_LOADED_EVENT ? "-d-o-m-content-loaded" : createEventName(
+    name.charAt(0) === "-" ? (
+      // marker for case sensitive event name
+      name.slice(1)
+    ) : name.toLowerCase()
+  );
+};
 function isPreventDefault(key) {
   return key.startsWith("preventdefault:");
 }
 var fromCamelToKebabCase = (text) => {
   return text.replace(/([A-Z-])/g, (a) => "-" + a.toLowerCase());
 };
+var getEventDataFromHtmlAttribute = (htmlKey) => {
+  const separatorIndex = htmlKey.indexOf(":");
+  return [htmlKey.slice(2, separatorIndex), htmlKey.slice(separatorIndex + 1)];
+};
 
 // packages/qwik/src/core/use/use-context.ts
 import { isDev as isDev4 } from "@qwik.dev/core/build";
@@ -24287,7 +24293,106 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser3, isDev as isDev20 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser4, isDev as isDev20 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/shared/qrl/qrl-class-dev.ts
+import { isBrowser } from "@qwik.dev/core/build";
+var initLazyRefDev = (lazy) => {
+  lazy.dev = null;
+  if (typeof document !== "undefined") {
+    lazy.qrls = /* @__PURE__ */ new Set();
+  }
+};
+var initQrlClassDev = (lazy, captures, qrl) => {
+  if (captures && typeof captures === "object") {
+    for (let i = 0; i < captures.length; i++) {
+      const item = captures[i];
+      verifySerializable(item, "Captured variable in the closure can not be serialized");
+    }
+  }
+  if (lazy.qrls) {
+    lazy.qrls.add(new WeakRef(qrl));
+  }
+};
+var setupHmr = (LazyRefClass, setGetLazyRef) => {
+  if (!(isBrowser && import.meta.hot)) {
+    return;
+  }
+  const allLazyRefs = /* @__PURE__ */ new Map();
+  setGetLazyRef((chunk, symbol, symbolFn, ref, container) => {
+    let lazyRef = allLazyRefs.get(symbol);
+    if (!lazyRef) {
+      lazyRef = new LazyRefClass(chunk, symbol, symbolFn, ref, container);
+      if (chunk !== "") {
+        allLazyRefs.set(symbol, lazyRef);
+      }
+    }
+    return lazyRef;
+  });
+  const bustTimestamp = (url, t) => {
+    const [path, query] = url.split("?", 2);
+    if (!query) {
+      return `${path}?t=${t}`;
+    }
+    const params = query.split("&").filter((p) => !p.startsWith("t="));
+    params.push(`t=${t}`);
+    return `${path}?${params.join("&")}`;
+  };
+  document.addEventListener("qHmr", (ev) => {
+    const files = ev.detail.files;
+    const t = ev.detail.t || document.__hmrT || Date.now();
+    let didReload = false;
+    for (const lazy of allLazyRefs.values()) {
+      const devFile = lazy.dev?.file || lazy.$chunk$;
+      if (!devFile || !files.some((file) => devFile.startsWith(file))) {
+        continue;
+      }
+      const chunk = lazy.$chunk$;
+      if (chunk) {
+        lazy.$chunk$ = bustTimestamp(chunk, t);
+        didReload = true;
+      }
+      const fnStr = lazy.$symbolFn$?.toString();
+      if (fnStr) {
+        const newStr = fnStr.replace(/import\((['"])(.+?)\1\)/, (match, p1, p2) => {
+          const newPath = bustTimestamp(p2, t);
+          return `import(${p1}${newPath}${p1})`;
+        });
+        if (newStr !== fnStr) {
+          try {
+            lazy.$symbolFn$ = new Function(`return (${newStr})`)();
+            didReload = true;
+          } catch (err) {
+            console.error(`Failed to update symbolFn for ${lazy.$symbol$}`, err);
+          }
+        } else {
+          console.warn(
+            `Couldn't find import() in symbolFn for ${lazy.$symbol$}, cannot update it for HMR`,
+            fnStr
+          );
+        }
+      }
+      if (didReload) {
+        lazy.$ref$ = void 0;
+        document.__hmrDone = document.__hmrT;
+        if (lazy.qrls) {
+          for (const qrlRef of lazy.qrls) {
+            const qrl = qrlRef.deref();
+            if (qrl) {
+              if (qrl.resolved) {
+                qrl.resolved = void 0;
+              }
+            } else {
+              lazy.qrls.delete(qrlRef);
+            }
+          }
+        }
+      }
+    }
+  });
+};
+
+// packages/qwik/src/core/shared/qrl/qrl-class.ts
 import { p as preload } from "@qwik.dev/core/preloader";
 
 // packages/qwik/src/core/shared/serdes/inflate.ts
@@ -24738,7 +24843,7 @@ var isPropsProxy = (obj) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
-import { isBrowser, isDev as isDev10, isServer as isServer5 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser2, isDev as isDev10, isServer as isServer5 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/reactive-primitives/subscriber.ts
 import { isServer as isServer4 } from "@qwik.dev/core/build";
@@ -24800,7 +24905,8 @@ var cleanupFn = (target, handleError) => {
         target.$destroy$ = () => {
           target.$destroy$ = null;
           let cleanupPromises = null;
-          for (const fn2 of cleanupFns) {
+          for (let i = 0; i < cleanupFns.length; i++) {
+            const fn2 = cleanupFns[i];
             try {
               const result2 = fn2();
               if (isPromise(result2)) {
@@ -24904,15 +25010,16 @@ var log3 = (...args) => (
   console.log("ASYNC COMPUTED SIGNAL", ...args.map(qwikDebugToString))
 );
 var AsyncJob = class {
-  constructor($signal$) {
+  constructor($signal$, info, $infoVersion$) {
     this.$signal$ = $signal$;
     /** First holds the compute promise and then the cleanup promise */
     __publicField(this, "$promise$", null);
     __publicField(this, "$cleanupRequested$", false);
     __publicField(this, "$canWrite$", true);
-    __publicField(this, "$track$");
-    __publicField(this, "$cleanups$");
-    __publicField(this, "$abortController$");
+    if (info !== void 0) {
+      this.info = info;
+      this.$infoVersion$ = $infoVersion$;
+    }
   }
   get track() {
     return this.$track$ || (this.$track$ = trackFn(this.$signal$, this.$signal$.$container$));
@@ -24923,7 +25030,7 @@ var AsyncJob = class {
   /** Backward compatible cache method for resource */
   cache() {
     isDev10 && console.error(
-      "useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior."
+      "useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `expires` option for polling behavior."
     );
   }
   get previous() {
@@ -24944,37 +25051,45 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     super(container, fn, flags);
     __publicField(this, "$untrackedLoading$", false);
     __publicField(this, "$untrackedError$");
-    __publicField(this, "$loadingEffects$");
-    __publicField(this, "$errorEffects$");
     __publicField(this, "$current$", null);
-    // TODO only create the array if concurrency > 1
-    __publicField(this, "$jobs$", []);
-    __publicField(this, "$concurrency$", 1);
-    __publicField(this, "$interval$", 0);
-    __publicField(this, "$timeoutMs$");
     __publicField(this, _a3);
-    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 (!options) {
+      return;
+    }
+    const initial = options.initial;
     if (initial !== void 0) {
       const initialValue = typeof initial === "function" ? initial() : initial;
       this.$untrackedValue$ = initialValue;
     }
-    this.$concurrency$ = concurrency;
+    const concurrency = options.concurrency;
+    if (concurrency !== void 0 && concurrency >= 0 && concurrency !== 1) {
+      this.$concurrency$ = concurrency;
+      this.$jobs$ = [];
+    }
+    const timeout = options.timeout;
     if (timeout) {
       this.$timeoutMs$ = timeout;
     }
-    if (eagerCleanup) {
+    if (options.eagerCleanup) {
       this.$flags$ |= 32 /* EAGER_CLEANUP */;
     }
-    if (clientOnly) {
+    if (options.clientOnly) {
       this.$flags$ |= 64 /* CLIENT_ONLY */;
     }
-    if (interval) {
-      this.interval = interval;
+    if (options.allowStale === false) {
+      if (isDev10 && initial !== void 0) {
+        throw new Error(
+          "allowStale: false and initial cannot be used together. allowStale: false clears the value on invalidation, which conflicts with providing an initial value."
+        );
+      }
+      this.$flags$ |= 128 /* CLEAR_ON_INVALIDATE */;
+    }
+    const expires = options.expires ?? (options.interval ? Math.abs(options.interval) : void 0);
+    if (expires) {
+      this.expires = expires;
+    }
+    if (options.poll === false || options.interval !== void 0 && options.interval < 0) {
+      this.$flags$ |= 256 /* NO_POLL */;
     }
   }
   get untrackedValue() {
@@ -24992,15 +25107,43 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
       throw this.$untrackedError$;
     }
     if ((import.meta.env.TEST ? isServerPlatform() : isServer5) && this.$flags$ & 64 /* CLIENT_ONLY */ && this.$untrackedValue$ === NEEDS_COMPUTATION) {
-      throw new Error(
-        isDev10 ? "During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value." : "Cannot read .value from clientOnly"
-      );
+      throw qError(35 /* asyncClientOnlyValueDuringSSR */);
     }
     return this.$untrackedValue$;
   }
   set untrackedValue(value) {
     this.$untrackedValue$ = value;
   }
+  /**
+   * Read the value, subscribing if in a tracking context. Triggers computation if needed.
+   *
+   * Setting the value will mark the signal as not loading and clear any error, and prevent any
+   * pending computations from writing their results.
+   *
+   * If you want to set the value without affecting loading or error state, set `untrackedValue`
+   * instead and make sure to trigger effects manually if needed.
+   *
+   * If you want to abort pending computations when setting, you have to call `abort()` manually.
+   */
+  get value() {
+    return super.value;
+  }
+  set value(value) {
+    this.$flags$ &= ~1 /* INVALID */;
+    this.untrackedLoading = false;
+    this.untrackedError = void 0;
+    this.$info$ = void 0;
+    if (this.$jobs$) {
+      for (let i = 0; i < this.$jobs$.length; i++) {
+        this.$jobs$[i].$canWrite$ = false;
+      }
+    } else if (this.$current$) {
+      this.$current$.$canWrite$ = false;
+    }
+    this.$clearNextPoll$();
+    super.value = value;
+    this.$scheduleNextPoll$();
+  }
   /**
    * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
    * has resolved or rejected.
@@ -25067,23 +25210,59 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
   get untrackedError() {
     return this.$untrackedError$;
   }
-  get interval() {
-    return this.$interval$;
+  get expires() {
+    return this.$expires$ || 0;
   }
-  set interval(value) {
+  set expires(value) {
     this.$clearNextPoll$();
-    this.$interval$ = value;
-    if (this.$interval$ > 0 && this.$effects$?.size) {
+    this.$expires$ = value;
+    if (this.$expires$ && this.$hasSubscribers$()) {
+      this.$scheduleNextPoll$();
+    }
+  }
+  get poll() {
+    return !(this.$flags$ & 256 /* NO_POLL */);
+  }
+  set poll(value) {
+    if (value) {
+      this.$flags$ &= ~256 /* NO_POLL */;
+    } else {
+      this.$flags$ |= 256 /* NO_POLL */;
+    }
+    if (this.$expires$ && this.$hasSubscribers$()) {
+      this.$clearNextPoll$();
       this.$scheduleNextPoll$();
     }
   }
+  /** @deprecated Use `expires` and `poll` instead. */
+  get interval() {
+    const expires = this.$expires$ || 0;
+    return this.$flags$ & 256 /* NO_POLL */ ? -expires : expires;
+  }
+  set interval(value) {
+    if (value < 0) {
+      this.$flags$ |= 256 /* NO_POLL */;
+    } else {
+      this.$flags$ &= ~256 /* NO_POLL */;
+    }
+    this.expires = Math.abs(value);
+  }
   /** Invalidates the signal, causing it to re-compute its value. */
-  async invalidate() {
+  async invalidate(info) {
+    if (arguments.length > 0) {
+      this.$info$ = info;
+      this.$infoVersion$ = this.$infoVersion$ === void 0 ? 1 : this.$infoVersion$ + 1;
+    }
+    this.$setInvalid$(true, this.$flags$ & 128 /* CLEAR_ON_INVALIDATE */);
+  }
+  $setInvalid$(allowRecalc, mustClear) {
     this.$flags$ |= 1 /* INVALID */;
     this.$clearNextPoll$();
-    if (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) {
-      await true;
-      this.$computeIfNeeded$();
+    if (mustClear) {
+      this.$untrackedValue$ = NEEDS_COMPUTATION;
+    }
+    if (allowRecalc && (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size)) {
+      Promise.resolve().then(() => this.$computeIfNeeded$());
     }
   }
   /** Abort the current computation and run cleanups if needed. */
@@ -25097,7 +25276,7 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     if (!(this.$flags$ & 32 /* EAGER_CLEANUP */) || this.$hasSubscribers$()) {
       return;
     }
-    if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser)) {
+    if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser2)) {
       return;
     }
     setTimeout(() => {
@@ -25124,58 +25303,75 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
       return;
     }
     this.$clearNextPoll$();
-    if (this.$current$) {
-      this.$requestCleanups$(this.$current$);
+    this.$flags$ &= ~1 /* INVALID */;
+    const current = this.$current$;
+    if (current) {
+      this.$requestCleanups$(current);
     }
-    const limit = this.$concurrency$ === 0 ? Number.POSITIVE_INFINITY : this.$concurrency$;
-    if (this.$jobs$.length >= limit) {
+    const limit = this.$concurrency$ === 0 ? Number.POSITIVE_INFINITY : this.$concurrency$ ?? 1;
+    if (this.$jobs$ ? this.$jobs$.length >= limit : current?.$promise$) {
       DEBUG3 && log3(`Concurrency limit ${limit} reached, not starting new computation`);
+      this.$flags$ |= 1 /* INVALID */;
       return;
     }
     DEBUG3 && log3("Starting new async computation");
-    this.$flags$ &= ~1 /* INVALID */;
-    const running = new AsyncJob(this);
+    const infoVersion = this.$infoVersion$;
+    const running = new AsyncJob(this, this.$info$, infoVersion);
     this.$current$ = running;
-    this.$jobs$.push(running);
+    if (this.$jobs$) {
+      this.$jobs$.push(running);
+    }
     running.$promise$ = this.$runComputation$(running);
   }
   async $runComputation$(running) {
     const isCurrent = () => running === this.$current$;
     this.untrackedLoading = true;
-    const fn = this.$computeQrl$.resolved || await this.$computeQrl$.resolve();
+    let fn = this.$computeQrl$.resolved;
+    if (!fn) {
+      fn = await this.$computeQrl$.resolve();
+      if (running.$abortController$?.signal.aborted) {
+        DEBUG3 && log3("Computation aborted before it started");
+        running.$promise$ = null;
+        return;
+      }
+    }
     try {
       if (this.$timeoutMs$) {
         this.$computationTimeoutId$ = setTimeout(() => {
-          running.$abortController$?.abort();
-          const error = new Error(`timeout`);
-          if (isCurrent()) {
-            this.untrackedError = error;
-            running.$canWrite$ = false;
-          }
+          const error = new Error(`timeout ${this.$timeoutMs$}ms`);
+          this.$setError$(running, error);
+          running.$abortController$?.abort(error);
         }, this.$timeoutMs$);
       }
-      const value = await retryOnPromise(fn.bind(null, running));
+      const valuePromise = retryOnPromise(fn.bind(null, running));
+      const value = isPromise(valuePromise) ? await valuePromise : valuePromise;
       running.$promise$ = null;
       if (running.$canWrite$) {
-        const index = this.$jobs$.indexOf(running);
-        if (index !== -1) {
-          for (let i = 0; i < index; i++) {
-            this.$jobs$[i].$canWrite$ = false;
+        const jobs = this.$jobs$;
+        if (jobs) {
+          let doDisable = false;
+          for (let i = jobs.length - 1; i >= 0; i--) {
+            if (jobs[i] === running) {
+              doDisable = true;
+            } else if (doDisable) {
+              jobs[i].$canWrite$ = false;
+            }
           }
         }
         DEBUG3 && log3("Promise resolved", value);
         this.untrackedError = void 0;
-        this.value = value;
+        super.value = value;
       }
     } catch (err) {
       running.$promise$ = null;
       DEBUG3 && log3("Error caught in promise.catch", err);
-      if (isCurrent()) {
-        this.untrackedError = err;
-      }
+      this.$setError$(running, err);
     }
     if (isCurrent()) {
       clearTimeout(this.$computationTimeoutId$);
+      if (running.$infoVersion$ === this.$infoVersion$) {
+        this.$info$ = void 0;
+      }
       if (this.$flags$ & 1 /* INVALID */) {
         DEBUG3 && log3("Computation finished but signal is invalid, re-running");
         this.$computeIfNeeded$();
@@ -25185,14 +25381,34 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
       }
     }
   }
+  /**
+   * Sets the error from the given job. We only accept errors from the current job and we ignore
+   * AbortErrors.
+   */
+  $setError$(job, error) {
+    if (job !== this.$current$ || !job.$canWrite$) {
+      return;
+    }
+    job.$canWrite$ = false;
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    this.untrackedError = error;
+    this.untrackedValue = NEEDS_COMPUTATION;
+  }
   /** Called after SSR/unmount */
   async $destroy$() {
     this.$clearNextPoll$();
     clearTimeout(this.$computationTimeoutId$);
-    if (this.$current$) {
-      await this.$requestCleanups$(this.$current$);
+    const current = this.$current$;
+    if (current) {
+      this.$requestCleanups$(current);
+    }
+    if (this.$jobs$) {
+      await Promise.all(this.$jobs$.map((job) => job.$promise$));
+    } else {
+      await current?.$promise$;
     }
-    await Promise.all(this.$jobs$.map((job) => job.$promise$));
   }
   $clearNextPoll$() {
     if (this.$pollTimeoutId$ !== void 0) {
@@ -25201,61 +25417,76 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     }
   }
   $scheduleNextPoll$() {
-    if ((import.meta.env.TEST ? !isServerPlatform() : isBrowser) && this.$interval$ > 0) {
-      this.$clearNextPoll$();
-      this.$pollTimeoutId$ = setTimeout(this.invalidate.bind(this), this.$interval$);
-      this.$pollTimeoutId$?.unref?.();
+    if ((import.meta.env.TEST ? isServerPlatform() : isServer5) || !this.$expires$) {
+      return;
     }
+    this.$clearNextPoll$();
+    const allowRecalc = !(this.$flags$ & 256 /* NO_POLL */);
+    const mustClear = this.$flags$ & 128 /* CLEAR_ON_INVALIDATE */ && !allowRecalc;
+    this.$pollTimeoutId$ = setTimeout(
+      () => this.$setInvalid$(allowRecalc, mustClear),
+      this.$expires$
+    );
+    this.$pollTimeoutId$?.unref?.();
   }
   $hasSubscribers$() {
     return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
   }
-  async $requestCleanups$(job, reason) {
+  $requestCleanups$(job, reason) {
     if (job.$cleanupRequested$) {
-      return job.$promise$;
+      return;
     }
     DEBUG3 && log3("Requesting cleanups for job", job);
     job.$cleanupRequested$ = true;
     job.$abortController$?.abort(reason);
-    job.$promise$ = Promise.resolve(job.$promise$).then(
-      () => job.$promise$ = this.$runCleanups$(job)
-    );
+    job.$promise$ = maybeThen(job.$promise$, () => this.$runCleanups$(job));
   }
   /** Clean up and trigger signal compute once complete */
-  async $runCleanups$(job) {
+  $runCleanups$(job) {
     const cleanups = job.$cleanups$;
-    if (cleanups?.length) {
-      DEBUG3 && log3("cleanup start", job);
-      const onError = (err) => {
-        const handleError = this.$container$?.handleError;
-        if (handleError) {
-          handleError(err, null);
-        } else {
-          console.error("Error in async signal cleanup", err);
+    DEBUG3 && log3("cleanup start", job);
+    const onError = (err) => {
+      const handleError = this.$container$?.handleError;
+      if (handleError) {
+        handleError(err, null);
+      } else {
+        console.error("Error in async signal cleanup", err);
+      }
+    };
+    const onDone = () => {
+      job.$promise$ = null;
+      if (cleanups) {
+        cleanups.length = 0;
+      }
+      DEBUG3 && log3("cleanup finished", job);
+      const jobs = this.$jobs$;
+      if (jobs) {
+        const idx = jobs.indexOf(job);
+        if (idx !== -1) {
+          jobs.splice(idx, 1);
         }
-      };
+      }
+      this.$computeIfNeeded$();
+    };
+    let promiseChain = void 0;
+    if (cleanups) {
       DEBUG3 && log3("cleanup start for real", job);
-      await Promise.all(
-        cleanups.map((fn) => {
-          try {
-            const result2 = fn();
-            if (isPromise(result2)) {
-              return result2.catch(onError);
-            }
-          } catch (err) {
-            onError(err);
+      for (let i = 0; i < cleanups.length; i++) {
+        try {
+          const result2 = cleanups[i]();
+          if (isPromise(result2)) {
+            promiseChain = (promiseChain ? promiseChain.then(() => result2) : result2).catch(onError);
           }
-        })
-      );
-      cleanups.length = 0;
-      DEBUG3 && log3("cleanup finished", job);
+        } catch (err) {
+          onError(err);
+        }
+      }
     }
-    const jobs = this.$jobs$;
-    const idx = jobs.indexOf(job);
-    if (idx !== -1) {
-      jobs.splice(idx, 1);
+    if (promiseChain) {
+      return promiseChain.then(onDone);
+    } else {
+      onDone();
     }
-    this.$computeIfNeeded$();
   }
 };
 
@@ -25398,6 +25629,7 @@ function removeCursorFromQueue(cursor, container, keepCursorFlag) {
 var cursorDatas = /* @__PURE__ */ new WeakMap();
 var NODE_PROPS_DATA_KEY = ":nodeProps";
 var NODE_DIFF_DATA_KEY = ":nodeDiff";
+var ERROR_DATA_KEY = ":errorData";
 var HOST_SIGNAL = ":signal";
 function setCursorPosition(container, cursorData, position) {
   cursorData.position = position;
@@ -25650,8 +25882,9 @@ function addUseOnEvents(jsx2, useOnEvents) {
             targetElement = placeholderElement;
           } else {
             if (isDev12) {
+              const sourceLocation = getUseOnSourceLocation(useOnEvents[key].qrls);
               logWarn(
-                'You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component has a valid element node. '
+                'You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component outputs a DOM element.' + (sourceLocation ? ` Offending \`useOn\`: ${sourceLocation}.` : "")
               );
             }
             continue;
@@ -25661,8 +25894,9 @@ function addUseOnEvents(jsx2, useOnEvents) {
           if (targetElement.type === "script" && key === qVisibleEvent) {
             eventKey = "q-d:qinit";
             if (isDev12) {
+              const sourceLocation = getUseOnSourceLocation(useOnEvents[key].qrls);
               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.'
+                `You are trying to add the event "${key}" using the \`useVisibleTask$\` hook with the "intersection-observer" strategy, but this only works when the component outputs a DOM element. Falling back to "document-ready" instead.` + (sourceLocation ? ` Offending \`useVisibleTask$\`: ${sourceLocation}.` : "")
               );
             }
           }
@@ -25673,25 +25907,57 @@ function addUseOnEvents(jsx2, useOnEvents) {
     return jsxResult;
   });
 }
+function getUseOnSourceLocation(eventQrls) {
+  for (let i = 0; i < eventQrls.length; i++) {
+    const eventQrl = eventQrls[i];
+    const task = eventQrl?.getCaptured()?.[0];
+    if (isTask(task)) {
+      const dev = task.$qrl$.dev;
+      if (dev?.file) {
+        return typeof dev.lo === "number" && typeof dev.hi === "number" ? `${dev.file}:${dev.lo}-${dev.hi}` : dev.file;
+      }
+    }
+  }
+  return null;
+}
 function addUseOnEvent(jsxElement, key, value) {
   const props = jsxElement.constProps || (jsxElement.constProps = {});
   const propValue = props[key];
+  const qrls = value.qrls;
   if (propValue == null) {
-    props[key] = value;
+    props[key] = qrls;
   } else if (Array.isArray(propValue)) {
-    propValue.push(...value);
+    propValue.push(...qrls);
   } else {
-    props[key] = [propValue, ...value];
+    props[key] = [propValue, ...qrls];
   }
   const varProp = jsxElement.varProps[key];
   if (varProp) {
     if (Array.isArray(propValue)) {
       propValue.push(...props[key]);
     } else {
-      jsxElement.varProps[key] = [propValue, ...value];
+      jsxElement.varProps[key] = [propValue, ...qrls];
     }
     props[key] = void 0;
   }
+  const capture = value.capture;
+  const preventdefault = value.preventdefault;
+  const stoppropagation = value.stoppropagation;
+  if (!capture && !preventdefault && !stoppropagation) {
+    return;
+  }
+  const [, eventName] = getEventDataFromHtmlAttribute(key);
+  capture && addUseOnModifier(jsxElement, eventName, "capture");
+  preventdefault && addUseOnModifier(jsxElement, eventName, "preventdefault");
+  stoppropagation && addUseOnModifier(jsxElement, eventName, "stoppropagation");
+}
+function addUseOnModifier(jsxElement, eventName, modifier) {
+  const key = `${modifier}:${eventName}`;
+  const varProps = jsxElement.varProps;
+  if (varProps === EMPTY_OBJ) {
+    jsxElement.varProps = {};
+  }
+  jsxElement.varProps[key] = true;
 }
 function findFirstElementNode(jsx2) {
   const queue2 = [jsx2];
@@ -25770,13 +26036,15 @@ var vnode_getElementNamespaceFlags = (element) => {
 };
 function cloneDomTreeWithNamespace(element, elementName, namespace, deep = false) {
   const newElement = element.ownerDocument.createElementNS(namespace, elementName);
-  for (const attr of element.attributes) {
+  for (let i = 0; i < element.attributes.length; i++) {
+    const attr = element.attributes[i];
     if (attr.name !== Q_PROPS_SEPARATOR) {
       newElement.setAttribute(attr.name, attr.value);
     }
   }
   if (deep) {
-    for (const child of element.childNodes) {
+    for (let i = 0; i < element.childNodes.length; i++) {
+      const child = element.childNodes[i];
       const nodeType = child.nodeType;
       if (nodeType === 3) {
         newElement.appendChild(child.cloneNode());
@@ -26415,7 +26683,8 @@ var serializeClass = (obj) => {
   }
   const classes = [];
   if (isArray(obj)) {
-    for (const o of obj) {
+    for (let i = 0; i < obj.length; i++) {
+      const o = obj[i];
       const classList = serializeClass(o);
       if (classList) {
         classes.push(classList);
@@ -27038,15 +27307,16 @@ function getSlotNameKey(diffContext, vHost) {
   return directGetPropsProxyProp(jsxNode, "name") || QDefaultSlot;
 }
 function cleanupSideBuffer(diffContext) {
-  if (diffContext.$vSideBuffer$) {
-    for (const vNode of diffContext.$vSideBuffer$.values()) {
+  const sideBuffer = diffContext.$vSideBuffer$;
+  if (sideBuffer) {
+    for (const vNode of sideBuffer.values()) {
       if (vNode.flags & 32 /* Deleted */) {
         continue;
       }
       cleanup(diffContext.$container$, diffContext.$journal$, vNode, diffContext.$cursor$);
       vnode_remove(diffContext.$journal$, diffContext.$vParent$, vNode, true);
     }
-    diffContext.$vSideBuffer$.clear();
+    sideBuffer.clear();
     diffContext.$vSideBuffer$ = null;
   }
   diffContext.$vCurrent$ = null;
@@ -27849,7 +28119,9 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
         }
         const attrs = vCursor.props;
         if (attrs) {
-          for (const key of Object.keys(attrs)) {
+          const keys = Object.keys(attrs);
+          for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             if (isSlotProp(key)) {
               const value = attrs[key];
               if (value) {
@@ -27948,7 +28220,8 @@ function containsWrappedSignal(data, signal) {
   if (!(signal instanceof WrappedSignalImpl)) {
     return false;
   }
-  for (const item of data) {
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
     if (item instanceof WrappedSignalImpl && areWrappedSignalsEqual(item, signal)) {
       return true;
     }
@@ -28218,7 +28491,8 @@ function executeTasks(vNode, container, cursorData) {
     return;
   }
   let taskPromise;
-  for (const item of elementSeq) {
+  for (let i = 0; i < elementSeq.length; i++) {
+    const item = elementSeq[i];
     if (item instanceof Task) {
       const task = item;
       if (!(task.$flags$ & 4 /* DIRTY */)) {
@@ -28249,6 +28523,36 @@ function setNodeDiffPayload(vNode, payload) {
   const props = vNode.props || (vNode.props = {});
   props[NODE_DIFF_DATA_KEY] = payload;
 }
+function getErrorPayload(vNode) {
+  const props = vNode.props;
+  return props?.[ERROR_DATA_KEY] ?? null;
+}
+function setErrorPayload(vNode, error) {
+  const props = vNode.props || (vNode.props = {});
+  props[ERROR_DATA_KEY] = error;
+}
+function executeErrorWrap(vNode, journal) {
+  vNode.dirty &= ~256 /* ERROR_WRAP */;
+  const err = getErrorPayload(vNode);
+  if (!err) {
+    return;
+  }
+  setErrorPayload(vNode, null);
+  const vHost = vNode;
+  const vHostParent = vHost.parent;
+  const vHostNextSibling = vHost.nextSibling;
+  const vErrorDiv = vnode_createErrorDiv(journal, document, vHost, err);
+  const insertHost = vnode_isElementVNode(vHost) ? vHostParent || vHost : vHost;
+  const insertBefore = insertHost === vHost ? null : vHostNextSibling;
+  vnode_insertElementBefore(
+    journal,
+    insertHost,
+    vErrorDiv,
+    insertBefore
+  );
+  vNode.dirty &= ~32 /* CHILDREN */;
+  vNode.dirtyChildren = null;
+}
 function executeNodeDiff(vNode, container, journal, cursor) {
   vNode.dirty &= ~2 /* NODE_DIFF */;
   const domVNode = vNode;
@@ -28358,7 +28662,8 @@ function executeCleanup(vNode, container) {
   if (!elementSeq || elementSeq.length === 0) {
     return;
   }
-  for (const item of elementSeq) {
+  for (let i = 0; i < elementSeq.length; i++) {
+    const item = elementSeq[i];
     if (item instanceof Task) {
       if (item.$flags$ & 16 /* NEEDS_CLEANUP */) {
         item.$flags$ &= ~16 /* NEEDS_CLEANUP */;
@@ -28557,8 +28862,8 @@ function executeAfterFlush(container, cursorData) {
     visibleTasks.map((t) => t.$qrl$.$symbol$)
   );
   let visibleTaskPromise;
-  for (const visibleTask of visibleTasks) {
-    const task = visibleTask;
+  for (let i = 0; i < visibleTasks.length; i++) {
+    const task = visibleTasks[i];
     const result2 = runTask(task, container, task.$el$);
     if (isPromise(result2)) {
       visibleTaskPromise = visibleTaskPromise ? visibleTaskPromise.then(() => result2) : result2;
@@ -28597,7 +28902,7 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isBrowser as isBrowser2, isDev as isDev16, isServer as isServer7 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser3, isDev as isDev16, isServer as isServer7 } from "@qwik.dev/core/build";
 var DEBUG6 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
@@ -28650,7 +28955,7 @@ function walkCursor(cursor, options) {
     if (cursorData.promise) {
       return;
     }
-    if (!(currentVNode.dirty & 255 /* DIRTY_MASK */)) {
+    if (!(currentVNode.dirty & 511 /* DIRTY_MASK */)) {
       setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
       continue;
     }
@@ -28664,7 +28969,7 @@ function walkCursor(cursor, options) {
           continue;
         }
       }
-      currentVNode.dirty &= ~255 /* DIRTY_MASK */;
+      currentVNode.dirty &= ~511 /* DIRTY_MASK */;
       setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
       continue;
     }
@@ -28688,6 +28993,8 @@ function walkCursor(cursor, options) {
           currentVNode = next;
           continue;
         }
+      } else if (currentVNode.dirty & 256 /* ERROR_WRAP */) {
+        executeErrorWrap(currentVNode, journal);
       }
     } catch (error) {
       container.handleError(error, currentVNode);
@@ -28706,7 +29013,7 @@ function walkCursor(cursor, options) {
       });
       return;
     }
-    if (isBrowser2) {
+    if (isBrowser3) {
       const elapsed = performance.now() - startTime;
       if (elapsed >= timeBudget) {
         scheduleYield();
@@ -28715,16 +29022,16 @@ function walkCursor(cursor, options) {
     }
   }
   isDev16 && assertFalse(
-    !!(cursor.dirty & 255 /* DIRTY_MASK */ && !cursorData.position),
+    !!(cursor.dirty & 511 /* DIRTY_MASK */ && !cursorData.position),
     "Cursor is still dirty and position is not set after walking"
   );
   finishWalk(container, cursor, cursorData, isRunningOnServer);
 }
-function finishWalk(container, cursor, cursorData, isServer13) {
-  if (!(cursor.dirty & 255 /* DIRTY_MASK */)) {
+function finishWalk(container, cursor, cursorData, isServer15) {
+  if (!(cursor.dirty & 511 /* DIRTY_MASK */)) {
     removeCursorFromQueue(cursor, container);
     DEBUG6 && console.warn("walkCursor: cursor done", cursor.toString());
-    if (!isServer13) {
+    if (!isServer15) {
       executeFlushPhase(cursor, container);
     }
     if (cursorData.extraPromises) {
@@ -28768,7 +29075,7 @@ function partitionDirtyChildren(dirtyChildren, parent) {
 }
 function getNextVNode(vNode, cursor) {
   if (vNode === cursor) {
-    if (cursor.dirty & 255 /* DIRTY_MASK */) {
+    if (cursor.dirty & 511 /* DIRTY_MASK */) {
       return cursor;
     }
     return null;
@@ -28780,7 +29087,7 @@ function getNextVNode(vNode, cursor) {
     parent = vNode.parent;
   }
   if (!parent) {
-    if (cursor.dirty & 255 /* DIRTY_MASK */) {
+    if (cursor.dirty & 511 /* DIRTY_MASK */) {
       return cursor;
     }
     return null;
@@ -28791,7 +29098,7 @@ function getNextVNode(vNode, cursor) {
   let count = len;
   while (count-- > 0) {
     const nextVNode = dirtyChildren[index];
-    if (nextVNode.dirty & 255 /* DIRTY_MASK */) {
+    if (nextVNode.dirty & 511 /* DIRTY_MASK */) {
       parent.nextDirtyChildIndex = (index + 1) % len;
       return nextVNode;
     }
@@ -28854,7 +29161,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
   reusablePath.push(vNode);
   let current = vNode.slotParent || vNode.parent;
   while (current) {
-    const isDirty = current.dirty & 255 /* DIRTY_MASK */;
+    const isDirty = current.dirty & 511 /* DIRTY_MASK */;
     const currentIsCursor = isCursor(current);
     if (current === cursorRoot || isDirty) {
       propagatePath(current);
@@ -28908,8 +29215,8 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     }
     return;
   }
-  const isRealDirty = bits & 255 /* DIRTY_MASK */;
-  if ((isRealDirty ? prevDirty & 255 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
+  const isRealDirty = bits & 511 /* DIRTY_MASK */;
+  if ((isRealDirty ? prevDirty & 511 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
     return;
   }
   const parent = vNode.slotParent || vNode.parent;
@@ -28917,7 +29224,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     propagateToCursorRoot(vNode, cursorRoot);
     return;
   }
-  if (parent && parent.dirty & 255 /* DIRTY_MASK */) {
+  if (parent && parent.dirty & 511 /* DIRTY_MASK */) {
     if (isRealDirty) {
       parent.dirty |= 32 /* CHILDREN */;
     }
@@ -29164,7 +29471,7 @@ function _executeSsrChores(container, ssrNode) {
     if (ssrNode.dirty & 16 /* COMPUTE */) {
       executeCompute(ssrNode, container);
     }
-    if (ssrNode.dirty & 255 /* DIRTY_MASK */) {
+    if (ssrNode.dirty & 511 /* DIRTY_MASK */) {
       const warningMessage = `A chore was scheduled on a host element that has already been streamed to the client.
         This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).
         
@@ -29175,7 +29482,7 @@ function _executeSsrChores(container, ssrNode) {
         This is often caused by modifying a signal in an already rendered component during SSR.`;
       logWarn(warningMessage);
     }
-    ssrNode.dirty &= ~255 /* DIRTY_MASK */;
+    ssrNode.dirty &= ~511 /* DIRTY_MASK */;
     return;
   }
   let promise = null;
@@ -29189,7 +29496,7 @@ function _executeSsrChores(container, ssrNode) {
     const result2 = executeReconcileChore(container, ssrNode);
     promise = promise ? promise.then(() => result2) : result2;
   }
-  ssrNode.dirty &= ~(255 /* DIRTY_MASK */ & ~4 /* COMPONENT */);
+  ssrNode.dirty &= ~(511 /* DIRTY_MASK */ & ~4 /* COMPONENT */);
   if (promise) {
     return promise;
   }
@@ -29201,7 +29508,8 @@ function executeTasksChore(container, ssrNode) {
     return null;
   }
   let promise = null;
-  for (const item of elementSeq) {
+  for (let i = 0; i < elementSeq.length; i++) {
+    const item = elementSeq[i];
     if (item instanceof Task) {
       const task = item;
       if (!(task.$flags$ & 4 /* DIRTY */)) {
@@ -29306,6 +29614,8 @@ var Serializer = class {
     __publicField(this, "$parent$");
     __publicField(this, "$qrlMap$", /* @__PURE__ */ new Map());
     __publicField(this, "$writer$");
+    /** We need to determine this at runtime because polyfills may not be loaded a module load time */
+    __publicField(this, "$hasTemporal$", typeof Temporal !== "undefined");
     this.$writer$ = $serializationContext$.$writer$;
   }
   async serialize() {
@@ -29345,6 +29655,29 @@ var Serializer = class {
     }
     return false;
   }
+  maybeNumericObjectKey$(key) {
+    if (key.length === 0 || key.length >= 8) {
+      return key;
+    }
+    let i = 0;
+    if (key.charCodeAt(0) === 45) {
+      if (key.length === 1) {
+        return key;
+      }
+      i = 1;
+    }
+    const first = key.charCodeAt(i);
+    if (first < 49 || first > 57) {
+      return key;
+    }
+    for (i++; i < key.length; i++) {
+      const c = key.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        return key;
+      }
+    }
+    return Number(key);
+  }
   /** 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") {
@@ -29450,6 +29783,8 @@ var Serializer = class {
             this.output(3 /* Constant */, 8 /* STORE_ALL_PROPS */);
           } else if (value === _UNINITIALIZED) {
             this.output(3 /* Constant */, 9 /* UNINITIALIZED */);
+          } else if (value === explicitUndefined) {
+            this.output(3 /* Constant */, 0 /* Undefined */);
           }
           break;
         case "function":
@@ -29483,7 +29818,7 @@ var Serializer = class {
           } else if (isQwikComponent(value)) {
             const [qrl] = value[SERIALIZABLE_STATE];
             this.$serializationContext$.$renderSymbols$.add(qrl.$symbol$);
-            this.output(21 /* Component */, [qrl]);
+            this.output(29 /* Component */, [qrl]);
           } else {
             throw qError(34 /* serializeErrorCannotSerializeFunction */, [value.toString()]);
           }
@@ -29515,19 +29850,19 @@ var Serializer = class {
   writeObjectValue(value) {
     if (isPropsProxy(value)) {
       const owner = value[_OWNER];
-      this.output(30 /* PropsProxy */, [
+      this.output(38 /* PropsProxy */, [
         _serializationWeakRef(owner),
         owner.varProps,
         owner.constProps,
         value[_PROPS_HANDLER].$effects$
       ]);
     } else if (value instanceof SubscriptionData) {
-      this.output(31 /* SubscriptionData */, [
+      this.output(39 /* SubscriptionData */, [
         value.data.$scopedStyleIdPrefix$,
         value.data.$isConst$
       ]);
     } else if (value instanceof EffectSubscription) {
-      this.output(32 /* EffectSubscription */, [value.consumer, value.property, value.data]);
+      this.output(40 /* EffectSubscription */, [value.consumer, value.property, value.data]);
     } else if (isStore(value)) {
       const storeHandler = getStoreHandler(value);
       const storeTarget = getStoreTarget(value);
@@ -29545,13 +29880,13 @@ var Serializer = class {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      this.output(27 /* Store */, out);
+      this.output(35 /* Store */, out);
     } else if (isSerializerObj(value)) {
       const result2 = value[SerializerSymbol](value);
       if (isPromise(result2)) {
         const forwardRef = this.resolvePromise(result2, (resolved, resolvedValue) => {
           return new PromiseResult(
-            26 /* SerializerSignal */,
+            34 /* SerializerSignal */,
             resolved,
             resolvedValue,
             void 0,
@@ -29573,7 +29908,7 @@ var Serializer = class {
           if (Object.prototype.hasOwnProperty.call(value, key)) {
             const subVal = value[key];
             if (!fastSkipSerialize(subVal)) {
-              out.push(key, subVal);
+              out.push(this.maybeNumericObjectKey$(key), subVal);
             }
           }
         }
@@ -29588,7 +29923,7 @@ var Serializer = class {
         if (isPromise(maybeValue)) {
           const forwardRefId = this.resolvePromise(maybeValue, (resolved, resolvedValue) => {
             return new PromiseResult(
-              26 /* SerializerSignal */,
+              34 /* SerializerSignal */,
               resolved,
               resolvedValue,
               value.$effects$,
@@ -29597,12 +29932,12 @@ var Serializer = class {
           });
           this.output(2 /* ForwardRef */, forwardRefId);
         } else {
-          this.output(26 /* SerializerSignal */, [value.$computeQrl$, value.$effects$, maybeValue]);
+          this.output(34 /* SerializerSignal */, [value.$computeQrl$, value.$effects$, maybeValue]);
         }
         return;
       }
       if (value instanceof WrappedSignalImpl) {
-        this.output(23 /* WrappedSignal */, [
+        this.output(31 /* WrappedSignal */, [
           ...serializeWrappingFn(this.$serializationContext$, value),
           value.$flags$,
           value.$hostElement$,
@@ -29615,7 +29950,7 @@ var Serializer = class {
         const isInvalid = value.$flags$ & 1 /* INVALID */;
         const isSkippable = fastSkipSerialize(value.$untrackedValue$);
         const isAsync = value instanceof AsyncSignalImpl;
-        const interval = isAsync && value.$interval$ > 0 ? value.$interval$ : void 0;
+        const expires = isAsync && value.$expires$ !== 0 ? value.$expires$ : void 0;
         const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : void 0;
         const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : void 0;
         const asyncFlags = isAsync && value.$flags$ & ~24 /* SERIALIZATION_ALL_STRATEGIES */ || void 0;
@@ -29631,32 +29966,43 @@ var Serializer = class {
           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) {
-          out.push(v);
-          if (v === void 0) {
-            keepUndefined = true;
-          }
+        if (v !== NEEDS_COMPUTATION || expires !== void 0 || concurrency !== void 0 || timeout !== void 0) {
+          out.push(v === void 0 ? explicitUndefined : v);
         }
         if (isAsync) {
-          out.push(interval);
+          out.push(expires);
           out.push(concurrency);
           out.push(timeout);
         }
-        this.output(isAsync ? 25 /* AsyncSignal */ : 24 /* ComputedSignal */, out, keepUndefined);
+        this.output(isAsync ? 33 /* AsyncSignal */ : 32 /* ComputedSignal */, out);
       } else {
         const v = value.$untrackedValue$;
-        const keepUndefined = v === void 0;
-        const out = [v];
+        const out = [v === void 0 ? explicitUndefined : v];
         if (value.$effects$) {
           out.push(...value.$effects$);
         }
-        this.output(22 /* Signal */, out, keepUndefined);
+        this.output(30 /* Signal */, out);
       }
     } else if (value instanceof URL) {
       this.output(6 /* URL */, value.href);
     } else if (value instanceof Date) {
       this.output(7 /* Date */, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.Duration) {
+      this.output(15 /* TemporalDuration */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.Instant) {
+      this.output(16 /* TemporalInstant */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDate) {
+      this.output(17 /* TemporalPlainDate */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainDateTime) {
+      this.output(18 /* TemporalPlainDateTime */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainMonthDay) {
+      this.output(19 /* TemporalPlainMonthDay */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainTime) {
+      this.output(20 /* TemporalPlainTime */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.PlainYearMonth) {
+      this.output(21 /* TemporalPlainYearMonth */, value.toJSON());
+    } else if (this.$hasTemporal$ && value instanceof Temporal.ZonedDateTime) {
+      this.output(22 /* TemporalZonedDateTime */, value.toJSON());
     } else if (value instanceof RegExp) {
       this.output(8 /* Regex */, value.toString());
     } else if (value instanceof Error) {
@@ -29665,7 +30011,7 @@ var Serializer = class {
       if (isDev18) {
         out.push("stack", value.stack);
       }
-      this.output(15 /* Error */, out);
+      this.output(23 /* Error */, out);
     } else if (this.$serializationContext$.$isSsrNode$(value)) {
       const rootIndex = this.$serializationContext$.$addRoot$(value);
       this.$serializationContext$.$setProp$(value, ELEMENT_ID, String(rootIndex));
@@ -29684,15 +30030,6 @@ var Serializer = class {
           const child = value.children[i];
           const childVNodeData = child.vnodeData;
           if (childVNodeData) {
-            for (let i2 = 0; i2 < childVNodeData.length; i2++) {
-              const value2 = childVNodeData[i2];
-              if (isSsrAttrs(value2)) {
-                const backRefs = tryGetBackRefs(value2);
-                if (backRefs) {
-                  this.$serializationContext$.$addRoot$(backRefs);
-                }
-              }
-            }
             childVNodeData[0] |= 16 /* SERIALIZE */;
           }
         }
@@ -29704,17 +30041,17 @@ var Serializer = class {
           array.push(k, v);
         }
       }
-      this.output(28 /* FormData */, array);
+      this.output(36 /* FormData */, array);
     } else if (value instanceof URLSearchParams) {
       this.output(13 /* URLSearchParams */, value.toString());
     } else if (value instanceof Set) {
-      this.output(17 /* Set */, [...value.values()]);
+      this.output(25 /* Set */, [...value.values()]);
     } else if (value instanceof Map) {
       const combined = [];
       for (const [k, v] of value.entries()) {
         combined.push(k, v);
       }
-      this.output(18 /* Map */, combined);
+      this.output(26 /* Map */, combined);
     } else if (isJSXNode(value)) {
       const out = [
         value.type,
@@ -29727,22 +30064,22 @@ var Serializer = class {
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      this.output(29 /* JSXNode */, out);
+      this.output(37 /* JSXNode */, out);
     } else if (value instanceof Task) {
       const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$state$];
       while (out[out.length - 1] === void 0) {
         out.pop();
       }
-      this.output(20 /* Task */, out);
+      this.output(28 /* Task */, out);
     } else if (isPromise(value)) {
       const forwardRefId = this.resolvePromise(value, (resolved, resolvedValue) => {
-        return new PromiseResult(16 /* Promise */, resolved, resolvedValue);
+        return new PromiseResult(24 /* Promise */, resolved, resolvedValue);
       });
       this.output(2 /* ForwardRef */, forwardRefId);
     } else if (value instanceof PromiseResult) {
-      if (value.$type$ === 26 /* SerializerSignal */) {
+      if (value.$type$ === 34 /* SerializerSignal */) {
         if (value.$qrl$) {
-          this.output(26 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
+          this.output(34 /* SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
         } else if (value.$resolved$) {
           const index = this.$parent$.$index$;
           this.$parent$ = this.$parent$.$parent$;
@@ -29752,7 +30089,7 @@ var Serializer = class {
           throw qError(33 /* serializerSymbolRejectedPromise */);
         }
       } else {
-        this.output(16 /* Promise */, [value.$resolved$, value.$value$]);
+        this.output(24 /* Promise */, [value.$resolved$, value.$value$]);
       }
     } else if (value instanceof Uint8Array) {
       let buf = "";
@@ -29761,7 +30098,7 @@ var Serializer = class {
         buf += String.fromCharCode(value[i]);
       }
       const out = btoa(buf).replace(/=+$/, "");
-      this.output(19 /* Uint8Array */, out);
+      this.output(27 /* Uint8Array */, out);
     } else if (value instanceof SerializationWeakRef) {
       const obj = value.$obj$;
       if (this.getSeenRefOrOutput(obj, this.$parent$.$index$, true)) {
@@ -29898,9 +30235,6 @@ function serializeWrappingFn(serializationContext, value) {
   );
   return [syncFnId, value.$args$];
 }
-function tryGetBackRefs(props) {
-  return Object.prototype.hasOwnProperty.call(props, QBackRefs) ? props[QBackRefs] : void 0;
-}
 var SerializationWeakRef = class {
   constructor($obj$) {
     this.$obj$ = $obj$;
@@ -30127,30 +30461,46 @@ var allocate = (container, typeId, value) => {
       }
       return qrl;
     }
-    case 20 /* Task */:
+    case 28 /* Task */:
       return new Task(-1, -1, null, null, null, null);
     case 6 /* URL */:
       return new URL(value);
     case 7 /* Date */:
       return new Date(value);
+    case 15 /* TemporalDuration */:
+      return Temporal.Duration.from(value);
+    case 16 /* TemporalInstant */:
+      return Temporal.Instant.from(value);
+    case 17 /* TemporalPlainDate */:
+      return Temporal.PlainDate.from(value);
+    case 18 /* TemporalPlainDateTime */:
+      return Temporal.PlainDateTime.from(value);
+    case 19 /* TemporalPlainMonthDay */:
+      return Temporal.PlainMonthDay.from(value);
+    case 20 /* TemporalPlainTime */:
+      return Temporal.PlainTime.from(value);
+    case 21 /* TemporalPlainYearMonth */:
+      return Temporal.PlainYearMonth.from(value);
+    case 22 /* TemporalZonedDateTime */:
+      return Temporal.ZonedDateTime.from(value);
     case 8 /* Regex */:
       const idx = value.lastIndexOf("/");
       return new RegExp(value.slice(1, idx), value.slice(idx + 1));
-    case 15 /* Error */:
+    case 23 /* Error */:
       return new Error();
-    case 21 /* Component */:
+    case 29 /* Component */:
       return componentQrl(null);
-    case 22 /* Signal */:
+    case 30 /* Signal */:
       return new SignalImpl(container, 0);
-    case 23 /* WrappedSignal */:
+    case 31 /* WrappedSignal */:
       return new WrappedSignalImpl(container, null, null, null);
-    case 24 /* ComputedSignal */:
+    case 32 /* ComputedSignal */:
       return new ComputedSignalImpl(container, null);
-    case 25 /* AsyncSignal */:
-      return new AsyncSignalImpl(container, null, void 0, { interval: 0 });
-    case 26 /* SerializerSignal */:
+    case 33 /* AsyncSignal */:
+      return new AsyncSignalImpl(container, null, void 0, {});
+    case 34 /* SerializerSignal */:
       return new SerializerSignalImpl(container, null);
-    case 27 /* Store */: {
+    case 35 /* Store */: {
       const data = value;
       const t = data[0];
       const v = data[1];
@@ -30165,17 +30515,17 @@ var allocate = (container, typeId, value) => {
     }
     case 13 /* URLSearchParams */:
       return new URLSearchParams(value);
-    case 28 /* FormData */:
+    case 36 /* FormData */:
       return new FormData();
-    case 29 /* JSXNode */:
+    case 37 /* JSXNode */:
       return new JSXNodeImpl(null, null, null, null, 0, null);
     case 12 /* BigInt */:
       return BigInt(value);
-    case 17 /* Set */:
+    case 25 /* Set */:
       return /* @__PURE__ */ new Set();
-    case 18 /* Map */:
+    case 26 /* Map */:
       return /* @__PURE__ */ new Map();
-    case 16 /* Promise */:
+    case 24 /* Promise */:
       let resolve;
       let reject;
       const promise = new Promise((res, rej) => {
@@ -30186,13 +30536,13 @@ var allocate = (container, typeId, value) => {
       promise.catch(() => {
       });
       return promise;
-    case 19 /* Uint8Array */:
+    case 27 /* Uint8Array */:
       const encodedLength = value.length;
       const blocks = encodedLength >>> 2;
       const rest = encodedLength & 3;
       const decodedLength = blocks * 3 + (rest ? rest - 1 : 0);
       return new Uint8Array(decodedLength);
-    case 30 /* PropsProxy */:
+    case 38 /* PropsProxy */:
       return createPropsProxy(null);
     case 10 /* VNode */:
       return retrieveVNodeOrDocument(container, value);
@@ -30204,9 +30554,9 @@ var allocate = (container, typeId, value) => {
       } else {
         throw qError(17 /* serializeErrorExpectedVNode */, [typeof vNode]);
       }
-    case 31 /* SubscriptionData */:
+    case 39 /* SubscriptionData */:
       return new SubscriptionData({});
-    case 32 /* EffectSubscription */:
+    case 40 /* EffectSubscription */:
       return new EffectSubscription(null, null, null, null);
     default:
       throw qError(18 /* serializeErrorCannotAllocate */, [typeId]);
@@ -30227,6 +30577,9 @@ var dangerousObjectKeys = /* @__PURE__ */ new Set([
   "then"
 ]);
 var isSafeObjectKV = (key, value) => {
+  if (typeof key === "number") {
+    return true;
+  }
   return typeof key === "string" && key !== "__proto__" && (typeof value !== "function" || !dangerousObjectKeys.has(key));
 };
 var inflate = (container, target, typeId, data) => {
@@ -30253,7 +30606,7 @@ var inflate = (container, target, typeId, data) => {
         target[key] = value;
       }
       break;
-    case 20 /* Task */:
+    case 28 /* Task */:
       const task = target;
       const v = data;
       task.$qrl$ = v[0];
@@ -30262,10 +30615,10 @@ var inflate = (container, target, typeId, data) => {
       task.$el$ = v[3];
       task.$state$ = v[4];
       break;
-    case 21 /* Component */:
+    case 29 /* Component */:
       target[SERIALIZABLE_STATE][0] = data[0];
       break;
-    case 27 /* Store */: {
+    case 35 /* Store */: {
       const store = unwrapStore(target);
       const storeTarget = pendingStoreTargets.get(store);
       if (storeTarget) {
@@ -30279,7 +30632,7 @@ var inflate = (container, target, typeId, data) => {
       restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
       break;
     }
-    case 22 /* Signal */: {
+    case 30 /* Signal */: {
       const signal = target;
       const d2 = data;
       signal.$untrackedValue$ = d2[0];
@@ -30287,7 +30640,7 @@ var inflate = (container, target, typeId, data) => {
       restoreEffectBackRefForEffects(signal.$effects$, signal);
       break;
     }
-    case 23 /* WrappedSignal */: {
+    case 31 /* WrappedSignal */: {
       const signal = target;
       const d2 = data;
       signal.$func$ = container.getSyncFn(d2[0]);
@@ -30301,14 +30654,22 @@ var inflate = (container, target, typeId, data) => {
       restoreEffectBackRefForEffects(signal.$effects$, signal);
       break;
     }
-    case 25 /* AsyncSignal */: {
+    case 33 /* AsyncSignal */: {
       const asyncSignal = target;
       const d2 = data;
       asyncSignal.$computeQrl$ = d2[0];
-      asyncSignal.$effects$ = new Set(d2[1]);
-      asyncSignal.$loadingEffects$ = new Set(d2[2]);
-      asyncSignal.$errorEffects$ = new Set(d2[3]);
-      asyncSignal.$untrackedError$ = d2[4];
+      if (d2[1]) {
+        asyncSignal.$effects$ = new Set(d2[1]);
+      }
+      if (d2[2]) {
+        asyncSignal.$loadingEffects$ = new Set(d2[2]);
+      }
+      if (d2[3]) {
+        asyncSignal.$errorEffects$ = new Set(d2[3]);
+      }
+      if (d2[4]) {
+        asyncSignal.$untrackedError$ = d2[4];
+      }
       asyncSignal.$flags$ = d2[5] ?? 0;
       if (asyncSignal.$flags$ & 64 /* CLIENT_ONLY */) {
         asyncSignal.$untrackedLoading$ = true;
@@ -30320,8 +30681,15 @@ var inflate = (container, target, typeId, data) => {
       if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
         asyncSignal.$flags$ |= 1 /* INVALID */;
       }
-      asyncSignal.interval = d2[7] ?? 0;
-      asyncSignal.$concurrency$ = d2[8] ?? 1;
+      const rawExpires = d2[7] ?? 0;
+      asyncSignal.expires = Math.abs(rawExpires);
+      if (rawExpires < 0) {
+        asyncSignal.$flags$ |= 256 /* NO_POLL */;
+      }
+      if (d2[8] !== void 0 && d2[8] !== 1) {
+        asyncSignal.$concurrency$ = d2[8] ?? 1;
+        asyncSignal.$jobs$ = [];
+      }
       asyncSignal.$timeoutMs$ = d2[9] ?? 0;
       restoreEffectBackRefForEffects(asyncSignal.$effects$, asyncSignal);
       restoreEffectBackRefForEffects(asyncSignal.$loadingEffects$, asyncSignal);
@@ -30329,8 +30697,8 @@ var inflate = (container, target, typeId, data) => {
       break;
     }
     // Inflating a SerializerSignal is the same as inflating a ComputedSignal
-    case 26 /* SerializerSignal */:
-    case 24 /* ComputedSignal */: {
+    case 34 /* SerializerSignal */:
+    case 32 /* ComputedSignal */: {
       const computed = target;
       const d2 = data;
       computed.$computeQrl$ = d2[0];
@@ -30344,13 +30712,13 @@ var inflate = (container, target, typeId, data) => {
       if (hasValue) {
         computed.$untrackedValue$ = d2[2];
       }
-      if (typeId !== 26 /* SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
+      if (typeId !== 34 /* SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
         computed.$flags$ &= ~1 /* INVALID */;
       }
       restoreEffectBackRefForEffects(computed.$effects$, computed);
       break;
     }
-    case 15 /* Error */: {
+    case 23 /* Error */: {
       const d2 = data;
       target.message = d2[0];
       for (let i2 = 1; i2 < d2.length; i2 += 2) {
@@ -30358,7 +30726,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 28 /* FormData */: {
+    case 36 /* FormData */: {
       const formData = target;
       const d2 = data;
       for (let i2 = 0; i2 < d2.length; i2++) {
@@ -30366,7 +30734,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 29 /* JSXNode */: {
+    case 37 /* JSXNode */: {
       const jsx2 = target;
       const [type, key, varProps, constProps, children, toSort] = data;
       jsx2.type = type;
@@ -30377,7 +30745,7 @@ var inflate = (container, target, typeId, data) => {
       jsx2.toSort = !!toSort;
       break;
     }
-    case 17 /* Set */: {
+    case 25 /* Set */: {
       const set = target;
       const d2 = data;
       for (let i2 = 0; i2 < d2.length; i2++) {
@@ -30385,7 +30753,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 18 /* Map */: {
+    case 26 /* Map */: {
       const map = target;
       const d2 = data;
       for (let i2 = 0; i2 < d2.length; i2++) {
@@ -30393,7 +30761,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 16 /* Promise */: {
+    case 24 /* Promise */: {
       const promise = target;
       const [resolved, result2] = data;
       const [resolve, reject] = resolvers.get(promise);
@@ -30404,15 +30772,16 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 19 /* Uint8Array */:
+    case 27 /* Uint8Array */:
       const bytes = target;
       const buf = atob(data);
       let i = 0;
-      for (const s of buf) {
+      for (let j = 0; j < buf.length; j++) {
+        const s = buf[j];
         bytes[i++] = s.charCodeAt(0);
       }
       break;
-    case 30 /* PropsProxy */:
+    case 38 /* PropsProxy */:
       const propsProxy = target;
       const d = data;
       let owner = d[0];
@@ -30425,13 +30794,13 @@ var inflate = (container, target, typeId, data) => {
       propsHandler.$effects$ = d[3];
       restoreEffectBackRefForEffectsMap(propsHandler.$effects$, propsProxy);
       break;
-    case 31 /* SubscriptionData */: {
+    case 39 /* SubscriptionData */: {
       const effectData = target;
       effectData.data.$scopedStyleIdPrefix$ = data[0];
       effectData.data.$isConst$ = data[1];
       break;
     }
-    case 32 /* EffectSubscription */: {
+    case 40 /* EffectSubscription */: {
       const effectSub = target;
       const d2 = data;
       effectSub.consumer = d2[0];
@@ -30558,6 +30927,9 @@ var ElementVNode = class extends VirtualVNode {
 };
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
+var getLazyRef = (chunk, symbol, symbolFn, ref, container) => {
+  return new LazyRef(chunk, symbol, symbolFn, ref, container);
+};
 var LazyRef = class {
   constructor($chunk$, $symbol$, $symbolFn$, $ref$, container) {
     this.$chunk$ = $chunk$;
@@ -30565,18 +30937,14 @@ var LazyRef = class {
     this.$symbolFn$ = $symbolFn$;
     this.$ref$ = $ref$;
     __publicField(this, "$container$");
-    // Don't allocate dev property immediately so that in prod we don't have this property
-    __publicField(this, "dev");
     if ($ref$) {
       this.$setRef$($ref$);
     }
     if (container && !$ref$ && typeof $chunk$ === "string" && !$symbolFn$) {
       this.$container$ = container;
     }
-    if (qDev) {
-      this.dev = null;
-    }
-    if (isBrowser3 && $chunk$) {
+    qDev && initLazyRefDev(this);
+    if (isBrowser4 && $chunk$) {
       preload($chunk$, 0.8);
     }
   }
@@ -30608,7 +30976,7 @@ var LazyRef = class {
       const qFuncs2 = getQFuncs(doc2, hash2);
       return this.$ref$ = qFuncs2[Number(this.$symbol$)];
     }
-    if (isBrowser3 && this.$chunk$) {
+    if (isBrowser4 && this.$chunk$) {
       preload(this.$chunk$, 1);
     }
     const symbol = this.$symbol$;
@@ -30621,6 +30989,9 @@ var LazyRef = class {
     return this.$ref$;
   }
 };
+isBrowser4 && import.meta.hot && setupHmr(LazyRef, (fn) => {
+  getLazyRef = fn;
+});
 var QRL_STATE = /* @__PURE__ */ Symbol("qrl-state");
 var getInstance = (instance) => {
   return instance?.[QRL_STATE] ?? instance;
@@ -30632,18 +31003,14 @@ var QRLClass = class {
     // This is defined or undefined for the lifetime of the QRL, so we set it lazily
     __publicField(this, "$captures$");
     __publicField(this, "$container$");
+    if (qDev) {
+      initQrlClassDev($lazy$, $captures$, this);
+    }
     if ($captures$) {
       this.$captures$ = $captures$;
       if (typeof $captures$ === "string") {
         this.$container$ = container;
       }
-      if (qDev) {
-        if ($captures$ && typeof $captures$ === "object") {
-          for (const item of $captures$) {
-            verifySerializable(item, "Captured variable in the closure can not be serialized");
-          }
-        }
-      }
     }
     if ($lazy$.$ref$ != null && typeof this.$captures$ !== "string" && !isPromise($lazy$.$ref$)) {
       this.resolved = bindCaptures(this, $lazy$.$ref$);
@@ -30755,6 +31122,13 @@ var QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
       return this[QRL_STATE].$lazy$.dev;
     }
   },
+  ...qDev ? {
+    $setDev$: {
+      value(dev) {
+        this[QRL_STATE].$lazy$.dev = dev;
+      }
+    }
+  } : void 0,
   $callFn$: {
     value: qrlCallFn
   },
@@ -30786,7 +31160,9 @@ var setCaptures = (captures) => {
 };
 var deserializeCaptures = (container, captures) => {
   const refs = [];
-  for (const id of captures.split(" ")) {
+  const captureIds = captures.split(" ");
+  for (let i = 0; i < captureIds.length; i++) {
+    const id = captureIds[i];
     refs.push(container.$getObjectById$(id));
   }
   return refs;
@@ -30848,7 +31224,7 @@ var $resolve$ = (qrl, container) => {
   return maybePromise;
 };
 var createQRL = (chunk, symbol, symbolRef, symbolFn, captures, container) => {
-  const lazy = new LazyRef(chunk, symbol, symbolFn, symbolRef, container);
+  const lazy = getLazyRef(chunk, symbol, symbolFn, symbolRef, container);
   const qrl = new QRLClass(lazy, captures, container);
   return makeQrlFn(qrl);
 };
@@ -30894,7 +31270,69 @@ var now = () => {
 // packages/qwik/src/core/shared/jsx/jsx-internal.ts
 var BIND_VALUE = "bind:value";
 var BIND_CHECKED = "bind:checked";
+var PASSIVE = "passive:";
+var PREVENT_DEFAULT = "preventdefault:";
 var _hasOwnProperty3 = Object.prototype.hasOwnProperty;
+var removePassiveMarkers = (props, passiveKeys, preventDefaultKeys, passiveEvents, canMutate = false) => {
+  let mutableProps = props;
+  let copied = canMutate;
+  if (passiveKeys.length > 0) {
+    if (!copied) {
+      mutableProps = { ...mutableProps };
+      copied = true;
+    }
+    for (let i = 0; i < passiveKeys.length; i++) {
+      const k = passiveKeys[i];
+      delete mutableProps[k];
+    }
+  }
+  if (preventDefaultKeys.length > 0) {
+    for (let i = 0; i < preventDefaultKeys.length; i++) {
+      const k = preventDefaultKeys[i];
+      if (passiveEvents.has(normalizeJsxEventName(k.slice(PREVENT_DEFAULT.length)))) {
+        if (!copied) {
+          mutableProps = { ...mutableProps };
+          copied = true;
+        }
+        delete mutableProps[k];
+      }
+    }
+  }
+  return mutableProps;
+};
+var getPassiveEventKey = (key) => {
+  if (key.startsWith("on") && key.endsWith("$")) {
+    return normalizeJsxEventName(key.slice(2, -1));
+  }
+  if (key.startsWith("window:on") && key.endsWith("$")) {
+    return normalizeJsxEventName(key.slice(9, -1));
+  }
+  if (key.startsWith("document:on") && key.endsWith("$")) {
+    return normalizeJsxEventName(key.slice(11, -1));
+  }
+  return null;
+};
+var convertJsxEventProps = (props, eventKeys, keyOrder, passiveEvents, canMutate = false) => {
+  let mutableProps = props;
+  let copied = canMutate;
+  for (let i = 0; i < eventKeys.length; i++) {
+    const k = eventKeys[i];
+    const passiveEventKey = getPassiveEventKey(k);
+    const attr = jsxEventToHtmlAttribute(k, passiveEvents.has(passiveEventKey));
+    if (attr) {
+      if (!copied) {
+        mutableProps = { ...mutableProps };
+        copied = true;
+      }
+      const attrIndex = keyOrder.get(attr);
+      if (attrIndex === void 0 || attrIndex < keyOrder.get(k)) {
+        mutableProps[attr] = mutableProps[k];
+      }
+      delete mutableProps[k];
+    }
+  }
+  return mutableProps;
+};
 var _jsxSorted = (type, varProps, constProps, children, flags, key, dev) => {
   return new JSXNodeImpl(type, varProps, constProps, children, flags, key, false, dev);
 };
@@ -30905,49 +31343,90 @@ var _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
   let bindValueSignal = null;
   let bindCheckedSignal = null;
   if (typeof type === "string") {
+    const passiveEvents = /* @__PURE__ */ new Set();
+    const constEventKeys = [];
+    const varEventKeys = [];
+    const constPassiveKeys = [];
+    const varPassiveKeys = [];
+    const constPreventDefaultKeys = [];
+    const varPreventDefaultKeys = [];
+    const constKeyOrder = /* @__PURE__ */ new Map();
+    const varKeyOrder = /* @__PURE__ */ new Map();
     if (constProps) {
-      const processedKeys = /* @__PURE__ */ new Set();
+      let index = 0;
       for (const k in constProps) {
-        const attr = jsxEventToHtmlAttribute(k);
-        if (attr) {
-          if (!constPropsCopied) {
-            constProps = { ...constProps };
-            constPropsCopied = true;
-          }
-          if (!_hasOwnProperty3.call(constProps, attr) || processedKeys.has(attr)) {
-            constProps[attr] = constProps[k];
-          }
-          delete constProps[k];
+        constKeyOrder.set(k, index++);
+        if (k.startsWith(PASSIVE)) {
+          constPassiveKeys.push(k);
+          passiveEvents.add(normalizeJsxEventName(k.slice(PASSIVE.length)));
+        } else if (k.startsWith(PREVENT_DEFAULT)) {
+          constPreventDefaultKeys.push(k);
+        } else if (getPassiveEventKey(k) !== null) {
+          constEventKeys.push(k);
         } else if (k === BIND_CHECKED) {
           bindCheckedSignal = constProps[k];
         } else if (k === BIND_VALUE) {
           bindValueSignal = constProps[k];
         }
-        processedKeys.add(k);
       }
     }
     if (varProps) {
-      const processedKeys = /* @__PURE__ */ new Set();
+      let index = 0;
       for (const k in varProps) {
-        const attr = jsxEventToHtmlAttribute(k);
-        if (attr) {
-          if (!varPropsCopied) {
-            varProps = { ...varProps };
-            varPropsCopied = true;
-          }
-          if (!_hasOwnProperty3.call(varProps, attr) || processedKeys.has(attr)) {
-            varProps[attr] = varProps[k];
-          }
-          delete varProps[k];
-          toSort = true;
+        varKeyOrder.set(k, index++);
+        if (k.startsWith(PASSIVE)) {
+          varPassiveKeys.push(k);
+          passiveEvents.add(normalizeJsxEventName(k.slice(PASSIVE.length)));
+        } else if (k.startsWith(PREVENT_DEFAULT)) {
+          varPreventDefaultKeys.push(k);
+        } else if (getPassiveEventKey(k) !== null) {
+          varEventKeys.push(k);
         } else if (k === BIND_CHECKED) {
           bindCheckedSignal = varProps[k];
         } else if (k === BIND_VALUE) {
           bindValueSignal = varProps[k];
         }
-        processedKeys.add(k);
       }
     }
+    if (constProps) {
+      const originalConstProps = constProps;
+      constProps = removePassiveMarkers(
+        constProps,
+        constPassiveKeys,
+        constPreventDefaultKeys,
+        passiveEvents,
+        constPropsCopied
+      );
+      constPropsCopied = constPropsCopied || constProps !== originalConstProps;
+      constProps = convertJsxEventProps(
+        constProps,
+        constEventKeys,
+        constKeyOrder,
+        passiveEvents,
+        constPropsCopied
+      );
+      constPropsCopied = constPropsCopied || constProps !== originalConstProps;
+    }
+    if (varProps) {
+      const originalVarProps = varProps;
+      varProps = removePassiveMarkers(
+        varProps,
+        varPassiveKeys,
+        varPreventDefaultKeys,
+        passiveEvents,
+        varPropsCopied
+      );
+      varPropsCopied = varPropsCopied || varProps !== originalVarProps;
+      varProps = convertJsxEventProps(
+        varProps,
+        varEventKeys,
+        varKeyOrder,
+        passiveEvents,
+        varPropsCopied
+      );
+      varPropsCopied = varPropsCopied || varProps !== originalVarProps;
+      toSort = toSort || varEventKeys.length > 0;
+    }
     if (bindCheckedSignal || bindValueSignal) {
       if (!varPropsCopied) {
         varProps = { ...varProps };
@@ -31071,6 +31550,7 @@ var Slot = (props) => {
 };
 
 // packages/qwik/src/core/shared/serdes/constants.ts
+var explicitUndefined = /* @__PURE__ */ Symbol("undefined");
 var _constants = [
   void 0,
   null,
@@ -31127,6 +31607,14 @@ var _typeIdNames = [
   "BigInt",
   "URLSearchParams",
   "ForwardRefs",
+  "TemporalDuration",
+  "TemporalInstant",
+  "TemporalPlainDate",
+  "TemporalPlainDateTime",
+  "TemporalPlainMonthDay",
+  "TemporalPlainTime",
+  "TemporalPlainYearMonth",
+  "TemporalZonedDateTime",
   "Error",
   "Promise",
   "Set",
@@ -31148,7 +31636,7 @@ var _typeIdNames = [
 ];
 
 // packages/qwik/src/core/shared/serdes/deser-proxy.ts
-var needsInflation = (typeId) => typeId >= 15 /* Error */ || typeId === 4 /* Array */ || typeId === 5 /* Object */;
+var needsInflation = (typeId) => typeId >= 23 /* Error */ || typeId === 4 /* Array */ || typeId === 5 /* Object */;
 var deserializedProxyMap = /* @__PURE__ */ new WeakMap();
 var isDeserializerProxy = (value) => {
   return isObject(value) && SERIALIZER_PROXY_UNWRAP in value;
@@ -31247,15 +31735,19 @@ function processVNodeData(document2) {
   const hasAttribute = prototype.hasAttribute;
   const getNodeType = getter(prototype, "nodeType");
   const attachVnodeDataAndRefs = (element) => {
-    Array.from(element.querySelectorAll('script[type="qwik/vnode"]')).forEach((script2) => {
+    const scripts = element.querySelectorAll('script[type="qwik/vnode"]');
+    for (let i = 0; i < scripts.length; i++) {
+      const script2 = scripts[i];
       const qContainerElement = script2.closest("[q\\:container]");
       qContainerElement.qVnodeData = script2.textContent;
       qContainerElement.qVNodeRefs = /* @__PURE__ */ new Map();
-    });
-    element.querySelectorAll("[q\\:shadowroot]").forEach((parent) => {
+    }
+    const shadowRoots = element.querySelectorAll("[q\\:shadowroot]");
+    for (let i = 0; i < shadowRoots.length; i++) {
+      const parent = shadowRoots[i];
       const shadowRoot = parent.shadowRoot;
       shadowRoot && attachVnodeDataAndRefs(shadowRoot);
-    });
+    }
   };
   attachVnodeDataAndRefs(document2);
   let NodeType;
@@ -31582,22 +32074,8 @@ var DomContainer = class extends _SharedContainer {
   handleError(err, host) {
     if (qDev && host) {
       if (typeof document !== "undefined") {
-        const createErrorWrapper = () => {
-          const vHost = host;
-          const vHostParent = vHost.parent;
-          const vHostNextSibling = vHost.nextSibling;
-          const journal = [];
-          const vErrorDiv = vnode_createErrorDiv(journal, document, vHost, err);
-          const insertHost = vnode_isElementVNode(vHost) ? vHostParent || vHost : vHost;
-          const insertBefore = insertHost === vHost ? null : vHostNextSibling;
-          vnode_insertElementBefore(
-            journal,
-            insertHost,
-            vErrorDiv,
-            insertBefore
-          );
-        };
-        this.$renderPromise$ ? this.$renderPromise$.then(createErrorWrapper) : createErrorWrapper();
+        setErrorPayload(host, err);
+        markVNodeDirty(this, host, 256 /* ERROR_WRAP */);
       }
       if (err && err instanceof Error) {
         if (!("hostElement" in err)) {
@@ -31673,7 +32151,9 @@ var DomContainer = class extends _SharedContainer {
       vNode.flags |= 16 /* Resolved */;
       const props = vNode.props;
       if (props) {
-        for (const prop of Object.keys(props)) {
+        const propKeys = Object.keys(props);
+        for (let i = 0; i < propKeys.length; i++) {
+          const prop = propKeys[i];
           if (isSlotProp(prop)) {
             const value = props[prop];
             if (typeof value == "string") {
@@ -31699,9 +32179,11 @@ var DomContainer = class extends _SharedContainer {
     }
     if (this.$styleIds$ == null) {
       this.$styleIds$ = /* @__PURE__ */ new Set();
-      this.element.querySelectorAll(QStyleSelector).forEach((style) => {
+      const styleElements = this.document.querySelectorAll(QStyleSelector);
+      for (let i = 0; i < styleElements.length; i++) {
+        const style = styleElements[i];
         this.$styleIds$.add(style.getAttribute(QStyle));
-      });
+      }
     }
     if (!this.$styleIds$.has(styleId)) {
       this.$styleIds$.add(styleId);
@@ -32053,6 +32535,7 @@ function getEffects2(target, prop, storeEffects) {
 // packages/qwik/src/core/shared/serdes/can-serialize.ts
 var getKeyVal = (value, key) => value[key];
 var canSerialize = (value, seen = /* @__PURE__ */ new WeakSet()) => {
+  const hasTemporal = typeof Temporal !== "undefined";
   if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
     return true;
   } else if (typeof value === "object") {
@@ -32073,6 +32556,9 @@ var canSerialize = (value, seen = /* @__PURE__ */ new WeakSet()) => {
       return true;
     } else if (proto == Array.prototype) {
       for (let i = 0; i < value.length; i++) {
+        if (!(i in value)) {
+          return false;
+        }
         if (!canSerialize(value[i], seen)) {
           return false;
         }
@@ -32086,12 +32572,30 @@ var canSerialize = (value, seen = /* @__PURE__ */ new WeakSet()) => {
       return true;
     } else if (isJSXNode(value)) {
       return true;
+    } else if (isSerializerObj(value)) {
+      return true;
     } else if (value instanceof Error) {
       return true;
     } else if (value instanceof URL) {
       return true;
     } else if (value instanceof Date) {
       return true;
+    } else if (hasTemporal && value instanceof Temporal.Duration) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.Instant) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.PlainDate) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.PlainDateTime) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.PlainMonthDay) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.PlainTime) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.PlainYearMonth) {
+      return true;
+    } else if (hasTemporal && value instanceof Temporal.ZonedDateTime) {
+      return true;
     } else if (value instanceof RegExp) {
       return true;
     } else if (value instanceof URLSearchParams) {
@@ -32292,16 +32796,23 @@ var _verifySerializable = (value, seen, ctx, preMessage) => {
         }
         if (isArray(unwrapped)) {
           let expectIndex = 0;
-          unwrapped.forEach((v, i) => {
+          for (let i = 0; i < unwrapped.length; i++) {
+            if (!(i in unwrapped)) {
+              throw qError(3 /* verifySerializable */, [unwrapped]);
+            }
+            const v = unwrapped[i];
             if (i !== expectIndex) {
               throw qError(3 /* verifySerializable */, [unwrapped]);
             }
             _verifySerializable(v, seen, ctx + "[" + i + "]");
             expectIndex = i + 1;
-          });
+          }
           return value;
         }
-        if (unwrapped.__brand) {
+        if (unwrapped instanceof VNode) {
+          return value;
+        }
+        if (unwrapped.__brand || unwrapped.__brand__) {
           return value;
         }
         if (isSerializableObject(unwrapped)) {
@@ -32387,7 +32898,7 @@ var addQrlToSerializationCtx = (effectSubscriber, container) => {
   }
 };
 var scheduleEffects = (container, signal, effects) => {
-  const isBrowser6 = import.meta.env.TEST ? !isServerPlatform() : !isServer12;
+  const isBrowser8 = import.meta.env.TEST ? !isServerPlatform() : !isServer12;
   if (effects) {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
@@ -32401,7 +32912,7 @@ var scheduleEffects = (container, signal, effects) => {
       } else if (property === ":" /* COMPONENT */) {
         markVNodeDirty(container, consumer, 4 /* COMPONENT */);
       } else if (property === "." /* VNODE */) {
-        if (isBrowser6) {
+        if (isBrowser8) {
           setNodeDiffPayload(consumer, signal);
           markVNodeDirty(container, consumer, 2 /* NODE_DIFF */);
         }
@@ -32414,7 +32925,7 @@ var scheduleEffects = (container, signal, effects) => {
             scopedStyleIdPrefix: data.$scopedStyleIdPrefix$,
             value: signal
           };
-          if (isBrowser6) {
+          if (isBrowser8) {
             setNodePropData(consumer, property, payload);
           } else {
             const node = consumer;
@@ -32510,16 +33021,19 @@ var jsxToString = (value) => {
     }
     let str = "<" + value.type;
     if (value.props) {
-      for (const [key, val] of Object.entries(value.props)) {
+      const propsEntries = Object.entries(value.props);
+      for (let i = 0; i < propsEntries.length; i++) {
+        const [key, val] = propsEntries[i];
         str += " " + key + "=" + qwikDebugToString(val);
       }
       const children = value.children;
       if (children != null) {
         str += ">";
         if (Array.isArray(children)) {
-          children.forEach((child) => {
+          for (let i = 0; i < children.length; i++) {
+            const child = children[i];
             str += jsxToString(child);
-          });
+          }
         } else {
           str += jsxToString(children);
         }
@@ -33780,12 +34294,14 @@ function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings
         attrs.push(` dirty:${vnode.dirty}`);
       }
       if (container) {
-        vnode_getAttrKeys(container, vnode).forEach((key) => {
+        const attrKeys = vnode_getAttrKeys(container, vnode);
+        for (let i = 0; i < attrKeys.length; i++) {
+          const key = attrKeys[i];
           if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
             const value = vnode_getProp(vnode, key, null);
             attrs.push(" " + key + "=" + qwikDebugToString(value));
           }
-        });
+        }
       }
       const name = (colorize ? NAME_COL_PREFIX : "") + (VirtualTypeName[vnode_getProp(vnode, DEBUG_TYPE, null) || "V" /* Virtual */] || VirtualTypeName["V" /* Virtual */]) + (colorize ? NAME_COL_SUFFIX : "");
       strings.push("<" + name + attrs.join("") + ">");
@@ -33807,7 +34323,8 @@ function vnode_toString(depth = 20, offset = "", materialize2 = false, siblings
         attrs.push(` dirtyChildren[${vnode.dirtyChildren.length}]`);
       }
       const keys = container ? vnode_getAttrKeys(container, vnode) : [];
-      for (const key of keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
         const value = vnode_getProp(vnode, key, null);
         attrs.push(" " + key + "=" + qwikDebugToString(value));
       }
@@ -34140,9 +34657,12 @@ var MockShadowRoot = class extends import_domino.default.impl.DocumentFragment {
     this.ownerDocument = host.ownerDocument;
   }
   append(...nodes) {
-    for (const node of nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
       if (node.nodeType === 11) {
-        for (const child of Array.from(node.childNodes)) {
+        const childNodes = Array.from(node.childNodes);
+        for (let j = 0; j < childNodes.length; j++) {
+          const child = childNodes[j];
           this.appendChild(child);
         }
       } else {
@@ -34665,9 +35185,10 @@ function diffJsxVNode(received, expected, path = [], container, isSsr) {
     receivedElement && propsAdd(allProps, constPropsFromElement(receivedElement));
     path.push(tagToString(expected.type));
     allProps.sort();
-    allProps.forEach((prop) => {
+    for (let i = 0; i < allProps.length; i++) {
+      const prop = allProps[i];
       if (isJsxPropertyAnEventName(prop) || isHtmlAttributeAnEventName(prop)) {
-        return;
+        continue;
       }
       const propLowerCased = prop.toLowerCase();
       let convertNullToUndefined = false;
@@ -34691,7 +35212,7 @@ function diffJsxVNode(received, expected, path = [], container, isSsr) {
         diffs.push("  EXPECTED: " + JSON.stringify(expectedValue));
         diffs.push("  RECEIVED: " + JSON.stringify(receivedValue));
       }
-    });
+    }
     diffJsxVNodeChildren(received, expected, path, container, isSsr, diffs);
   } else if (isSsr && isSkippableNode(expected)) {
     diffJsxVNodeChildren(received, expected, path, container, isSsr, diffs);
@@ -34745,7 +35266,8 @@ function getFilteredJSXChildren(children, isSsr, data) {
     }
   };
   function processChildren(children2) {
-    for (const child of children2) {
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
       if (typeof child === "string" || typeof child === "number") {
         if (child !== "") {
           data.mergedText = typeof data.mergedText === "string" ? data.mergedText + child : String(child);
@@ -34805,9 +35327,11 @@ function jsxToHTML(jsx2, pad2 = "") {
   const html = [];
   if (jsx2.type) {
     html.push(pad2, "<", tagToString(jsx2.type), ">\n");
-    getJSXChildren(jsx2).forEach((jsx3) => {
+    const children = getJSXChildren(jsx2);
+    for (let i = 0; i < children.length; i++) {
+      const jsx3 = children[i];
       html.push(jsxToHTML(jsx3, pad2 + "  "));
-    });
+    }
     html.push(pad2, "</", tagToString(jsx2.type), ">\n");
   } else {
     html.push(pad2, JSON.stringify(jsx2), "\n");
@@ -34839,7 +35363,8 @@ function walkJSX(jsx2, apply) {
   if (_isJSXNode(jsx2)) {
     apply.enter(jsx2);
     if (Array.isArray(jsx2.children)) {
-      for (const child of jsx2.children) {
+      for (let i = 0; i < jsx2.children.length; i++) {
+        const child = jsx2.children[i];
         processChild(child);
       }
     } else if (jsx2.children) {
@@ -34935,11 +35460,12 @@ function constPropsFromElement(element) {
   return props;
 }
 function propsAdd(existing, incoming) {
-  for (const prop of incoming) {
+  for (let i = 0; i < incoming.length; i++) {
+    const prop = incoming[i];
     if (prop !== "children") {
       let found = false;
-      for (let i = 0; i < existing.length; i++) {
-        if (existing[i].toLowerCase() === prop.toLowerCase()) {
+      for (let j = 0; j < existing.length; j++) {
+        if (existing[j].toLowerCase() === prop.toLowerCase()) {
           found = true;
           break;
         }
@@ -34990,7 +35516,9 @@ var ElementFixture = class {
       this.parent.innerHTML = options.html;
       this.host = this.parent.firstElementChild;
       assertDefined(this.host, "host element must be defined");
-      this.host.querySelectorAll('script[q\\:func="qwik/json"]').forEach((script2) => {
+      const scripts = this.host.querySelectorAll('script[q\\:func="qwik/json"]');
+      for (let i = 0; i < scripts.length; i++) {
+        const script2 = scripts[i];
         const code2 = script2.textContent;
         if (code2?.match(Q_FUNCS_PREFIX)) {
           const equal = code2.indexOf("=");
@@ -34999,7 +35527,7 @@ var ElementFixture = class {
           const hash2 = container.getAttribute(QInstanceAttr);
           document[QFuncsPrefix + hash2] = qFuncs2;
         }
-      });
+      }
       this.child = null;
     } else {
       this.host = this.document.createElement(options.tagName || "host");
@@ -35011,28 +35539,15 @@ var ElementFixture = class {
 };
 async function trigger(root, queryOrElement, eventName, eventPayload = {}, options) {
   const waitForIdle = options?.waitForIdle ?? true;
-  let scope;
-  let kebabName;
-  let scopedKebabName;
-  if (eventName.charAt(1) === ":") {
-    scopedKebabName = eventName;
-    scope = eventName.charAt(0);
-    kebabName = eventName.substring(2);
-    if (kebabName === "DOMContentLoaded") {
-      kebabName = "-d-o-m-content-loaded";
-      scopedKebabName = scope + ":" + kebabName;
-    }
-  } else {
-    scope = "e";
-    kebabName = fromCamelToKebabCase(eventName);
-    scopedKebabName = "e:" + kebabName;
-  }
-  if (scope !== "e") {
-    queryOrElement = `[q-${scope}\\:${kebabName}]`;
+  const { rootScope, kebabName, selectors, scopedEventNames } = parseTriggerEvent(eventName);
+  let event = null;
+  if (selectors) {
+    queryOrElement = selectors;
   }
   const elements = typeof queryOrElement === "string" ? Array.from(root.querySelectorAll(queryOrElement)) : [queryOrElement];
   let container = null;
-  for (const element of elements) {
+  for (let i = 0; i < elements.length; i++) {
+    const element = elements[i];
     if (!element) {
       continue;
     }
@@ -35040,29 +35555,114 @@ async function trigger(root, queryOrElement, eventName, eventPayload = {}, optio
       container = getDomContainer2(element);
     }
     const { bubbles = true, cancelable = true, ...rest } = eventPayload ?? {};
-    const event = new Event(eventName, {
+    event = new Event(eventName, {
       bubbles,
       cancelable
     });
     Object.assign(event, rest);
-    await dispatch(element, event, scopedKebabName, kebabName);
+    for (let i2 = 0; i2 < scopedEventNames.length; i2++) {
+      const { scope, scopedKebabName } = scopedEventNames[i2];
+      await dispatch(element, event, scopedKebabName, kebabName, scope === rootScope);
+    }
   }
   if (waitForIdle && container) {
     await waitForDrain(container);
   }
+  return event;
 }
-var PREVENT_DEFAULT = "preventdefault:";
+var parseTriggerEvent = (eventName) => {
+  let scope = "e";
+  let kebabName = eventName;
+  const separatorIndex = eventName.indexOf(":");
+  if (separatorIndex !== -1) {
+    scope = eventName.slice(0, separatorIndex);
+    kebabName = eventName.substring(separatorIndex + 1);
+    if (kebabName === "DOMContentLoaded") {
+      kebabName = "-d-o-m-content-loaded";
+    }
+  } else {
+    kebabName = fromCamelToKebabCase(eventName);
+  }
+  const rootScope = scope.charAt(0);
+  const scopes = scope.length === 2 ? [scope] : [scope, `${scope}p`];
+  return {
+    rootScope,
+    kebabName,
+    selectors: rootScope === "e" ? void 0 : scopes.map((scope2) => `[q-${scope2}\\:${kebabName}]`).join(", "),
+    scopedEventNames: scopes.map((scope2) => ({
+      scope: scope2,
+      scopedKebabName: `${scope2}:${kebabName}`
+    }))
+  };
+};
+var PREVENT_DEFAULT2 = "preventdefault:";
 var STOP_PROPAGATION = "stoppropagation:";
+var CAPTURE = "capture:";
 var Q_FUNCS_PREFIX = /document.qdata\["qFuncs_(.+)"\]=/;
 var QContainerSelector2 = "[q\\:container]";
-var dispatch = async (element, event, scopedKebabName, kebabName) => {
-  const preventAttributeName = PREVENT_DEFAULT + kebabName;
+var isElementNode = (node) => !!node && node.nodeType === 1;
+var isPromise2 = (promise) => promise && typeof promise.then === "function";
+var queuedTasks;
+var runTasks = async (tasks) => {
+  for (let i = 0; i < tasks.length; i++) {
+    await tasks[i]();
+  }
+};
+var queueTasks = (tasks) => {
+  const run = () => runTasks(tasks);
+  queuedTasks = queuedTasks ? queuedTasks.then(run, run) : run();
+  return queuedTasks;
+};
+var dispatch = async (element, event, scopedKebabName, kebabName, allowPreventDefault = true) => {
+  const captureAttributeName = CAPTURE + kebabName;
+  const elements = [];
+  const captureHandlers = [];
+  const tasks = [];
+  let current = element;
+  while (current) {
+    if (isElementNode(current)) {
+      elements.push(current);
+      captureHandlers.push(
+        current.hasAttribute(captureAttributeName) && (!!current.getAttribute("q-" + scopedKebabName) || "_qDispatch" in current && !!current._qDispatch?.[scopedKebabName])
+      );
+      current = current.parentElement;
+    } else {
+      current = current.parentElement;
+    }
+  }
+  for (let i = elements.length - 1; i >= 0; i--) {
+    if (captureHandlers[i]) {
+      dispatchOnElement(elements[i], event, scopedKebabName, tasks, kebabName, allowPreventDefault);
+      const continuePropagation = !event.cancelBubble;
+      if (!continuePropagation || event.cancelBubble) {
+        await queueTasks(tasks);
+        return;
+      }
+    }
+  }
+  for (let i = 0; i < elements.length; i++) {
+    if (!captureHandlers[i]) {
+      dispatchOnElement(elements[i], event, scopedKebabName, tasks, kebabName, allowPreventDefault);
+      const doBubble = event.bubbles && !event.cancelBubble;
+      if (!doBubble || event.cancelBubble) {
+        await queueTasks(tasks);
+        return;
+      }
+    }
+  }
+  await queueTasks(tasks);
+};
+var dispatchOnElement = (element, event, scopedKebabName, tasks, kebabName, allowPreventDefault = true) => {
+  const preventAttributeName = PREVENT_DEFAULT2 + kebabName;
   const stopPropagationName = STOP_PROPAGATION + kebabName;
-  while (element) {
+  if (element) {
+    let defer = false;
+    const handlers = "_qDispatch" in element ? element._qDispatch?.[scopedKebabName] : void 0;
+    const attrValue = element.getAttribute("q-" + scopedKebabName);
     if (kebabName) {
       const preventDefault = element.hasAttribute(preventAttributeName);
       const stopPropagation = element.hasAttribute(stopPropagationName);
-      if (preventDefault) {
+      if (allowPreventDefault && preventDefault) {
         event.preventDefault();
       }
       if (stopPropagation) {
@@ -35070,44 +35670,91 @@ var dispatch = async (element, event, scopedKebabName, kebabName) => {
       }
     }
     if ("_qDispatch" in element) {
-      const handlers = element._qDispatch?.[scopedKebabName];
       if (handlers) {
         if (typeof handlers === "function") {
-          await handlers(event, element);
+          const run = () => handlers(event, element);
+          if (defer) {
+            tasks.push(async () => {
+              const result2 = run();
+              if (isPromise2(result2)) {
+                await result2;
+              }
+            });
+          } else {
+            const result2 = run();
+            if (isPromise2(result2)) {
+              defer = true;
+              tasks.push(() => result2);
+            }
+          }
         } else if (handlers.length) {
-          for (const handler of handlers) {
+          for (let i = 0; i < handlers.length; i++) {
+            const handler = handlers[i];
             if (handler) {
-              await handler(event, element);
+              const run = () => handler(event, element);
+              if (defer) {
+                tasks.push(async () => {
+                  const result2 = run();
+                  if (isPromise2(result2)) {
+                    await result2;
+                  }
+                });
+              } else {
+                const result2 = run();
+                if (isPromise2(result2)) {
+                  defer = true;
+                  tasks.push(() => result2);
+                }
+              }
             }
           }
         }
+        return;
       }
-    } else if (element.hasAttribute("q-" + scopedKebabName)) {
-      const qrls = element.getAttribute("q-" + scopedKebabName);
+    }
+    if (attrValue) {
+      const qrls = attrValue;
       try {
-        for (const qrl of qrls.split("|")) {
+        const qrlsArray = qrls.split("|");
+        for (let i = 0; i < qrlsArray.length; i++) {
+          const qrl = qrlsArray[i];
           const [chunk, symbol, captures] = qrl.split("#");
-          let fn;
-          if (chunk) {
-            fn = globalThis.__qrl_back_channel__?.get(symbol);
-            if (typeof fn !== "function") {
-              throw new Error(`QRL function not found in back channel for ${qrl}`);
+          const run = () => {
+            let fn;
+            if (chunk) {
+              fn = globalThis.__qrl_back_channel__?.get(symbol);
+              if (typeof fn !== "function") {
+                throw new Error(`QRL function not found in back channel for ${qrl}`);
+              }
+            } else {
+              const container = getDomContainer2(element);
+              const sync = container.parseQRL(qrl);
+              sync.resolve();
+              fn = sync.resolved;
             }
+            return fn.apply(captures, [event, element]);
+          };
+          if (chunk || defer) {
+            defer = true;
+            tasks.push(async () => {
+              const result2 = run();
+              if (isPromise2(result2)) {
+                await result2;
+              }
+            });
           } else {
-            const container = getDomContainer2(element);
-            const sync = container.parseQRL(qrl);
-            sync.resolve();
-            fn = sync.resolved;
+            const result2 = run();
+            if (isPromise2(result2)) {
+              defer = true;
+              tasks.push(() => result2);
+            }
           }
-          await fn.apply(captures, [event, element]);
         }
       } catch (error) {
         console.error("!!! qrl error", qrls, error);
         throw error;
       }
-      return;
     }
-    element = event.bubbles && !event.cancelBubble ? element.parentElement : null;
   }
 };
 
@@ -35180,7 +35827,8 @@ function toPath(url) {
   }
   const path = fileURLToPath(String(normalizedUrl));
   const importPaths = [path, ...testExts.map((ext) => path + ext)];
-  for (const importPath of importPaths) {
+  for (let i = 0; i < importPaths.length; i++) {
+    const importPath = importPaths[i];
     if (existsSync(importPath)) {
       return importPath;
     }
@@ -35234,19 +35882,24 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { expect as expect2 } from "vitest";
 
 // packages/qwik/src/core/preloader/queue.ts
-import { isBrowser as isBrowser5 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser7 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/preloader/bundle-graph.ts
+import { isServer as isServer14 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/preloader/constants.ts
-import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
-var doc = isBrowser4 ? document : void 0;
+import { isServer as isServer13 } from "@qwik.dev/core/build";
+var isBrowser5 = import.meta.env.TEST ? !isServerPlatform() : !isServer13;
+var doc = isBrowser5 ? document : void 0;
 var config = {
   $DEBUG$: false,
   $maxIdlePreloads$: 25,
   $invPreloadProbability$: 0.65
 };
-var rel = isBrowser4 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
-var loadStart = Date.now();
+var rel = isBrowser5 && doc.createElement("link").relList?.supports?.("modulepreload") ? "modulePreload" : "preload";
+var loadStart = performance.now();
 var isJSRegex = /\.[mc]?js$/;
+var yieldInterval = 1e3 / 60;
 
 // packages/qwik/src/core/preloader/types.ts
 var BundleImportState_None = 0;
@@ -35258,13 +35911,14 @@ var BundleImportState_Loaded = 4;
 // packages/qwik/src/core/preloader/bundle-graph.ts
 var base;
 var graph;
+var isBrowser6 = import.meta.env.TEST ? !isServerPlatform() : !isServer14;
 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(),
+    $createdTs$: performance.now(),
     $waitedMs$: 0,
     $loadedMs$: 0
   };
@@ -35333,9 +35987,16 @@ var shouldResetFactor;
 var queueDirty;
 var preloadCount = 0;
 var queue = [];
+var nextTriggerMacroTask = createMacroTask(trigger2);
+var nextAdjustmentMacroTask = createMacroTask(processPendingAdjustments);
+var isTriggerScheduled = false;
+var isAdjustmentScheduled = false;
+var isProcessingAdjustments = false;
+var shouldYieldInBrowser = import.meta.env.TEST ? !isServerPlatform() : isBrowser7;
+var adjustmentStack = [];
 var log7 = (...args) => {
   console.log(
-    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
+    `Preloader ${performance.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
     ...args
   );
 };
@@ -35345,6 +36006,10 @@ var resetQueue = () => {
   shouldResetFactor = true;
   preloadCount = 0;
   queue.length = 0;
+  adjustmentStack.length = 0;
+  isTriggerScheduled = false;
+  isAdjustmentScheduled = false;
+  isProcessingAdjustments = false;
 };
 var sortQueue = () => {
   if (queueDirty) {
@@ -35356,7 +36021,8 @@ var getQueue = () => {
   sortQueue();
   let probability = 0.4;
   const result2 = [];
-  for (const b of queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const b = queue[i];
     const nextProbability = Math.round((1 - b.$inverseProbability$) * 10);
     if (nextProbability !== probability) {
       probability = nextProbability;
@@ -35366,11 +36032,14 @@ var getQueue = () => {
   }
   return result2;
 };
-var trigger2 = () => {
+function trigger2() {
+  isTriggerScheduled = false;
   if (!queue.length) {
     return;
   }
   sortQueue();
+  const deadline = performance.now() + yieldInterval;
+  let shouldYield = false;
   while (queue.length) {
     const bundle = queue[0];
     const inverseProbability = bundle.$inverseProbability$;
@@ -35382,10 +36051,18 @@ var trigger2 = () => {
     if (probability >= 0.99 || preloadCount < allowedPreloads) {
       queue.shift();
       preloadOne(bundle);
+      if (performance.now() >= deadline) {
+        shouldYield = true;
+        break;
+      }
     } else {
       break;
     }
   }
+  if (shouldYield && queue.length && !isTriggerScheduled) {
+    isTriggerScheduled = true;
+    nextTriggerMacroTask();
+  }
   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);
@@ -35394,13 +36071,112 @@ var trigger2 = () => {
       `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
     );
   }
+}
+var enqueueAdjustment = (bundle, inverseProbability, context, seen) => {
+  adjustmentStack.unshift({
+    $bundle$: bundle,
+    $inverseProbability$: inverseProbability,
+    $seen$: seen,
+    $context$: context
+  });
 };
+var processAdjustmentFrame = () => {
+  const frame = adjustmentStack[adjustmentStack.length - 1];
+  const bundle = frame.$bundle$;
+  if (frame.$deps$) {
+    const index = frame.$index$;
+    if (index >= frame.$deps$.length) {
+      adjustmentStack.pop();
+      return false;
+    }
+    const dep = frame.$deps$[index];
+    frame.$index$ = index + 1;
+    const depBundle = getBundle(dep.$name$);
+    if (depBundle.$inverseProbability$ === 0) {
+      return true;
+    }
+    const probability = 1 - bundle.$inverseProbability$;
+    let newInverseProbability;
+    if (probability === 1 || probability >= 0.99 && frame.$context$.$depsCount$ < 100) {
+      frame.$context$.$depsCount$++;
+      newInverseProbability = Math.min(0.01, 1 - dep.$importProbability$);
+    } else {
+      const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
+      const prevAdjust = dep.$factor$;
+      const factor = newInverseImportProbability / prevAdjust;
+      newInverseProbability = Math.max(0.02, depBundle.$inverseProbability$ * factor);
+      dep.$factor$ = factor;
+    }
+    adjustmentStack.push({
+      $bundle$: depBundle,
+      $inverseProbability$: newInverseProbability,
+      $seen$: frame.$seen$,
+      $context$: frame.$context$
+    });
+    return true;
+  }
+  if (frame.$seen$?.has(bundle)) {
+    adjustmentStack.pop();
+    return false;
+  }
+  const previousInverseProbability = bundle.$inverseProbability$;
+  bundle.$inverseProbability$ = frame.$inverseProbability$;
+  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
+    adjustmentStack.pop();
+    return false;
+  }
+  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$?.length) {
+    const seen = frame.$seen$ || /* @__PURE__ */ new Set();
+    seen.add(bundle);
+    frame.$seen$ = seen;
+    frame.$deps$ = bundle.$deps$;
+    frame.$index$ = 0;
+    return false;
+  }
+  adjustmentStack.pop();
+  return false;
+};
+function processPendingAdjustments() {
+  if (isProcessingAdjustments || !adjustmentStack.length) {
+    return;
+  }
+  isAdjustmentScheduled = false;
+  isProcessingAdjustments = true;
+  const deadline = shouldYieldInBrowser ? performance.now() + yieldInterval : 0;
+  let processed = false;
+  while (adjustmentStack.length) {
+    processed = true;
+    const checkDeadline = processAdjustmentFrame();
+    if (shouldYieldInBrowser && checkDeadline && performance.now() >= deadline) {
+      if (!isAdjustmentScheduled) {
+        isAdjustmentScheduled = true;
+        nextAdjustmentMacroTask();
+      }
+      break;
+    }
+  }
+  isProcessingAdjustments = false;
+  if (processed && shouldYieldInBrowser) {
+    nextTriggerMacroTask();
+  }
+}
 var preloadOne = (bundle) => {
   if (bundle.$state$ >= BundleImportState_Preload) {
     return;
   }
   preloadCount++;
-  const start = Date.now();
+  const start = performance.now();
   bundle.$waitedMs$ = start - bundle.$createdTs$;
   bundle.$state$ = BundleImportState_Preload;
   config.$DEBUG$ && log7(
@@ -35413,89 +36189,58 @@ var preloadOne = (bundle) => {
   link.as = "script";
   link.onload = link.onerror = () => {
     preloadCount--;
-    const end = Date.now();
+    const end = performance.now();
     bundle.$loadedMs$ = end - start;
     bundle.$state$ = BundleImportState_Loaded;
     config.$DEBUG$ && log7(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
     link.remove();
-    trigger2();
+    nextTriggerMacroTask();
   };
   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);
-    }
+  enqueueAdjustment(bundle, newInverseProbability, { $depsCount$: 0 }, seen);
+  if (shouldYieldInBrowser) {
+    nextAdjustmentMacroTask();
+  } else {
+    processPendingAdjustments();
   }
 };
-var handleBundle = (name, inverseProbability) => {
+var handleBundle = (name, inverseProbability, context) => {
   const bundle = getBundle(name);
   if (bundle && bundle.$inverseProbability$ > inverseProbability) {
-    adjustProbabilities(bundle, inverseProbability);
+    if (context) {
+      enqueueAdjustment(bundle, inverseProbability, context);
+    } else {
+      adjustProbabilities(bundle, inverseProbability);
+    }
   }
 };
-var depsCount;
 var preload2 = (name, probability) => {
   if (!name?.length) {
     return;
   }
-  depsCount = 0;
   let inverseProbability = probability ? 1 - probability : 0.4;
+  const context = { $depsCount$: 0 };
   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);
+        handleBundle(item, inverseProbability, context);
       }
     }
   } else {
-    handleBundle(name, inverseProbability);
+    handleBundle(name, inverseProbability, context);
   }
-  if (isBrowser5) {
-    trigger2();
+  if (shouldYieldInBrowser) {
+    nextAdjustmentMacroTask();
+  } else {
+    processPendingAdjustments();
   }
 };
-if (isBrowser5) {
+if (import.meta.env.TEST ? !isServerPlatform() : isBrowser7) {
   document.addEventListener("qsymbol", (ev) => {
     const { symbol, href } = ev.detail;
     if (href) {
@@ -35629,7 +36374,8 @@ function flattenPrefetchResources(prefetchResources) {
   const urls = [];
   const addPrefetchResource = (prefetchResources2) => {
     if (prefetchResources2) {
-      for (const prefetchResource of prefetchResources2) {
+      for (let i = 0; i < prefetchResources2.length; i++) {
+        const prefetchResource = prefetchResources2[i];
         if (!urls.includes(prefetchResource.url)) {
           urls.push(prefetchResource.url);
           if (prefetchResource.imports) {
@@ -35676,8 +36422,8 @@ function getPreloadPaths(qrls, opts, resolvedManifest) {
     }
   }
   const symbols = /* @__PURE__ */ new Set();
-  for (const qrl of qrls) {
-    const symbol = getSymbolHash2(qrl.$symbol$);
+  for (let i = 0; i < qrls.length; i++) {
+    const symbol = getSymbolHash2(qrls[i].$symbol$);
     if (symbol && symbol.length >= 10) {
       symbols.add(symbol);
     }
@@ -35690,8 +36436,8 @@ var expandBundles = (names, resolvedManifest) => {
   }
   resetQueue();
   let probability = 0.99;
-  for (const name of names) {
-    preload2(name, probability);
+  for (let i = 0; i < names.length; i++) {
+    preload2(names[i], probability);
     probability *= 0.95;
   }
   return getQueue();
@@ -35704,7 +36450,8 @@ var simplifyPath = (base2, path) => {
   }
   const segments = `${base2}${path}`.split("/");
   const simplified = [];
-  for (const segment of segments) {
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
     if (segment === ".." && simplified.length > 0) {
       simplified.pop();
     } else {
@@ -35806,7 +36553,8 @@ var includePreloader = (container, options, referencedBundles, nonce) => {
     const expandedBundles = expandBundles(referencedBundles, resolvedManifest);
     let probability = 4;
     const tenXMinProbability = ssrPreloadProbability * 10;
-    for (const hrefOrProbability of expandedBundles) {
+    for (let i = 0; i < expandedBundles.length; i++) {
+      const hrefOrProbability = expandedBundles[i];
       if (typeof hrefOrProbability === "string") {
         if (probability < tenXMinProbability) {
           break;
@@ -35970,7 +36718,8 @@ var SsrNode = class {
     if (this.flags & 1 /* Updatable */) {
       this.flags &= ~1 /* Updatable */;
       if (this.children) {
-        for (const child of this.children) {
+        for (let i = 0; i < this.children.length; i++) {
+          const child = this.children[i];
           child.setTreeNonUpdatable();
         }
       }
@@ -36365,6 +37114,9 @@ var SSRContainer = class extends _SharedContainer2 {
   /** Renders opening tag for DOM element */
   openElement(elementName, key, varAttrs, constAttrs = null, styleScopedId = null, currentFile = null, hasMovedCaptures = true) {
     const isQwikStyle = isQwikStyleElement(elementName, varAttrs) || isQwikStyleElement(elementName, constAttrs);
+    if (elementName === "noscript" || elementName === "template" || elementName === "script") {
+      this.$noScriptHere$++;
+    }
     if (
       // don't append qwik loader before qwik style elements
       // it will confuse the resuming, because styles are expected to be the first nodes in subtree
@@ -36372,8 +37124,6 @@ var SSRContainer = class extends _SharedContainer2 {
     ) {
       if (this.$noScriptHere$ === 0 && this.size > 30 * 1024 && elementName !== "body") {
         this.emitQwikLoaderInline();
-      } else if (elementName === "noscript" || elementName === "template") {
-        this.$noScriptHere$++;
       }
     }
     let innerHTML = void 0;
@@ -36462,10 +37212,8 @@ var SSRContainer = class extends _SharedContainer2 {
       this.write(GT);
     }
     this.lastNode = null;
-    if (this.qlInclude === 1 /* Inline */) {
-      if (elementName === "noscript" || elementName === "template") {
-        this.$noScriptHere$--;
-      }
+    if (elementName === "noscript" || elementName === "template" || elementName === "script") {
+      this.$noScriptHere$--;
     }
   }
   /** Writes opening data to vNodeData for fragment boundaries */
@@ -36828,7 +37576,8 @@ var SSRContainer = class extends _SharedContainer2 {
   emitPatchDataIfNeeded() {
     const patches = [];
     for (const [elementIndex, backpatchEntries] of this.backpatchMap) {
-      for (const backpatchEntry of backpatchEntries) {
+      for (let i = 0; i < backpatchEntries.length; i++) {
+        const backpatchEntry = backpatchEntries[i];
         patches.push(
           elementIndex,
           backpatchEntry.attrName,
@@ -36980,7 +37729,8 @@ var SSRContainer = class extends _SharedContainer2 {
           );
           let indent = "    ";
           let lastName = "";
-          for (const frame3 of frames) {
+          for (let i = 0; i < frames.length; i++) {
+            const frame3 = frames[i];
             const [name, example] = allowedContent(frame3.tagNesting);
             text.push(
               `${indent}<${frame3.elementName}>${lastName !== name ? ` [${name}]${example ? ` -> ${example}` : ""}` : ""}`
@@ -36991,7 +37741,7 @@ var SSRContainer = class extends _SharedContainer2 {
           text.push(
             `${indent}<${elementName}> <= is not allowed as a child of ${allowedContent(previousTagNesting)[0]}.`
           );
-          throw newTagError(text.join("\n"));
+          throw newTagError(text.map(escapeHTML).join("\n"));
         }
       }
     }
@@ -37319,9 +38069,10 @@ function resolveManifest(manifest) {
   }
   if (mergedManifest.mapping) {
     const mapper = {};
-    Object.entries(mergedManifest.mapping).forEach(([symbol, bundleFilename]) => {
+    for (const symbol in mergedManifest.mapping) {
+      const bundleFilename = mergedManifest.mapping[symbol];
       mapper[getSymbolHash2(symbol)] = [symbol, bundleFilename];
-    });
+    }
     return {
       mapper,
       manifest: mergedManifest,
@@ -37356,7 +38107,9 @@ async function domRender(jsx2, opts = {}) {
 function getStylesFactory(document2) {
   return () => {
     const styles = {};
-    Array.from(document2.querySelectorAll("style")).forEach((style) => {
+    const styleElements = document2.querySelectorAll("style");
+    for (let i = 0; i < styleElements.length; i++) {
+      const style = styleElements[i];
       const id = style.hasAttribute(QStyle) ? style.getAttribute(QStyle) : style.getAttribute(QScopedStyle) ? style.getAttribute(QScopedStyle) : null;
       if (id !== null) {
         const text = style.textContent;
@@ -37367,7 +38120,7 @@ function getStylesFactory(document2) {
           styles[id] = text;
         }
       }
-    });
+    }
     return styles;
   };
 }
@@ -37439,7 +38192,8 @@ async function ssrRenderToDom(jsx2, opts = {}) {
       child = child.nextSibling;
     }
     vnode_insertBefore(journal, containerVNode, fragment, insertBefore);
-    for (const child2 of childrenToMove) {
+    for (let i = 0; i < childrenToMove.length; i++) {
+      const child2 = childrenToMove[i];
       vnode_moveToVirtual(fragment, child2, null);
     }
     vNode = fragment;