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

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.31-dev+906321a
+ * @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";
@@ -25006,15 +25012,14 @@ var log3 = (...args) => (
 var AsyncJob = class {
   constructor($signal$, info, $infoVersion$) {
     this.$signal$ = $signal$;
-    this.info = info;
-    this.$infoVersion$ = $infoVersion$;
     /** 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$));
@@ -25025,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() {
@@ -25046,39 +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, "$info$");
-    __publicField(this, "$infoVersion$", 0);
     __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() {
@@ -25096,9 +25107,7 @@ 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$;
   }
@@ -25124,8 +25133,12 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     this.untrackedLoading = false;
     this.untrackedError = void 0;
     this.$info$ = void 0;
-    for (let i = 0; i < this.$jobs$.length; i++) {
-      this.$jobs$[i].$canWrite$ = false;
+    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;
@@ -25197,27 +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.$hasSubscribers$()) {
+    this.$expires$ = value;
+    if (this.$expires$ && this.$hasSubscribers$()) {
       this.$scheduleNextPoll$();
     }
   }
+  get poll() {
+    return !(this.$flags$ & 256 /* NO_POLL */);
+  }
+  set poll(value) {
+    if (value) {
+      this.$flags$ &= ~256 /* NO_POLL */;
+    } else {
+      this.$flags$ |= 256 /* NO_POLL */;
+    }
+    if (this.$expires$ && this.$hasSubscribers$()) {
+      this.$clearNextPoll$();
+      this.$scheduleNextPoll$();
+    }
+  }
+  /** @deprecated Use `expires` and `poll` instead. */
+  get interval() {
+    const expires = this.$expires$ || 0;
+    return this.$flags$ & 256 /* NO_POLL */ ? -expires : expires;
+  }
+  set interval(value) {
+    if (value < 0) {
+      this.$flags$ |= 256 /* NO_POLL */;
+    } else {
+      this.$flags$ &= ~256 /* NO_POLL */;
+    }
+    this.expires = Math.abs(value);
+  }
   /** Invalidates the signal, causing it to re-compute its value. */
   async invalidate(info) {
-    this.$flags$ |= 1 /* INVALID */;
-    this.$clearNextPoll$();
     if (arguments.length > 0) {
       this.$info$ = info;
-      this.$infoVersion$++;
+      this.$infoVersion$ = this.$infoVersion$ === void 0 ? 1 : this.$infoVersion$ + 1;
     }
-    if (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) {
-      await true;
-      this.$computeIfNeeded$();
+    this.$setInvalid$(true, this.$flags$ & 128 /* CLEAR_ON_INVALIDATE */);
+  }
+  $setInvalid$(allowRecalc, mustClear) {
+    this.$flags$ |= 1 /* INVALID */;
+    this.$clearNextPoll$();
+    if (mustClear) {
+      this.$untrackedValue$ = NEEDS_COMPUTATION;
+    }
+    if (allowRecalc && (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size)) {
+      Promise.resolve().then(() => this.$computeIfNeeded$());
     }
   }
   /** Abort the current computation and run cleanups if needed. */
@@ -25258,45 +25303,59 @@ 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 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 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);
@@ -25306,9 +25365,7 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     } 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$);
@@ -25324,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) {
@@ -25340,69 +25417,76 @@ var AsyncSignalImpl = class extends (_b2 = ComputedSignalImpl, _a3 = _EFFECT_BAC
     }
   }
   $scheduleNextPoll$() {
-    if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser2) || this.$interval$ === 0) {
+    if ((import.meta.env.TEST ? isServerPlatform() : isServer5) || !this.$expires$) {
       return;
     }
     this.$clearNextPoll$();
-    if (this.$interval$ < 0) {
-      this.$pollTimeoutId$ = setTimeout(() => {
-        this.$pollTimeoutId$ = void 0;
-        this.$flags$ |= 1 /* INVALID */;
-      }, -this.$interval$);
-    } else {
-      this.$pollTimeoutId$ = setTimeout(this.invalidate.bind(this), this.$interval$);
-    }
+    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$();
   }
 };
 
@@ -25798,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;
@@ -25809,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}.` : "")
               );
             }
           }
@@ -25821,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];
@@ -29496,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() {
@@ -29535,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") {
@@ -29640,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":
@@ -29673,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()]);
           }
@@ -29705,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);
@@ -29735,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,
@@ -29763,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);
             }
           }
         }
@@ -29778,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$,
@@ -29787,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$,
@@ -29805,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;
@@ -29821,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) {
@@ -29855,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));
@@ -29885,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,
@@ -29908,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$;
@@ -29933,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 = "";
@@ -29942,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)) {
@@ -30305,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];
@@ -30343,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) => {
@@ -30364,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);
@@ -30382,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]);
@@ -30405,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) => {
@@ -30431,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];
@@ -30440,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) {
@@ -30457,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];
@@ -30465,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]);
@@ -30479,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;
@@ -30498,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);
@@ -30507,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];
@@ -30522,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) {
@@ -30536,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++) {
@@ -30544,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;
@@ -30555,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++) {
@@ -30563,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++) {
@@ -30571,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);
@@ -30582,7 +30772,7 @@ var inflate = (container, target, typeId, data) => {
       }
       break;
     }
-    case 19 /* Uint8Array */:
+    case 27 /* Uint8Array */:
       const bytes = target;
       const buf = atob(data);
       let i = 0;
@@ -30591,7 +30781,7 @@ var inflate = (container, target, typeId, data) => {
         bytes[i++] = s.charCodeAt(0);
       }
       break;
-    case 30 /* PropsProxy */:
+    case 38 /* PropsProxy */:
       const propsProxy = target;
       const d = data;
       let owner = d[0];
@@ -30604,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];
@@ -30813,12 +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;
       }
-      qDev && initQrlClassDev($lazy$, $captures$, this);
     }
     if ($lazy$.$ref$ != null && typeof this.$captures$ !== "string" && !isPromise($lazy$.$ref$)) {
       this.resolved = bindCaptures(this, $lazy$.$ref$);
@@ -31078,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);
 };
@@ -31089,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 };
@@ -31255,6 +31550,7 @@ var Slot = (props) => {
 };
 
 // packages/qwik/src/core/shared/serdes/constants.ts
+var explicitUndefined = /* @__PURE__ */ Symbol("undefined");
 var _constants = [
   void 0,
   null,
@@ -31311,6 +31607,14 @@ var _typeIdNames = [
   "BigInt",
   "URLSearchParams",
   "ForwardRefs",
+  "TemporalDuration",
+  "TemporalInstant",
+  "TemporalPlainDate",
+  "TemporalPlainDateTime",
+  "TemporalPlainMonthDay",
+  "TemporalPlainTime",
+  "TemporalPlainYearMonth",
+  "TemporalZonedDateTime",
   "Error",
   "Promise",
   "Set",
@@ -31332,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;
@@ -32231,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") {
@@ -32275,6 +32580,22 @@ var canSerialize = (value, seen = /* @__PURE__ */ new WeakSet()) => {
       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) {
@@ -35218,24 +35539,10 @@ 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;
@@ -35248,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) {
@@ -35278,47 +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 (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 {
         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;
   }
 };