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

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.19-dev+0d046fb
+ * @qwik.dev/core 2.0.0-beta.21-dev+c008e88
  * 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
@@ -14,7 +14,7 @@ import { p } from '@qwik.dev/core/preloader';
  *
  * @public
  */
-const version = "2.0.0-beta.19-dev+0d046fb";
+const version = "2.0.0-beta.21-dev+c008e88";
 
 // same as isDev but separate so we can test
 const qDev = globalThis.qDev !== false;
@@ -401,29 +401,64 @@ const delay = (timeout) => {
         setTimeout(resolve, timeout);
     });
 };
-/** Retries a function that throws a promise. */
-function retryOnPromise(fn, retryCount = 0) {
-    const retryOrThrow = (e) => {
-        if (isPromise(e) && retryCount < MAX_RETRY_ON_PROMISE_COUNT) {
-            return e.then(retryOnPromise.bind(null, fn, retryCount++));
-        }
-        throw e;
-    };
+const checkError = (e) => {
+    if (isServer && e instanceof ReferenceError && e.message.includes('window')) {
+        e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
+    }
+};
+const justThrow = (e) => {
+    throw e;
+};
+/**
+ * Retries a function that throws a promise. If you pass `onError`, you're responsible for handling
+ * errors.
+ */
+function retryOnPromise(fn, onError = justThrow) {
+    let ok = false;
+    let result;
     try {
-        const result = fn();
-        if (isPromise(result)) {
-            // not awaited promise is not caught by try/catch block
-            return result.catch((e) => retryOrThrow(e));
-        }
-        return result;
+        result = fn();
+        ok = true;
     }
     catch (e) {
-        if (isDev && isServer && e instanceof ReferenceError && e.message.includes('window')) {
-            e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
-            throw e;
+        result = e;
+    }
+    if (!isPromise(result)) {
+        // Synchronous function or error, no need to retry
+        if (ok) {
+            return result;
         }
-        return retryOrThrow(e);
+        isDev && checkError(result);
+        return onError(result);
     }
+    let retryCount = MAX_RETRY_ON_PROMISE_COUNT;
+    const retry = async (p) => {
+        while (isPromise(p)) {
+            try {
+                await p;
+                // We waited for the thrown promise, now try again
+                return await fn();
+            }
+            catch (err) {
+                if (isPromise(err)) {
+                    if (!--retryCount) {
+                        p = new Error('Exceeded max retry count in retryOnPromise');
+                        break;
+                    }
+                    else {
+                        p = err;
+                    }
+                }
+                else {
+                    p = err;
+                    break;
+                }
+            }
+        }
+        isDev && checkError(p);
+        return onError(p);
+    };
+    return ok ? result.catch(retry) : retry(result);
 }
 
 const ASSERT_DISCLAIMER = 'Internal assert, this is likely caused by a bug in Qwik: ';
@@ -529,15 +564,15 @@ const isSvgElement = (elementName) => elementName === 'svg' || isForeignObjectEl
 const isMathElement = (elementName) => elementName === 'math';
 const vnode_isDefaultNamespace = (vnode) => {
     const flags = vnode.flags;
-    return (flags & 384 /* VNodeFlags.NAMESPACE_MASK */) === 0;
+    return (flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) === 0;
 };
 const vnode_getElementNamespaceFlags = (element) => {
     const namespace = fastNamespaceURI(element);
     switch (namespace) {
         case SVG_NS:
-            return 128 /* VNodeFlags.NS_svg */;
+            return 512 /* VNodeFlags.NS_svg */;
         case MATH_NS:
-            return 256 /* VNodeFlags.NS_math */;
+            return 1024 /* VNodeFlags.NS_math */;
         default:
             return 0 /* VNodeFlags.NS_html */;
     }
@@ -560,8 +595,8 @@ function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNo
                 domChildren.push(childVNode);
                 continue;
             }
-            if ((childVNode.flags & 384 /* VNodeFlags.NAMESPACE_MASK */) ===
-                (domParentVNode.flags & 384 /* VNodeFlags.NAMESPACE_MASK */)) {
+            if ((childVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) ===
+                (domParentVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */)) {
                 // if the child and parent have the same namespace, we don't need to clone the element
                 domChildren.push(childVNode);
                 continue;
@@ -648,7 +683,7 @@ function vnode_cloneElementWithNamespace(elementVNode, parentVNode, namespace, n
             // This is because we need to materialize the children before we assign new element
             vCursor.node = newChildElement;
             // Set correct namespace flag
-            vCursor.flags &= -385 /* VNodeFlags.NEGATED_NAMESPACE_MASK */;
+            vCursor.flags &= -1537 /* VNodeFlags.NEGATED_NAMESPACE_MASK */;
             vCursor.flags |= namespaceFlag;
             if (vFirstChild) {
                 vCursor = vFirstChild;
@@ -717,17 +752,17 @@ function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
     const isElementVNodeOrString = typeof tagOrVNode === 'string' || vnode_isElementVNode(tagOrVNode);
     if (isElementVNodeOrString && isSvg(tagOrVNode)) {
         elementNamespace = SVG_NS;
-        elementNamespaceFlag = 128 /* VNodeFlags.NS_svg */;
+        elementNamespaceFlag = 512 /* VNodeFlags.NS_svg */;
     }
     else if (isElementVNodeOrString && isMath(tagOrVNode)) {
         elementNamespace = MATH_NS;
-        elementNamespaceFlag = 256 /* VNodeFlags.NS_math */;
+        elementNamespaceFlag = 1024 /* VNodeFlags.NS_math */;
     }
     else if (domParentVNode && !parentIsForeignObject && !parentIsDefaultNamespace) {
-        const isParentSvg = (domParentVNode.flags & 128 /* VNodeFlags.NS_svg */) !== 0;
-        const isParentMath = (domParentVNode.flags & 256 /* VNodeFlags.NS_math */) !== 0;
+        const isParentSvg = (domParentVNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0;
+        const isParentMath = (domParentVNode.flags & 1024 /* VNodeFlags.NS_math */) !== 0;
         elementNamespace = isParentSvg ? SVG_NS : isParentMath ? MATH_NS : HTML_NS;
-        elementNamespaceFlag = domParentVNode.flags & 384 /* VNodeFlags.NAMESPACE_MASK */;
+        elementNamespaceFlag = domParentVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */;
     }
     NEW_NAMESPACE_DATA.elementNamespace = elementNamespace;
     NEW_NAMESPACE_DATA.elementNamespaceFlag = elementNamespaceFlag;
@@ -738,7 +773,7 @@ function isSvg(tagOrVNode) {
         return isSvgElement(tagOrVNode);
     }
     if (vnode_isElementVNode(tagOrVNode)) {
-        return (isSvgElement(vnode_getElementName(tagOrVNode)) || (tagOrVNode.flags & 128 /* VNodeFlags.NS_svg */) !== 0);
+        return (isSvgElement(vnode_getElementName(tagOrVNode)) || (tagOrVNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
     }
     return false;
 }
@@ -748,7 +783,7 @@ function isMath(tagOrVNode) {
     }
     if (vnode_isElementVNode(tagOrVNode)) {
         return (isMathElement(vnode_getElementName(tagOrVNode)) ||
-            (tagOrVNode.flags & 256 /* VNodeFlags.NS_math */) !== 0);
+            (tagOrVNode.flags & 1024 /* VNodeFlags.NS_math */) !== 0);
     }
     return false;
 }
@@ -778,6 +813,75 @@ const mergeMaps = (map1, map2) => {
     return map1;
 };
 
+/**
+ * Think of `-` as an escape character which makes the next character uppercase. `--` is just `-`.
+ *
+ * Rules for JSX property event names starting with `on`:
+ *
+ * - Are case insensitive: `onClick$` is same `onclick$`
+ * - A `--` is `-`: `dbl--click` => `dbl-click`
+ * - Become case sensitive if prefixed by `-`: `-Click` is `Click`
+ * - A `-` (not at the beginning) makes next character uppercase: `dbl-click` => `dblClick`
+ */
+const EVENT_SUFFIX = '$';
+const isHtmlAttributeAnEventName = (name) => {
+    return (name.charCodeAt(0) === 113 /* q */ &&
+        name.charCodeAt(1) === 45 /* - */ &&
+        name.charCodeAt(3) === 58 /* : */);
+};
+function jsxEventToHtmlAttribute(jsxEvent) {
+    if (jsxEvent.endsWith(EVENT_SUFFIX)) {
+        const [prefix, idx] = getEventScopeDataFromJsxEvent(jsxEvent);
+        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 null; // Return null if not matching expected format
+}
+function createEventName(event, prefix) {
+    const eventName = fromCamelToKebabCase(event);
+    return prefix + eventName;
+}
+function getEventScopeDataFromJsxEvent(eventName) {
+    let prefix;
+    let idx = -1;
+    // set prefix and idx based on the scope
+    if (eventName.startsWith("on" /* EventNameJSXScope.on */)) {
+        prefix = "q-e:" /* EventNameHtmlScope.on */;
+        idx = 2;
+    }
+    else if (eventName.startsWith("window:on" /* EventNameJSXScope.window */)) {
+        prefix = "q-w:" /* EventNameHtmlScope.window */;
+        idx = 9;
+    }
+    else if (eventName.startsWith("document:on" /* EventNameJSXScope.document */)) {
+        prefix = "q-d:" /* EventNameHtmlScope.document */;
+        idx = 11;
+    }
+    return [prefix, idx];
+}
+function isPreventDefault(key) {
+    return key.startsWith('preventdefault:');
+}
+/** Converts a camelCase string to kebab-case. This is used for event names. */
+const fromCamelToKebabCase = (text) => {
+    return text.replace(/([A-Z-])/g, (a) => '-' + a.toLowerCase());
+};
+/** E.g. `"q-e:click"` => `['e', 'click']` */
+const getEventDataFromHtmlAttribute = (htmlKey) => [
+    htmlKey.charAt(2),
+    htmlKey.substring(4),
+];
+/** E.g. `"e:click"`, `"w:load"` */
+const getScopedEventName = (scope, eventName) => scope + ':' + eventName;
+
 /** @internal */
 const _EFFECT_BACK_REF = Symbol('backRef');
 /** Class for back reference to the EffectSubscription */
@@ -924,7 +1028,7 @@ function resumeCursor(cursor, container) {
  */
 function removeCursorFromQueue(cursor, container, keepCursorFlag) {
     if (!keepCursorFlag) {
-        cursor.flags &= -65 /* VNodeFlags.Cursor */;
+        cursor.flags &= -257 /* VNodeFlags.Cursor */;
     }
     const index = globalCursorQueue.indexOf(cursor);
     if (index !== -1) {
@@ -1144,88 +1248,6 @@ const _IMMUTABLE = Symbol('IMMUTABLE');
 /** @internal */
 const _UNINITIALIZED = Symbol('UNINITIALIZED');
 
-/**
- * Think of `-` as an escape character which makes the next character uppercase. `--` is just `-`.
- *
- * Rules for JSX property event names starting with `on`:
- *
- * - Are case insensitive: `onClick$` is same `onclick$`
- * - A `--` is `-`: `dbl--click` => `dbl-click`
- * - Become case sensitive if prefixed by `-`: `-Click` is `Click`
- * - A `-` (not at the beginning) makes next character uppercase: `dbl-click` => `dblClick`
- */
-const EVENT_SUFFIX = '$';
-const isHtmlAttributeAnEventName = (name) => {
-    if (name.charCodeAt(0) !== 111 /* o */ || name.charCodeAt(1) !== 110 /* n */) {
-        return false;
-    }
-    if (name.charCodeAt(2) === 58 /* : */) {
-        return true; // on:
-    }
-    return name.startsWith("on-window:" /* EventNameHtmlScope.window */) || name.startsWith("on-document:" /* EventNameHtmlScope.document */);
-};
-function jsxEventToHtmlAttribute(jsxEvent) {
-    if (jsxEvent.endsWith(EVENT_SUFFIX)) {
-        const [prefix, idx] = getEventScopeDataFromJsxEvent(jsxEvent);
-        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 null; // Return null if not matching expected format
-}
-function createEventName(event, prefix) {
-    const eventName = fromCamelToKebabCase(event);
-    return prefix + eventName;
-}
-function getEventScopeDataFromJsxEvent(eventName) {
-    let prefix = "on:" /* EventNameHtmlScope.on */;
-    let idx = -1;
-    // set prefix and idx based on the scope
-    if (eventName.startsWith("on" /* EventNameJSXScope.on */)) {
-        prefix = "on:" /* EventNameHtmlScope.on */;
-        idx = 2;
-    }
-    else if (eventName.startsWith("window:on" /* EventNameJSXScope.window */)) {
-        prefix = "on-window:" /* EventNameHtmlScope.window */;
-        idx = 9;
-    }
-    else if (eventName.startsWith("document:on" /* EventNameJSXScope.document */)) {
-        prefix = "on-document:" /* EventNameHtmlScope.document */;
-        idx = 11;
-    }
-    return [prefix, idx];
-}
-function isPreventDefault(key) {
-    return key.startsWith('preventdefault:');
-}
-/** Converts a camelCase string to kebab-case. This is used for event names. */
-const fromCamelToKebabCase = (text) => {
-    return text.replace(/([A-Z-])/g, (a) => '-' + a.toLowerCase());
-};
-const getEventDataFromHtmlAttribute = (htmlKey) => {
-    if (htmlKey.startsWith("on:" /* EventNameHtmlScope.on */)) {
-        return ['', htmlKey.substring(3)];
-    }
-    if (htmlKey.startsWith("on-window:" /* EventNameHtmlScope.window */)) {
-        return ['window', htmlKey.substring(10)];
-    }
-    return ['document', htmlKey.substring(12)];
-};
-const getScopedEventName = (scope, eventName) => {
-    const suffix = ':' + eventName;
-    return scope ? scope + suffix : suffix;
-};
-const getLoaderScopedEventName = (scope, scopedEvent) => {
-    return scope ? '-' + scopedEvent : scopedEvent;
-};
-
 /** @internal */
 const EMPTY_ARRAY = [];
 const EMPTY_OBJ = {};
@@ -1618,7 +1640,7 @@ class ComputedSignalImpl extends SignalImpl {
     // We need a separate flag to know when the computation needs running because
     // we need the old value to know if effects need running after computation
     flags = 1 /* SignalFlags.INVALID */ |
-        32 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */) {
+        16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */) {
         // The value is used for comparison when signals trigger, which can only happen
         // when it was calculated before. Therefore we can pass whatever we like.
         super(container, NEEDS_COMPUTATION);
@@ -1687,24 +1709,16 @@ class ComputedSignalImpl extends SignalImpl {
             }
         }
     }
-    // Make this signal read-only
-    set value(_) {
-        throw qError(30 /* QError.computedReadOnly */);
-    }
-    // Getters don't get inherited when overriding a setter
-    get value() {
-        return super.value;
-    }
 }
 
 /**
  * # ================================
  *
- * AsyncComputedSignalImpl
+ * AsyncSignalImpl
  *
  * # ================================
  */
-class AsyncComputedSignalImpl extends ComputedSignalImpl {
+class AsyncSignalImpl extends ComputedSignalImpl {
     $untrackedLoading$ = false;
     $untrackedError$ = undefined;
     $loadingEffects$ = undefined;
@@ -1753,7 +1767,7 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
     async promise() {
         // make sure we get a new promise during the next computation
         this.$promise$ = null;
-        await retryOnPromise(() => this.$computeIfNeeded$());
+        await retryOnPromise(this.$computeIfNeeded$.bind(this));
         return this.$untrackedValue$;
     }
     $computeIfNeeded$() {
@@ -1815,6 +1829,42 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
                 track: trackFn(this, this.$container$),
                 cleanup,
             });
+            // TODO implement these
+            // const arg: {
+            //   track: Tracker;
+            //   cleanup: ReturnType<typeof cleanupFn>[0];
+            //   poll: (ms: number) => void;
+            // } = {
+            //   poll: (ms: number) => {
+            //     setTimeout(() => {
+            //       super.invalidate();
+            //       if (this.$effects$?.size) {
+            //         this.$computeIfNeeded$();
+            //       }
+            //     }, ms);
+            //   },
+            // } as any;
+            // Object.defineProperty(arg, 'track', {
+            //   get() {
+            //     const fn = trackFn(this, this.$container$);
+            //     arg.track = fn;
+            //     return fn;
+            //   },
+            //   configurable: true,
+            //   enumerable: true,
+            //   writable: true,
+            // });
+            // Object.defineProperty(arg, 'cleanup', {
+            //   get() {
+            //     const [fn] = cleanupFn(this, (err) => this.$container$?.handleError(err, null!));
+            //     arg.cleanup = fn;
+            //     return fn;
+            //   },
+            //   configurable: true,
+            //   enumerable: true,
+            //   writable: true,
+            // });
+            // this.$promise$ = this.$computeQrl$.getFn()(arg) as ValueOrPromise<T>;
         }
         return this.$promise$;
     }
@@ -1883,7 +1933,7 @@ const implicit$FirstArg = (fn) => {
  */
 class SerializerSignalImpl extends ComputedSignalImpl {
     constructor(container, argQrl) {
-        super(container, argQrl, 1 /* SignalFlags.INVALID */ | 32 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */);
+        super(container, argQrl, 1 /* SignalFlags.INVALID */ | 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */);
     }
     $didInitialize$ = false;
     $computeIfNeeded$() {
@@ -1921,8 +1971,8 @@ const createComputedSignal = (qrl, options) => {
     return new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'always'));
 };
 /** @internal */
-const createAsyncComputedSignal = (qrl, options) => {
-    return new AsyncComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'never'));
+const createAsyncSignal = (qrl, options) => {
+    return new AsyncSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'never'));
 };
 /** @internal */
 const createSerializerSignal = (arg) => {
@@ -1944,7 +1994,7 @@ const createSignal = createSignal$1;
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects, and it must be synchronous.
  *
- * If you need the function to be async, use `useAsyncComputed$` instead.
+ * If you need the function to be async, use `useAsync$` instead.
  *
  * @public
  */
@@ -1959,7 +2009,8 @@ const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
  *
  * @public
  */
-const createAsyncComputed$ = /*#__PURE__*/ implicit$FirstArg(createAsyncComputedSignal);
+const createAsync$ = 
+/*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
  * details.
@@ -2003,7 +2054,7 @@ const _wrapProp = (...args) => {
         return obj[prop];
     }
     if (isSignal(obj)) {
-        if (!(obj instanceof AsyncComputedSignalImpl)) {
+        if (!(obj instanceof AsyncSignalImpl)) {
             isDev && assertEqual(prop, 'value', 'Left side is a signal, prop must be value');
         }
         if (obj instanceof WrappedSignalImpl && obj.$flags$ & 4 /* WrappedSignalFlags.UNWRAP */) {
@@ -2153,9 +2204,9 @@ function clearEffectSubscription(container, effect) {
         return;
     }
     for (const producer of backRefs) {
-        // Check AsyncComputedSignalImpl before SignalImpl since it extends SignalImpl
-        if (producer instanceof AsyncComputedSignalImpl) {
-            clearAsyncComputedSignal(producer, effect);
+        // Check AsyncSignalImpl before SignalImpl since it extends SignalImpl
+        if (producer instanceof AsyncSignalImpl) {
+            clearAsyncSignal(producer, effect);
         }
         else if (producer instanceof SignalImpl) {
             clearSignal(container, producer, effect);
@@ -2183,7 +2234,7 @@ function clearSignal(container, producer, effect) {
         clearAllEffects(container, producer);
     }
 }
-function clearAsyncComputedSignal(producer, effect) {
+function clearAsyncSignal(producer, effect) {
     const effects = producer.$effects$;
     if (effects && effects.has(effect)) {
         effects.delete(effect);
@@ -2215,58 +2266,38 @@ class SubscriptionData {
     }
 }
 
-// <docs markdown="../readme.md#useLexicalScope">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useLexicalScope instead and run `pnpm docs.sync`)
 /**
- * Used by the Qwik Optimizer to restore the lexically scoped variables.
- *
- * This method should not be present in the application source code.
- *
- * NOTE: `useLexicalScope` method can only be used in the synchronous portion of the callback
- * (before any `await` statements.)
- *
- * @internal
+ * Qwikloader provides the captures string of the QRL when calling a handler. In that case we must
+ * load the QRL captured scope ourselves. Otherwise, we are being called as a QRL and the captures
+ * are already set.
  */
-// </docs>
-const useLexicalScope = () => {
-    const context = getInvokeContext();
-    let qrl = context.$qrl$;
-    if (!qrl) {
-        const el = context.$hostElement$ instanceof ElementVNode ? context.$hostElement$.node : undefined;
-        isDev && assertDefined(el, 'invoke: element must be defined inside useLexicalScope()', context);
-        const containerElement = _getQContainerElement(el);
-        isDev && assertDefined(containerElement, `invoke: cant find parent q:container of`, el);
-        const container = getDomContainer(containerElement);
-        context.$container$ ||= container;
-        qrl = container.parseQRL(decodeURIComponent(String(context.$url$)));
+const maybeScopeFromQL = (captureIds, element) => {
+    if (typeof captureIds === 'string') {
+        const container = getDomContainer(element);
+        setCaptures(deserializeCaptures(container, captureIds));
     }
-    else {
-        isDev && assertQrl(qrl);
-        isDev &&
-            assertDefined(qrl.$captureRef$, 'invoke: qrl $captureRef$ must be defined inside useLexicalScope()', qrl);
-    }
-    return qrl.$captureRef$;
+    return null;
 };
-
 /**
  * Handles events for bind:value
  *
  * @internal
  */
-const _val = (_, element) => {
-    const [signal] = useLexicalScope();
+function _val(_, element) {
+    maybeScopeFromQL(this, element);
+    const signal = _captures[0];
     signal.value = element.type === 'number' ? element.valueAsNumber : element.value;
-};
+}
 /**
  * Handles events for bind:checked
  *
  * @internal
  */
-const _chk = (_, element) => {
-    const [signal] = useLexicalScope();
+function _chk(_, element) {
+    maybeScopeFromQL(this, element);
+    const signal = _captures[0];
     signal.value = element.checked;
-};
+}
 
 const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 // TODO store props as the arrays the vnodes also use?
@@ -2357,7 +2388,9 @@ const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
  * @param children - JSX children. Any `children` in the props objects are ignored.
  * @internal
  */
-const _jsxSorted = (type, varProps, constProps, children, flags, key, dev) => {
+const _jsxSorted = (type, varProps, constProps, children, 
+// TODO use this to know static parts of the tree
+flags, key, dev) => {
     return new JSXNodeImpl(type, varProps, constProps, children, key, false, dev);
 };
 /**
@@ -2384,7 +2417,7 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
     let bindCheckedSignal = null;
     // Apply transformations for native HTML elements only
     if (typeof type === 'string') {
-        // Transform event names (onClick$ -> on:click)
+        // Transform event names (onClick$ -> q-e:click)
         if (constProps) {
             const processedKeys = new Set();
             for (const k in constProps) {
@@ -2437,34 +2470,34 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                 if (bindCheckedSignal) {
                     delete varProps[BIND_CHECKED];
                     varProps.checked = bindCheckedSignal;
-                    const handler = createQRL(null, '_chk', _chk, null, null, [bindCheckedSignal]);
-                    // Move on:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'on:input')) {
+                    const handler = createQRL(null, '_chk', _chk, null, [bindCheckedSignal]);
+                    // Move q-e:input from constProps if it exists
+                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
                         if (!constPropsCopied) {
                             constProps = { ...constProps };
                             constPropsCopied = true;
                         }
-                        const existingHandler = constProps['on:input'];
-                        delete constProps['on:input'];
-                        toSort = mergeHandlers(varProps, 'on:input', existingHandler) || toSort;
+                        const existingHandler = constProps['q-e:input'];
+                        delete constProps['q-e:input'];
+                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
                     }
-                    toSort = mergeHandlers(varProps, 'on:input', handler) || toSort;
+                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
                 }
                 else if (bindValueSignal) {
                     delete varProps[BIND_VALUE];
                     varProps.value = bindValueSignal;
-                    const handler = createQRL(null, '_val', _val, null, null, [bindValueSignal]);
-                    // Move on:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'on:input')) {
+                    const handler = createQRL(null, '_val', _val, null, [bindValueSignal]);
+                    // Move q-e:input from constProps if it exists
+                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
                         if (!constPropsCopied) {
                             constProps = { ...constProps };
                             constPropsCopied = true;
                         }
-                        const existingHandler = constProps['on:input'];
-                        delete constProps['on:input'];
-                        toSort = mergeHandlers(varProps, 'on:input', existingHandler) || toSort;
+                        const existingHandler = constProps['q-e:input'];
+                        delete constProps['q-e:input'];
+                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
                     }
-                    toSort = mergeHandlers(varProps, 'on:input', handler) || toSort;
+                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
                 }
             }
         }
@@ -2695,7 +2728,7 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
 function addUseOnEvents(jsx, useOnEvents) {
     const jsxElement = findFirstElementNode(jsx);
     let jsxResult = jsx;
-    const qVisibleEvent = 'on:qvisible';
+    const qVisibleEvent = 'q-e:qvisible';
     return maybeThen(jsxElement, (jsxElement) => {
         // headless components are components that don't render a real DOM element
         const isHeadless = !jsxElement;
@@ -2708,8 +2741,8 @@ function addUseOnEvents(jsx, useOnEvents) {
                 if (isHeadless) {
                     // if the component is headless, we need to add the event to the placeholder element
                     if (key === qVisibleEvent ||
-                        key.startsWith("on-document:" /* EventNameHtmlScope.document */) ||
-                        key.startsWith("on-window:" /* EventNameHtmlScope.window */)) {
+                        key.startsWith("q-d:" /* EventNameHtmlScope.document */) ||
+                        key.startsWith("q-w:" /* EventNameHtmlScope.window */)) {
                         if (!placeholderElement) {
                             const [createdElement, newJsx] = injectPlaceholderElement(jsxResult);
                             jsxResult = newJsx;
@@ -2730,7 +2763,7 @@ function addUseOnEvents(jsx, useOnEvents) {
                 }
                 if (targetElement) {
                     if (targetElement.type === 'script' && key === qVisibleEvent) {
-                        eventKey = 'on-document:qinit';
+                        eventKey = 'q-d:qinit';
                         if (isDev) {
                             logWarn('You are trying to add an event "' +
                                 key +
@@ -2778,6 +2811,7 @@ function addUseOnEvent(jsxElement, key, value) {
         props[key] = undefined;
     }
 }
+const getValue$1 = (o) => o.value;
 /**
  * Finds the first element node in the JSX output.
  *
@@ -2801,7 +2835,7 @@ function findFirstElementNode(jsx) {
             return maybeThen(jsx, (jsx) => findFirstElementNode(jsx));
         }
         else if (isSignal(jsx)) {
-            return findFirstElementNode(untrack(() => jsx.value));
+            return findFirstElementNode(untrack(getValue$1, jsx));
         }
     }
     return null;
@@ -2880,6 +2914,34 @@ const SSRStreamBlock = (props) => {
 const SSRStream = (props, key) => jsx(RenderOnce, { children: jsx(InternalSSRStream, props) }, key);
 const InternalSSRStream = () => null;
 
+let _setAttribute = null;
+const fastSetAttribute = (target, name, value) => {
+    if (!_setAttribute) {
+        _setAttribute = target.setAttribute;
+    }
+    _setAttribute.call(target, name, value);
+};
+let _setAttributeNS = null;
+const fastSetAttributeNS = (target, namespace, name, value) => {
+    if (!_setAttributeNS) {
+        _setAttributeNS = target.setAttributeNS;
+    }
+    _setAttributeNS.call(target, namespace, name, value);
+};
+function directSetAttribute(element, attrName, attrValue, isSvg) {
+    if (attrValue != null) {
+        if (isSvg) {
+            // only svg elements can have namespace attributes
+            const namespace = getAttributeNamespace(attrName);
+            if (namespace) {
+                fastSetAttributeNS(element, namespace, attrName, attrValue);
+                return;
+            }
+        }
+        fastSetAttribute(element, attrName, attrValue);
+    }
+}
+
 function escapeHTML(html) {
     let escapedHTML = '';
     const length = html.length;
@@ -3149,55 +3211,6 @@ const styleKey = (qStyles, index) => {
     return `${hashCode(qStyles.$hash$)}-${index}`;
 };
 
-/** @internal */
-const mapApp_findIndx = (array, key, start) => {
-    isDev && assertTrue(start % 2 === 0, 'Expecting even number.');
-    let bottom = start >> 1;
-    let top = (array.length - 2) >> 1;
-    while (bottom <= top) {
-        const mid = bottom + ((top - bottom) >> 1);
-        const midKey = array[mid << 1];
-        if (midKey === key) {
-            return mid << 1;
-        }
-        if (midKey < key) {
-            bottom = mid + 1;
-        }
-        else {
-            top = mid - 1;
-        }
-    }
-    return (bottom << 1) ^ -1;
-};
-/** @internal */
-const mapArray_set = (array, key, value, start, allowNullValue = false) => {
-    const indx = mapApp_findIndx(array, key, start);
-    if (indx >= 0) {
-        if (value == null && !allowNullValue) {
-            array.splice(indx, 2);
-        }
-        else {
-            array[indx + 1] = value;
-        }
-    }
-    else if (value != null || allowNullValue) {
-        array.splice(indx ^ -1, 0, key, value);
-    }
-};
-/** @internal */
-const mapArray_get = (array, key, start) => {
-    const indx = mapApp_findIndx(array, key, start);
-    if (indx >= 0) {
-        return array[indx + 1];
-    }
-    else {
-        return null;
-    }
-};
-const mapArray_has = (array, key, start) => {
-    return mapApp_findIndx(array, key, start) >= 0;
-};
-
 class DeleteOperation {
     target;
     constructor(target) {
@@ -3250,74 +3263,103 @@ const createSetTextOperation = (target, text) => new SetTextOperation(target, te
 const createInsertOrMoveOperation = (target, parent, beforeTarget) => new InsertOrMoveOperation(target, parent, beforeTarget);
 const createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg = false) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg);
 
-function callQrl(container, host, qrl, event, element, useGetObjectById) {
-    const getObjectById = useGetObjectById ? container?.$getObjectById$ || null : null;
-    const singleItem = vnode_getProp(host, ITERATION_ITEM_SINGLE, getObjectById);
-    if (singleItem !== null) {
-        return qrl(event, element, singleItem);
-    }
-    const multiItems = vnode_getProp(host, ITERATION_ITEM_MULTI, getObjectById);
-    if (multiItems !== null) {
-        return qrl(event, element, ...multiItems);
+/**
+ * This safely calls an event handler, handling errors and retrying on thrown Promises, and
+ * providing extra parameters defined on the elements as arguments (used for loop optimization)
+ */
+function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+    const container = ctx.$container$;
+    const hostElement = ctx.$hostElement$;
+    vnode_ensureElementInflated(container, hostElement);
+    let realHandler = handler;
+    if (hostElement.flags & 64 /* VNodeFlags.HasIterationItems */) {
+        let shouldInflate;
+        if (!(hostElement.flags & 128 /* VNodeFlags.InflatedIterationItems */)) {
+            shouldInflate = true;
+            hostElement.flags |= 128 /* VNodeFlags.InflatedIterationItems */;
+        }
+        const getObj = shouldInflate ? container.$getObjectById$ : null;
+        const singleItem = vnode_getProp(hostElement, ITERATION_ITEM_SINGLE, getObj);
+        if (singleItem !== null) {
+            realHandler = (() => handler(event, element, singleItem));
+        }
+        else {
+            const multiItems = vnode_getProp(hostElement, ITERATION_ITEM_MULTI, getObj);
+            if (multiItems !== null) {
+                realHandler = (() => handler(event, element, ...multiItems));
+            }
+        }
     }
-    return qrl(event, element);
+    return retryOnPromise(() => {
+        // Check if the host element was deleted while waiting for the promise to resolve
+        if (!(hostElement.flags & 32 /* VNodeFlags.Deleted */)) {
+            return invokeApply(ctx, realHandler, [event, element]);
+        }
+    }, (err) => container.handleError(err, hostElement));
 }
 /**
- * This is called by qwik-loader to run a QRL. It has to be synchronous.
+ * This is called by qwik-loader to run a QRL. It has to be synchronous when possible.
  *
  * @internal
  */
-const _run = (...args) => {
-    // This will already check container
-    const [qrl] = useLexicalScope();
-    const context = getInvokeContext();
-    const hostElement = context.$hostElement$;
-    if (hostElement) {
-        context.$container$ ||= getDomContainer(hostElement.node);
-        vnode_ensureElementInflated(hostElement);
-        return retryOnPromise(() => {
-            if (!(hostElement.flags & 32 /* VNodeFlags.Deleted */)) {
-                return callQrl(context.$container$, hostElement, qrl, args[0], args[1], true).catch((err) => {
-                    const container = context.$container$;
-                    if (container) {
-                        container.handleError(err, hostElement);
-                    }
-                    else {
-                        throw err;
-                    }
-                });
-            }
-        });
+function _run(event, element) {
+    const ctx = newInvokeContextFromDOM(event, element);
+    if (typeof this === 'string') {
+        setCaptures(deserializeCaptures(ctx.$container$, this));
     }
-};
+    const qrlToRun = _captures[0];
+    isDev && assertQrl(qrlToRun);
+    return runEventHandlerQRL(qrlToRun, event, element, ctx);
+}
 
-let _setAttribute = null;
-const fastSetAttribute = (target, name, value) => {
-    if (!_setAttribute) {
-        _setAttribute = target.setAttribute;
+/** @internal */
+const mapApp_findIndx = (array, key, start) => {
+    isDev && assertTrue(start % 2 === 0, 'Expecting even number.');
+    let bottom = start >> 1;
+    let top = (array.length - 2) >> 1;
+    while (bottom <= top) {
+        const mid = bottom + ((top - bottom) >> 1);
+        const midKey = array[mid << 1];
+        if (midKey === key) {
+            return mid << 1;
+        }
+        if (midKey < key) {
+            bottom = mid + 1;
+        }
+        else {
+            top = mid - 1;
+        }
     }
-    _setAttribute.call(target, name, value);
+    return (bottom << 1) ^ -1;
 };
-let _setAttributeNS = null;
-const fastSetAttributeNS = (target, namespace, name, value) => {
-    if (!_setAttributeNS) {
-        _setAttributeNS = target.setAttributeNS;
+/** @internal */
+const mapArray_set = (array, key, value, start, allowNullValue = false) => {
+    const indx = mapApp_findIndx(array, key, start);
+    if (indx >= 0) {
+        if (value == null && !allowNullValue) {
+            array.splice(indx, 2);
+        }
+        else {
+            array[indx + 1] = value;
+        }
+    }
+    else if (value != null || allowNullValue) {
+        array.splice(indx ^ -1, 0, key, value);
     }
-    _setAttributeNS.call(target, namespace, name, value);
 };
-function directSetAttribute(element, attrName, attrValue, isSvg) {
-    if (attrValue != null) {
-        if (isSvg) {
-            // only svg elements can have namespace attributes
-            const namespace = getAttributeNamespace(attrName);
-            if (namespace) {
-                fastSetAttributeNS(element, namespace, attrName, attrValue);
-                return;
-            }
-        }
-        fastSetAttribute(element, attrName, attrValue);
+/** @internal */
+const mapArray_get = (array, key, start) => {
+    const indx = mapApp_findIndx(array, key, start);
+    if (indx >= 0) {
+        return array[indx + 1];
     }
-}
+    else {
+        return null;
+    }
+};
+const mapArray_has = (array, key, start) => {
+    return mapApp_findIndx(array, key, start) >= 0;
+};
 
 /**
  * Helper to get the next sibling of a VNode. Extracted to module scope to help V8 inline it
@@ -3333,7 +3375,7 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
         scopedStyleIdPrefix &&
         vnode_setProp(vnode, debugStyleScopeIdPrefixAttr, scopedStyleIdPrefix);
     vnode_setProp(vnode, key, originalValue);
-    addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, (vnode.flags & 128 /* VNodeFlags.NS_svg */) !== 0));
+    addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, (vnode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
 }
 const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
     const diffContext = {
@@ -3828,16 +3870,9 @@ function expectNoMoreTextNodes(diffContext) {
         vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
     }
 }
-/**
- * Returns whether `qDispatchEvent` needs patching. This is true when one of the `jsx` argument's
- * const props has the name of an event.
- *
- * @returns {boolean}
- */
 function createNewElement(diffContext, jsx, elementName, currentFile) {
     const element = createElementWithNamespace(diffContext, elementName);
     const { constProps } = jsx;
-    let needsQDispatchEventPatch = false;
     if (constProps) {
         // Const props are, well, constant, they will never change!
         // For this reason we can cheat and write them directly into the DOM.
@@ -3845,22 +3880,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
         for (const key in constProps) {
             let value = constProps[key];
             if (isHtmlAttributeAnEventName(key)) {
-                const data = getEventDataFromHtmlAttribute(key);
-                if (data) {
-                    const [scope, eventName] = data;
-                    const scopedEvent = getScopedEventName(scope, eventName);
-                    const loaderScopedEvent = getLoaderScopedEventName(scope, scopedEvent);
-                    if (eventName) {
-                        vnode_setProp(diffContext.vNewNode, '::' + scopedEvent, value);
-                        if (scope) {
-                            // window and document need attrs so qwik loader can find them
-                            vnode_setAttr(diffContext.journal, diffContext.vNewNode, key, '');
-                        }
-                        // register an event for qwik loader (window/document prefixed with '-')
-                        registerQwikLoaderEvent(diffContext, loaderScopedEvent);
-                    }
-                }
-                needsQDispatchEventPatch = true;
+                registerEventHandlers(key, value, element, diffContext.vNewNode, diffContext);
                 continue;
             }
             if (key === 'ref') {
@@ -3886,7 +3906,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
             }
             if (isPromise(value)) {
                 const vHost = diffContext.vNewNode;
-                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.scopedStyleIdPrefix), (vHost.flags & 128 /* VNodeFlags.NS_svg */) !== 0));
+                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.scopedStyleIdPrefix), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
                 diffContext.asyncAttributePromises.push(attributePromise);
                 continue;
             }
@@ -3907,7 +3927,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
                 element.value = escapeHTML(value || '');
                 continue;
             }
-            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.scopedStyleIdPrefix), (diffContext.vNewNode.flags & 128 /* VNodeFlags.NS_svg */) !== 0);
+            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.scopedStyleIdPrefix), (diffContext.vNewNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
         }
     }
     const key = jsx.key;
@@ -3923,7 +3943,25 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
         }
     }
     vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent);
-    return needsQDispatchEventPatch;
+}
+function registerEventHandlers(key, value, element, vnode, diffContext) {
+    const scopedKebabName = key.slice(2);
+    if (!Array.isArray(value)) {
+        value = [value];
+    }
+    const handlers = [];
+    for (const handler of value.flat(2)) {
+        if (handler) {
+            handlers.push(runEventHandlerQRL.bind(null, handler));
+        }
+    }
+    (element._qDispatch ||= {})[scopedKebabName] = handlers;
+    // window and document events need attrs so qwik loader can find them
+    // TODO only do these when not already present
+    if (key.charAt(2) !== 'e') {
+        vnode_setAttr(diffContext.journal, vnode, key, '');
+    }
+    registerQwikLoaderEvent(diffContext, scopedKebabName);
 }
 function createElementWithNamespace(diffContext, elementName) {
     const domParentVNode = vnode_getDomParentVNode(diffContext.vParent, true);
@@ -3937,9 +3975,8 @@ function createElementWithNamespace(diffContext, elementName) {
     return element;
 }
 function expectElement(diffContext, jsx, elementName) {
-    let needsQDispatchEventPatch = false;
     if (diffContext.isCreationMode) {
-        needsQDispatchEventPatch = createNewElement(diffContext, jsx, elementName, null);
+        createNewElement(diffContext, jsx, elementName, null);
     }
     else {
         const isElementVNode = diffContext.vCurrent && vnode_isElementVNode(diffContext.vCurrent);
@@ -3949,7 +3986,7 @@ function expectElement(diffContext, jsx, elementName) {
         if (!isSameElementName || jsxKey !== currentKey) {
             const sideBufferKey = getSideBufferKey(elementName, jsxKey);
             if (moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.vParent)) {
-                needsQDispatchEventPatch = createNewElement(diffContext, jsx, elementName, null);
+                createNewElement(diffContext, jsx, elementName, null);
             }
         }
         else {
@@ -3960,48 +3997,20 @@ function expectElement(diffContext, jsx, elementName) {
     // reconcile attributes
     const jsxProps = jsx.varProps;
     const vNode = (diffContext.vNewNode || diffContext.vCurrent);
-    const element = vNode.node;
-    if (jsxProps) {
-        needsQDispatchEventPatch =
-            diffProps(diffContext, vNode, jsxProps, (isDev && getFileLocationFromJsx(jsx.dev)) || null) ||
-                needsQDispatchEventPatch;
-    }
-    if (needsQDispatchEventPatch) {
-        // Event handler needs to be patched onto the element.
-        if (!element.qDispatchEvent) {
-            element.qDispatchEvent = (event, scope) => {
-                if (vNode.flags & 32 /* VNodeFlags.Deleted */) {
-                    return;
-                }
-                const eventName = fromCamelToKebabCase(event.type);
-                const eventProp = ':' + scope.substring(1) + ':' + eventName;
-                const qrls = [
-                    vnode_getProp(vNode, eventProp, null),
-                    vnode_getProp(vNode, HANDLER_PREFIX + eventProp, null),
-                ];
-                for (const qrl of qrls.flat(2)) {
-                    if (qrl) {
-                        callQrl(diffContext.container, vNode, qrl, event, vNode.node, false).catch((e) => {
-                            diffContext.container.handleError(e, vNode);
-                        });
-                    }
-                }
-            };
-        }
+    if (jsxProps) {
+        diffProps(diffContext, vNode, jsxProps, (isDev && getFileLocationFromJsx(jsx.dev)) || null);
     }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
     if (!diffContext.isCreationMode) {
         // inflate only resumed vnodes
-        vnode_ensureElementInflated(vnode);
+        vnode_ensureElementInflated(diffContext.container, vnode);
     }
     const oldAttrs = vnode.props;
-    let patchEventDispatch = false;
     // Actual diffing logic
     // Apply all new attributes
     for (const key in newAttrs) {
         const newValue = newAttrs[key];
-        const isEvent = isHtmlAttributeAnEventName(key);
         if (oldAttrs && _hasOwnProperty.call(oldAttrs, key)) {
             const oldValue = oldAttrs[key];
             if (newValue !== oldValue) {
@@ -4010,46 +4019,40 @@ function diffProps(diffContext, vnode, newAttrs, currentFile) {
                     areWrappedSignalsEqual(newValue, oldValue)) {
                     continue;
                 }
-                if (isEvent) {
-                    const result = recordJsxEvent(diffContext, vnode, key, newValue, currentFile);
-                    patchEventDispatch ||= result;
-                }
-                else {
-                    patchProperty(diffContext, vnode, key, newValue, currentFile);
-                }
+                patchProperty(diffContext, vnode, key, newValue, currentFile);
             }
         }
         else if (newValue != null) {
-            if (isEvent) {
-                const result = recordJsxEvent(diffContext, vnode, key, newValue, currentFile);
-                patchEventDispatch ||= result;
-            }
-            else {
-                patchProperty(diffContext, vnode, key, newValue, currentFile);
-            }
+            patchProperty(diffContext, vnode, key, newValue, currentFile);
         }
     }
     if (oldAttrs) {
         // Remove attributes that no longer exist in new props
         for (const key in oldAttrs) {
             if (!_hasOwnProperty.call(newAttrs, key) &&
-                !key.startsWith(HANDLER_PREFIX) &&
+                // do not remove special attributes
+                key.charAt(0) !== ':' &&
+                // we keep these handler props to indicate to qwikloader that these events are used
                 !isHtmlAttributeAnEventName(key)) {
                 patchProperty(diffContext, vnode, key, null, currentFile);
             }
         }
     }
-    return patchEventDispatch;
 }
 const patchProperty = (diffContext, vnode, key, value, currentFile) => {
+    // During CSR we do handlers via qDispatch
+    if (isHtmlAttributeAnEventName(key)) {
+        registerEventHandlers(key, value, vnode.node, vnode, diffContext);
+        return;
+    }
     if (
     // set only property for iteration item, not an attribute
     key === ITERATION_ITEM_SINGLE ||
-        key === ITERATION_ITEM_MULTI ||
-        key.charAt(0) === HANDLER_PREFIX) {
+        key === ITERATION_ITEM_MULTI) {
         // TODO: there is a potential deoptimization here, because we are setting different keys on props.
         // Eager bailout - Insufficient type feedback for generic keyed access
         vnode_setProp(vnode, key, value);
+        vnode.flags |= 64 /* VNodeFlags.HasIterationItems */ | 128 /* VNodeFlags.InflatedIterationItems */;
         return;
     }
     const originalValue = value;
@@ -4094,29 +4097,12 @@ const patchProperty = (diffContext, vnode, key, value, currentFile) => {
     }
     setAttribute(diffContext.journal, vnode, key, value, diffContext.scopedStyleIdPrefix, originalValue);
 };
-const recordJsxEvent = (diffContext, vnode, key, value, currentFile) => {
-    const data = getEventDataFromHtmlAttribute(key);
-    if (data) {
-        const props = vnode.props;
-        const [scope, eventName] = data;
-        const scopedEvent = getScopedEventName(scope, eventName);
-        const loaderScopedEvent = getLoaderScopedEventName(scope, scopedEvent);
-        const scopedEventKey = ':' + scopedEvent;
-        if (props && _hasOwnProperty.call(props, scopedEventKey)) {
-            return false;
-        }
-        patchProperty(diffContext, vnode, scopedEventKey, value, currentFile);
-        registerQwikLoaderEvent(diffContext, loaderScopedEvent);
-        return true;
-    }
-    return false;
-};
 function registerQwikLoaderEvent(diffContext, eventName) {
     const qWindow = import.meta.env.TEST
         ? diffContext.container.document.defaultView
         : window;
     if (qWindow) {
-        (qWindow.qwikevents ||= []).push(eventName);
+        (qWindow._qwikEv ||= []).push(eventName);
     }
 }
 function retrieveChildWithKey(diffContext, nodeName, key) {
@@ -4238,7 +4224,9 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
     // 1) Try to find the node among upcoming siblings
     diffContext.vNewNode = retrieveChildWithKey(diffContext, nodeName, lookupKey);
     if (diffContext.vNewNode) {
-        vnode_insertBefore(diffContext.journal, parentForInsert, diffContext.vNewNode, diffContext.vCurrent);
+        if (!sideBufferKey) {
+            vnode_insertBefore(diffContext.journal, parentForInsert, diffContext.vNewNode, diffContext.vCurrent);
+        }
         diffContext.vCurrent = diffContext.vNewNode;
         diffContext.vNewNode = null;
         return false;
@@ -4262,7 +4250,10 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
                     }
                 }
             }
-            vnode_insertBefore(diffContext.journal, parentForInsert, buffered, diffContext.vCurrent);
+            // Only move if the node is not already in the correct position
+            if (buffered !== diffContext.vCurrent) {
+                vnode_insertBefore(diffContext.journal, parentForInsert, buffered, diffContext.vCurrent);
+            }
             diffContext.vCurrent = buffered;
             diffContext.vNewNode = null;
             return false;
@@ -4587,7 +4578,7 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
                             else if (obj instanceof SignalImpl || isStore(obj)) {
                                 clearAllEffects(container, obj);
                             }
-                            if (objIsTask || obj instanceof AsyncComputedSignalImpl) {
+                            if (objIsTask || obj instanceof AsyncSignalImpl) {
                                 cleanupDestroyable(obj);
                             }
                         }
@@ -4733,11 +4724,6 @@ function containsWrappedSignal(data, signal) {
     }
     return false;
 }
-/**
- * This marks the property as immutable. It is needed for the QRLs so that QwikLoader can get a hold
- * of them. This character must be `:` so that the `vnode_getAttr` can ignore them.
- */
-const HANDLER_PREFIX = ':';
 let count = 0;
 
 /**
@@ -4852,6 +4838,9 @@ const Resource = (props) => {
     // Resource path
     return _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
 };
+const getResolved = (resource) => resource._resolved;
+const getValue = (resource) => resource.value;
+const getLoading = (resource) => resource.loading;
 function getResourceValueAsPromise(props) {
     const resource = props.value;
     if (isResourceReturn(resource)) {
@@ -4867,14 +4856,14 @@ function getResourceValueAsPromise(props) {
                 return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
             }
             else {
-                const resolvedValue = untrack(() => resource._resolved);
+                const resolvedValue = untrack(getResolved, resource);
                 if (resolvedValue !== undefined) {
                     // resolved, pending without onPending prop or rejected without onRejected prop
                     return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
                 }
             }
         }
-        return untrack(() => resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+        return untrack(getValue, resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
     }
     else if (isPromise(resource)) {
         return resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
@@ -4971,8 +4960,8 @@ const runResource = (task, container, host) => {
      * previous one is not resolved yet. The next `runResource` run will call this cleanup
      */
     cleanups.push(() => {
-        if (untrack(() => resource.loading) === true) {
-            const value = untrack(() => resource._resolved);
+        if (untrack(getLoading, resource) === true) {
+            const value = untrack(getResolved, resource);
             setState(true, value);
         }
     });
@@ -5156,7 +5145,7 @@ function clearNodePropData(vNode) {
     delete props[NODE_PROPS_DATA_KEY];
 }
 function setNodeProp(domVNode, journal, property, value, isConst, scopedStyleIdPrefix = null) {
-    journal.push(createSetAttributeOperation(domVNode.node, property, value, scopedStyleIdPrefix, (domVNode.flags & 128 /* VNodeFlags.NS_svg */) !== 0));
+    journal.push(createSetAttributeOperation(domVNode.node, property, value, scopedStyleIdPrefix, (domVNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
     if (!isConst) {
         if (domVNode.props && value == null) {
             delete domVNode.props[property];
@@ -5549,15 +5538,6 @@ function walkCursor(cursor, options) {
     // Get starting position (resume from last position or start at root)
     let currentVNode = null;
     while ((currentVNode = cursorData.position)) {
-        // Check time budget (only for DOM, not SSR)
-        if (!isRunningOnServer && !import.meta.env.TEST) {
-            const elapsed = performance.now() - startTime;
-            if (elapsed >= timeBudget) {
-                // Schedule continuation as macrotask to actually yield to browser
-                scheduleYield();
-                return;
-            }
-        }
         if (cursorData.promise) {
             return;
         }
@@ -5632,6 +5612,15 @@ function walkCursor(cursor, options) {
             });
             return;
         }
+        // Check time budget (only for DOM, not SSR)
+        if (!isRunningOnServer && !import.meta.env.TEST) {
+            const elapsed = performance.now() - startTime;
+            if (elapsed >= timeBudget) {
+                // Schedule continuation as macrotask to actually yield to browser
+                scheduleYield();
+                return;
+            }
+        }
     }
     isDev &&
         assertFalse(!!(cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */ && !cursorData.position), 'Cursor is still dirty and position is not set after walking');
@@ -5743,7 +5732,7 @@ function addCursor(container, root, priority) {
     };
     setCursorData(root, cursorData);
     const cursor = root;
-    cursor.flags |= 64 /* VNodeFlags.Cursor */;
+    cursor.flags |= 256 /* VNodeFlags.Cursor */;
     // Add cursor to global queue
     addCursorToQueue(container, cursor);
     triggerCursors();
@@ -5756,7 +5745,7 @@ function addCursor(container, root, priority) {
  * @returns True if the vNode has the CURSOR flag set
  */
 function isCursor(vNode) {
-    return (vNode.flags & 64 /* VNodeFlags.Cursor */) !== 0;
+    return (vNode.flags & 256 /* VNodeFlags.Cursor */) !== 0;
 }
 /**
  * Finds the root cursor for the given vNode.
@@ -6140,14 +6129,14 @@ const fastGetter = (prototype, name) => {
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 const vnode_newElement = (element, elementName, key = null) => {
     isDev && assertEqual(fastNodeType(element), 1 /* ELEMENT_NODE */, 'Expecting element node.');
-    const vnode = new ElementVNode(key, 1 /* VNodeFlags.Element */ | 8 /* VNodeFlags.Inflated */ | (-1 << 9 /* VNodeFlagsIndex.shift */), // Flag
+    const vnode = new ElementVNode(key, 1 /* VNodeFlags.Element */ | 8 /* VNodeFlags.Inflated */ | (-1 << 11 /* VNodeFlagsIndex.shift */), // Flag
     null, null, null, null, null, null, element, elementName);
     element.vNode = vnode;
     return vnode;
 };
 const vnode_newUnMaterializedElement = (element) => {
     isDev && assertEqual(fastNodeType(element), 1 /* ELEMENT_NODE */, 'Expecting element node.');
-    const vnode = new ElementVNode(null, 1 /* VNodeFlags.Element */ | (-1 << 9 /* VNodeFlagsIndex.shift */), // Flag
+    const vnode = new ElementVNode(null, 1 /* VNodeFlags.Element */ | (-1 << 11 /* VNodeFlagsIndex.shift */), // Flag
     null, null, null, null, undefined, undefined, element, undefined);
     element.vNode = vnode;
     return vnode;
@@ -6156,7 +6145,7 @@ const vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
     isDev &&
         sharedTextNode &&
         assertEqual(fastNodeType(sharedTextNode), 3 /* TEXT_NODE */, 'Expecting text node.');
-    const vnode = new TextVNode(4 /* VNodeFlags.Text */ | (-1 << 9 /* VNodeFlagsIndex.shift */), // Flag
+    const vnode = new TextVNode(4 /* VNodeFlags.Text */ | (-1 << 11 /* VNodeFlagsIndex.shift */), // Flag
     null, // Parent
     previousTextNode, // Previous TextNode (usually first child)
     null, // Next sibling
@@ -6164,7 +6153,7 @@ const vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
     return vnode;
 };
 const vnode_newText = (textNode, textContent) => {
-    const vnode = new TextVNode(4 /* VNodeFlags.Text */ | 8 /* VNodeFlags.Inflated */ | (-1 << 9 /* VNodeFlagsIndex.shift */), // Flags
+    const vnode = new TextVNode(4 /* VNodeFlags.Text */ | 8 /* VNodeFlags.Inflated */ | (-1 << 11 /* VNodeFlagsIndex.shift */), // Flags
     null, // Parent
     null, // No previous sibling
     null, // We may have a next sibling.
@@ -6178,7 +6167,7 @@ const vnode_newText = (textNode, textContent) => {
     return vnode;
 };
 const vnode_newVirtual = () => {
-    const vnode = new VirtualVNode(null, 2 /* VNodeFlags.Virtual */ | (-1 << 9 /* VNodeFlagsIndex.shift */), // Flags
+    const vnode = new VirtualVNode(null, 2 /* VNodeFlags.Virtual */ | (-1 << 11 /* VNodeFlagsIndex.shift */), // Flags
     null, null, null, null, null, null);
     isDev && assertFalse(vnode_isElementVNode(vnode), 'Incorrect format of TextVNode.');
     isDev && assertFalse(vnode_isTextVNode(vnode), 'Incorrect format of TextVNode.');
@@ -6274,7 +6263,7 @@ const vnode_setAttr = (journal, vNode, key, value, scopedStyleIdPrefix = null) =
             scopedStyleIdPrefix &&
             vnode_setProp(vNode, debugStyleScopeIdPrefixAttr, scopedStyleIdPrefix);
         vnode_setProp(vNode, key, value);
-        addVNodeOperation(journal, createSetAttributeOperation(vNode.node, key, value, scopedStyleIdPrefix, (vNode.flags & 128 /* VNodeFlags.NS_svg */) !== 0));
+        addVNodeOperation(journal, createSetAttributeOperation(vNode.node, key, value, scopedStyleIdPrefix, (vNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
     }
 };
 const vnode_ensureElementKeyInflated = (vnode) => {
@@ -6287,16 +6276,23 @@ const vnode_ensureElementKeyInflated = (vnode) => {
     }
 };
 /** @internal */
-const vnode_ensureElementInflated = (vnode) => {
+const vnode_ensureElementInflated = (container, vnode) => {
     if ((vnode.flags & 15 /* VNodeFlags.INFLATED_TYPE_MASK */) === 1 /* VNodeFlags.Element */) {
         const elementVNode = vnode;
         elementVNode.flags ^= 8 /* VNodeFlags.Inflated */;
         const element = elementVNode.node;
         const attributes = element.attributes;
+        let isConst = false;
         for (let idx = 0; idx < attributes.length; idx++) {
             const attr = attributes[idx];
             const key = attr.name;
-            if (key === Q_PROPS_SEPARATOR || !key) {
+            // We need to grab all handlers, even const ones, because as soon as qDispatch exists, qwikloader will use it
+            if (isHtmlAttributeAnEventName(key)) {
+                registerQrlHandlers(attr, key, container, element);
+                continue;
+            }
+            if (isConst) ;
+            else if (key === Q_PROPS_SEPARATOR || !key) {
                 // SVG in Domino does not support ':' so it becomes an empty string.
                 // all attributes after the ':' are considered immutable, and so we ignore them.
                 const value = attr.value;
@@ -6304,7 +6300,7 @@ const vnode_ensureElementInflated = (vnode) => {
                     // don't assign empty string as a key
                     elementVNode.key = value;
                 }
-                break;
+                isConst = true;
             }
             else if (key.startsWith(QContainerAttr)) {
                 const value = attr.value;
@@ -6315,13 +6311,29 @@ const vnode_ensureElementInflated = (vnode) => {
                     vnode_setProp(elementVNode, 'value', element.value);
                 }
             }
-            else if (!key.startsWith("on:" /* EventNameHtmlScope.on */)) {
+            else {
                 const value = attr.value;
                 vnode_setProp(elementVNode, key, value);
             }
         }
+        if (vnode_getProp(elementVNode, ITERATION_ITEM_SINGLE, null) !== null ||
+            vnode_getProp(elementVNode, ITERATION_ITEM_MULTI, null) !== null) {
+            vnode.flags |= 64 /* VNodeFlags.HasIterationItems */;
+        }
     }
 };
+function registerQrlHandlers(attr, key, container, element) {
+    const value = attr.value;
+    const scopedKebabName = key.slice(2);
+    const qrls = value.split('|');
+    const handlers = qrls.map((qrl) => {
+        const handler = parseQRL(qrl);
+        handler.$container$ = container;
+        // These QRLs are mostly _run and _task and don't need wrapping with retryOnPromise
+        return handler;
+    });
+    (element._qDispatch ||= {})[scopedKebabName] = handlers;
+}
 /** Walks the VNode tree and materialize it using `vnode_getFirstChild`. */
 function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
@@ -6407,6 +6419,21 @@ function vnode_getDOMChildNodes(journal, root, isVNode = false, childNodes = [])
     }
     return childNodes;
 }
+function vnode_getDOMContainer(vNode) {
+    let cursor = vNode;
+    while (cursor) {
+        if (vnode_isElementVNode(cursor)) {
+            try {
+                return getDomContainer(cursor.node);
+            }
+            catch {
+                return null;
+            }
+        }
+        cursor = cursor.parent;
+    }
+    return null;
+}
 /**
  * Returns the previous/next sibling but from the point of view of the DOM.
  *
@@ -6620,7 +6647,7 @@ const vnode_locate = (rootVNode, id) => {
 const vnode_getChildWithIdx = (vNode, childIdx) => {
     let child = vnode_getFirstChild(vNode);
     isDev && assertDefined(child, 'Missing child.');
-    while (child.flags >>> 9 /* VNodeFlagsIndex.shift */ !== childIdx) {
+    while (child.flags >>> 11 /* VNodeFlagsIndex.shift */ !== childIdx) {
         child = child.nextSibling;
         isDev && assertDefined(child, 'Missing child.');
     }
@@ -7250,10 +7277,10 @@ const processVNodeData$1 = (vData, callback) => {
     }
 };
 /** @internal */
-const vnode_getAttrKeys = (vnode) => {
+const vnode_getAttrKeys = (container, vnode) => {
     const type = vnode.flags;
     if ((type & 3 /* VNodeFlags.ELEMENT_OR_VIRTUAL_MASK */) !== 0) {
-        vnode_ensureElementInflated(vnode);
+        vnode_ensureElementInflated(container, vnode);
         const keys = [];
         const props = vnode.props;
         if (props) {
@@ -7287,7 +7314,7 @@ const vnode_getNode = (vnode) => {
     return vnode.node;
 };
 /** @internal */
-function vnode_toString(depth = 20, offset = '', materialize = false, siblings = false, colorize = true) {
+function vnode_toString(depth = 20, offset = '', materialize = false, siblings = false, colorize = true, container = this && vnode_getDOMContainer(this)) {
     let vnode = this;
     if (depth === 0) {
         return '...';
@@ -7306,12 +7333,12 @@ function vnode_toString(depth = 20, offset = '', materialize = false, siblings =
             strings.push(qwikDebugToString(vnode_getText(vnode)));
         }
         else if (vnode_isVirtualVNode(vnode)) {
-            const idx = vnode.flags >>> 9 /* VNodeFlagsIndex.shift */;
+            const idx = vnode.flags >>> 11 /* VNodeFlagsIndex.shift */;
             const attrs = ['[' + String(idx) + ']'];
             if (vnode.dirty) {
                 attrs.push(` dirty:${vnode.dirty}`);
             }
-            vnode_getAttrKeys(vnode).forEach((key) => {
+            vnode_getAttrKeys(container, vnode).forEach((key) => {
                 if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
                     const value = vnode_getProp(vnode, key, null);
                     attrs.push(' ' + key + '=' + qwikDebugToString(value));
@@ -7339,7 +7366,7 @@ function vnode_toString(depth = 20, offset = '', materialize = false, siblings =
             if (vnode.dirtyChildren) {
                 attrs.push(` dirtyChildren[${vnode.dirtyChildren.length}]`);
             }
-            const keys = vnode_getAttrKeys(vnode);
+            const keys = vnode_getAttrKeys(container, vnode);
             for (const key of keys) {
                 const value = vnode_getProp(vnode, key, null);
                 attrs.push(' ' + key + '=' + qwikDebugToString(value));
@@ -7391,7 +7418,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
     let vLast = null;
     let previousTextNode = null;
     const addVNode = (node) => {
-        node.flags = (node.flags & 511 /* VNodeFlagsIndex.mask */) | (idx << 9 /* VNodeFlagsIndex.shift */);
+        node.flags = (node.flags & 2047 /* VNodeFlagsIndex.mask */) | (idx << 11 /* VNodeFlagsIndex.shift */);
         idx++;
         vLast && (vLast.nextSibling = node);
         node.previousSibling = vLast;
@@ -7677,16 +7704,6 @@ function setLocale(locale) {
 
 let _context;
 const tryGetInvokeContext = () => {
-    if (!_context) {
-        const context = typeof document !== 'undefined' && document && document.__q_context__;
-        if (!context) {
-            return undefined;
-        }
-        if (isArray(context)) {
-            return (document.__q_context__ = newInvokeContextFromTuple(context));
-        }
-        return context;
-    }
     return _context;
 };
 const getInvokeContext = () => {
@@ -7722,29 +7739,27 @@ function invoke(context, fn, ...args) {
 /** Call a function with the given InvokeContext and array of arguments. */
 function invokeApply(context, fn, args) {
     const previousContext = _context;
-    let returnValue;
     try {
         _context = context;
-        returnValue = fn.apply(this, args);
+        return fn.apply(this, args);
     }
     finally {
         _context = previousContext;
     }
-    return returnValue;
 }
-const newInvokeContextFromTuple = ([element, event, url]) => {
+const newInvokeContextFromDOM = (event, element) => {
     const domContainer = getDomContainer(element);
     const hostElement = vnode_locate(domContainer.rootVNode, element);
     const locale = domContainer.$locale$;
     locale && setLocale(locale);
-    return newInvokeContext(locale, hostElement, event, url);
+    const context = newInvokeContext(locale, hostElement, event);
+    context.$container$ = domContainer;
+    return context;
 };
-function newRenderInvokeContext(locale, hostElement, container, url) {
+function newRenderInvokeContext(locale, hostElement, container) {
     const ctx = {
-        $url$: url,
         $hostElement$: hostElement,
         $event$: RenderEvent,
-        $qrl$: undefined,
         $effectSubscriber$: undefined,
         $locale$: locale,
         $container$: container,
@@ -7754,14 +7769,12 @@ function newRenderInvokeContext(locale, hostElement, container, url) {
     return ctx;
 }
 // TODO how about putting url and locale (and event/custom?) in to a "static" object
-function newInvokeContext(locale, hostElement, event, url) {
+function newInvokeContext(locale, hostElement, event) {
     // ServerRequestEvent has .locale, but it's not always defined.
     const $locale$ = locale || (event && isObject(event) && 'locale' in event ? event.locale : undefined);
     const ctx = {
-        $url$: url,
         $hostElement$: hostElement,
         $event$: event,
-        $qrl$: undefined,
         $effectSubscriber$: undefined,
         $locale$,
         $container$: undefined,
@@ -7832,24 +7845,8 @@ const trackSignalAndAssignHost = (value, host, property, container, data) => {
     return trackSignal(() => value.value, host, property, container, data);
 };
 /** @internal */
-const _getContextElement = () => {
-    const iCtx = tryGetInvokeContext();
-    if (iCtx) {
-        const hostElement = iCtx.$hostElement$;
-        let element = null;
-        if (hostElement != null) {
-            if (vnode_isVNode(hostElement)) {
-                if (vnode_isElementVNode(hostElement)) {
-                    element = vnode_getNode(hostElement);
-                }
-            }
-            else {
-                // isSSRnode
-                element = hostElement;
-            }
-        }
-        return element ?? iCtx.$qrl$?.$setContainer$(undefined);
-    }
+const _getContextHostElement = () => {
+    return tryGetInvokeContext()?.$hostElement$;
 };
 /** @internal */
 const _getContextEvent = () => {
@@ -7874,10 +7871,8 @@ const _jsxBranch = (input) => {
     return input;
 };
 /** @internal */
-const _waitUntilRendered = (elm) => {
-    const container = getDomContainer(elm);
-    const promise = container?.$renderPromise$;
-    return promise || Promise.resolve();
+const _waitUntilRendered = (container) => {
+    return container.$renderPromise$ || Promise.resolve();
 };
 
 // <docs markdown="../readme.md#createContextId">
@@ -8158,6 +8153,7 @@ const _typeIdNames = [
     'URL',
     'Date',
     'Regex',
+    'QRL',
     'VNode',
     'RefVNode',
     'BigInt',
@@ -8168,15 +8164,13 @@ const _typeIdNames = [
     'Set',
     'Map',
     'Uint8Array',
-    'QRL',
-    'PreloadQRL',
     'Task',
     'Resource',
     'Component',
     'Signal',
     'WrappedSignal',
     'ComputedSignal',
-    'AsyncComputedSignal',
+    'AsyncSignal',
     'SerializerSignal',
     'Store',
     'FormData',
@@ -8186,61 +8180,64 @@ const _typeIdNames = [
     'EffectSubscription',
 ];
 
-function qrlToString(serializationContext, value, raw) {
-    let symbol = value.$symbol$;
-    let chunk = value.$chunk$;
+function qrlToString(serializationContext, qrl, raw) {
+    let symbol = qrl.$symbol$;
+    let chunk = qrl.$chunk$;
     const platform = getPlatform();
     if (platform) {
-        const result = platform.chunkForSymbol(symbol, chunk, value.dev?.file);
+        const result = isDev
+            ? platform.chunkForSymbol(symbol, chunk, qrl.dev?.file)
+            : platform.chunkForSymbol(symbol, chunk);
         if (result) {
             chunk = result[1];
             symbol = result[0];
         }
     }
-    const isSync = isSyncQrl(value);
+    const isSync = isSyncQrl(qrl);
     if (!isSync) {
         // If we have a symbol we need to resolve the chunk.
         if (!chunk) {
-            chunk = serializationContext.$symbolToChunkResolver$(value.$hash$);
+            chunk = serializationContext.$symbolToChunkResolver$(qrl.$hash$);
         }
         // in Dev mode we need to keep track of the symbols
         if (isDev) {
             const backChannel = (globalThis.__qrl_back_channel__ ||=
                 new Map());
             // During tests the resolved value is always available
-            backChannel.set(value.$symbol$, value.resolved);
+            backChannel.set(qrl.$symbol$, qrl.$symbolRef$);
             if (!chunk) {
                 chunk = QRL_RUNTIME_CHUNK;
             }
         }
         if (!chunk) {
-            throw qError(14 /* QError.qrlMissingChunk */, [value.$symbol$]);
+            throw qError(14 /* QError.qrlMissingChunk */, [qrl.$symbol$]);
         }
         if (chunk.startsWith('./')) {
             chunk = chunk.slice(2);
         }
     }
     else {
-        const fn = value.resolved;
+        const fn = qrl.resolved;
         chunk = '';
         // TODO test that provided stringified fn is used
         symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
     }
-    let capturedIds = null;
-    if (Array.isArray(value.$captureRef$) && value.$captureRef$.length > 0) {
+    const captures = qrl.getCaptured();
+    let captureIds = null;
+    if (captures && captures.length > 0) {
         // We refer by id so every capture needs to be a root
-        capturedIds = value.$captureRef$.map((ref) => `${serializationContext.$addRoot$(ref)}`);
+        captureIds = captures.map((ref) => `${serializationContext.$addRoot$(ref)}`).join(' ');
     }
     if (raw) {
-        return [chunk, symbol, capturedIds];
+        return [chunk, symbol, captureIds];
     }
     let qrlStringInline = `${chunk}#${symbol}`;
-    if (capturedIds && capturedIds.length > 0) {
-        qrlStringInline += `[${capturedIds.join(' ')}]`;
+    if (captureIds) {
+        qrlStringInline += `#${captureIds}`;
     }
     return qrlStringInline;
 }
-function createQRLWithBackChannel(chunk, symbol, captureIds) {
+function createQRLWithBackChannel(chunk, symbol, captures) {
     let qrlImporter = null;
     if (isDev && chunk === QRL_RUNTIME_CHUNK) {
         const backChannel = globalThis.__qrl_back_channel__;
@@ -8250,23 +8247,12 @@ function createQRLWithBackChannel(chunk, symbol, captureIds) {
             qrlImporter = () => Promise.resolve({ [symbol]: fn });
         }
     }
-    return createQRL(chunk, symbol, null, qrlImporter, captureIds, null);
+    return createQRL(chunk, symbol, null, qrlImporter, captures);
 }
-/** Parses "chunk#hash[...rootRef]" */
+/** Parses "chunk#hash#...rootRef" */
 function parseQRL(qrl) {
-    const hashIdx = qrl.indexOf('#');
-    const captureStart = qrl.indexOf('[', hashIdx);
-    const captureEnd = qrl.indexOf(']', captureStart);
-    const chunk = hashIdx > -1 ? qrl.slice(0, hashIdx) : qrl.slice(0, captureStart);
-    const symbol = captureStart > -1 ? qrl.slice(hashIdx + 1, captureStart) : qrl.slice(hashIdx + 1);
-    const captureIds = captureStart > -1 && captureEnd > -1
-        ? qrl
-            .slice(captureStart + 1, captureEnd)
-            .split(' ')
-            .filter((v) => v.length)
-            .map((s) => parseInt(s, 10))
-        : null;
-    return createQRLWithBackChannel(chunk, symbol, captureIds);
+    const [chunk, symbol, captures] = qrl.split('#');
+    return createQRLWithBackChannel(chunk, symbol, captures || null);
 }
 const QRL_RUNTIME_CHUNK = 'mock-chunk';
 
@@ -8289,7 +8275,7 @@ const allocate = (container, typeId, value) => {
             else {
                 return container.$getObjectById$(rootRef);
             }
-        case 13 /* TypeIds.ForwardRefs */:
+        case 14 /* TypeIds.ForwardRefs */:
             return value;
         case 3 /* TypeIds.Constant */:
             return _constants[value];
@@ -8297,22 +8283,24 @@ const allocate = (container, typeId, value) => {
             return Array(value.length / 2);
         case 5 /* TypeIds.Object */:
             return {};
-        case 19 /* TypeIds.QRL */:
-        case 20 /* TypeIds.PreloadQRL */: {
+        case 9 /* TypeIds.QRL */: {
+            let qrl;
             if (typeof value === 'string') {
-                const data = value.split(' ').map(Number);
-                const chunk = container.$getObjectById$(data[0]);
-                const symbol = container.$getObjectById$(data[1]);
-                const captureIds = data.length > 2 ? data.slice(2) : null;
-                return createQRLWithBackChannel(chunk, symbol, captureIds);
+                const [chunkId, symbolId, captureIds] = value.split('#');
+                const chunk = container.$getObjectById$(chunkId);
+                const symbol = container.$getObjectById$(symbolId);
+                qrl = createQRLWithBackChannel(chunk, symbol, captureIds || null);
             }
             else {
-                return createQRLWithBackChannel('', String(value));
+                // Sync qrl
+                qrl = createQRLWithBackChannel('', String(value), null);
             }
+            qrl.$container$ = container;
+            return qrl;
         }
-        case 21 /* TypeIds.Task */:
+        case 20 /* TypeIds.Task */:
             return new Task(-1, -1, null, null, null, null);
-        case 22 /* TypeIds.Resource */: {
+        case 21 /* TypeIds.Resource */: {
             const res = createResourceReturn(container, 
             // we don't care about the timeout value
             undefined, undefined);
@@ -8326,21 +8314,21 @@ const allocate = (container, typeId, value) => {
         case 8 /* TypeIds.Regex */:
             const idx = value.lastIndexOf('/');
             return new RegExp(value.slice(1, idx), value.slice(idx + 1));
-        case 14 /* TypeIds.Error */:
+        case 15 /* TypeIds.Error */:
             return new Error();
-        case 23 /* TypeIds.Component */:
+        case 22 /* TypeIds.Component */:
             return componentQrl(null);
-        case 24 /* TypeIds.Signal */:
+        case 23 /* TypeIds.Signal */:
             return new SignalImpl(container, 0);
-        case 25 /* TypeIds.WrappedSignal */:
+        case 24 /* TypeIds.WrappedSignal */:
             return new WrappedSignalImpl(container, null, null, null);
-        case 26 /* TypeIds.ComputedSignal */:
+        case 25 /* TypeIds.ComputedSignal */:
             return new ComputedSignalImpl(container, null);
-        case 27 /* TypeIds.AsyncComputedSignal */:
-            return new AsyncComputedSignalImpl(container, null);
-        case 28 /* TypeIds.SerializerSignal */:
+        case 26 /* TypeIds.AsyncSignal */:
+            return new AsyncSignalImpl(container, null);
+        case 27 /* TypeIds.SerializerSignal */:
             return new SerializerSignalImpl(container, null);
-        case 29 /* TypeIds.Store */: {
+        case 28 /* TypeIds.Store */: {
             const data = value;
             // We need to allocate the store first, before we inflate its data, because the data can
             // reference the store itself (circular)
@@ -8357,19 +8345,19 @@ const allocate = (container, typeId, value) => {
             data[1] = storeValue;
             return store;
         }
-        case 12 /* TypeIds.URLSearchParams */:
+        case 13 /* TypeIds.URLSearchParams */:
             return new URLSearchParams(value);
-        case 30 /* TypeIds.FormData */:
+        case 29 /* TypeIds.FormData */:
             return new FormData();
-        case 31 /* TypeIds.JSXNode */:
+        case 30 /* TypeIds.JSXNode */:
             return new JSXNodeImpl(null, null, null, null, null);
-        case 11 /* TypeIds.BigInt */:
+        case 12 /* TypeIds.BigInt */:
             return BigInt(value);
-        case 16 /* TypeIds.Set */:
+        case 17 /* TypeIds.Set */:
             return new Set();
-        case 17 /* TypeIds.Map */:
+        case 18 /* TypeIds.Map */:
             return new Map();
-        case 15 /* TypeIds.Promise */:
+        case 16 /* TypeIds.Promise */:
             let resolve;
             let reject;
             const promise = new Promise((res, rej) => {
@@ -8380,17 +8368,17 @@ const allocate = (container, typeId, value) => {
             // Don't leave unhandled promise rejections
             promise.catch(() => { });
             return promise;
-        case 18 /* TypeIds.Uint8Array */:
+        case 19 /* TypeIds.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 32 /* TypeIds.PropsProxy */:
+        case 31 /* TypeIds.PropsProxy */:
             return createPropsProxy(null);
-        case 9 /* TypeIds.VNode */:
+        case 10 /* TypeIds.VNode */:
             return retrieveVNodeOrDocument(container, value);
-        case 10 /* TypeIds.RefVNode */:
+        case 11 /* TypeIds.RefVNode */:
             const vNode = retrieveVNodeOrDocument(container, value);
             if (vnode_isVNode(vNode)) {
                 /**
@@ -8424,9 +8412,9 @@ const allocate = (container, typeId, value) => {
             else {
                 throw qError(17 /* QError.serializeErrorExpectedVNode */, [typeof vNode]);
             }
-        case 33 /* TypeIds.SubscriptionData */:
+        case 32 /* TypeIds.SubscriptionData */:
             return new SubscriptionData({});
-        case 34 /* TypeIds.EffectSubscription */:
+        case 33 /* TypeIds.EffectSubscription */:
             return new EffectSubscription(null, null, null, null);
         default:
             throw qError(18 /* QError.serializeErrorCannotAllocate */, [typeId]);
@@ -8463,7 +8451,7 @@ const EXTRACT_FILE_NAME = /[\\/(]([\w\d.\-_]+\.(js|ts)x?):/;
  * @see `QRL`, `$(...)`
  */
 // </docs>
-const qrl = (chunkOrFn, symbol, lexicalScopeCapture = EMPTY_ARRAY, stackOffset = 0) => {
+const qrl = (chunkOrFn, symbol, lexicalScopeCapture, stackOffset = 0) => {
     let chunk = null;
     let symbolFn = null;
     if (isFunction(chunkOrFn)) {
@@ -8499,7 +8487,7 @@ const qrl = (chunkOrFn, symbol, lexicalScopeCapture = EMPTY_ARRAY, stackOffset =
         throw qError(7 /* QError.unknownTypeArgument */, [chunkOrFn]);
     }
     // Unwrap subscribers
-    return createQRL(chunk, symbol, null, symbolFn, null, lexicalScopeCapture);
+    return createQRL(chunk, symbol, null, symbolFn, lexicalScopeCapture);
 };
 /**
  * Create an inlined QRL. This is mostly useful on the server side for serialization.
@@ -8510,28 +8498,28 @@ const qrl = (chunkOrFn, symbol, lexicalScopeCapture = EMPTY_ARRAY, stackOffset =
  * @param lexicalScopeCapture - A set of lexically scoped variables to capture.
  * @public
  */
-const inlinedQrl = (symbol, symbolName, lexicalScopeCapture = EMPTY_ARRAY) => {
+const inlinedQrl = (symbol, symbolName, lexicalScopeCapture) => {
     // Unwrap subscribers
-    return createQRL(null, symbolName, symbol, null, null, lexicalScopeCapture);
+    return createQRL(null, symbolName, symbol, null, lexicalScopeCapture);
 };
 /** @internal */
-const _noopQrl = (symbolName, lexicalScopeCapture = EMPTY_ARRAY) => {
-    return createQRL(null, symbolName, null, null, null, lexicalScopeCapture);
+const _noopQrl = (symbolName, lexicalScopeCapture) => {
+    return createQRL(null, symbolName, null, null, lexicalScopeCapture);
 };
 /** @internal */
-const _noopQrlDEV = (symbolName, opts, lexicalScopeCapture = EMPTY_ARRAY) => {
+const _noopQrlDEV = (symbolName, opts, lexicalScopeCapture) => {
     const newQrl = _noopQrl(symbolName, lexicalScopeCapture);
     newQrl.dev = opts;
     return newQrl;
 };
 /** @internal */
-const qrlDEV = (chunkOrFn, symbol, opts, lexicalScopeCapture = EMPTY_ARRAY) => {
+const qrlDEV = (chunkOrFn, symbol, opts, lexicalScopeCapture) => {
     const newQrl = qrl(chunkOrFn, symbol, lexicalScopeCapture, 1);
     newQrl.dev = opts;
     return newQrl;
 };
 /** @internal */
-const inlinedQrlDEV = (symbol, symbolName, opts, lexicalScopeCapture = EMPTY_ARRAY) => {
+const inlinedQrlDEV = (symbol, symbolName, opts, lexicalScopeCapture) => {
     const qrl = inlinedQrl(symbol, symbolName, lexicalScopeCapture);
     qrl.dev = opts;
     return qrl;
@@ -8579,7 +8567,6 @@ async function serialize(serializationContext) {
     const forwardRefs = [];
     let forwardRefsId = 0;
     const promises = new Set();
-    const preloadQrls = new Set();
     const s11nWeakRefs = new Map();
     let parent;
     const qrlMap = new Map();
@@ -8632,12 +8619,6 @@ async function serialize(serializationContext) {
             });
         }
     };
-    const addPreloadQrl = (qrl) => {
-        if (!isSyncQrl(qrl)) {
-            preloadQrls.add(qrl);
-            serializationContext.$addRoot$(qrl);
-        }
-    };
     const getSeenRefOrOutput = (value, index, keepWeak) => {
         let seen = getSeenRef(value);
         const forwardRefIdx = !keepWeak && s11nWeakRefs.get(value);
@@ -8728,7 +8709,7 @@ async function serialize(serializationContext) {
                     break;
                 case 'bigint':
                     if ((value < 10000 && value > -1e3) || getSeenRefOrOutput(value, index)) {
-                        output(11 /* TypeIds.BigInt */, value.toString());
+                        output(12 /* TypeIds.BigInt */, value.toString());
                     }
                     break;
                 case 'symbol':
@@ -8751,12 +8732,11 @@ async function serialize(serializationContext) {
                     }
                     else if (isQrl(value)) {
                         if (getSeenRefOrOutput(value, index)) {
-                            const [chunk, symbol, captureIds] = qrlToString(serializationContext, value, true);
+                            const [chunk, symbol, captures] = qrlToString(serializationContext, value, true);
                             let data;
-                            let type;
                             if (chunk !== '') {
                                 // not a sync QRL, replace all parts with string references
-                                data = `${$addRoot$(chunk)} ${$addRoot$(symbol)}${captureIds ? ' ' + captureIds.join(' ') : ''}`;
+                                data = `${$addRoot$(chunk)}#${$addRoot$(symbol)}${captures ? '#' + captures : ''}`;
                                 // Since we map QRLs to strings, we need to keep track of this secondary mapping
                                 const existing = qrlMap.get(data);
                                 if (existing) {
@@ -8768,19 +8748,18 @@ async function serialize(serializationContext) {
                                 else {
                                     qrlMap.set(data, value);
                                 }
-                                type = preloadQrls.has(value) ? 20 /* TypeIds.PreloadQRL */ : 19 /* TypeIds.QRL */;
                             }
                             else {
+                                // sync QRL
                                 data = Number(symbol);
-                                type = 19 /* TypeIds.QRL */;
                             }
-                            output(type, data);
+                            output(9 /* TypeIds.QRL */, data);
                         }
                     }
                     else if (isQwikComponent(value)) {
                         const [qrl] = value[SERIALIZABLE_STATE];
                         serializationContext.$renderSymbols$.add(qrl.$symbol$);
-                        output(23 /* TypeIds.Component */, [qrl]);
+                        output(22 /* TypeIds.Component */, [qrl]);
                     }
                     else {
                         throw qError(34 /* QError.serializeErrorCannotSerializeFunction */, [value.toString()]);
@@ -8818,7 +8797,7 @@ async function serialize(serializationContext) {
     const writeObjectValue = (value) => {
         if (isPropsProxy(value)) {
             const owner = value[_OWNER];
-            output(32 /* TypeIds.PropsProxy */, [
+            output(31 /* TypeIds.PropsProxy */, [
                 _serializationWeakRef(owner),
                 owner.varProps,
                 owner.constProps,
@@ -8826,10 +8805,10 @@ async function serialize(serializationContext) {
             ]);
         }
         else if (value instanceof SubscriptionData) {
-            output(33 /* TypeIds.SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+            output(32 /* TypeIds.SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
         }
         else if (value instanceof EffectSubscription) {
-            output(34 /* TypeIds.EffectSubscription */, [
+            output(33 /* TypeIds.EffectSubscription */, [
                 value.consumer,
                 value.property,
                 value.backRef,
@@ -8842,7 +8821,7 @@ async function serialize(serializationContext) {
                 serializationContext.$resources$.add(value);
                 // TODO the effects include the resource return which has duplicate data
                 const forwardRefId = resolvePromise(value.value, $addRoot$, (resolved, resolvedValue) => {
-                    return new PromiseResult(22 /* TypeIds.Resource */, resolved, resolvedValue, getStoreHandler(value).$effects$);
+                    return new PromiseResult(21 /* TypeIds.Resource */, resolved, resolvedValue, getStoreHandler(value).$effects$);
                 });
                 output(2 /* TypeIds.ForwardRef */, forwardRefId);
             }
@@ -8864,14 +8843,14 @@ async function serialize(serializationContext) {
                 while (out[out.length - 1] === undefined) {
                     out.pop();
                 }
-                output(29 /* TypeIds.Store */, out);
+                output(28 /* TypeIds.Store */, out);
             }
         }
         else if (isSerializerObj(value)) {
             const result = value[SerializerSymbol](value);
             if (isPromise(result)) {
                 const forwardRef = resolvePromise(result, $addRoot$, (resolved, resolvedValue) => {
-                    return new PromiseResult(28 /* TypeIds.SerializerSignal */, resolved, resolvedValue, undefined, undefined);
+                    return new PromiseResult(27 /* TypeIds.SerializerSignal */, resolved, resolvedValue, undefined, undefined);
                 });
                 output(2 /* TypeIds.ForwardRef */, forwardRef);
             }
@@ -8901,20 +8880,19 @@ async function serialize(serializationContext) {
         }
         else if ($isDomRef$(value)) {
             value.$ssrNode$.vnodeData[0] |= 16 /* VNodeDataFlag.SERIALIZE */;
-            output(10 /* TypeIds.RefVNode */, value.$ssrNode$.id);
+            output(11 /* TypeIds.RefVNode */, value.$ssrNode$.id);
         }
         else if (value instanceof SignalImpl) {
             if (value instanceof SerializerSignalImpl) {
-                addPreloadQrl(value.$computeQrl$);
                 const maybeValue = getCustomSerializerPromise(value, value.$untrackedValue$);
                 if (isPromise(maybeValue)) {
                     const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => {
-                        return new PromiseResult(28 /* TypeIds.SerializerSignal */, resolved, resolvedValue, value.$effects$, value.$computeQrl$);
+                        return new PromiseResult(27 /* TypeIds.SerializerSignal */, resolved, resolvedValue, value.$effects$, value.$computeQrl$);
                     });
                     output(2 /* TypeIds.ForwardRef */, forwardRefId);
                 }
                 else {
-                    output(28 /* TypeIds.SerializerSignal */, [
+                    output(27 /* TypeIds.SerializerSignal */, [
                         value.$computeQrl$,
                         filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                         value.$effects$,
@@ -8924,7 +8902,7 @@ async function serialize(serializationContext) {
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
-                output(25 /* TypeIds.WrappedSignal */, [
+                output(24 /* TypeIds.WrappedSignal */, [
                     ...serializeWrappingFn(serializationContext, value),
                     filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$flags$,
@@ -8934,8 +8912,8 @@ async function serialize(serializationContext) {
             }
             else if (value instanceof ComputedSignalImpl) {
                 let v = value.$untrackedValue$;
-                const shouldAlwaysSerialize = value.$flags$ & 32 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
-                const shouldNeverSerialize = value.$flags$ & 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
+                const shouldAlwaysSerialize = value.$flags$ & 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
+                const shouldNeverSerialize = value.$flags$ & 8 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
                 const isInvalid = value.$flags$ & 1 /* SignalFlags.INVALID */;
                 const isSkippable = fastSkipSerialize(value.$untrackedValue$);
                 if (shouldAlwaysSerialize) {
@@ -8947,13 +8925,12 @@ async function serialize(serializationContext) {
                 else if (isInvalid || isSkippable) {
                     v = NEEDS_COMPUTATION;
                 }
-                addPreloadQrl(value.$computeQrl$);
                 const out = [
                     value.$computeQrl$,
                     filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$effects$,
                 ];
-                const isAsync = value instanceof AsyncComputedSignalImpl;
+                const isAsync = value instanceof AsyncSignalImpl;
                 if (isAsync) {
                     out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$);
                 }
@@ -8969,7 +8946,7 @@ async function serialize(serializationContext) {
                         keepUndefined = true;
                     }
                 }
-                output(isAsync ? 27 /* TypeIds.AsyncComputedSignal */ : 26 /* TypeIds.ComputedSignal */, out, keepUndefined);
+                output(isAsync ? 26 /* TypeIds.AsyncSignal */ : 25 /* TypeIds.ComputedSignal */, out, keepUndefined);
             }
             else {
                 const v = value.$untrackedValue$;
@@ -8978,7 +8955,7 @@ async function serialize(serializationContext) {
                 if (value.$effects$) {
                     out.push(...value.$effects$);
                 }
-                output(24 /* TypeIds.Signal */, out, keepUndefined);
+                output(23 /* TypeIds.Signal */, out, keepUndefined);
             }
         }
         else if (value instanceof URL) {
@@ -8998,13 +8975,13 @@ async function serialize(serializationContext) {
             if (isDev) {
                 out.push('stack', value.stack);
             }
-            output(14 /* TypeIds.Error */, out);
+            output(15 /* TypeIds.Error */, out);
         }
         else if ($isSsrNode$(value)) {
             const rootIndex = $addRoot$(value);
             serializationContext.$setProp$(value, ELEMENT_ID, String(rootIndex));
             // we need to output before the vnode overwrites its values
-            output(9 /* TypeIds.VNode */, value.id);
+            output(10 /* TypeIds.VNode */, value.id);
             const vNodeData = value.vnodeData;
             if (vNodeData) {
                 discoverValuesForVNodeData(vNodeData, (vNodeDataValue) => $addRoot$(vNodeDataValue));
@@ -9040,20 +9017,20 @@ async function serialize(serializationContext) {
                     array.push(key, value.name);
                 }
             });
-            output(30 /* TypeIds.FormData */, array);
+            output(29 /* TypeIds.FormData */, array);
         }
         else if (value instanceof URLSearchParams) {
-            output(12 /* TypeIds.URLSearchParams */, value.toString());
+            output(13 /* TypeIds.URLSearchParams */, value.toString());
         }
         else if (value instanceof Set) {
-            output(16 /* TypeIds.Set */, [...value.values()]);
+            output(17 /* TypeIds.Set */, [...value.values()]);
         }
         else if (value instanceof Map) {
             const combined = [];
             for (const [k, v] of value.entries()) {
                 combined.push(k, v);
             }
-            output(17 /* TypeIds.Map */, combined);
+            output(18 /* TypeIds.Map */, combined);
         }
         else if (isJSXNode(value)) {
             const out = [
@@ -9067,7 +9044,7 @@ async function serialize(serializationContext) {
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
-            output(31 /* TypeIds.JSXNode */, out);
+            output(30 /* TypeIds.JSXNode */, out);
         }
         else if (value instanceof Task) {
             const out = [
@@ -9081,21 +9058,21 @@ async function serialize(serializationContext) {
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
-            output(21 /* TypeIds.Task */, out);
+            output(20 /* TypeIds.Task */, out);
         }
         else if (isPromise(value)) {
             const forwardRefId = resolvePromise(value, $addRoot$, (resolved, resolvedValue) => {
-                return new PromiseResult(15 /* TypeIds.Promise */, resolved, resolvedValue);
+                return new PromiseResult(16 /* TypeIds.Promise */, resolved, resolvedValue);
             });
             output(2 /* TypeIds.ForwardRef */, forwardRefId);
         }
         else if (value instanceof PromiseResult) {
-            if (value.$type$ === 22 /* TypeIds.Resource */) {
-                output(22 /* TypeIds.Resource */, [value.$resolved$, value.$value$, value.$effects$]);
+            if (value.$type$ === 21 /* TypeIds.Resource */) {
+                output(21 /* TypeIds.Resource */, [value.$resolved$, value.$value$, value.$effects$]);
             }
-            else if (value.$type$ === 28 /* TypeIds.SerializerSignal */) {
+            else if (value.$type$ === 27 /* TypeIds.SerializerSignal */) {
                 if (value.$qrl$) {
-                    output(28 /* TypeIds.SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
+                    output(27 /* TypeIds.SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
                 }
                 else if (value.$resolved$) {
                     // We replace ourselves with this value
@@ -9109,7 +9086,7 @@ async function serialize(serializationContext) {
                 }
             }
             else {
-                output(15 /* TypeIds.Promise */, [value.$resolved$, value.$value$]);
+                output(16 /* TypeIds.Promise */, [value.$resolved$, value.$value$]);
             }
         }
         else if (value instanceof Uint8Array) {
@@ -9118,7 +9095,7 @@ async function serialize(serializationContext) {
                 buf += String.fromCharCode(c);
             }
             const out = btoa(buf).replace(/=+$/, '');
-            output(18 /* TypeIds.Uint8Array */, out);
+            output(19 /* TypeIds.Uint8Array */, out);
         }
         else if (value instanceof SerializationWeakRef) {
             const obj = value.$obj$;
@@ -9187,7 +9164,7 @@ async function serialize(serializationContext) {
             }
             if (lastIdx >= 0) {
                 $writer$.write(',');
-                $writer$.write(13 /* TypeIds.ForwardRefs */ + ',');
+                $writer$.write(14 /* TypeIds.ForwardRefs */ + ',');
                 const out = lastIdx === forwardRefs.length - 1 ? forwardRefs : forwardRefs.slice(0, lastIdx + 1);
                 // We could also implement RLE of -1 values
                 outputArray(out, true, (value) => {
@@ -9787,7 +9764,7 @@ function setEvent(serializationCtx, key, rawValue) {
     let value = null;
     const qrls = rawValue;
     const appendToValue = (valueToAppend) => {
-        value = (value == null ? '' : value + '\n') + valueToAppend;
+        value = (value == null ? '' : value + '|') + valueToAppend;
     };
     const getQrlString = (qrl) => {
         /**
@@ -9796,8 +9773,8 @@ function setEvent(serializationCtx, key, rawValue) {
          *
          * For internal qrls (starting with `_`) we assume that they do the right thing.
          */
-        if (!qrl.$symbol$.startsWith('_') && qrl.$captureRef$?.length) {
-            qrl = createQRL(null, '_run', _run, null, null, [qrl]);
+        if (!qrl.$symbol$.startsWith('_') && qrl.$captures$?.length) {
+            qrl = createQRL(null, '_run', _run, null, [qrl]);
         }
         return qrlToString(serializationCtx, qrl);
     };
@@ -9824,19 +9801,17 @@ function setEvent(serializationCtx, key, rawValue) {
     return value;
 }
 function addQwikEventToSerializationContext(serializationCtx, key, qrl) {
-    // TODO extract window/document too so qwikloader can precisely listen
     const data = getEventDataFromHtmlAttribute(key);
     if (data) {
         const [scope, eventName] = data;
         const scopedEvent = getScopedEventName(scope, eventName);
-        const loaderScopedEvent = getLoaderScopedEventName(scope, scopedEvent);
-        serializationCtx.$eventNames$.add(loaderScopedEvent);
+        serializationCtx.$eventNames$.add(scopedEvent);
         serializationCtx.$eventQrls$.add(qrl);
     }
 }
 function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
-    // skip first 15 chars, this is length of the `preventdefault`, leave the ":"
-    const eventName = key.substring(14);
+    // skip the `preventdefault`, leave the ':'
+    const eventName = 'e' + key.substring(14);
     if (eventName) {
         serializationCtx.$eventNames$.add(eventName);
     }
@@ -9867,6 +9842,27 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
     }
 }
 
+// <docs markdown="../readme.md#useLexicalScope">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useLexicalScope instead and run `pnpm docs.sync`)
+/**
+ * Used by the Qwik Optimizer to restore the lexically scoped variables.
+ *
+ * This method should not be present in the application source code.
+ *
+ * NOTE: `useLexicalScope` method can only be used in the synchronous portion of the callback
+ * (before any `await` statements.)
+ *
+ * @deprecated Read from `_captures` directly instead.
+ * @internal
+ */
+// </docs>
+const useLexicalScope = () => {
+    isDev && assertDefined(_captures, 'invoke: captures must be defined for useLexicalScope()');
+    return _captures;
+};
+
+let loading = Promise.resolve();
 const inflate = (container, target, typeId, data) => {
     if (typeId === 0 /* TypeIds.Plain */) {
         // Already processed
@@ -9892,14 +9888,7 @@ const inflate = (container, target, typeId, data) => {
                 target[key] = value;
             }
             break;
-        case 19 /* TypeIds.QRL */:
-        case 20 /* TypeIds.PreloadQRL */:
-            _inflateQRL(container, target);
-            if (typeId === 20 /* TypeIds.PreloadQRL */) {
-                target.resolve();
-            }
-            break;
-        case 21 /* TypeIds.Task */:
+        case 20 /* TypeIds.Task */:
             const task = target;
             const v = data;
             task.$qrl$ = v[0];
@@ -9909,7 +9898,7 @@ const inflate = (container, target, typeId, data) => {
             task[_EFFECT_BACK_REF] = v[4];
             task.$state$ = v[5];
             break;
-        case 22 /* TypeIds.Resource */:
+        case 21 /* TypeIds.Resource */:
             const [resolved, result, effects] = data;
             const resource = target;
             if (resolved) {
@@ -9924,10 +9913,10 @@ const inflate = (container, target, typeId, data) => {
             }
             getStoreHandler(target).$effects$ = effects;
             break;
-        case 23 /* TypeIds.Component */:
+        case 22 /* TypeIds.Component */:
             target[SERIALIZABLE_STATE][0] = data[0];
             break;
-        case 29 /* TypeIds.Store */: {
+        case 28 /* TypeIds.Store */: {
             // Inflate the store target
             const store = unwrapStore(target);
             const storeTarget = pendingStoreTargets.get(store);
@@ -9945,14 +9934,14 @@ const inflate = (container, target, typeId, data) => {
             storeHandler.$effects$ = effects;
             break;
         }
-        case 24 /* TypeIds.Signal */: {
+        case 23 /* TypeIds.Signal */: {
             const signal = target;
             const d = data;
             signal.$untrackedValue$ = d[0];
             signal.$effects$ = new Set(d.slice(1));
             break;
         }
-        case 25 /* TypeIds.WrappedSignal */: {
+        case 24 /* TypeIds.WrappedSignal */: {
             const signal = target;
             const d = data;
             signal.$func$ = container.getSyncFn(d[0]);
@@ -9966,30 +9955,39 @@ const inflate = (container, target, typeId, data) => {
             inflateWrappedSignalValue(signal);
             break;
         }
-        case 27 /* TypeIds.AsyncComputedSignal */: {
-            const asyncComputed = target;
+        case 26 /* TypeIds.AsyncSignal */: {
+            const asyncSignal = target;
             const d = data;
-            asyncComputed.$computeQrl$ = d[0];
-            asyncComputed[_EFFECT_BACK_REF] = d[1];
-            asyncComputed.$effects$ = new Set(d[2]);
-            asyncComputed.$loadingEffects$ = new Set(d[3]);
-            asyncComputed.$errorEffects$ = new Set(d[4]);
-            asyncComputed.$untrackedLoading$ = d[5];
-            asyncComputed.$untrackedError$ = d[6];
+            asyncSignal.$computeQrl$ = d[0];
+            asyncSignal[_EFFECT_BACK_REF] = d[1];
+            asyncSignal.$effects$ = new Set(d[2]);
+            asyncSignal.$loadingEffects$ = new Set(d[3]);
+            asyncSignal.$errorEffects$ = new Set(d[4]);
+            asyncSignal.$untrackedLoading$ = d[5];
+            asyncSignal.$untrackedError$ = d[6];
             const hasValue = d.length > 7;
             if (hasValue) {
-                asyncComputed.$untrackedValue$ = d[7];
-                asyncComputed.$promiseValue$ = d[7];
+                asyncSignal.$untrackedValue$ = d[7];
+                asyncSignal.$promiseValue$ = d[7];
             }
-            asyncComputed.$flags$ |= 1 /* SignalFlags.INVALID */;
+            asyncSignal.$flags$ |= 1 /* SignalFlags.INVALID */;
             break;
         }
         // Inflating a SerializerSignal is the same as inflating a ComputedSignal
-        case 28 /* TypeIds.SerializerSignal */:
-        case 26 /* TypeIds.ComputedSignal */: {
+        case 27 /* TypeIds.SerializerSignal */:
+        case 25 /* TypeIds.ComputedSignal */: {
             const computed = target;
             const d = data;
             computed.$computeQrl$ = d[0];
+            /**
+             * If we try to compute value and the qrl is not resolved, then system throws an error with
+             * the resolve promise. To prevent that we load it now and qrls wait for the loading to
+             * finish.
+             */
+            const p = computed.$computeQrl$.resolve(container).catch(() => {
+                // ignore preload errors
+            });
+            loading = loading.finally(() => p);
             computed[_EFFECT_BACK_REF] = d[1];
             if (d[2]) {
                 computed.$effects$ = new Set(d[2]);
@@ -9998,24 +9996,16 @@ const inflate = (container, target, typeId, data) => {
             if (hasValue) {
                 computed.$untrackedValue$ = d[3];
                 // The serialized signal is always invalid so it can recreate the custom object
-                if (typeId === 28 /* TypeIds.SerializerSignal */) {
+                if (typeId === 27 /* TypeIds.SerializerSignal */) {
                     computed.$flags$ |= 1 /* SignalFlags.INVALID */;
                 }
             }
             else {
                 computed.$flags$ |= 1 /* SignalFlags.INVALID */;
-                /**
-                 * If we try to compute value and the qrl is not resolved, then system throws an error with
-                 * qrl promise. To prevent that we should early resolve computed qrl while computed
-                 * deserialization. This also prevents anything from firing while computed qrls load,
-                 * because of scheduler
-                 */
-                // try to download qrl in this tick
-                computed.$computeQrl$.resolve();
             }
             break;
         }
-        case 14 /* TypeIds.Error */: {
+        case 15 /* TypeIds.Error */: {
             const d = data;
             target.message = d[0];
             for (let i = 1; i < d.length; i += 2) {
@@ -10023,7 +10013,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 30 /* TypeIds.FormData */: {
+        case 29 /* TypeIds.FormData */: {
             const formData = target;
             const d = data;
             for (let i = 0; i < d.length; i++) {
@@ -10031,7 +10021,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 31 /* TypeIds.JSXNode */: {
+        case 30 /* TypeIds.JSXNode */: {
             const jsx = target;
             const [type, key, varProps, constProps, children, toSort] = data;
             jsx.type = type;
@@ -10042,7 +10032,7 @@ const inflate = (container, target, typeId, data) => {
             jsx.toSort = !!toSort;
             break;
         }
-        case 16 /* TypeIds.Set */: {
+        case 17 /* TypeIds.Set */: {
             const set = target;
             const d = data;
             for (let i = 0; i < d.length; i++) {
@@ -10050,7 +10040,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 17 /* TypeIds.Map */: {
+        case 18 /* TypeIds.Map */: {
             const map = target;
             const d = data;
             for (let i = 0; i < d.length; i++) {
@@ -10058,7 +10048,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 15 /* TypeIds.Promise */: {
+        case 16 /* TypeIds.Promise */: {
             const promise = target;
             const [resolved, result] = data;
             const [resolve, reject] = resolvers.get(promise);
@@ -10070,7 +10060,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 18 /* TypeIds.Uint8Array */:
+        case 19 /* TypeIds.Uint8Array */:
             const bytes = target;
             const buf = atob(data);
             let i = 0;
@@ -10078,7 +10068,7 @@ const inflate = (container, target, typeId, data) => {
                 bytes[i++] = s.charCodeAt(0);
             }
             break;
-        case 32 /* TypeIds.PropsProxy */:
+        case 31 /* TypeIds.PropsProxy */:
             const propsProxy = target;
             const d = data;
             let owner = d[0];
@@ -10089,13 +10079,13 @@ const inflate = (container, target, typeId, data) => {
             propsProxy[_OWNER] = owner;
             propsProxy[_PROPS_HANDLER].$effects$ = d[3];
             break;
-        case 33 /* TypeIds.SubscriptionData */: {
+        case 32 /* TypeIds.SubscriptionData */: {
             const effectData = target;
             effectData.data.$scopedStyleIdPrefix$ = data[0];
             effectData.data.$isConst$ = data[1];
             break;
         }
-        case 34 /* TypeIds.EffectSubscription */: {
+        case 33 /* TypeIds.EffectSubscription */: {
             const effectSub = target;
             const d = data;
             effectSub.consumer = d[0];
@@ -10117,20 +10107,6 @@ const _eagerDeserializeArray = (container, data, output = Array(data.length / 2)
     }
     return output;
 };
-function _inflateQRL(container, qrl) {
-    if (qrl.$captureRef$) {
-        // early return if capture references are already set and qrl is already inflated
-        return qrl;
-    }
-    const captureIds = qrl.$capture$;
-    qrl.$captureRef$ = captureIds ? captureIds.map((id) => container.$getObjectById$(id)) : null;
-    // clear serialized capture references
-    qrl.$capture$ = null;
-    if (container.element) {
-        qrl.$setContainer$(container.element);
-    }
-    return qrl;
-}
 function deserializeData(container, typeId, value) {
     if (typeId === 0 /* TypeIds.Plain */) {
         return value;
@@ -10174,7 +10150,7 @@ function inflateWrappedSignalValue(signal) {
 }
 
 /** Arrays/Objects are special-cased so their identifiers is a single digit. */
-const needsInflation = (typeId) => typeId >= 14 /* TypeIds.Error */ || typeId === 4 /* TypeIds.Array */ || typeId === 5 /* TypeIds.Object */;
+const needsInflation = (typeId) => typeId >= 15 /* TypeIds.Error */ || typeId === 4 /* TypeIds.Array */ || typeId === 5 /* TypeIds.Object */;
 const deserializedProxyMap = new WeakMap();
 const isDeserializerProxy = (value) => {
     return isObject(value) && SERIALIZER_PROXY_UNWRAP in value;
@@ -10664,8 +10640,10 @@ class DomContainer extends _SharedContainer {
     $setRawState$(id, vParent) {
         this.$stateData$[id] = vParent;
     }
-    parseQRL(qrl) {
-        return _inflateQRL(this, parseQRL(qrl));
+    parseQRL(qrlStr) {
+        const qrl = parseQRL(qrlStr);
+        qrl.$container$ = this;
+        return qrl;
     }
     handleError(err, host) {
         if (qDev && host) {
@@ -10884,16 +10862,20 @@ const isTask = (value) => {
     return value instanceof Task;
 };
 /**
- * Used internally as a qrl event handler to schedule a task.
+ * Used internally as a qwikloader event handler to schedule a task. The `this` context is the
+ * captures part of the QRL, provided by qwikloader.
  *
  * @internal
  */
-const scheduleTask = (_event, element) => {
-    const [task] = useLexicalScope();
+function scheduleTask(_event, element) {
     const container = getDomContainer(element);
+    if (typeof this === 'string') {
+        setCaptures(deserializeCaptures(container, this));
+    }
+    const task = _captures[0];
     task.$flags$ |= 8 /* TaskFlags.DIRTY */;
     markVNodeDirty(container, task.$el$, 1 /* ChoreBits.TASKS */);
-};
+}
 
 const throwIfQRLNotResolved = (qrl) => {
     const resolved = qrl.resolved;
@@ -11002,10 +10984,10 @@ const getComputedSignalFlags = (serializationStrategy) => {
         //   flags |= ComputedSignalFlags.SERIALIZATION_STRATEGY_AUTO;
         //   break;
         case 'never':
-            flags |= 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
+            flags |= 8 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
             break;
         case 'always':
-            flags |= 32 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
+            flags |= 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
             break;
     }
     return flags;
@@ -11356,6 +11338,7 @@ function getEffects(target, prop, storeEffects) {
     return effectsToTrigger;
 }
 
+const getKeyVal = (value, key) => value[key];
 const canSerialize = (value, seen = new WeakSet()) => {
     if (value == null ||
         typeof value === 'string' ||
@@ -11377,7 +11360,7 @@ const canSerialize = (value, seen = new WeakSet()) => {
             for (const key in value) {
                 // if the value is a props proxy, then sometimes we could create a component-level subscription,
                 // so we should call untrack here to avoid tracking the value
-                if (!canSerialize(untrack(() => value[key]), seen)) {
+                if (!canSerialize(untrack(getKeyVal, value, key), seen)) {
                     return false;
                 }
             }
@@ -11504,7 +11487,7 @@ const _dumpState = (state, color = false, prefix = '', limit = 20) => {
                     value = value.slice(0, 120) + '"...';
                 }
             }
-            else if (key === 13 /* TypeIds.ForwardRefs */) {
+            else if (key === 14 /* TypeIds.ForwardRefs */) {
                 value = '[' + `\n${prefix}  ${value.join(`\n${prefix}  `)}\n${prefix}]`;
             }
             else if (Array.isArray(value)) {
@@ -11580,10 +11563,7 @@ function preprocessState(data, container) {
         return type === 1 /* TypeIds.RootRef */ && typeof value === 'string';
     };
     const isForwardRefsMap = (type) => {
-        return type === 13 /* TypeIds.ForwardRefs */;
-    };
-    const isPreloadQrlType = (type) => {
-        return type === 20 /* TypeIds.PreloadQRL */;
+        return type === 14 /* TypeIds.ForwardRefs */;
     };
     const processRootRef = (index) => {
         const rootRefPath = data[index + 1].split(' ');
@@ -11612,7 +11592,6 @@ function preprocessState(data, container) {
         data[index] = objectType;
         data[index + 1] = object;
     };
-    const toPreload = isServer ? undefined : [];
     for (let i = 0; i < data.length; i += 2) {
         if (isRootDeepRef(data[i], data[i + 1])) {
             processRootRef(i);
@@ -11620,45 +11599,6 @@ function preprocessState(data, container) {
         else if (isForwardRefsMap(data[i])) {
             container.$forwardRefs$ = data[i + 1];
         }
-        else if (!isServer && isPreloadQrlType(data[i])) {
-            // preload QRLs are always serialized as strings with chunk and symbol ids
-            const qrl = data[i + 1];
-            const chunkIdx = Number(qrl.split(' ')[0]);
-            toPreload.push(chunkIdx);
-        }
-    }
-    /**
-     * Preloads QRLs that are defined in the state data as `PreloadQRL`.
-     *
-     * This is done because when computed and custom serializer QRLs are called they need QRL to work.
-     * If the QRL is not resolved at this point, it will be resolved by throwing a promise and
-     * rerunning the whole wrapping function again. We want to avoid that, because it means that the
-     * function can execute twice.
-     *
-     * ```ts
-     * useVisibleTask$(() => {
-     *   runHeavyLogic(); // This will be called again if the QRL of `computedOrCustomSerializer` is not resolved.
-     *   console.log(computedOrCustomSerializer.value); // Throw a promise if QRL not resolved and execute visible task again.
-     * });
-     * ```
-     */
-    if (!isServer) {
-        for (const idx of toPreload) {
-            // we preload the chunk instead of the symbol so it also works in dev
-            const chunkType = data[idx * 2];
-            let chunk;
-            if (chunkType === 0 /* TypeIds.Plain */) {
-                chunk = data[idx * 2 + 1];
-            }
-            else if (chunkType === 1 /* TypeIds.RootRef */) {
-                const refIdx = data[idx * 2 + 1];
-                chunk = data[refIdx * 2 + 1];
-            }
-            else {
-                continue;
-            }
-            p(chunk, 0.3);
-        }
     }
 }
 
@@ -11680,10 +11620,9 @@ async function _serialize(data) {
  * Deserialize data from string to an array of objects.
  *
  * @param rawStateData - Data to deserialize
- * @param element - Container element
  * @internal
  */
-function _deserialize(rawStateData, element) {
+function _deserialize(rawStateData) {
     if (rawStateData == null) {
         return [];
     }
@@ -11691,13 +11630,7 @@ function _deserialize(rawStateData, element) {
     if (!Array.isArray(stateData)) {
         return [];
     }
-    let container;
-    if (isNode(element) && isElement$1(element)) {
-        container = _createDeserializeContainer(stateData, element);
-    }
-    else {
-        container = _createDeserializeContainer(stateData);
-    }
+    const container = _createDeserializeContainer(stateData);
     const output = [];
     for (let i = 0; i < stateData.length; i += 2) {
         output[i / 2] = deserializeData(container, stateData[i], stateData[i + 1]);
@@ -11707,11 +11640,13 @@ function _deserialize(rawStateData, element) {
 function getObjectById(id, stateData) {
     if (typeof id === 'string') {
         id = parseInt(id, 10);
+        // This return statement is needed to prevent the function from turning megamorphic
+        return stateData[id];
     }
     isDev && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
     return stateData[id];
 }
-function _createDeserializeContainer(stateData, element) {
+function _createDeserializeContainer(stateData) {
     // eslint-disable-next-line prefer-const
     let state;
     const container = {
@@ -11727,16 +11662,13 @@ function _createDeserializeContainer(stateData, element) {
     preprocessState(stateData, container);
     state = wrapDeserializerProxy(container, stateData);
     container.$state$ = state;
-    if (element) {
-        container.element = element;
-    }
     return container;
 }
 
 /** @internal */
 const verifySerializable = (value, preMessage) => {
     const seen = new WeakSet();
-    return untrack(() => _verifySerializable(value, seen, '_', preMessage));
+    return untrack(_verifySerializable, value, seen, '_', preMessage);
 };
 const _verifySerializable = (value, seen, ctx, preMessage) => {
     const unwrapped = unwrapStore(value);
@@ -11871,173 +11803,202 @@ const NoSerializeSymbol = Symbol('noSerialize');
 const SerializerSymbol = Symbol('serialize');
 
 // keep these imports above the rest to prevent circular dep issues
-const resolvedSymbol = Symbol('resolved');
-const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
-    if (qDev && qSerialize) {
-        if (captureRef) {
-            for (const item of captureRef) {
-                verifySerializable(item, 'Captured variable in the closure can not be serialized');
-            }
+/**
+ * The current captured scope during QRL invocation. This is used to provide the lexical scope for
+ * QRL functions. It is used one time per invocation, synchronously, so it is safe to store it in
+ * module scope.
+ *
+ * @internal
+ */
+let _captures = null;
+const setCaptures = (captures) => {
+    _captures = captures;
+};
+const deserializeCaptures = (container, captures) => {
+    const refs = [];
+    for (const id of captures.split(' ')) {
+        refs.push(container.$getObjectById$(id));
+    }
+    return refs;
+};
+/** Puts the qrl captures into `_captures`, and returns a Promise that should be awaited if possible */
+const ensureQrlCaptures = (qrl) => {
+    // We read the captures once, synchronously, so no need to keep previous
+    _captures = qrl.$captures$;
+    if (typeof _captures === 'string') {
+        if (!qrl.$container$) {
+            throw qError(13 /* QError.qrlMissingContainer */);
+        }
+        const prevLoading = loading;
+        _captures = qrl.$captures$ = deserializeCaptures(qrl.$container$, _captures);
+        if (loading !== prevLoading) {
+            // return the loading promise so callers can await it
+            return loading;
         }
     }
-    let _containerEl;
-    const qrl = async function (...args) {
-        const boundedFn = bindFnToContext.call(this, tryGetInvokeContext());
-        const result = await boundedFn(...args);
-        return result;
-    };
-    const setContainer = (el) => {
-        if (!_containerEl) {
-            _containerEl = el;
+};
+function bindFnToContext(qrl, currentCtx, beforeFn) {
+    // Note that we bind the current `this`
+    const bound = (...args) => {
+        if (!qrl.resolved) {
+            return qrl.resolve().then((fn) => {
+                if (!isFunction(fn)) {
+                    throw qError(5 /* QError.qrlIsNotFunction */);
+                }
+                return bound(...args);
+            });
         }
-        return _containerEl;
+        if (beforeFn && beforeFn() === false) {
+            return;
+        }
+        return invokeApply.call(this, currentCtx, qrl.resolved, args);
     };
-    function bindFnToContext(currentCtx, beforeFn) {
-        // Note that we bind the current `this`
-        const bound = (...args) => {
-            if (!qrl.resolved) {
-                return qrl.resolve().then((fn) => {
-                    if (!isFunction(fn)) {
-                        throw qError(5 /* QError.qrlIsNotFunction */);
-                    }
-                    return bound(...args);
-                });
-            }
-            if (beforeFn && beforeFn() === false) {
-                return;
-            }
-            const context = createOrReuseInvocationContext(currentCtx);
-            const prevQrl = context.$qrl$;
-            const prevEvent = context.$event$;
-            // Note that we set the qrl here instead of in wrapFn because
-            // it is possible we're called on a copied qrl
-            context.$qrl$ = qrl;
-            context.$event$ ||= this;
-            try {
-                return invoke.call(this, context, symbolRef, ...args);
-            }
-            finally {
-                context.$qrl$ = prevQrl;
-                context.$event$ = prevEvent;
-            }
-        };
-        return bound;
+    return bound;
+}
+// Wrap functions to provide their lexical scope
+const bindCaptures = (qrl, fn) => {
+    if (typeof fn !== 'function' || !qrl.$captures$) {
+        return fn;
     }
-    // Wrap functions to provide their lexical scope
-    const wrapFn = (fn) => {
-        if (typeof fn !== 'function' || (!capture?.length && !captureRef?.length)) {
-            return fn;
-        }
-        return function (...args) {
-            let context = tryGetInvokeContext();
-            // use the given qrl if it is the right one
-            if (context) {
-                // TODO check if this is necessary in production
-                if (context.$qrl$?.$symbol$ === qrl.$symbol$) {
-                    return fn.apply(this, args);
-                }
-                const prevQrl = context.$qrl$;
-                context.$qrl$ = qrl;
-                try {
-                    return fn.apply(this, args);
-                }
-                finally {
-                    context.$qrl$ = prevQrl;
-                }
-            }
-            context = newInvokeContext();
-            context.$qrl$ = qrl;
-            context.$event$ = this;
-            return invoke.call(this, context, fn, ...args);
-        };
+    return function withCaptures(...args) {
+        ensureQrlCaptures(qrl);
+        return fn.apply(this, args);
     };
-    // Retrieve memoized result from symbolFn
-    if (symbolFn && resolvedSymbol in symbolFn) {
-        symbolRef = symbolFn[resolvedSymbol];
-    }
-    const resolve = symbolRef
-        ? async () => symbolRef
-        : async (containerEl) => {
-            if (symbolRef !== null) {
-                // Resolving (Promise) or already resolved (value)
-                return symbolRef;
-            }
-            if (containerEl) {
-                setContainer(containerEl);
-            }
-            if (chunk === '') {
-                // Sync QRL
-                isDev && assertDefined(_containerEl, 'Sync QRL must have container element');
-                const hash = _containerEl.getAttribute(QInstanceAttr);
-                const doc = _containerEl.ownerDocument;
-                const qFuncs = getQFuncs(doc, hash);
-                // No need to wrap, syncQRLs can't have captured scope
-                return (qrl.resolved = symbolRef = qFuncs[Number(symbol)]);
-            }
-            if (isBrowser && chunk) {
-                /** We run the QRL, so now the probability of the chunk is 100% */
-                p(chunk, 1);
-            }
-            const start = now();
-            const ctx = tryGetInvokeContext();
-            if (symbolFn !== null) {
-                symbolRef = symbolFn().then((module) => {
-                    const resolved = wrapFn((symbolRef = module[symbol]));
-                    // We memoize the result on the symbolFn
-                    symbolFn[resolvedSymbol] = resolved;
-                    qrl.resolved = resolved;
-                    return resolved;
-                });
-            }
-            else {
-                // TODO cache the imported symbol but watch out for dev mode
-                const imported = getPlatform().importSymbol(_containerEl, chunk, symbol);
-                symbolRef = maybeThen(imported, (ref) => (qrl.resolved = wrapFn((symbolRef = ref))));
-            }
-            if (isPromise(symbolRef)) {
-                symbolRef.then(() => emitUsedSymbol(symbol, ctx?.$hostElement$ instanceof ElementVNode ? ctx?.$hostElement$.node : undefined, start), (err) => {
-                    console.error(`qrl ${symbol} failed to load`, err);
-                    // We shouldn't cache rejections, we can try again later
-                    symbolRef = null;
-                });
-            }
+};
+const makeResolveFunction = (qrl, symbolFn) => {
+    let symbolRef;
+    // Always return a promise, even for sync QRLs
+    return async (container) => {
+        if (symbolRef != null) {
+            // Resolving (Promise) or already resolved (value)
             return symbolRef;
-        };
-    const createOrReuseInvocationContext = (invoke) => {
-        if (invoke == null) {
-            return newInvokeContext();
         }
-        else if (isArray(invoke)) {
-            return newInvokeContextFromTuple(invoke);
+        if (container) {
+            qrl.$container$ = container;
         }
-        else {
-            return invoke;
+        else if (!qrl.$container$) {
+            const ctx = tryGetInvokeContext();
+            if (ctx?.$container$) {
+                qrl.$container$ = ctx.$container$;
+            }
+        }
+        if (qrl.$chunk$ === '') {
+            // Sync QRL
+            isDev && assertDefined(qrl.$container$, 'Sync QRL must have container element');
+            const hash = qrl.$container$.$instanceHash$;
+            const doc = qrl.$container$.element?.ownerDocument || document;
+            const qFuncs = getQFuncs(doc, hash);
+            // No need to wrap, syncQRLs can't have captured scope
+            return (qrl.resolved = symbolRef = qFuncs[Number(qrl.$symbol$)]);
+        }
+        if (isBrowser && qrl.$chunk$) {
+            /** We run the QRL, so now the probability of the chunk is 100% */
+            p(qrl.$chunk$, 1);
+        }
+        const start = now();
+        const symbol = qrl.$symbol$;
+        const importP = symbolFn
+            ? symbolFn().then((module) => module[symbol])
+            : getPlatform().importSymbol(qrl.$container$?.element, qrl.$chunk$, symbol);
+        symbolRef = maybeThen(importP, (resolved) => {
+            // We memoize the result on the symbolFn
+            // Make sure not to memoize the wrapped function!
+            if (symbolFn) {
+                symbolFn[symbol] = resolved;
+            }
+            return (symbolRef = qrl.resolved = bindCaptures(qrl, resolved));
+        });
+        if (isPromise(symbolRef)) {
+            const ctx = tryGetInvokeContext();
+            symbolRef.then(() => emitUsedSymbol(symbol, ctx?.$hostElement$ instanceof ElementVNode ? ctx?.$hostElement$.node : undefined, start), (err) => {
+                console.error(`qrl ${symbol} failed to load`, err);
+                // We shouldn't cache rejections, we can try again later
+                symbolRef = null;
+            });
+        }
+        // Try to deserialize captures if any
+        if (qrl.$container$) {
+            await ensureQrlCaptures(qrl);
+        }
+        return symbolRef;
+    };
+};
+function getSymbol() {
+    return this.$symbol$;
+}
+function getHash() {
+    return this.$hash$;
+}
+function getCaptured() {
+    ensureQrlCaptures(this);
+    return this.$captures$;
+}
+/**
+ * Creates a QRL instance to represent a lazily loaded value. Normally this is a function, but it
+ * can be any value.
+ *
+ * When the value is a function, calling the returned qrl will load the underlying code when
+ * invoked, and call it with the captured scope. This always returns a promise since the code may
+ * not be loaded yet.
+ *
+ * To get the underlying function without invoking it, await `qrl.resolve()` and then `qrl.resolved`
+ * holds the loaded function, wrapped with the captured scope.
+ *
+ * @internal
+ */
+const createQRL = (chunk, symbol, symbolRef, symbolFn, captures) => {
+    // In dev mode we need to preserve the original symbolRef without wrapping
+    const origSymbolRef = symbolRef;
+    if (qDev && qSerialize) {
+        if (captures && typeof captures === 'object') {
+            for (const item of captures) {
+                verifySerializable(item, 'Captured variable in the closure can not be serialized');
+            }
         }
+    }
+    const qrl = async function qrlFn(...args) {
+        if (qrl.resolved) {
+            return qrl.resolved.apply(this, args);
+        }
+        // grab the context while we are sync
+        const ctx = tryGetInvokeContext();
+        await qrl.resolve(ctx?.$container$);
+        return invokeApply.call(this, ctx, qrl.resolved, args);
     };
+    // Retrieve memoized result from symbolFn
+    if (symbolFn && symbol in symbolFn) {
+        symbolRef = symbolFn[symbol];
+    }
+    const resolve = symbolRef != null ? async () => symbolRef : makeResolveFunction(qrl, symbolFn);
     const hash = getSymbolHash(symbol);
     Object.assign(qrl, {
-        getSymbol: () => symbol,
-        getHash: () => hash,
-        // captureRef is replaced during deserialization
-        getCaptured: () => qrl.$captureRef$,
+        getSymbol,
+        getHash,
+        getCaptured,
+        // This can be called with other `this`
+        getFn: function (currentCtx, beforeFn) {
+            return bindFnToContext.call(this, qrl, currentCtx, beforeFn);
+        },
         resolve,
-        $setContainer$: setContainer,
+        resolved: undefined,
         $chunk$: chunk,
         $symbol$: symbol,
         $hash$: hash,
-        getFn: bindFnToContext,
-        $capture$: capture,
-        $captureRef$: captureRef,
-        dev: null,
-        resolved: undefined,
+        $captures$: captures,
+        $container$: null,
     });
-    if (symbolRef) {
-        // Unwrap any promises
-        symbolRef = maybeThen(symbolRef, (resolved) => (qrl.resolved = wrapFn((symbolRef = resolved))));
-    }
     if (qDev) {
+        qrl.dev = null;
+        qrl.$symbolRef$ = origSymbolRef;
         seal(qrl);
     }
+    // Now that the qrl is fully constructed, we can resolve/wrap the symbolRef if we received it. If it is a plain value without computed captures, the qrl will be resolved immediately.
+    if (symbolRef != null) {
+        symbolRef = maybeThen(ensureQrlCaptures(qrl), () => maybeThen(symbolRef, (resolved) => {
+            symbolRef = qrl.resolved = bindCaptures(qrl, resolved);
+            return symbolRef;
+        }));
+    }
     if (isBrowser && symbol) {
         /**
          * Preloading the symbol instead of the chunk allows us to get probabilities for the bundle
@@ -12159,7 +12120,7 @@ const $ = (expression) => {
     if (!qRuntimeQrl && qDev) {
         throw new Error('Optimizer should replace all usages of $() with some special syntax. If you need to create a QRL manually, use inlinedQrl() instead.');
     }
-    return createQRL(null, 's' + runtimeSymbolId++, expression, null, null, null);
+    return createQRL(null, 's' + runtimeSymbolId++, expression, null, null);
 };
 /** @private Use To avoid optimizer replacement */
 const dollar = $;
@@ -12185,7 +12146,7 @@ const sync$ = (fn) => {
         // eslint-disable-next-line no-new-func
         fn = new Function('return ' + fn.toString())();
     }
-    return createQRL('', SYNC_QRL, fn, null, null, null);
+    return createQRL('', SYNC_QRL, fn, null, null);
 };
 /**
  * Extract function into a synchronously loadable QRL.
@@ -12202,7 +12163,7 @@ const _qrlSync = function (fn, serializedFn) {
         serializedFn = fn.toString();
     }
     fn.serialized = serializedFn;
-    return createQRL('', SYNC_QRL, fn, null, null, null);
+    return createQRL('', SYNC_QRL, fn, null, null);
 };
 
 /** @internal */
@@ -12250,11 +12211,11 @@ const isQwikComponent = (component) => {
  *   step?: number;
  * }
  * export const Counter = component$((props: CounterProps) => {
- *   const state = useStore({ count: props.initialValue || 0 });
+ *   const state = useSignal(props.initialValue || 0);
  *   return (
  *     <div>
- *       <span>{state.count}</span>
- *       <button onClick$={() => (state.count += props.step || 1)}>+</button>
+ *       <span>{state.value}</span>
+ *       <button onClick$={() => (state.value += props.step || 1)}>+</button>
  *     </div>
  *   );
  * });
@@ -12331,10 +12292,15 @@ const render = async (parent, jsxNode, opts = {}) => {
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
 // (edit ../readme.md#useStore instead and run `pnpm docs.sync`)
 /**
- * Creates an object that Qwik can track across serializations.
+ * Creates a reactive object that Qwik can track across serialization.
  *
- * Use `useStore` to create a state for your application. The returned object is a proxy that has a
- * unique ID. The ID of the object is used in the `QRL`s to refer to the store.
+ * Use it to create state for your application. The returned object is a Proxy that tracks reads and
+ * writes. When any of the properties change, the functions that read those properties will re-run.
+ *
+ * `Store`s are deep by default, meaning that any objects assigned to properties will also become
+ * `Store`s. This includes arrays.
+ *
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
  *
  * ### Example
  *
@@ -12886,7 +12852,7 @@ const _useStyles = (styleQrl, transform, scoped) => {
  */
 // </docs>
 const useOn = (event, eventQrl) => {
-    _useOn("on:" /* EventNameHtmlScope.on */, event, eventQrl);
+    _useOn("q-e:" /* EventNameHtmlScope.on */, event, eventQrl);
 };
 // <docs markdown="../readme.md#useOnDocument">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
@@ -12920,7 +12886,7 @@ const useOn = (event, eventQrl) => {
  */
 // </docs>
 const useOnDocument = (event, eventQrl) => {
-    _useOn("on-document:" /* EventNameHtmlScope.document */, event, eventQrl);
+    _useOn("q-d:" /* EventNameHtmlScope.document */, event, eventQrl);
 };
 // <docs markdown="../readme.md#useOnWindow">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
@@ -12955,7 +12921,7 @@ const useOnDocument = (event, eventQrl) => {
  */
 // </docs>
 const useOnWindow = (event, eventQrl) => {
-    _useOn("on-window:" /* EventNameHtmlScope.window */, event, eventQrl);
+    _useOn("q-w:" /* EventNameHtmlScope.window */, event, eventQrl);
 };
 const _useOn = (prefix, eventName, eventQrl) => {
     const { isAdded, addEvent } = useOnEventsSequentialScope();
@@ -13020,50 +12986,99 @@ const useOnEventsSequentialScope = () => {
     };
 };
 
-/** @public */
+const getSignal = (initialState) => {
+    const value = isFunction(initialState) && !isQwikComponent(initialState)
+        ? invoke(undefined, initialState)
+        : initialState;
+    return createSignal(value);
+};
+// <docs markdown="../readme.md#useSignal">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useSignal instead and run `pnpm docs.sync`)
+/**
+ * Creates an object with a single reactive `.value` property, that Qwik can track across
+ * serializations.
+ *
+ * Use it to create state for your application. The object has a getter and setter to track reads
+ * and writes of the `.value` property. When the value changes, any functions that read from it will
+ * re-run.
+ *
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * const Signals = component$(() => {
+ *   const counter = useSignal(1);
+ *   const text = useSignal('changeme');
+ *   const toggle = useSignal(false);
+ *
+ *   // useSignal() can also accept a function to calculate the initial value
+ *   const state = useSignal(() => {
+ *     return expensiveInitialValue();
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick$={() => counter.value++}>Counter: {counter.value}</button>
+ *       {
+ *         // pass signal values as the value, the optimizer will make it pass the signal
+ *       }
+ *       <Child state={state.value} />
+ *       {
+ *         // signals can be bound to inputs. A property named `bind:x` implies that the property
+ * is a signal
+ *       }
+ *       <input type="text" bind:value={text} />
+ *       <input type="checkbox" bind:checked={toggle} />
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @public
+ */
+// </docs>
 const useSignal = (initialState) => {
-    return useConstant(() => {
-        const value = isFunction(initialState) && !isQwikComponent(initialState)
-            ? invoke(undefined, initialState)
-            : initialState;
-        return createSignal(value);
-    });
+    return useConstant((getSignal), initialState);
 };
 /**
  * Stores a value which is retained for the lifetime of the component. Subsequent calls to
  * `useConstant` will always return the first value given.
  *
- * If the value is a function, the function is invoked once to calculate the actual value.
+ * If the value is a function, the function is invoked once to calculate the actual value. You can
+ * then also pass arguments to call the function with, so that you don't need to create a new
+ * function on every render.
+ *
+ * @example
+ *
+ * ```tsx
+ * const fixedRandomValue = useConstant(() => Math.random);
+ * const otherFixedRandomValue = useConstant(Math.random);
+ *
+ * const getConfig = (env: string) => { ... }
+ * const config = useConstant(getConfig, environment);
+ * ```
  *
  * @public
  */
-const useConstant = (value) => {
+const useConstant = (value, ...args) => {
     const { val, set } = useSequentialScope();
     if (val != null) {
         return val;
     }
     // Note: We are not using `invoke` here because we don't want to clear the context
-    value = isFunction(value) && !isQwikComponent(value) ? value() : value;
+    value = isFunction(value) && !isQwikComponent(value) ? untrack(value, ...args) : value;
     return set(value);
 };
 
-const useComputedCommon = (qrl, createFn, options) => {
-    const { val, set } = useSequentialScope();
-    if (val) {
-        return val;
-    }
-    assertQrl(qrl);
-    const signal = createFn(qrl, options);
-    set(signal);
-    // Note that we first save the signal
-    // and then we throw to load the qrl
-    // This is why we can't use useConstant, we need to keep using the same qrl object
-    throwIfQRLNotResolved(qrl);
-    return signal;
+const creator$2 = (qrl, options) => {
+    qrl.resolve();
+    return createComputedSignal(qrl, options);
 };
 /** @internal */
 const useComputedQrl = (qrl, options) => {
-    return useComputedCommon(qrl, createComputedSignal, options);
+    return useConstant((creator$2), qrl, options);
 };
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -13077,8 +13092,12 @@ const useComputedQrl = (qrl, options) => {
  */
 const useComputed$ = implicit$FirstArg(useComputedQrl);
 
+const creator$1 = (qrl) => {
+    qrl.resolve();
+    return createSerializerSignal(qrl);
+};
 /** @internal */
-const useSerializerQrl = (qrl) => useComputedCommon(qrl, createSerializerSignal);
+const useSerializerQrl = (qrl) => useConstant((creator$1), qrl);
 /**
  * Creates a signal which holds a custom serializable value. It requires that the value implements
  * the `CustomSerializable` type, which means having a function under the `[SerializeSymbol]`
@@ -13181,7 +13200,7 @@ const useRegisterTaskEvents = (task, eagerness) => {
     }
 };
 const getTaskHandlerQrl = (task) => {
-    return createQRL(null, '_task', scheduleTask, null, null, [task]);
+    return createQRL(null, '_task', scheduleTask, null, [task]);
 };
 
 // <docs markdown="../readme.md#useResource">
@@ -13340,21 +13359,36 @@ const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
 // We need to cast to help out the api extractor
 const useVisibleTask$ = /*#__PURE__*/ implicit$FirstArg(useVisibleTaskQrl);
 
+const creator = (qrl, options) => {
+    qrl.resolve();
+    return createAsyncSignal(qrl, options);
+};
 /** @internal */
-const useAsyncComputedQrl = (qrl, options) => {
-    return useComputedCommon(qrl, createAsyncComputedSignal, options);
+const useAsyncQrl = (qrl, options) => {
+    return useConstant((creator), qrl, options);
 };
 /**
- * Creates a computed signal which is calculated from the given function. A computed signal is a
- * signal which is calculated from other signals. When the signals change, the computed signal is
- * recalculated, and if the result changed, all tasks which are tracking the signal will be re-run
- * and all components that read the signal will be re-rendered.
+ * Creates an AsyncSignal which holds the result of the given async function. If the function uses
+ * `track()` to track reactive state, and that state changes, the AsyncSignal is recalculated, and
+ * if the result changed, all tasks which are tracking the AsyncSignal will be re-run and all
+ * subscribers (components, tasks etc) that read the AsyncSignal will be updated.
  *
- * The function must be synchronous and must not have any side effects.
+ * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
+ * property. The error can be cleared by re-running the async function successfully.
+ *
+ * While the async function is running, the `loading` property will be set to `true`. Once the
+ * function completes, `loading` will be set to `false`.
+ *
+ * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
+ * retry the component or task once the value resolves.
+ *
+ * If the value has been resolved, but the async function is re-running, reading the AsyncSignal
+ * will subscribe to it and return the last resolved value until the new value is ready. As soon as
+ * the new value is ready, the subscribers will be updated.
  *
  * @public
  */
-const useAsyncComputed$ = implicit$FirstArg(useAsyncComputedQrl);
+const useAsync$ = implicit$FirstArg(useAsyncQrl);
 
 /** @public */
 const useErrorBoundary = () => {
@@ -13461,5 +13495,5 @@ if (import.meta.hot) {
     });
 }
 
-export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _chk, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _resolveContextWithoutSequentialScope, _restProps, _run, _serialize, scheduleTask as _task, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsyncComputed$, createAsyncComputedSignal as createAsyncComputedQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsyncComputed$, useAsyncComputedQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _captures, _chk, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _resolveContextWithoutSequentialScope, _restProps, _run, _serialize, scheduleTask as _task, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
 //# sourceMappingURL=core.mjs.map