@qwik.dev/core 2.0.0-beta.17 → 2.0.0-beta.18

package/dist/core.prod.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.17-dev+c34c237
+ * @qwik.dev/core 2.0.0-beta.18-dev+a8081d4
  * 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
@@ -11,7 +11,7 @@ export { isBrowser, isDev, isServer } from "@qwik.dev/core/build";
 
 import { p } from "@qwik.dev/core/preloader";
 
-const version = "2.0.0-beta.17-dev+c34c237";
+const version = "2.0.0-beta.18-dev+a8081d4";
 
 const qDev = !1;
 
@@ -70,7 +70,7 @@ const isString = v => "string" == typeof v;
 
 const isFunction = v => "function" == typeof v;
 
-const isPrimitive = v => "object" != typeof v && "function" != typeof v && null != v;
+const isPrimitiveOrNullUndefined = v => "object" != typeof v && "function" != typeof v || null == v;
 
 const codeToText = code => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code}`;
 
@@ -176,6 +176,10 @@ const ELEMENT_SEQ = "q:seq";
 
 const ELEMENT_SEQ_IDX = "q:seqIdx";
 
+const ITERATION_ITEM_SINGLE = "q:p";
+
+const ITERATION_ITEM_MULTI = "q:ps";
+
 const NON_SERIALIZABLE_MARKER_PREFIX = ":";
 
 const USE_ON_LOCAL = ":on";
@@ -196,6 +200,8 @@ const dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
 
 const qwikInspectorAttr = "data-qwik-inspector";
 
+const debugStyleScopeIdPrefixAttr = "__scopedStyleIdPrefix__";
+
 const createPlatform = () => ({
     isServer,
     importSymbol(containerEl, url, symbolName) {
@@ -258,14 +264,6 @@ const safeCall = (call, thenFn, rejectFn) => {
     }
 };
 
-const catchError = (valueOrPromise, rejectFn) => {
-    try {
-        return isPromise(valueOrPromise) ? valueOrPromise.catch(rejectFn) : valueOrPromise;
-    } catch (e) {
-        return rejectFn(e);
-    }
-};
-
 const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
 
 const delay = timeout => new Promise(resolve => {
@@ -513,13 +511,10 @@ function vnode_cloneElementWithNamespace(elementVNode, parentVNode, namespace, n
     return rootElement;
 }
 
-function isSvg(tagOrVNode) {
-    return "string" == typeof tagOrVNode ? isSvgElement(tagOrVNode) : !!(128 & tagOrVNode.flags);
-}
-
-function isMath(tagOrVNode) {
-    return "string" == typeof tagOrVNode ? isMathElement(tagOrVNode) : !!(256 & tagOrVNode.flags);
-}
+const NEW_NAMESPACE_DATA = {
+    elementNamespace: HTML_NS,
+    elementNamespaceFlag: 0
+};
 
 function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
     const parentIsDefaultNamespace = !domParentVNode || !!vnode_getElementName(domParentVNode) && vnode_isDefaultNamespace(domParentVNode);
@@ -535,10 +530,16 @@ function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
         elementNamespace = !!(128 & domParentVNode.flags) ? SVG_NS : !!(256 & domParentVNode.flags) ? MATH_NS : HTML_NS, 
         elementNamespaceFlag = 384 & domParentVNode.flags;
     }
-    return {
-        elementNamespace,
-        elementNamespaceFlag
-    };
+    return NEW_NAMESPACE_DATA.elementNamespace = elementNamespace, NEW_NAMESPACE_DATA.elementNamespaceFlag = elementNamespaceFlag, 
+    NEW_NAMESPACE_DATA;
+}
+
+function isSvg(tagOrVNode) {
+    return "string" == typeof tagOrVNode ? isSvgElement(tagOrVNode) : !!vnode_isElementVNode(tagOrVNode) && (isSvgElement(vnode_getElementName(tagOrVNode)) || !!(128 & tagOrVNode.flags));
+}
+
+function isMath(tagOrVNode) {
+    return "string" == typeof tagOrVNode ? isMathElement(tagOrVNode) : !!vnode_isElementVNode(tagOrVNode) && (isMathElement(vnode_getElementName(tagOrVNode)) || !!(256 & tagOrVNode.flags));
 }
 
 function getAttributeNamespace(attributeName) {
@@ -575,34 +576,42 @@ class BackRef {
     [_EFFECT_BACK_REF]=void 0;
 }
 
-class VNode extends BackRef {
+class VNode {
     flags;
     parent;
     previousSibling;
     nextSibling;
     props;
+    [_EFFECT_BACK_REF]=void 0;
     slotParent=null;
     dirty=0;
     dirtyChildren=null;
     nextDirtyChildIndex=0;
     constructor(flags, parent, previousSibling, nextSibling, props) {
-        super(), this.flags = flags, this.parent = parent, this.previousSibling = previousSibling, 
+        this.flags = flags, this.parent = parent, this.previousSibling = previousSibling, 
         this.nextSibling = nextSibling, this.props = props;
     }
     toString() {
-        return isDev ? vnode_toString.call(this) : super.toString();
+        return isDev ? vnode_toString.call(this) : Object.prototype.toString.call(this);
     }
 }
 
-class ElementVNode extends VNode {
+class VirtualVNode extends VNode {
     key;
     firstChild;
     lastChild;
+    constructor(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild) {
+        super(flags, parent, previousSibling, nextSibling, props), this.key = key, this.firstChild = firstChild, 
+        this.lastChild = lastChild;
+    }
+}
+
+class ElementVNode extends VirtualVNode {
     node;
     elementName;
     constructor(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild, node, elementName) {
-        super(flags, parent, previousSibling, nextSibling, props), this.key = key, this.firstChild = firstChild, 
-        this.lastChild = lastChild, this.node = node, this.elementName = elementName;
+        super(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild), 
+        this.node = node, this.elementName = elementName;
     }
 }
 
@@ -614,16 +623,6 @@ class TextVNode extends VNode {
     }
 }
 
-class VirtualVNode extends VNode {
-    key;
-    firstChild;
-    lastChild;
-    constructor(key, flags, parent, previousSibling, nextSibling, props, firstChild, lastChild) {
-        super(flags, parent, previousSibling, nextSibling, props), this.key = key, this.firstChild = firstChild, 
-        this.lastChild = lastChild;
-    }
-}
-
 const globalCursorQueue = [];
 
 const pausedCursorQueue = [];
@@ -658,7 +657,7 @@ function getHighestPriorityCursor() {
 }
 
 function pauseCursor(cursor, container) {
-    pausedCursorQueue.push(cursor), removeCursorFromQueue(cursor, container, !0);
+    pausedCursorQueue.push(cursor), removeCursorFromQueue(cursor, container, !0), container.$pausedCursorCount$++;
 }
 
 function resumeCursor(cursor, container) {
@@ -666,15 +665,15 @@ function resumeCursor(cursor, container) {
     if (-1 !== index) {
         const lastIndex = pausedCursorQueue.length - 1;
         index !== lastIndex && (pausedCursorQueue[index] = pausedCursorQueue[lastIndex]), 
-        pausedCursorQueue.pop();
+        pausedCursorQueue.pop(), container.$pausedCursorCount$--;
     }
     addCursorToQueue(container, cursor);
 }
 
 function removeCursorFromQueue(cursor, container, keepCursorFlag) {
-    container.$cursorCount$ > 0 && container.$cursorCount$--, keepCursorFlag || (cursor.flags &= -65);
+    keepCursorFlag || (cursor.flags &= -65);
     const index = globalCursorQueue.indexOf(cursor);
-    -1 !== index && globalCursorQueue.splice(index, 1);
+    -1 !== index && (globalCursorQueue.splice(index, 1), container.$cursorCount$--);
 }
 
 const cursorDatas = new WeakMap;
@@ -738,7 +737,22 @@ class SignalImpl {
         this.$untrackedValue$ = value;
     }
     get value() {
-        return setupSignalValueAccess(this, () => this.$effects$ ||= new Set, () => this.untrackedValue);
+        const ctx = tryGetInvokeContext();
+        if (!ctx) {
+            return this.untrackedValue;
+        }
+        if (null === this.$container$) {
+            if (!ctx.$container$) {
+                return this.untrackedValue;
+            }
+            this.$container$ = ctx.$container$;
+        } else {
+            isDev && assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
+        }
+        const effectSubscriber = ctx.$effectSubscriber$;
+        return effectSubscriber && (ensureContainsSubscription(this.$effects$ ||= new Set, effectSubscriber), 
+        ensureContainsBackRef(effectSubscriber, this), (import.meta.env.TEST ? !isDomContainer(this.$container$) : isServer) && addQrlToSerializationCtx(effectSubscriber, this.$container$)), 
+        this.untrackedValue;
     }
     set value(value) {
         value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, scheduleEffects(this.$container$, this, this.$effects$));
@@ -747,7 +761,7 @@ class SignalImpl {
         qDev;
     }
     toString() {
-        return isDev ? `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map(e => "\n -> " + pad(qwikDebugToString(e[0]), "    ")).join("\n") || "") : this.constructor.name;
+        return isDev ? `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map(e => "\n -> " + pad(qwikDebugToString(e.consumer), "    ")).join("\n") || "") : this.constructor.name;
     }
     toJSON() {
         return {
@@ -756,26 +770,23 @@ class SignalImpl {
     }
 }
 
-const addEffect = (signal, effectSubscriber, effects) => {
-    ensureContainsSubscription(effects, effectSubscriber), ensureContainsBackRef(effectSubscriber, signal), 
-    addQrlToSerializationCtx(effectSubscriber, signal.$container$);
-};
-
 const setupSignalValueAccess = (target, effectsFn, returnValueFn) => {
     const ctx = tryGetInvokeContext();
-    if (ctx) {
-        if (null === target.$container$) {
-            if (!ctx.$container$) {
-                return returnValueFn();
-            }
-            target.$container$ = ctx.$container$;
-        } else {
-            assertTrue(!ctx.$container$ || ctx.$container$ === target.$container$, "Do not use signals across containers");
+    if (!ctx) {
+        return returnValueFn();
+    }
+    if (null === target.$container$) {
+        if (!ctx.$container$) {
+            return returnValueFn();
         }
-        const effectSubscriber = ctx.$effectSubscriber$;
-        effectSubscriber && addEffect(target, effectSubscriber, effectsFn());
+        target.$container$ = ctx.$container$;
+    } else {
+        isDev && assertTrue(!ctx.$container$ || ctx.$container$ === target.$container$, "Do not use signals across containers");
     }
-    return returnValueFn();
+    const effectSubscriber = ctx.$effectSubscriber$;
+    return effectSubscriber && (ensureContainsSubscription(effectsFn(), effectSubscriber), 
+    ensureContainsBackRef(effectSubscriber, target), addQrlToSerializationCtx(effectSubscriber, target.$container$)), 
+    returnValueFn();
 };
 
 const _CONST_PROPS = Symbol("CONST");
@@ -792,7 +803,7 @@ const _UNINITIALIZED = Symbol("UNINITIALIZED");
 
 const EVENT_SUFFIX = "$";
 
-const isHtmlAttributeAnEventName = name => name.startsWith("on:") || name.startsWith("on-window:") || name.startsWith("on-document:");
+const isHtmlAttributeAnEventName = name => 111 === name.charCodeAt(0) && 110 === name.charCodeAt(1) && (58 === name.charCodeAt(2) || (name.startsWith("on-window:") || name.startsWith("on-document:")));
 
 function jsxEventToHtmlAttribute(jsxEvent) {
     if (jsxEvent.endsWith("$")) {
@@ -934,14 +945,15 @@ class PropsProxyHandler {
 
 const addPropsProxyEffect = (propsProxy, prop) => {
     const ctx = tryGetInvokeContext();
-    ctx && (null === propsProxy.$container$ ? ctx.$container$ && (propsProxy.$container$ = ctx.$container$) : assertTrue(!ctx.$container$ || ctx.$container$ === propsProxy.$container$, "Do not use props across containers"));
+    ctx && (null === propsProxy.$container$ ? ctx.$container$ && (propsProxy.$container$ = ctx.$container$) : isDev && assertTrue(!ctx.$container$ || ctx.$container$ === propsProxy.$container$, "Do not use props across containers"));
     const effectSubscriber = ctx?.$effectSubscriber$;
     effectSubscriber && addStoreEffect(propsProxy.owner._proxy, prop, propsProxy, effectSubscriber);
 };
 
 const triggerPropsProxyEffect = (propsProxy, prop) => {
     const effects = getEffects$1(propsProxy.$effects$, prop);
-    effects && scheduleEffects(propsProxy.$container$, propsProxy, effects);
+    return effects && scheduleEffects(propsProxy.$container$, propsProxy, effects), 
+    !!effects;
 };
 
 function getEffects$1(effects, prop) {
@@ -971,26 +983,36 @@ const cleanupDestroyable = destroyable => {
     }
 };
 
+const NEEDS_COMPUTATION = Symbol("invalid");
+
+class EffectSubscription {
+    consumer;
+    property;
+    backRef;
+    data;
+    constructor(consumer, property, backRef = null, data = null) {
+        this.consumer = consumer, this.property = property, this.backRef = backRef, this.data = data;
+    }
+}
+
+const STORE_TARGET = Symbol("store.target");
+
+const STORE_HANDLER = Symbol("store.handler");
+
+const STORE_ALL_PROPS = Symbol("store.all");
+
 function getSubscriber(effect, prop, data) {
     effect[_EFFECT_BACK_REF] || (isServer && isSsrNode(effect) ? effect.setProp("q:brefs", new Map) : effect[_EFFECT_BACK_REF] = new Map);
     const subMap = effect[_EFFECT_BACK_REF];
     let sub = subMap.get(prop);
-    return sub || (sub = [ effect, prop ], subMap.set(prop, sub)), data && (sub[3] = data), 
-    sub;
+    return sub || (sub = new EffectSubscription(effect, prop), subMap.set(prop, sub)), 
+    data && (sub.data = data), sub;
 }
 
 function isSsrNode(value) {
     return "__brand__" in value && "SsrNode" === value.__brand__;
 }
 
-const NEEDS_COMPUTATION = Symbol("invalid");
-
-const STORE_TARGET = Symbol("store.target");
-
-const STORE_HANDLER = Symbol("store.handler");
-
-const STORE_ALL_PROPS = Symbol("store.all");
-
 const trackFn = (target, container) => (obj, prop) => {
     const ctx = newInvokeContext();
     return ctx.$effectSubscriber$ = getSubscriber(target, ":"), ctx.$container$ = container || void 0, 
@@ -1050,7 +1072,7 @@ class ComputedSignalImpl extends SignalImpl {
         this.$flags$ |= 2, super.force();
     }
     get untrackedValue() {
-        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
     }
     $computeIfNeeded$() {
@@ -1061,7 +1083,10 @@ class ComputedSignalImpl extends SignalImpl {
         throwIfQRLNotResolved(computeQrl);
         const ctx = tryGetInvokeContext();
         const previousEffectSubscription = ctx?.$effectSubscriber$;
-        ctx && (ctx.$effectSubscriber$ = getSubscriber(this, "."));
+        if (ctx) {
+            const effectSubscriber = getSubscriber(this, ".");
+            clearEffectSubscription(this.$container$, effectSubscriber), ctx.$effectSubscriber$ = effectSubscriber;
+        }
         try {
             const untrackedValue = computeQrl.getFn(ctx)();
             if (isPromise(untrackedValue)) {
@@ -1212,16 +1237,16 @@ const _wrapProp = (...args) => {
         return obj[prop];
     }
     if (isSignal(obj)) {
-        return obj instanceof AsyncComputedSignalImpl || assertEqual(prop, "value", "Left side is a signal, prop must be value"), 
+        return obj instanceof AsyncComputedSignalImpl || isDev && assertEqual(prop, "value", "Left side is a signal, prop must be value"), 
         obj instanceof WrappedSignalImpl && 4 & obj.$flags$ ? obj : getWrapped(args);
     }
     if (isPropsProxy(obj)) {
         const constProps = obj[_CONST_PROPS];
         const varProps = obj[_VAR_PROPS];
-        if (constProps && prop in constProps) {
+        if (constProps && Object.prototype.hasOwnProperty.call(constProps, prop)) {
             return constProps[prop];
         }
-        if (prop in varProps) {
+        if (Object.prototype.hasOwnProperty.call(varProps, prop)) {
             return wrapIfNotSignal(varProps[prop], args);
         }
     } else {
@@ -1266,7 +1291,7 @@ class WrappedSignalImpl extends SignalImpl {
         markVNodeDirty(this.$container$, this.$hostElement$, 16));
     }
     get untrackedValue() {
-        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
     }
     $computeIfNeeded$() {
@@ -1300,7 +1325,7 @@ function clearAllEffects(container, consumer) {
 }
 
 function clearEffectSubscription(container, effect) {
-    const backRefs = effect[2];
+    const backRefs = effect.backRef;
     if (backRefs) {
         for (const producer of backRefs) {
             if (producer instanceof SignalImpl) {
@@ -1351,13 +1376,14 @@ const useLexicalScope = () => {
     const context = getInvokeContext();
     let qrl = context.$qrl$;
     if (qrl) {
-        assertQrl(qrl), assertDefined(qrl.$captureRef$, "invoke: qrl $captureRef$ must be defined inside useLexicalScope()", qrl);
+        isDev && assertQrl(qrl), isDev && assertDefined(qrl.$captureRef$, "invoke: qrl $captureRef$ must be defined inside useLexicalScope()", qrl);
     } else {
         const el = context.$hostElement$ instanceof ElementVNode ? context.$hostElement$.node : void 0;
-        assertDefined(el, "invoke: element must be defined inside useLexicalScope()", context);
+        isDev && assertDefined(el, "invoke: element must be defined inside useLexicalScope()", context);
         const containerElement = _getQContainerElement(el);
-        assertDefined(containerElement, "invoke: cant find parent q:container of", el);
-        qrl = getDomContainer(containerElement).parseQRL(decodeURIComponent(String(context.$url$)));
+        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$)));
     }
     return qrl.$captureRef$;
 };
@@ -1372,39 +1398,20 @@ const _chk = (_, element) => {
     signal.value = element.checked;
 };
 
-const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-
-const BIND_VALUE = "bind:value";
-
-const BIND_CHECKED = "bind:checked";
+const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 
 class JSXNodeImpl {
     type;
+    children;
     toSort;
     key;
     varProps;
     constProps;
-    children;
     dev;
     _proxy=null;
     constructor(type, varProps, constProps, children, key, toSort, dev) {
-        if (this.type = type, this.toSort = !!toSort, this.key = null == key ? null : String(key), 
+        this.type = type, this.children = children, this.toSort = !!toSort, this.key = null == key ? null : "string" == typeof key ? key : "" + key, 
         this.varProps = !varProps || isEmpty(varProps) ? EMPTY_OBJ : varProps, this.constProps = !constProps || isEmpty(constProps) ? null : constProps, 
-        this.children = children, "string" == typeof type) {
-            for (const k in this.constProps) {
-                const attr = jsxEventToHtmlAttribute(k);
-                attr && (mergeHandlers(this.constProps, attr, this.constProps[k]), delete this.constProps[k]);
-            }
-            for (const k in this.varProps) {
-                const attr = jsxEventToHtmlAttribute(k);
-                attr && (constProps && _hasOwnProperty$1.call(constProps, k) || (toSort = mergeHandlers(this.varProps, attr, this.varProps[k]) || toSort), 
-                delete this.varProps[k]);
-            }
-            _hasOwnProperty$1.call(this.varProps, BIND_CHECKED) ? toSort = handleBindProp(this.varProps, BIND_CHECKED) || toSort : _hasOwnProperty$1.call(this.varProps, BIND_VALUE) ? toSort = handleBindProp(this.varProps, BIND_VALUE) || toSort : this.constProps && (_hasOwnProperty$1.call(this.constProps, BIND_CHECKED) ? handleBindProp(this.constProps, BIND_CHECKED) : _hasOwnProperty$1.call(this.constProps, BIND_VALUE) && handleBindProp(this.constProps, BIND_VALUE)), 
-            _hasOwnProperty$1.call(this.varProps, "className") && (this.varProps.class = this.varProps.className, 
-            this.varProps.className = void 0, toSort = !0), this.constProps && _hasOwnProperty$1.call(this.constProps, "className") && (this.constProps.class = this.constProps.className, 
-            this.constProps.className = void 0);
-        }
         seal();
     }
     get props() {
@@ -1422,34 +1429,91 @@ const mergeHandlers = (obj, event, handler) => {
 
 const isJSXNode = n => n instanceof JSXNodeImpl;
 
-const isEmpty = obj => {
-    for (const prop in obj) {
-        if (void 0 !== obj[prop]) {
-            return !1;
-        }
-    }
-    return !0;
-};
+const isEmpty = obj => 0 === Object.keys(obj).length;
 
-const handleBindProp = (props, prop) => {
-    const value = props[prop];
-    if (props[prop] = void 0, value) {
-        return prop === BIND_CHECKED ? (props.checked = value, props["on:input"] = createQRL(null, "_chk", _chk, null, null, [ value ])) : (props.value = value, 
-        props["on:input"] = createQRL(null, "_val", _val, null, null, [ value ])), !0;
-    }
-};
+const BIND_VALUE = "bind:value";
 
-const _jsxSorted = (type, varProps, constProps, children, flags, key, dev) => untrack(() => new JSXNodeImpl(type, varProps, constProps, children, key, !1, dev));
+const BIND_CHECKED = "bind:checked";
 
-const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => untrack(() => {
+const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+const _jsxSorted = (type, varProps, constProps, children, flags, key, dev) => new JSXNodeImpl(type, varProps, constProps, children, key, !1, dev);
+
+const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
+    let toSort = !1;
+    let constPropsCopied = !1;
+    let varPropsCopied = !1;
+    let bindValueSignal = null;
+    let bindCheckedSignal = null;
+    if ("string" == typeof type) {
+        if (constProps) {
+            const processedKeys = new Set;
+            for (const k in constProps) {
+                const attr = jsxEventToHtmlAttribute(k);
+                attr && (constPropsCopied || (constProps = {
+                    ...constProps
+                }, constPropsCopied = !0), _hasOwnProperty$1.call(constProps, attr) && !processedKeys.has(attr) || (constProps[attr] = constProps[k]), 
+                delete constProps[k]), processedKeys.add(k);
+            }
+        }
+        if (varProps) {
+            const processedKeys = new Set;
+            for (const k in varProps) {
+                const attr = jsxEventToHtmlAttribute(k);
+                attr ? (varPropsCopied || (varProps = {
+                    ...varProps
+                }, varPropsCopied = !0), _hasOwnProperty$1.call(varProps, attr) && !processedKeys.has(attr) || (varProps[attr] = varProps[k]), 
+                delete varProps[k], toSort = !0) : k === BIND_CHECKED ? bindCheckedSignal = varProps[k] : k === BIND_VALUE && (bindValueSignal = varProps[k]), 
+                processedKeys.add(k);
+            }
+            if (bindCheckedSignal || bindValueSignal) {
+                if (varPropsCopied || (varProps = {
+                    ...varProps
+                }, varPropsCopied = !0), bindCheckedSignal) {
+                    delete varProps[BIND_CHECKED], varProps.checked = bindCheckedSignal;
+                    const handler = createQRL(null, "_chk", _chk, null, null, [ bindCheckedSignal ]);
+                    if (constProps && _hasOwnProperty$1.call(constProps, "on:input")) {
+                        constPropsCopied || (constProps = {
+                            ...constProps
+                        }, constPropsCopied = !0);
+                        const existingHandler = constProps["on:input"];
+                        delete constProps["on:input"], toSort = mergeHandlers(varProps, "on:input", existingHandler) || toSort;
+                    }
+                    toSort = mergeHandlers(varProps, "on:input", handler) || toSort;
+                } else if (bindValueSignal) {
+                    delete varProps[BIND_VALUE], varProps.value = bindValueSignal;
+                    const handler = createQRL(null, "_val", _val, null, null, [ bindValueSignal ]);
+                    if (constProps && _hasOwnProperty$1.call(constProps, "on:input")) {
+                        constPropsCopied || (constProps = {
+                            ...constProps
+                        }, constPropsCopied = !0);
+                        const existingHandler = constProps["on:input"];
+                        delete constProps["on:input"], toSort = mergeHandlers(varProps, "on:input", existingHandler) || toSort;
+                    }
+                    toSort = mergeHandlers(varProps, "on:input", handler) || toSort;
+                }
+            }
+        }
+        varProps && _hasOwnProperty$1.call(varProps, "className") && (varPropsCopied || (varProps = {
+            ...varProps
+        }, varPropsCopied = !0), varProps.class = varProps.className, varProps.className = void 0, 
+        toSort = !0), constProps && _hasOwnProperty$1.call(constProps, "className") && (constPropsCopied || (constProps = {
+            ...constProps
+        }, constPropsCopied = !0), constProps.class = constProps.className, constProps.className = void 0);
+    }
     if (varProps) {
         for (const k in varProps) {
-            "children" === k ? (children ||= varProps.children, delete varProps.children) : "key" === k ? (key ||= varProps.key, 
-            delete varProps.key) : constProps && k in constProps && delete varProps[k];
+            "children" === k ? (varPropsCopied || (varProps = {
+                ...varProps
+            }, varPropsCopied = !0), children ||= varProps.children, delete varProps.children) : "key" === k ? (varPropsCopied || (varProps = {
+                ...varProps
+            }, varPropsCopied = !0), key ||= varProps.key, delete varProps.key) : (constProps && k in constProps || null === varProps[k]) && (varPropsCopied || (varProps = {
+                ...varProps
+            }, varPropsCopied = !0), delete varProps[k]);
         }
     }
-    return new JSXNodeImpl(type, varProps, constProps, children, key, !0, dev);
-});
+    return new JSXNodeImpl(type, varProps, constProps, children, key, toSort || !0, dev);
+};
 
 const _jsxC = (type, mutable, _flags, key) => jsx(type, mutable, key);
 
@@ -1493,8 +1557,8 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
     subscriptionHost && (iCtx.$effectSubscriber$ = getSubscriber(subscriptionHost, ":"), 
     iCtx.$container$ = container), container.ensureProjectionResolved(renderHost);
     let isInlineComponent = !1;
-    if (null === componentQRL && assertDefined(componentQRL = container.getHostProp(renderHost, "q:renderFn"), "No Component found at this location"), 
-    isQrl(componentQRL)) {
+    if (null === componentQRL && (componentQRL = container.getHostProp(renderHost, "q:renderFn"), 
+    isDev && assertDefined(componentQRL, "No Component found at this location")), isQrl(componentQRL)) {
         "children" in (props = props || container.getHostProp(renderHost, "q:props") || EMPTY_OBJ) && delete props.children, 
         componentFn = componentQRL.getFn(iCtx);
     } else if (isQwikComponent(componentQRL)) {
@@ -1505,9 +1569,15 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
         const inlineComponent = componentQRL;
         componentFn = () => invokeApply(iCtx, inlineComponent, [ props || EMPTY_OBJ ]);
     }
+    const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer;
     const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall(() => (isInlineComponent || (container.setHostProp(renderHost, "q:seqIdx", null), 
     container.setHostProp(renderHost, ":onIdx", null)), retryCount > 0 && vnode_isVNode(renderHost) && clearAllEffects(container, renderHost), 
     maybeThen(componentFn(props), jsx => maybeThen(iCtx.$waitOn$, () => jsx))), jsx => {
+        if (isSsr && !isInlineComponent) {
+            if (4 & renderHost.dirty && (renderHost.dirty &= -5, retryCount < 100)) {
+                return executeComponentWithPromiseExceptionRetry(retryCount + 1);
+            }
+        }
         const useOnEvents = container.getHostProp(renderHost, ":on");
         return useOnEvents ? addUseOnEvents(jsx, useOnEvents) : jsx;
     }, err => {
@@ -1589,7 +1659,7 @@ function injectPlaceholderElement(jsx) {
         return jsx.type === Fragment || isQwikComponent(jsx.type) ? (null == jsx.children ? jsx.children = placeholder : isArray(jsx.children) ? jsx.children.push(placeholder) : jsx.children = [ jsx.children, placeholder ], 
         [ placeholder, jsx ]) : [ placeholder, _jsxSorted(Fragment, null, null, [ jsx, placeholder ], 0, null) ];
     }
-    if (isPrimitive(jsx)) {
+    if (isPrimitiveOrNullUndefined(jsx)) {
         const placeholder = createPlaceholderScriptNode();
         return [ placeholder, _jsxSorted(Fragment, null, null, [ jsx, placeholder ], 0, null) ];
     }
@@ -1603,7 +1673,7 @@ function injectPlaceholderElement(jsx) {
 function createPlaceholderScriptNode() {
     return new JSXNodeImpl("script", null, {
         hidden: ""
-    });
+    }, null, null);
 }
 
 const Slot = props => _jsxSorted(Virtual, null, {
@@ -1687,15 +1757,11 @@ const _restProps = (props, omit = [], target = {}) => {
     for (const key in varProps) {
         omit.includes(key) || (varPropsTarget[key] = varProps[key]);
     }
-    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget));
+    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget, null, null));
 };
 
 const styleContent = styleId => "⚡️" + styleId;
 
-function hasClassAttr(props) {
-    return "class" in props;
-}
-
 function isClassAttr(key) {
     return "class" === key;
 }
@@ -1798,79 +1864,8 @@ function isAriaAttribute(prop) {
 
 const styleKey = (qStyles, index) => (assertQrl(qStyles), `${hashCode(qStyles.$hash$)}-${index}`);
 
-const useSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const host = iCtx.$hostElement$;
-    let seq = iCtx.$container$.getHostProp(host, "q:seq");
-    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
-    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
-    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
-        seq.push(void 0);
-    }
-    return {
-        val: seq[seqIdx],
-        set: value => seq[seqIdx] = value,
-        i: seqIdx,
-        iCtx
-    };
-};
-
-const useTaskQrl = (qrl, opts) => {
-    const {val, set, iCtx, i} = useSequentialScope();
-    if (val) {
-        return;
-    }
-    assertQrl(qrl), set(1);
-    const task = new Task(10 | (!1 === opts?.deferUpdates ? 0 : 16), i, iCtx.$hostElement$, qrl, void 0, null);
-    set(task);
-    const container = iCtx.$container$;
-    const {$waitOn$: waitOn} = iCtx;
-    const result = maybeThen(waitOn, () => runTask(task, container, iCtx.$hostElement$));
-    isPromise(result) && (iCtx.$waitOn$ = result);
-};
-
-const runTask = (task, container, host) => {
-    task.$flags$ &= -9, cleanupDestroyable(task);
-    const iCtx = newInvokeContext(container.$locale$, host, "qTask");
-    iCtx.$container$ = container;
-    const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
-    const track = trackFn(task, container);
-    const [cleanup] = cleanupFn(task, reason => container.handleError(reason, host));
-    const taskApi = {
-        track,
-        cleanup
-    };
-    return safeCall(() => taskFn(taskApi), cleanup, err => {
-        if (isPromise(err)) {
-            return err.then(() => runTask(task, container, host));
-        }
-        container.handleError(err, host);
-    });
-};
-
-class Task extends BackRef {
-    $flags$;
-    $index$;
-    $el$;
-    $qrl$;
-    $state$;
-    $destroy$;
-    constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
-        super(), this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, 
-        this.$state$ = $state$, this.$destroy$ = $destroy$;
-    }
-}
-
-const isTask = value => value instanceof Task;
-
-const scheduleTask = (_event, element) => {
-    const [task] = useLexicalScope();
-    const container = getDomContainer(element);
-    task.$flags$ |= 8, markVNodeDirty(container, task.$el$, 1);
-};
-
 const mapApp_findIndx = (array, key, start) => {
-    assertTrue(start % 2 == 0, "Expecting even number.");
+    isDev && assertTrue(start % 2 == 0, "Expecting even number.");
     let bottom = start >> 1;
     let top = array.length - 2 >> 1;
     for (;bottom <= top; ) {
@@ -1896,15 +1891,123 @@ const mapArray_get = (array, key, start) => {
 
 const mapArray_has = (array, key, start) => mapApp_findIndx(array, key, start) >= 0;
 
+class DeleteOperation {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+}
+
+class RemoveAllChildrenOperation {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+}
+
+class SetTextOperation {
+    target;
+    text;
+    operationType=16;
+    constructor(target, text) {
+        this.target = target, this.text = text;
+    }
+}
+
+class InsertOrMoveOperation {
+    target;
+    parent;
+    beforeTarget;
+    constructor(target, parent, beforeTarget) {
+        this.target = target, this.parent = parent, this.beforeTarget = beforeTarget;
+    }
+}
+
+class SetAttributeOperation {
+    target;
+    attrName;
+    attrValue;
+    scopedStyleIdPrefix;
+    isSvg;
+    constructor(target, attrName, attrValue, scopedStyleIdPrefix, isSvg) {
+        this.target = target, this.attrName = attrName, this.attrValue = attrValue, this.scopedStyleIdPrefix = scopedStyleIdPrefix, 
+        this.isSvg = isSvg;
+    }
+}
+
+const createDeleteOperation = target => new DeleteOperation(target);
+
+const createRemoveAllChildrenOperation = target => new RemoveAllChildrenOperation(target);
+
+const createSetTextOperation = (target, text) => new SetTextOperation(target, text);
+
+const createInsertOrMoveOperation = (target, parent, beforeTarget) => new InsertOrMoveOperation(target, parent, beforeTarget);
+
+const createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg = !1) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg);
+
+function callQrl(container, host, qrl, event, element, useGetObjectById) {
+    const getObjectById = useGetObjectById && container?.$getObjectById$ || null;
+    const singleItem = vnode_getProp(host, "q:p", getObjectById);
+    if (null !== singleItem) {
+        return qrl(event, element, singleItem);
+    }
+    const multiItems = vnode_getProp(host, "q:ps", getObjectById);
+    return null !== multiItems ? qrl(event, element, ...multiItems) : qrl(event, element);
+}
+
+const _run = (...args) => {
+    const [qrl] = useLexicalScope();
+    const context = getInvokeContext();
+    const hostElement = context.$hostElement$;
+    if (hostElement) {
+        return context.$container$ ||= getDomContainer(hostElement.node), vnode_ensureElementInflated(hostElement), 
+        retryOnPromise(() => {
+            if (!(32 & hostElement.flags)) {
+                return callQrl(context.$container$, hostElement, qrl, args[0], args[1], !0).catch(err => {
+                    const container = context.$container$;
+                    if (!container) {
+                        throw err;
+                    }
+                    container.handleError(err, hostElement);
+                });
+            }
+        });
+    }
+};
+
+let _setAttribute = null;
+
+const fastSetAttribute = (target, name, value) => {
+    _setAttribute || (_setAttribute = target.setAttribute), _setAttribute.call(target, name, value);
+};
+
+let _setAttributeNS = null;
+
+const fastSetAttributeNS = (target, namespace, name, value) => {
+    _setAttributeNS || (_setAttributeNS = target.setAttributeNS), _setAttributeNS.call(target, namespace, name, value);
+};
+
+function directSetAttribute(element, attrName, attrValue, isSvg) {
+    if (null != attrValue) {
+        if (isSvg) {
+            const namespace = getAttributeNamespace(attrName);
+            if (namespace) {
+                return void fastSetAttributeNS(element, namespace, attrName, attrValue);
+            }
+        }
+        fastSetAttribute(element, attrName, attrValue);
+    }
+}
+
 function peekNextSibling(vCurrent) {
     return vCurrent ? vCurrent.nextSibling : null;
 }
 
 const _hasOwnProperty = Object.prototype.hasOwnProperty;
 
-function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix) {
-    const serializedValue = null != value ? serializeAttribute(key, value, scopedStyleIdPrefix) : null;
-    vnode_setAttr(journal, vnode, key, serializedValue);
+function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalValue) {
+    import.meta.env.TEST && scopedStyleIdPrefix && vnode_setProp(vnode, "__scopedStyleIdPrefix__", scopedStyleIdPrefix), 
+    vnode_setProp(vnode, key, originalValue), addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, !!(128 & vnode.flags)));
 }
 
 const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
@@ -1927,6 +2030,7 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
         jsxIdx: 0,
         jsxCount: 0,
         shouldAdvance: !0,
+        isCreationMode: !1,
         subscriptionData: {
             const: new SubscriptionData({
                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
@@ -1949,30 +2053,19 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
 };
 
 function diff(diffContext, jsxNode, vStartNode) {
-    if (assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
+    if (isDev && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), 
+    isDev && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
     diffContext.vParent = vStartNode, diffContext.vNewNode = null, diffContext.vCurrent = vnode_getFirstChild(vStartNode), 
     stackPush(diffContext, jsxNode, !0), !(32 & diffContext.vParent.flags)) {
         for (;diffContext.stack.length; ) {
             for (;diffContext.jsxIdx < diffContext.jsxCount; ) {
-                if (assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same"), 
+                if (isDev && assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same"), 
                 "string" == typeof diffContext.jsxValue) {
                     expectText(diffContext, diffContext.jsxValue);
                 } else if ("number" == typeof diffContext.jsxValue) {
                     expectText(diffContext, String(diffContext.jsxValue));
                 } else if (diffContext.jsxValue && "object" == typeof diffContext.jsxValue) {
-                    if (Array.isArray(diffContext.jsxValue)) {
-                        descend(diffContext, diffContext.jsxValue, !1);
-                    } else if (isSignal(diffContext.jsxValue)) {
-                        expectVirtual(diffContext, "S", null);
-                        const unwrappedSignal = diffContext.jsxValue instanceof WrappedSignalImpl ? diffContext.jsxValue.$unwrapIfSignal$() : diffContext.jsxValue;
-                        const hasUnwrappedSignal = diffContext.vCurrent?.[_EFFECT_BACK_REF]?.get(".")?.[2]?.has(unwrappedSignal);
-                        if (!hasUnwrappedSignal) {
-                            const vHost = diffContext.vNewNode || diffContext.vCurrent;
-                            descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, ".", diffContext.container)), !0);
-                        }
-                    } else if (isPromise(diffContext.jsxValue)) {
-                        expectVirtual(diffContext, "A", null), diffContext.asyncQueue.push(diffContext.jsxValue, diffContext.vNewNode || diffContext.vCurrent);
-                    } else if (isJSXNode(diffContext.jsxValue)) {
+                    if (isJSXNode(diffContext.jsxValue)) {
                         const type = diffContext.jsxValue.type;
                         if ("string" == typeof type) {
                             expectNoMoreTextNodes(diffContext), expectElement(diffContext, diffContext.jsxValue, type);
@@ -1984,6 +2077,20 @@ function diff(diffContext, jsxNode, vStartNode) {
                             descend(diffContext, diffContext.jsxValue.children, !0, !1)) : type === SSRComment || type === SSRRaw ? expectNoMore(diffContext) : (expectNoMoreTextNodes(diffContext), 
                             expectComponent(diffContext, type)));
                         }
+                    } else if (Array.isArray(diffContext.jsxValue)) {
+                        descend(diffContext, diffContext.jsxValue, !1);
+                    } else if (isSignal(diffContext.jsxValue)) {
+                        expectVirtual(diffContext, "S", null);
+                        const unwrappedSignal = diffContext.jsxValue instanceof WrappedSignalImpl ? diffContext.jsxValue.$unwrapIfSignal$() : diffContext.jsxValue;
+                        const signals = diffContext.vCurrent?.[_EFFECT_BACK_REF]?.get(".")?.backRef;
+                        let hasUnwrappedSignal = signals?.has(unwrappedSignal);
+                        if (signals && unwrappedSignal instanceof WrappedSignalImpl && (hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal)), 
+                        !hasUnwrappedSignal) {
+                            const vHost = diffContext.vNewNode || diffContext.vCurrent;
+                            descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, ".", diffContext.container)), !0);
+                        }
+                    } else {
+                        isPromise(diffContext.jsxValue) && (expectVirtual(diffContext, "A", null), diffContext.asyncQueue.push(diffContext.jsxValue, diffContext.vNewNode || diffContext.vCurrent));
                     }
                 } else {
                     diffContext.jsxValue === SkipRender || expectText(diffContext, "");
@@ -2022,15 +2129,23 @@ function advance(diffContext) {
 }
 
 function descend(diffContext, children, descendVNode, shouldExpectNoChildren = !0) {
-    shouldExpectNoChildren && (null == children || descendVNode && isArray(children) && 0 === children.length) ? expectNoChildren(diffContext) : (stackPush(diffContext, children, descendVNode), 
-    descendVNode && (assertDefined(diffContext.vCurrent || diffContext.vNewNode, "Expecting vCurrent to be defined."), 
-    diffContext.vSideBuffer = null, diffContext.vSiblings = null, diffContext.vSiblingsArray = null, 
-    diffContext.vParent = diffContext.vNewNode || diffContext.vCurrent, diffContext.vCurrent = vnode_getFirstChild(diffContext.vParent), 
-    diffContext.vNewNode = null), diffContext.shouldAdvance = !1);
+    if (shouldExpectNoChildren && (null == children || descendVNode && isArray(children) && 0 === children.length)) {
+        expectNoChildren(diffContext);
+    } else {
+        if (stackPush(diffContext, children, descendVNode), descendVNode) {
+            isDev && assertDefined(diffContext.vCurrent || diffContext.vNewNode, "Expecting vCurrent to be defined.");
+            const creationMode = diffContext.isCreationMode || !!diffContext.vNewNode || !vnode_getFirstChild(diffContext.vCurrent);
+            diffContext.isCreationMode = creationMode, diffContext.vSideBuffer = null, diffContext.vSiblings = null, 
+            diffContext.vSiblingsArray = null, diffContext.vParent = diffContext.vNewNode || diffContext.vCurrent, 
+            diffContext.vCurrent = vnode_getFirstChild(diffContext.vParent), diffContext.vNewNode = null;
+        }
+        diffContext.shouldAdvance = !1;
+    }
 }
 
 function ascend(diffContext) {
-    diffContext.stack.pop() && (diffContext.vSideBuffer = diffContext.stack.pop(), diffContext.vSiblings = diffContext.stack.pop(), 
+    diffContext.stack.pop() && (diffContext.isCreationMode = diffContext.stack.pop(), 
+    diffContext.vSideBuffer = diffContext.stack.pop(), diffContext.vSiblings = diffContext.stack.pop(), 
     diffContext.vSiblingsArray = diffContext.stack.pop(), diffContext.vNewNode = diffContext.stack.pop(), 
     diffContext.vCurrent = diffContext.stack.pop(), diffContext.vParent = diffContext.stack.pop()), 
     diffContext.jsxValue = diffContext.stack.pop(), diffContext.jsxCount = diffContext.stack.pop(), 
@@ -2040,7 +2155,7 @@ function ascend(diffContext) {
 
 function stackPush(diffContext, children, descendVNode) {
     diffContext.stack.push(diffContext.jsxChildren, diffContext.jsxIdx, diffContext.jsxCount, diffContext.jsxValue), 
-    descendVNode && diffContext.stack.push(diffContext.vParent, diffContext.vCurrent, diffContext.vNewNode, diffContext.vSiblingsArray, diffContext.vSiblings, diffContext.vSideBuffer), 
+    descendVNode && diffContext.stack.push(diffContext.vParent, diffContext.vCurrent, diffContext.vNewNode, diffContext.vSiblingsArray, diffContext.vSiblings, diffContext.vSideBuffer, diffContext.isCreationMode), 
     diffContext.stack.push(descendVNode), Array.isArray(children) ? (diffContext.jsxIdx = 0, 
     diffContext.jsxCount = children.length, diffContext.jsxChildren = children, diffContext.jsxValue = diffContext.jsxCount > 0 ? children[0] : null) : void 0 === children ? (diffContext.jsxIdx = 0, 
     diffContext.jsxValue = null, diffContext.jsxChildren = null, diffContext.jsxCount = 0) : (diffContext.jsxIdx = 0, 
@@ -2095,13 +2210,20 @@ function expectSlot(diffContext) {
     const vHost = vnode_getProjectionParentComponent(diffContext.vParent);
     const slotNameKey = getSlotNameKey(diffContext, vHost);
     const vProjectedNode = vHost ? vnode_getProp(vHost, slotNameKey, null) : null;
-    return null == vProjectedNode ? (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
-    isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++), 
-    !1) : (vProjectedNode === diffContext.vCurrent || (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vProjectedNode, diffContext.vCurrent && getInsertBefore(diffContext)), 
-    vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
-    isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++)), 
-    !0);
+    if (null == vProjectedNode) {
+        return vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
+        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
+        isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++), 
+        !1;
+    }
+    if (vProjectedNode === diffContext.vCurrent) {} else {
+        const oldParent = vProjectedNode.parent;
+        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vProjectedNode, diffContext.vCurrent && getInsertBefore(diffContext)), 
+        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
+        isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++), 
+        oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === QTemplate && vnode_remove(diffContext.journal, oldParent.parent, oldParent, !0);
+    }
+    return !0;
 }
 
 function getSlotNameKey(diffContext, vHost) {
@@ -2160,7 +2282,7 @@ function expectNoChildren(diffContext, removeDOM = !0) {
 }
 
 function expectNoMore(diffContext) {
-    if (assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same"), 
+    if (isDev && assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same"), 
     null !== diffContext.vCurrent) {
         for (;diffContext.vCurrent; ) {
             const toRemove = diffContext.vCurrent;
@@ -2180,17 +2302,6 @@ function expectNoMoreTextNodes(diffContext) {
 
 function createNewElement(diffContext, jsx, elementName, currentFile) {
     const element = createElementWithNamespace(diffContext, elementName);
-    function setAttribute(key, value, vHost) {
-        if (null != (value = serializeAttribute(key, value, diffContext.scopedStyleIdPrefix))) {
-            if (128 & vHost.flags) {
-                const namespace = getAttributeNamespace(key);
-                if (namespace) {
-                    return void element.setAttributeNS(namespace, key, value);
-                }
-            }
-            element.setAttribute(key, value);
-        }
-    }
     const {constProps} = jsx;
     let needsQDispatchEventPatch = !1;
     if (constProps) {
@@ -2229,13 +2340,13 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
             }
             if (isPromise(value)) {
                 const vHost = diffContext.vNewNode;
-                const attributePromise = value.then(resolvedValue => setAttribute(key, resolvedValue, vHost));
+                const attributePromise = value.then(resolvedValue => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.scopedStyleIdPrefix), !!(128 & vHost.flags)));
                 diffContext.asyncAttributePromises.push(attributePromise);
                 continue;
             }
             if (key !== dangerouslySetInnerHTML) {
                 if ("textarea" !== elementName || "value" !== key) {
-                    setAttribute(key, value, diffContext.vNewNode);
+                    directSetAttribute(element, key, serializeAttribute(key, value, diffContext.scopedStyleIdPrefix), !!(128 & diffContext.vNewNode.flags));
                 } else {
                     if (value && "string" != typeof value) {
                         if (isDev) {
@@ -2252,35 +2363,39 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
     }
     const key = jsx.key;
     if (key && (diffContext.vNewNode.key = key), diffContext.scopedStyleIdPrefix) {
-        hasClassAttr(jsx.varProps) || jsx.constProps && hasClassAttr(jsx.constProps) || element.setAttribute("class", diffContext.scopedStyleIdPrefix);
+        _hasOwnProperty.call(jsx.varProps, "class") || jsx.constProps && _hasOwnProperty.call(jsx.constProps, "class") || element.setAttribute("class", diffContext.scopedStyleIdPrefix);
     }
     return vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent), 
     needsQDispatchEventPatch;
 }
 
 function createElementWithNamespace(diffContext, elementName) {
-    const domParentVNode = vnode_getDomParentVNode(diffContext.vParent, !0);
-    const {elementNamespace, elementNamespaceFlag} = getNewElementNamespaceData(domParentVNode, elementName);
-    const element = diffContext.container.document.createElementNS(elementNamespace, elementName);
-    return diffContext.vNewNode = vnode_newElement(element, elementName), diffContext.vNewNode.flags |= elementNamespaceFlag, 
+    const namespaceData = getNewElementNamespaceData(vnode_getDomParentVNode(diffContext.vParent, !0), elementName);
+    const currentDocument = import.meta.env.TEST ? diffContext.container.document : document;
+    const element = 0 === namespaceData.elementNamespaceFlag ? currentDocument.createElement(elementName) : currentDocument.createElementNS(namespaceData.elementNamespace, elementName);
+    return diffContext.vNewNode = vnode_newElement(element, elementName), diffContext.vNewNode.flags |= namespaceData.elementNamespaceFlag, 
     element;
 }
 
 function expectElement(diffContext, jsx, elementName) {
-    const isSameElementName = diffContext.vCurrent && vnode_isElementVNode(diffContext.vCurrent) && elementName === vnode_getElementName(diffContext.vCurrent);
-    const jsxKey = jsx.key;
     let needsQDispatchEventPatch = !1;
-    const currentKey = getKey(diffContext.vCurrent);
-    if (isSameElementName && jsxKey === currentKey) {
-        deleteFromSideBuffer(diffContext, elementName, jsxKey);
+    if (diffContext.isCreationMode) {
+        needsQDispatchEventPatch = createNewElement(diffContext, jsx, elementName, null);
     } else {
-        const sideBufferKey = getSideBufferKey(elementName, jsxKey);
-        moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.vParent) && (needsQDispatchEventPatch = createNewElement(diffContext, jsx, elementName, null));
+        const isElementVNode = diffContext.vCurrent && vnode_isElementVNode(diffContext.vCurrent);
+        const isSameElementName = isElementVNode && elementName === vnode_getElementName(diffContext.vCurrent);
+        const jsxKey = jsx.key;
+        if (isSameElementName && jsxKey === (isElementVNode && diffContext.vCurrent.key)) {
+            deleteFromSideBuffer(diffContext, elementName, jsxKey);
+        } else {
+            const sideBufferKey = getSideBufferKey(elementName, jsxKey);
+            moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.vParent) && (needsQDispatchEventPatch = createNewElement(diffContext, jsx, elementName, null));
+        }
     }
     const jsxProps = jsx.varProps;
     const vNode = diffContext.vNewNode || diffContext.vCurrent;
     const element = vNode.node;
-    jsxProps && (needsQDispatchEventPatch = diffProps(diffContext, vNode, jsxProps, vNode.props ||= {}, isDev && getFileLocationFromJsx(jsx.dev) || null) || needsQDispatchEventPatch), 
+    jsxProps && (needsQDispatchEventPatch = diffProps(diffContext, vNode, jsxProps, isDev && getFileLocationFromJsx(jsx.dev) || null) || needsQDispatchEventPatch), 
     needsQDispatchEventPatch && (element.qDispatchEvent || (element.qDispatchEvent = (event, scope) => {
         if (32 & vNode.flags) {
             return;
@@ -2289,71 +2404,100 @@ function expectElement(diffContext, jsx, elementName) {
         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)) {
-            qrl && catchError(qrl(event, element), e => {
+            qrl && callQrl(diffContext.container, vNode, qrl, event, vNode.node, !1).catch(e => {
                 diffContext.container.handleError(e, vNode);
             });
         }
     }));
 }
 
-function diffProps(diffContext, vnode, newAttrs, oldAttrs, currentFile) {
-    vnode_ensureElementInflated(vnode);
+function diffProps(diffContext, vnode, newAttrs, currentFile) {
+    diffContext.isCreationMode || vnode_ensureElementInflated(vnode);
+    const oldAttrs = vnode.props;
     let patchEventDispatch = !1;
-    const record = (key, value) => {
-        if (key.startsWith(":")) {
-            return void vnode_setProp(vnode, key, value);
-        }
-        if ("ref" === key) {
-            const element = vnode.node;
-            if (isSignal(value)) {
-                return void (value.value = element);
+    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) {
+                if (newValue instanceof WrappedSignalImpl && oldValue instanceof WrappedSignalImpl && areWrappedSignalsEqual(newValue, oldValue)) {
+                    continue;
+                }
+                if (isEvent) {
+                    const result = recordJsxEvent(diffContext, vnode, key, newValue, currentFile);
+                    patchEventDispatch ||= result;
+                } else {
+                    patchProperty(diffContext, vnode, key, newValue, currentFile);
+                }
             }
-            if ("function" == typeof value) {
-                return void value(element);
+        } else if (null != newValue) {
+            if (isEvent) {
+                const result = recordJsxEvent(diffContext, vnode, key, newValue, currentFile);
+                patchEventDispatch ||= result;
+            } else {
+                patchProperty(diffContext, vnode, key, newValue, currentFile);
             }
-            throw qError(15, [ currentFile ]);
         }
-        const currentEffect = vnode[_EFFECT_BACK_REF]?.get(key);
+    }
+    if (oldAttrs) {
+        for (const key in oldAttrs) {
+            _hasOwnProperty.call(newAttrs, key) || key.startsWith(HANDLER_PREFIX) || isHtmlAttributeAnEventName(key) || patchProperty(diffContext, vnode, key, null, currentFile);
+        }
+    }
+    return patchEventDispatch;
+}
+
+const patchProperty = (diffContext, vnode, key, value, currentFile) => {
+    if ("q:p" === key || "q:ps" === key || key.charAt(0) === HANDLER_PREFIX) {
+        return void vnode_setProp(vnode, key, value);
+    }
+    const originalValue = value;
+    if ("ref" === key) {
+        const element = vnode.node;
         if (isSignal(value)) {
-            const unwrappedSignal = value instanceof WrappedSignalImpl ? value.$unwrapIfSignal$() : value;
-            if (currentEffect?.[2]?.has(unwrappedSignal)) {
-                return;
-            }
-            currentEffect && clearEffectSubscription(diffContext.container, currentEffect);
-            const vHost = vnode;
-            value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.container, diffContext.subscriptionData.var));
-        } else {
-            currentEffect && clearEffectSubscription(diffContext.container, currentEffect);
+            return void (value.value = element);
         }
-        if (isPromise(value)) {
-            const vHost = vnode;
-            const attributePromise = value.then(resolvedValue => {
-                setAttribute(diffContext.journal, vHost, key, resolvedValue, diffContext.scopedStyleIdPrefix);
-            });
-            return void diffContext.asyncAttributePromises.push(attributePromise);
+        if ("function" == typeof value) {
+            return void value(element);
         }
-        setAttribute(diffContext.journal, vnode, key, value, diffContext.scopedStyleIdPrefix);
-    };
-    const recordJsxEvent = (key, value) => {
-        const data = getEventDataFromHtmlAttribute(key);
-        if (data) {
-            const [scope, eventName] = data;
-            const scopedEvent = getScopedEventName(scope, eventName);
-            const loaderScopedEvent = getLoaderScopedEventName(scope, scopedEvent);
-            record(":" + scopedEvent, value), registerQwikLoaderEvent(diffContext, loaderScopedEvent), 
-            patchEventDispatch = !0;
+        throw qError(15, [ currentFile ]);
+    }
+    const currentEffect = vnode[_EFFECT_BACK_REF]?.get(key);
+    if (isSignal(value)) {
+        const unwrappedSignal = value instanceof WrappedSignalImpl ? value.$unwrapIfSignal$() : value;
+        if (currentEffect?.backRef?.has(unwrappedSignal)) {
+            return;
         }
-    };
-    for (const key of Object.keys(newAttrs)) {
-        const newValue = newAttrs[key];
-        const isEvent = isHtmlAttributeAnEventName(key);
-        _hasOwnProperty.call(oldAttrs, key) ? newValue !== oldAttrs[key] && (isEvent ? recordJsxEvent(key, newValue) : record(key, newValue)) : null != newValue && (isEvent ? recordJsxEvent(key, newValue) : record(key, newValue));
+        currentEffect && clearEffectSubscription(diffContext.container, currentEffect);
+        const vHost = vnode;
+        value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.container, diffContext.subscriptionData.var));
+    } else {
+        currentEffect && clearEffectSubscription(diffContext.container, currentEffect);
     }
-    for (const key of Object.keys(oldAttrs)) {
-        _hasOwnProperty.call(newAttrs, key) || key.startsWith(HANDLER_PREFIX) || isHtmlAttributeAnEventName(key) || record(key, null);
+    if (isPromise(value)) {
+        const vHost = vnode;
+        const attributePromise = value.then(resolvedValue => {
+            setAttribute(diffContext.journal, vHost, key, resolvedValue, diffContext.scopedStyleIdPrefix, originalValue);
+        });
+        return void diffContext.asyncAttributePromises.push(attributePromise);
     }
-    return patchEventDispatch;
-}
+    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;
+        return (!props || !_hasOwnProperty.call(props, scopedEventKey)) && (patchProperty(diffContext, vnode, scopedEventKey, value, currentFile), 
+        registerQwikLoaderEvent(diffContext, loaderScopedEvent), !0);
+    }
+    return !1;
+};
 
 function registerQwikLoaderEvent(diffContext, eventName) {
     const qWindow = import.meta.env.TEST ? diffContext.container.document.defaultView : window;
@@ -2363,6 +2507,13 @@ function registerQwikLoaderEvent(diffContext, eventName) {
 function retrieveChildWithKey(diffContext, nodeName, key) {
     let vNodeWithKey = null;
     if (null === diffContext.vSiblings) {
+        const vCurrent = diffContext.vCurrent;
+        if (vCurrent) {
+            const name = vnode_isElementVNode(vCurrent) ? vnode_getElementName(vCurrent) : null;
+            if ((getKey(vCurrent) || getComponentHash(vCurrent, diffContext.container.$getObjectById$)) === key && name === nodeName) {
+                return vCurrent;
+            }
+        }
         diffContext.vSiblings = new Map, diffContext.vSiblingsArray = [];
         let vNode = diffContext.vCurrent;
         for (;vNode; ) {
@@ -2380,8 +2531,8 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
         }
     } else {
         const siblingsKey = getSideBufferKey(nodeName, key);
-        diffContext.vSiblings.has(siblingsKey) && (vNodeWithKey = diffContext.vSiblings.get(siblingsKey), 
-        diffContext.vSiblings.delete(siblingsKey));
+        const sibling = diffContext.vSiblings.get(siblingsKey);
+        sibling && (vNodeWithKey = sibling, diffContext.vSiblings.delete(siblingsKey));
     }
     return collectSideBufferSiblings(diffContext, vNodeWithKey), vNodeWithKey;
 }
@@ -2425,8 +2576,8 @@ function deleteFromSideBuffer(diffContext, nodeName, key) {
 function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey, parentForInsert, addCurrentToSideBufferOnSideInsert) {
     if (diffContext.vNewNode = retrieveChildWithKey(diffContext, nodeName, lookupKey), 
     diffContext.vNewNode) {
-        return diffContext.vCurrent = diffContext.vNewNode, diffContext.vNewNode = null, 
-        !1;
+        return vnode_insertBefore(diffContext.journal, parentForInsert, diffContext.vNewNode, diffContext.vCurrent), 
+        diffContext.vCurrent = diffContext.vNewNode, diffContext.vNewNode = null, !1;
     }
     if (null != sideBufferKey) {
         const buffered = diffContext.vSideBuffer?.get(sideBufferKey) || null;
@@ -2449,7 +2600,7 @@ function expectVirtual(diffContext, type, jsxKey) {
     const checkKey = "F" === type;
     const currentKey = getKey(diffContext.vCurrent);
     if (!diffContext.vCurrent || !vnode_isVirtualVNode(diffContext.vCurrent) || currentKey !== jsxKey || checkKey && !jsxKey) {
-        return null === jsxKey ? (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
+        return null === jsxKey || diffContext.isCreationMode ? (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
         diffContext.vNewNode.key = jsxKey, void (isDev && vnode_setProp(diffContext.vNewNode, "q:type", type))) : void (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, !0) && (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
         diffContext.vNewNode.key = jsxKey, isDev && vnode_setProp(diffContext.vNewNode, "q:type", type)));
     }
@@ -2513,7 +2664,7 @@ function expectText(diffContext, text) {
             return text !== vnode_getText(diffContext.vCurrent) ? void vnode_setText(diffContext.journal, diffContext.vCurrent, text) : void 0;
         }
     }
-    vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newText(diffContext.container.document.createTextNode(text), text), diffContext.vCurrent);
+    vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newText((import.meta.env.TEST ? diffContext.container.document : document).createTextNode(text), text), diffContext.vCurrent);
 }
 
 function getKey(vNode) {
@@ -2533,10 +2684,10 @@ function Projection() {}
 function handleProps(host, jsxProps, vNodeProps, container) {
     let shouldRender = !1;
     if (vNodeProps) {
-        const effects = vNodeProps[_PROPS_HANDLER].$effects$;
         const constPropsDifferent = handleChangedProps(jsxProps[_CONST_PROPS], vNodeProps[_CONST_PROPS], vNodeProps[_PROPS_HANDLER], container, !1);
-        shouldRender ||= constPropsDifferent, effects && effects.size > 0 && handleChangedProps(jsxProps[_VAR_PROPS], vNodeProps[_VAR_PROPS], vNodeProps[_PROPS_HANDLER], container, !0), 
-        vNodeProps[_OWNER] = jsxProps[_OWNER];
+        shouldRender ||= constPropsDifferent;
+        const varPropsDifferent = handleChangedProps(jsxProps[_VAR_PROPS], vNodeProps[_VAR_PROPS], vNodeProps[_PROPS_HANDLER], container, !0);
+        shouldRender ||= varPropsDifferent, vNodeProps[_OWNER] = jsxProps[_OWNER];
     } else {
         jsxProps && (vnode_setProp(host, "q:props", jsxProps), vNodeProps = jsxProps);
     }
@@ -2552,17 +2703,20 @@ function handleChangedProps(src, dst, propsHandler, container, triggerEffects =
     if (src) {
         for (const key in src) {
             if ("children" !== key && "q:brefs" !== key && (!dst || src[key] !== dst[key])) {
-                if (changed = !0, !triggerEffects) {
+                if (!triggerEffects) {
                     return !0;
                 }
-                dst && (dst[key] = src[key]), triggerPropsProxyEffect(propsHandler, key);
+                dst && (dst[key] = src[key]);
+                triggerPropsProxyEffect(propsHandler, key) || (changed = !0);
             }
         }
     }
     if (dst) {
         for (const key in dst) {
-            "children" !== key && "q:brefs" !== key && (src && _hasOwnProperty.call(src, key) || (changed = !0, 
-            triggerEffects && (delete dst[key], triggerPropsProxyEffect(propsHandler, key))));
+            if ("children" !== key && "q:brefs" !== key && (!src || !_hasOwnProperty.call(src, key)) && triggerEffects) {
+                delete dst[key];
+                triggerPropsProxyEffect(propsHandler, key) || (changed = !0);
+            }
         }
     }
     return changed;
@@ -2669,10 +2823,58 @@ function markVNodeAsDeleted(vCursor) {
     vCursor.flags |= 32;
 }
 
+function areWrappedSignalsEqual(oldSignal, newSignal) {
+    return oldSignal === newSignal || newSignal.$func$ === oldSignal.$func$ && areArgumentsEqual(newSignal.$args$, oldSignal.$args$);
+}
+
+function areArgumentsEqual(oldArgs, newArgs) {
+    if (oldArgs === newArgs) {
+        return !0;
+    }
+    if (!oldArgs || !newArgs || oldArgs.length !== newArgs.length) {
+        return !1;
+    }
+    for (let i = 0; i < oldArgs.length; i++) {
+        if (oldArgs[i] !== newArgs[i]) {
+            return !1;
+        }
+    }
+    return !0;
+}
+
+function containsWrappedSignal(data, signal) {
+    if (!(signal instanceof WrappedSignalImpl)) {
+        return !1;
+    }
+    for (const item of data) {
+        if (item instanceof WrappedSignalImpl && areWrappedSignalsEqual(item, signal)) {
+            return !0;
+        }
+    }
+    return !1;
+}
+
 const HANDLER_PREFIX = ":";
 
 let count = 0;
 
+const useSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const host = iCtx.$hostElement$;
+    let seq = iCtx.$container$.getHostProp(host, "q:seq");
+    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
+    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
+    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
+        seq.push(void 0);
+    }
+    return {
+        val: seq[seqIdx],
+        set: value => seq[seqIdx] = value,
+        i: seqIdx,
+        iCtx
+    };
+};
+
 const useResourceQrl = (qrl, opts) => {
     const {val, set, i, iCtx} = useSequentialScope();
     if (null != val) {
@@ -2743,7 +2945,7 @@ const runResource = (task, container, host) => {
     iCtx.$container$ = container;
     const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
     const resource = task.$state$;
-    assertDefined(resource, 'useResource: when running a resource, "task.resource" must be a defined.', task);
+    isDev && assertDefined(resource, 'useResource: when running a resource, "task.resource" must be a defined.', task);
     const track = trackFn(task, container);
     const [cleanup, cleanups] = cleanupFn(task, reason => container.handleError(reason, host));
     const resourceTarget = unwrapStore(resource);
@@ -2789,36 +2991,6 @@ const runResource = (task, container, host) => {
     }) ]) : promise;
 };
 
-const createDeleteOperation = target => ({
-    operationType: 1,
-    target
-});
-
-const createRemoveAllChildrenOperation = target => ({
-    operationType: 4,
-    target
-});
-
-const createSetTextOperation = (target, text) => ({
-    operationType: 16,
-    target,
-    text
-});
-
-const createInsertOrMoveOperation = (target, parent, beforeTarget) => ({
-    operationType: 2,
-    target,
-    parent,
-    beforeTarget
-});
-
-const createSetAttributeOperation = (target, attrName, attrValue) => ({
-    operationType: 8,
-    target,
-    attrName,
-    attrValue
-});
-
 function executeTasks(vNode, container, cursorData) {
     vNode.dirty &= -2;
     const elementSeq = container.getHostProp(vNode, "q:seq");
@@ -2895,8 +3067,9 @@ function clearNodePropData(vNode) {
     delete (vNode.props ||= {})[":nodeProps"];
 }
 
-function setNodeProp(domVNode, journal, property, value, isConst) {
-    journal.push(createSetAttributeOperation(domVNode.node, property, value)), isConst || (domVNode.props && null == value ? delete domVNode.props[property] : (domVNode.props ||= {})[property] = value);
+function setNodeProp(domVNode, journal, property, value, isConst, scopedStyleIdPrefix = null) {
+    journal.push(createSetAttributeOperation(domVNode.node, property, value, scopedStyleIdPrefix, !!(128 & domVNode.flags))), 
+    isConst || (domVNode.props && null == value ? delete domVNode.props[property] : (domVNode.props ||= {})[property] = value);
 }
 
 function executeNodeProps(vNode, journal) {
@@ -2911,7 +3084,7 @@ function executeNodeProps(vNode, journal) {
     for (const [property, nodeProp] of allPropData.entries()) {
         let value = nodeProp.value;
         isSignal(value) && (value = value.value);
-        setNodeProp(domVNode, journal, property, serializeAttribute(property, value, nodeProp.scopedStyleIdPrefix), nodeProp.isConst);
+        setNodeProp(domVNode, journal, property, value, nodeProp.isConst, nodeProp.scopedStyleIdPrefix);
     }
     clearNodePropData(vNode);
 }
@@ -2958,39 +3131,69 @@ const fastInsertBefore = (insertBeforeParent, target, insertBefore) => {
 };
 
 function _flushJournal(journal) {
+    let batchParent = null;
+    let batchBefore = null;
+    let batchNodes = null;
+    const batchSet = new Set;
+    const flush = () => {
+        if (batchNodes) {
+            if (1 === batchNodes.length) {
+                fastInsertBefore(batchParent, batchNodes[0], batchBefore);
+            } else {
+                const fragment = (batchParent.ownerDocument || batchParent).createDocumentFragment();
+                for (const node of batchNodes) {
+                    fragment.appendChild(node);
+                }
+                fastInsertBefore(batchParent, fragment, batchBefore);
+            }
+            batchNodes = null, batchParent = null, batchBefore = null, batchSet.clear();
+        }
+    };
     for (const operation of journal) {
-        switch (operation.operationType) {
-          case 2:
+        if (operation instanceof InsertOrMoveOperation) {
+            if (batchParent === operation.parent && batchBefore === operation.beforeTarget) {
+                batchNodes || (batchNodes = []), batchNodes.push(operation.target), batchSet.add(operation.target);
+                continue;
+            }
+            if (!batchNodes) {
+                batchParent = operation.parent, batchBefore = operation.beforeTarget, batchNodes = [ operation.target ], 
+                batchSet.add(operation.target);
+                continue;
+            }
+            if (batchParent === operation.parent) {
+                flush(), batchParent = operation.parent, batchBefore = operation.beforeTarget, batchNodes = [ operation.target ], 
+                batchSet.add(operation.target);
+                continue;
+            }
+            if (batchSet.has(operation.target) || batchBefore && operation.target === batchBefore || batchParent && operation.target === batchParent) {
+                flush(), batchParent = operation.parent, batchBefore = operation.beforeTarget, batchNodes = [ operation.target ], 
+                batchSet.add(operation.target);
+                continue;
+            }
             fastInsertBefore(operation.parent, operation.target, operation.beforeTarget);
-            break;
-
-          case 1:
+        } else if (operation instanceof DeleteOperation) {
+            (batchSet.has(operation.target) || batchBefore && operation.target === batchBefore || batchParent && operation.target === batchParent) && flush(), 
             operation.target.remove();
-            break;
-
-          case 16:
-            operation.target.nodeValue = operation.text;
-            break;
-
-          case 8:
-            {
+        } else {
+            if (operation instanceof RemoveAllChildrenOperation) {
+                (batchSet.has(operation.target) || batchBefore && operation.target === batchBefore || batchParent && operation.target === batchParent) && flush();
+                operation.target.textContent = "";
+                continue;
+            }
+            if (operation instanceof SetTextOperation) {
+                operation.target.nodeValue = operation.text;
+            } else if (operation instanceof SetAttributeOperation) {
                 const element = operation.target;
                 const attrName = operation.attrName;
-                const attrValue = operation.attrValue;
+                const rawValue = operation.attrValue;
+                const attrValue = null != rawValue ? serializeAttribute(attrName, rawValue, operation.scopedStyleIdPrefix) : null;
                 const shouldRemove = null == attrValue || !1 === attrValue;
-                isBooleanAttr(element, attrName) ? element[attrName] = parseBoolean(attrValue) : attrName === dangerouslySetInnerHTML ? (element.innerHTML = attrValue, 
-                element.setAttribute("q:container", "html")) : shouldRemove ? element.removeAttribute(attrName) : "value" === attrName && attrName in element ? element.value = attrValue : element.setAttribute(attrName, attrValue);
-                break;
-            }
-
-          case 4:
-            {
-                const removeParent = operation.target;
-                removeParent.replaceChildren ? removeParent.replaceChildren() : removeParent.textContent = "";
-                break;
+                isBooleanAttr(element, attrName) ? element[attrName] = parseBoolean(attrValue) : attrName === dangerouslySetInnerHTML ? (batchParent === element && flush(), 
+                element.innerHTML = attrValue, element.setAttribute("q:container", "html")) : shouldRemove ? element.removeAttribute(attrName) : "value" === attrName && attrName in element ? element.value = attrValue : directSetAttribute(element, attrName, attrValue, operation.isSvg);
             }
         }
     }
+    flush();
 }
 
 function executeAfterFlush(container, cursorData) {
@@ -3050,20 +3253,20 @@ function processCursorQueue(options = {
 
 function walkCursor(cursor, options) {
     const {timeBudget} = options;
-    const isServer = isServerPlatform();
+    const isRunningOnServer = import.meta.env.TEST ? isServerPlatform() : isServer;
     const startTime = performance.now();
     const cursorData = getCursorData(cursor);
     if (cursorData.promise) {
         return;
     }
     const container = cursorData.container;
-    if (assertDefined(container, "Cursor container not found"), !cursor.dirty) {
-        return void finishWalk(container, cursor, cursorData, isServer);
+    if (isDev && assertDefined(container, "Cursor container not found"), !cursor.dirty) {
+        return void finishWalk(container, cursor, cursorData, isRunningOnServer);
     }
     const journal = cursorData.journal ||= [];
     let currentVNode = null;
     for (;currentVNode = cursorData.position; ) {
-        if (!isServer && !import.meta.env.TEST) {
+        if (!isRunningOnServer && !import.meta.env.TEST) {
             if (performance.now() - startTime >= timeBudget) {
                 return void scheduleYield();
             }
@@ -3114,8 +3317,8 @@ function walkCursor(cursor, options) {
             });
         }
     }
-    assertFalse(!(!(127 & cursor.dirty) || cursorData.position), "Cursor is still dirty and position is not set after walking"), 
-    finishWalk(container, cursor, cursorData, isServer);
+    isDev && assertFalse(!(!(127 & cursor.dirty) || cursorData.position), "Cursor is still dirty and position is not set after walking"), 
+    finishWalk(container, cursor, cursorData, isRunningOnServer);
 }
 
 function finishWalk(container, cursor, cursorData, isServer) {
@@ -3131,7 +3334,8 @@ function finishWalk(container, cursor, cursorData, isServer) {
 }
 
 function resolveCursor(container) {
-    0 === container.$cursorCount$ && (container.$resolveRenderPromise$(), container.$renderPromise$ = null);
+    0 === container.$cursorCount$ && 0 === container.$pausedCursorCount$ && (container.$resolveRenderPromise$(), 
+    container.$renderPromise$ = null);
 }
 
 function partitionDirtyChildren(dirtyChildren, parent) {
@@ -3168,7 +3372,8 @@ function getNextVNode(vNode, cursor) {
         }
         index++, index === len && (index = 0);
     }
-    return parent.dirty &= -33, parent.dirtyChildren = null, getNextVNode(parent, cursor);
+    return parent.dirty &= -33, parent.dirtyChildren = null, parent.nextDirtyChildIndex = 0, 
+    getNextVNode(parent, cursor);
 }
 
 function addCursor(container, root, priority) {
@@ -3214,7 +3419,7 @@ function _executeSsrChores(container, ssrNode) {
         const result = executeTasksChore(container, ssrNode);
         isPromise(result) && (promise = result);
     }
-    if (ssrNode.dirty &= -128, promise) {
+    if (ssrNode.dirty &= -124, promise) {
         return promise;
     }
 }
@@ -3298,7 +3503,7 @@ function findAndPropagateToBlockingCursor(vNode) {
 }
 
 function isSsrNodeGuard() {
-    return isServerPlatform();
+    return import.meta.env.TEST ? isServerPlatform() : isServer;
 }
 
 function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
@@ -3351,67 +3556,70 @@ const fastGetter = (prototype, name) => {
 };
 
 const vnode_newElement = (element, elementName, key = null) => {
-    assertEqual(fastNodeType(element), 1, "Expecting element node.");
+    isDev && assertEqual(fastNodeType(element), 1, "Expecting element node.");
     const vnode = new ElementVNode(key, -503, null, null, null, null, null, null, element, elementName);
     return element.vNode = vnode, vnode;
 };
 
 const vnode_newUnMaterializedElement = element => {
-    assertEqual(fastNodeType(element), 1, "Expecting element node.");
+    isDev && assertEqual(fastNodeType(element), 1, "Expecting element node.");
     const vnode = new ElementVNode(null, -511, null, null, null, null, void 0, void 0, element, void 0);
     return element.vNode = vnode, vnode;
 };
 
 const vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-    sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+    isDev && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
     return new TextVNode(-508, null, previousTextNode, null, null, sharedTextNode, textContent);
 };
 
 const vnode_newText = (textNode, textContent) => {
     const vnode = new TextVNode(-500, null, null, null, null, textNode, textContent);
-    return assertEqual(fastNodeType(textNode), 3, "Expecting text node."), assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode."), 
-    assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode."), assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode."), 
+    return isDev && assertEqual(fastNodeType(textNode), 3, "Expecting text node."), 
+    isDev && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode."), 
+    isDev && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode."), 
+    isDev && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode."), 
     vnode;
 };
 
 const vnode_newVirtual = () => {
     const vnode = new VirtualVNode(null, -510, null, null, null, null, null, null);
-    return assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode."), 
-    assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode."), assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode."), 
+    return isDev && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode."), 
+    isDev && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode."), 
+    isDev && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode."), 
     vnode;
 };
 
 const vnode_isVNode = vNode => vNode instanceof VNode;
 
-const vnode_isElementVNode = vNode => vNode instanceof ElementVNode;
+const vnode_isElementVNode = vNode => !(1 & ~vNode.flags);
 
 const vnode_isElementOrTextVNode = vNode => {
-    assertDefined(vNode, "Missing vNode");
+    isDev && assertDefined(vNode, "Missing vNode");
     return !!(5 & vNode.flags);
 };
 
 const vnode_isMaterialized = vNode => {
-    assertDefined(vNode, "Missing vNode");
+    isDev && assertDefined(vNode, "Missing vNode");
     return !(1 & ~vNode.flags) && void 0 !== vNode.firstChild && void 0 !== vNode.lastChild;
 };
 
-const vnode_isTextVNode = vNode => vNode instanceof TextVNode;
+const vnode_isTextVNode = vNode => !(4 & ~vNode.flags);
 
-const vnode_isVirtualVNode = vNode => vNode instanceof VirtualVNode;
+const vnode_isVirtualVNode = vNode => !(2 & ~vNode.flags);
 
 const vnode_isProjection = vNode => {
-    assertDefined(vNode, "Missing vNode");
+    isDev && assertDefined(vNode, "Missing vNode");
     return !(2 & ~vNode.flags) && null !== vnode_getProp(vNode, QSlot, null);
 };
 
-const ensureTextVNode = vNode => (assertTrue(vnode_isTextVNode(vNode), "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)), 
+const ensureTextVNode = vNode => (isDev && assertTrue(vnode_isTextVNode(vNode), "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)), 
 vNode);
 
 const ensureElementOrVirtualVNode = vNode => {
-    assertDefined(vNode, "Missing vNode"), assertTrue(!!(3 & vNode.flags), "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode));
+    isDev && assertDefined(vNode, "Missing vNode"), isDev && assertTrue(!!(3 & vNode.flags), "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode));
 };
 
-const ensureElementVNode = vNode => (assertTrue(vnode_isElementVNode(vNode), "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)), 
+const ensureElementVNode = vNode => (isDev && assertTrue(vnode_isElementVNode(vNode), "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)), 
 vNode);
 
 const vnode_getNodeTypeName = vNode => {
@@ -3443,12 +3651,12 @@ const vnode_getProp = (vNode, key, getObject) => {
 };
 
 const vnode_setProp = (vNode, key, value) => {
-    (vnode_isElementVNode(vNode) || vnode_isVirtualVNode(vNode)) && (null == value && vNode.props ? delete vNode.props[key] : (vNode.props ||= {}, 
-    vNode.props[key] = value));
+    null == value && vNode.props ? delete vNode.props[key] : (vNode.props ||= {}, vNode.props[key] = value);
 };
 
-const vnode_setAttr = (journal, vNode, key, value) => {
-    vnode_isElementVNode(vNode) && (vnode_setProp(vNode, key, value), addVNodeOperation(journal, createSetAttributeOperation(vNode.node, key, value)));
+const vnode_setAttr = (journal, vNode, key, value, scopedStyleIdPrefix = null) => {
+    vnode_isElementVNode(vNode) && (import.meta.env.TEST && scopedStyleIdPrefix && vnode_setProp(vNode, "__scopedStyleIdPrefix__", scopedStyleIdPrefix), 
+    vnode_setProp(vNode, key, value), addVNodeOperation(journal, createSetAttributeOperation(vNode.node, key, value, scopedStyleIdPrefix, !!(128 & vNode.flags))));
 };
 
 const vnode_ensureElementKeyInflated = vnode => {
@@ -3589,12 +3797,12 @@ const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     if (!(8 & textVNode.flags)) {
         const parentNode = vnode_getDomParent(vnode, !0);
-        assertDefined(parentNode, "Missing parent node.");
+        isDev && assertDefined(parentNode, "Missing parent node.");
         const sharedTextNode = textVNode.node;
         const doc = fastOwnerDocument(parentNode);
         let vCursor = vnode_getDomSibling(vnode, !1, !0);
         const node = vnode_getDomSibling(vnode, !0, !0);
-        const insertBeforeNode = sharedTextNode || (node instanceof ElementVNode ? node.node : node?.node) || null;
+        const insertBeforeNode = sharedTextNode || (node && vnode_isElementVNode(node) ? node.node : node?.node) || null;
         let lastPreviousTextNode = insertBeforeNode;
         for (;vCursor && vnode_isTextVNode(vCursor); ) {
             if (!(8 & vCursor.flags)) {
@@ -3630,7 +3838,7 @@ const vnode_locate = (rootVNode, id) => {
     let elementOffset = -1;
     let refElement;
     if ("string" == typeof id) {
-        assertDefined(qVNodeRefs, "Missing qVNodeRefs."), elementOffset = parseInt(id), 
+        isDev && assertDefined(qVNodeRefs, "Missing qVNodeRefs."), elementOffset = parseInt(id), 
         refElement = qVNodeRefs.get(elementOffset);
     } else {
         refElement = id;
@@ -3639,10 +3847,10 @@ const vnode_locate = (rootVNode, id) => {
             return vNode;
         }
     }
-    if (assertDefined(refElement, "Missing refElement."), vnode_isVNode(refElement)) {
+    if (isDev && assertDefined(refElement, "Missing refElement."), vnode_isVNode(refElement)) {
         vNode = refElement;
     } else {
-        assertTrue(containerElement.contains(refElement), "Couldn't find the element inside the container while locating the VNode.");
+        isDev && assertTrue(containerElement.contains(refElement), "Couldn't find the element inside the container while locating the VNode.");
         let parent = refElement;
         const elementPath = [ refElement ];
         for (;parent && parent !== containerElement && !parent.vNode; ) {
@@ -3669,8 +3877,8 @@ const vnode_locate = (rootVNode, id) => {
 
 const vnode_getChildWithIdx = (vNode, childIdx) => {
     let child = vnode_getFirstChild(vNode);
-    for (assertDefined(child, "Missing child."); child.flags >>> 9 !== childIdx; ) {
-        child = child.nextSibling, assertDefined(child, "Missing child.");
+    for (isDev && assertDefined(child, "Missing child."); child.flags >>> 9 !== childIdx; ) {
+        child = child.nextSibling, isDev && assertDefined(child, "Missing child.");
     }
     return child;
 };
@@ -3680,7 +3888,7 @@ const vNodeStack = [];
 const vnode_getVNodeForChildNode = (vNode, childElement) => {
     ensureElementVNode(vNode);
     let child = vnode_getFirstChild(vNode);
-    for (assertDefined(child, "Missing child."); child && (!(child instanceof ElementVNode) || child.node !== childElement); ) {
+    for (isDev && assertDefined(child, "Missing child."); child && (!(child instanceof ElementVNode) || child.node !== childElement); ) {
         if (vnode_isVirtualVNode(child)) {
             const next = child.nextSibling;
             const firstChild = vnode_getFirstChild(child);
@@ -3689,12 +3897,12 @@ const vnode_getVNodeForChildNode = (vNode, childElement) => {
             const next = child.nextSibling;
             child = next || (next || vNodeStack.pop());
         }
-        assertDefined(child, "Missing child.");
+        isDev && assertDefined(child, "Missing child.");
     }
     for (;vNodeStack.length; ) {
         vNodeStack.pop();
     }
-    return ensureElementVNode(child), assertEqual(child.node, childElement, "Child not found."), 
+    return ensureElementVNode(child), isDev && assertEqual(child.node, childElement, "Child not found."), 
     child;
 };
 
@@ -3760,7 +3968,7 @@ const vnode_getDomParentVNode = (vnode, includeProjection) => {
 };
 
 const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-    if (assertEqual(vParent, vToRemove.parent, "Parent mismatch."), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove), 
+    if (isDev && assertEqual(vParent, vToRemove.parent, "Parent mismatch."), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove), 
     removeDOM) {
         const domParent = vnode_getDomParent(vParent, !1);
         if (null !== vnode_getProp(vParent, dangerouslySetInnerHTML, null)) {
@@ -3780,7 +3988,7 @@ const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
 };
 
 const vnode_truncate = (journal, vParent, vDelete, removeDOM = !0) => {
-    assertDefined(vDelete, "Missing vDelete.");
+    isDev && assertDefined(vDelete, "Missing vDelete.");
     if (vnode_getDomParent(vParent, !0) && removeDOM) {
         if (vnode_isElementVNode(vParent)) {
             addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node));
@@ -3861,8 +4069,8 @@ const ensureMaterialized = vnode => {
     if (void 0 === vFirstChild) {
         vFirstChild = vParent.parent && shouldIgnoreChildren(vParent.node) ? vParent.firstChild = vParent.lastChild = null : vnode_materialize(vParent);
     }
-    return assertTrue(void 0 !== vParent.firstChild, "Did not materialize."), assertTrue(void 0 !== vParent.lastChild, "Did not materialize."), 
-    vFirstChild;
+    return isDev && assertTrue(void 0 !== vParent.firstChild, "Did not materialize."), 
+    isDev && assertTrue(void 0 !== vParent.lastChild, "Did not materialize."), vFirstChild;
 };
 
 let _fastHasAttribute = null;
@@ -4081,8 +4289,8 @@ function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1
             strings.push(qwikDebugToString(vnode_getText(vnode)));
         } else if (vnode_isVirtualVNode(vnode)) {
             const attrs = [ "[" + String(vnode.flags >>> 9) + "]" ];
-            vnode_getAttrKeys(vnode).forEach(key => {
-                if ("q:type" !== key) {
+            vnode.dirty && attrs.push(` dirty:${vnode.dirty}`), vnode_getAttrKeys(vnode).forEach(key => {
+                if ("q:type" !== key && "__scopedStyleIdPrefix__" !== key) {
                     const value = vnode_getProp(vnode, key, null);
                     attrs.push(" " + key + "=" + qwikDebugToString(value));
                 }
@@ -4286,8 +4494,8 @@ const useInvokeContext = () => {
     if (!ctx || "qRender" !== ctx.$event$) {
         throw qError(10);
     }
-    return assertDefined(ctx.$hostElement$, "invoke: $hostElement$ must be defined", ctx), 
-    assertDefined(ctx.$effectSubscriber$, "invoke: $effectSubscriber$ must be defined", ctx), 
+    return isDev && assertDefined(ctx.$hostElement$, "invoke: $hostElement$ must be defined", ctx), 
+    isDev && assertDefined(ctx.$effectSubscriber$, "invoke: $effectSubscriber$ must be defined", ctx), 
     ctx;
 };
 
@@ -4412,7 +4620,7 @@ const _waitUntilRendered = elm => {
     return promise || Promise.resolve();
 };
 
-const createContextId = name => (assertTrue(/^[\w/.-]+$/.test(name), "Context name must only contain A-Z,a-z,0-9,_,.,-", name), 
+const createContextId = name => (isDev && assertTrue(/^[\w/.-]+$/.test(name), "Context name must only contain A-Z,a-z,0-9,_,.,-", name), 
 /*#__PURE__*/ Object.freeze({
     id: fromCamelToKebabCase(name)
 }));
@@ -4463,7 +4671,7 @@ const _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COM
 
 const _constantNames = [ "undefined", "null", "true", "false", "''", "EMPTY_ARRAY", "EMPTY_OBJ", "NEEDS_COMPUTATION", "STORE_ALL_PROPS", "_UNINITIALIZED", "Slot", "Fragment", "NaN", "Infinity", "-Infinity", "MAX_SAFE_INTEGER", "MAX_SAFE_INTEGER-1", "MIN_SAFE_INTEGER" ];
 
-const _typeIdNames = [ "Plain", "RootRef", "ForwardRef", "Constant", "Array", "Object", "URL", "Date", "Regex", "VNode", "RefVNode", "BigInt", "URLSearchParams", "ForwardRefs", "Error", "Promise", "Set", "Map", "Uint8Array", "QRL", "PreloadQRL", "Task", "Resource", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncComputedSignal", "SerializerSignal", "Store", "FormData", "JSXNode", "PropsProxy", "SubscriptionData" ];
+const _typeIdNames = [ "Plain", "RootRef", "ForwardRef", "Constant", "Array", "Object", "URL", "Date", "Regex", "VNode", "RefVNode", "BigInt", "URLSearchParams", "ForwardRefs", "Error", "Promise", "Set", "Map", "Uint8Array", "QRL", "PreloadQRL", "Task", "Resource", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncComputedSignal", "SerializerSignal", "Store", "FormData", "JSXNode", "PropsProxy", "SubscriptionData", "EffectSubscription" ];
 
 function qrlToString(serializationContext, value, raw) {
     let symbol = value.$symbol$;
@@ -4497,12 +4705,16 @@ function qrlToString(serializationContext, value, raw) {
 }
 
 function createQRLWithBackChannel(chunk, symbol, captureIds) {
-    let qrlRef = null;
+    let qrlImporter = null;
     if (isDev && chunk === QRL_RUNTIME_CHUNK) {
         const backChannel = globalThis.__qrl_back_channel__;
-        assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK"), qrlRef = backChannel.get(symbol);
+        isDev && assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK");
+        const fn = backChannel.get(symbol);
+        fn && (qrlImporter = () => Promise.resolve({
+            [symbol]: fn
+        }));
     }
-    return createQRL(chunk, symbol, qrlRef, null, captureIds, null);
+    return createQRL(chunk, symbol, null, qrlImporter, captureIds, null);
 }
 
 function parseQRL(qrl) {
@@ -4611,7 +4823,7 @@ const allocate = (container, typeId, value) => {
         return new FormData;
 
       case 31:
-        return new JSXNodeImpl(null);
+        return new JSXNodeImpl(null, null, null, null, null);
 
       case 11:
         return BigInt(value);
@@ -4651,6 +4863,9 @@ const allocate = (container, typeId, value) => {
       case 33:
         return new SubscriptionData({});
 
+      case 34:
+        return new EffectSubscription(null, null, null, null);
+
       default:
         throw qError(18, [ typeId ]);
     }
@@ -4719,25 +4934,6 @@ const inlinedQrlDEV = (symbol, symbolName, opts, lexicalScopeCapture = EMPTY_ARR
 const _regSymbol = (symbol, hash) => (void 0 === globalThis.__qwik_reg_symbols && (globalThis.__qwik_reg_symbols = new Map), 
 globalThis.__qwik_reg_symbols.set(hash, symbol), symbol);
 
-const _run = (...args) => {
-    const [runQrl] = useLexicalScope();
-    const context = getInvokeContext();
-    const hostElement = context.$hostElement$;
-    if (hostElement) {
-        return retryOnPromise(() => {
-            if (!(32 & hostElement.flags)) {
-                return catchError(runQrl(...args), err => {
-                    const container = context.$container$ ||= getDomContainer(hostElement.node);
-                    if (!container) {
-                        throw err;
-                    }
-                    container.handleError(err, hostElement);
-                });
-            }
-        });
-    }
-};
-
 function isStringifiable(value) {
     return null === value || "string" == typeof value || "number" == typeof value || "boolean" == typeof value;
 }
@@ -4904,6 +5100,8 @@ async function serialize(serializationContext) {
             output(32, [ _serializationWeakRef(owner), owner.varProps, owner.constProps, value[_PROPS_HANDLER].$effects$ ]);
         } else if (value instanceof SubscriptionData) {
             output(33, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
+        } else if (value instanceof EffectSubscription) {
+            output(34, [ value.consumer, value.property, value.backRef, value.data ]);
         } else if (isStore(value)) {
             if (isResource(value)) {
                 serializationContext.$resources$.add(value);
@@ -5172,7 +5370,7 @@ function filterEffectBackRefs(effectBackRef) {
     let effectBackRefToSerialize;
     if (effectBackRef) {
         for (const [effectProp, effect] of effectBackRef) {
-            effect[2] && (effectBackRefToSerialize ||= new Map, effectBackRefToSerialize.set(effectProp, effect));
+            effect.backRef && (effectBackRefToSerialize ||= new Map, effectBackRefToSerialize.set(effectProp, effect));
         }
     }
     return effectBackRefToSerialize;
@@ -5291,6 +5489,7 @@ class _SharedContainer {
     $renderPromise$=null;
     $resolveRenderPromise$=null;
     $cursorCount$=0;
+    $pausedCursorCount$=0;
     constructor(serverData, locale) {
         this.$serverData$ = serverData, this.$locale$ = locale, this.$version$ = version, 
         this.$storeProxyMap$ = new WeakMap, this.$getObjectById$ = () => {
@@ -5423,7 +5622,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                     const children = jsx.children;
                     null != children && enqueue(children);
                 } else if (type === Slot) {
-                    const componentFrame = options.parentComponentFrame || ssr.unclaimedProjectionComponentFrameQueue.shift();
+                    const componentFrame = options.parentComponentFrame;
                     if (componentFrame) {
                         const projectionAttrs = isDev ? [ "q:type", "P" ] : [];
                         projectionAttrs.push("q:sparent", componentFrame.componentNode.id || ""), ssr.openProjection(projectionAttrs);
@@ -5497,7 +5696,7 @@ function toSsrAttrs(record, options) {
                 const eventValue = setEvent(options.serializationCtx, key, value);
                 return void (eventValue && ssrAttrs.push(key, eventValue));
             }
-            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) && addPreventDefaultEventToSerializationContext(options.serializationCtx, key), 
+            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) ? addPreventDefaultEventToSerializationContext(options.serializationCtx, key) : "q:p" !== key && "q:ps" !== key || (value = options.serializationCtx.$addRoot$(value)), 
             value = serializeAttribute(key, value, options.styleScopedId), ssrAttrs.push(key, value));
         }
     };
@@ -5737,8 +5936,8 @@ const inflate = (container, target, typeId, data) => {
             const propsProxy = target;
             const d = data;
             let owner = d[0];
-            owner === _UNINITIALIZED && (owner = new JSXNodeImpl(Fragment, d[1], d[2]), owner._proxy = propsProxy), 
-            propsProxy[_OWNER] = owner, propsProxy[_PROPS_HANDLER].$effects$ = d[3];
+            owner === _UNINITIALIZED && (owner = new JSXNodeImpl(Fragment, d[1], d[2], null, null), 
+            owner._proxy = propsProxy), propsProxy[_OWNER] = owner, propsProxy[_PROPS_HANDLER].$effects$ = d[3];
             break;
 
           case 33:
@@ -5748,6 +5947,15 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
+          case 34:
+            {
+                const effectSub = target;
+                const d = data;
+                effectSub.consumer = d[0], effectSub.property = d[1], effectSub.backRef = d[2], 
+                effectSub.data = d[3];
+                break;
+            }
+
           default:
             throw qError(16, [ typeId ]);
         }
@@ -5785,7 +5993,8 @@ function inflateWrappedSignalValue(signal) {
         const effects = signal.$effects$;
         let hasAttrValue = !1;
         if (effects) {
-            for (const [_, key] of effects) {
+            for (const effect of effects) {
+                const key = effect.property;
                 if (isString(key)) {
                     const attrValue = vnode_getProp(hostVNode, key, null);
                     if (null !== attrValue) {
@@ -6172,7 +6381,8 @@ class DomContainer extends _SharedContainer {
     $getObjectById$=id => getObjectById(id, this.$stateData$);
     getSyncFn(id) {
         const fn = this.$qFuncs$[id];
-        return assertTrue("function" == typeof fn, "Invalid reference: " + id), fn;
+        return isDev && assertTrue("function" == typeof fn, "Invalid reference: " + id), 
+        fn;
     }
     $appendStyle$(content, styleId, host, scoped) {
         if (scoped) {
@@ -6204,6 +6414,60 @@ class DomContainer extends _SharedContainer {
     }
 }
 
+const useTaskQrl = (qrl, opts) => {
+    const {val, set, iCtx, i} = useSequentialScope();
+    if (val) {
+        return;
+    }
+    assertQrl(qrl), set(1);
+    const task = new Task(10 | (!1 === opts?.deferUpdates ? 0 : 16), i, iCtx.$hostElement$, qrl, void 0, null);
+    set(task);
+    const container = iCtx.$container$;
+    const {$waitOn$: waitOn} = iCtx;
+    const result = maybeThen(waitOn, () => runTask(task, container, iCtx.$hostElement$));
+    isPromise(result) && (iCtx.$waitOn$ = result);
+};
+
+const runTask = (task, container, host) => {
+    task.$flags$ &= -9, cleanupDestroyable(task);
+    const iCtx = newInvokeContext(container.$locale$, host, "qTask");
+    iCtx.$container$ = container;
+    const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
+    const track = trackFn(task, container);
+    const [cleanup] = cleanupFn(task, reason => container.handleError(reason, host));
+    const taskApi = {
+        track,
+        cleanup
+    };
+    return safeCall(() => taskFn(taskApi), cleanup, err => {
+        if (isPromise(err)) {
+            return err.then(() => runTask(task, container, host));
+        }
+        container.handleError(err, host);
+    });
+};
+
+class Task extends BackRef {
+    $flags$;
+    $index$;
+    $el$;
+    $qrl$;
+    $state$;
+    $destroy$;
+    constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+        super(), this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, 
+        this.$state$ = $state$, this.$destroy$ = $destroy$;
+    }
+}
+
+const isTask = value => value instanceof Task;
+
+const scheduleTask = (_event, element) => {
+    const [task] = useLexicalScope();
+    const container = getDomContainer(element);
+    task.$flags$ |= 8, markVNodeDirty(container, task.$el$, 1);
+};
+
 const throwIfQRLNotResolved = qrl => {
     if (!qrl.resolved) {
         throw qrl.resolve();
@@ -6213,17 +6477,17 @@ const throwIfQRLNotResolved = qrl => {
 const isSignal = value => value instanceof SignalImpl;
 
 const ensureContainsSubscription = (array, effectSubscription) => {
-    !array.has(effectSubscription) && array.add(effectSubscription);
+    array.add(effectSubscription);
 };
 
 const ensureContainsBackRef = (array, value) => {
-    array[2] ||= new Set, !array[2].has(value) && array[2].add(value);
+    (array.backRef ||= new Set).add(value);
 };
 
 const addQrlToSerializationCtx = (effectSubscriber, container) => {
-    if (container && !isDomContainer(container)) {
-        const effect = effectSubscriber[0];
-        const property = effectSubscriber[1];
+    if (container) {
+        const effect = effectSubscriber.consumer;
+        const property = effectSubscriber.property;
         let qrl = null;
         isTask(effect) ? qrl = effect.$qrl$ : effect instanceof ComputedSignalImpl ? qrl = effect.$computeQrl$ : ":" === property && (qrl = container.getHostProp(effect, "q:renderFn")), 
         qrl && container.serializationCtx.$eventQrls$.add(qrl);
@@ -6231,14 +6495,13 @@ const addQrlToSerializationCtx = (effectSubscriber, container) => {
 };
 
 const scheduleEffects = (container, signal, effects) => {
-    const isBrowser = !isServerPlatform();
+    const isBrowser = import.meta.env.TEST ? !isServerPlatform() : !isServer;
     if (effects) {
-        let tasksToTrigger = null;
         const scheduleEffect = effectSubscription => {
-            const consumer = effectSubscription[0];
-            const property = effectSubscription[1];
-            if (assertDefined(container, "Container must be defined."), isTask(consumer)) {
-                consumer.$flags$ |= 8, isBrowser ? markVNodeDirty(container, consumer.$el$, 1) : (tasksToTrigger ||= []).push(consumer);
+            const consumer = effectSubscription.consumer;
+            const property = effectSubscription.property;
+            if (isDev && assertDefined(container, "Container must be defined."), isTask(consumer)) {
+                consumer.$flags$ |= 8, markVNodeDirty(container, consumer.$el$, 1);
             } else if (consumer instanceof SignalImpl) {
                 consumer.invalidate();
             } else if (":" === property) {
@@ -6246,7 +6509,7 @@ const scheduleEffects = (container, signal, effects) => {
             } else if ("." === property) {
                 isBrowser && (setNodeDiffPayload(consumer, signal), markVNodeDirty(container, consumer, 2));
             } else {
-                const effectData = effectSubscription[3];
+                const effectData = effectSubscription.data;
                 if (effectData instanceof SubscriptionData) {
                     const data = effectData.data;
                     const payload = {
@@ -6265,14 +6528,10 @@ const scheduleEffects = (container, signal, effects) => {
                 }
             }
         };
-        for (const effect of effects) {
+        const effectsSnapshot = Array.from(effects);
+        for (const effect of effectsSnapshot) {
             scheduleEffect(effect);
         }
-        if (!isBrowser && container && tasksToTrigger) {
-            for (const task of tasksToTrigger) {
-                markVNodeDirty(container, task.$el$, 1);
-            }
-        }
     }
 };
 
@@ -6428,7 +6687,7 @@ class StoreHandler {
                 }
                 this.$container$ = ctx.$container$;
             } else {
-                assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
+                isDev && assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
             }
             const effectSubscriber = ctx.$effectSubscriber$;
             effectSubscriber && addStoreEffect(target, Array.isArray(target) ? STORE_ALL_PROPS : prop, this, effectSubscriber);
@@ -6486,7 +6745,7 @@ function addStoreEffect(target, prop, store, effectSubscription) {
     const effectsMap = store.$effects$ ||= new Map;
     let effects = effectsMap.get(prop);
     effects || (effects = new Set, effectsMap.set(prop, effects)), ensureContainsSubscription(effects, effectSubscription), 
-    ensureContainsBackRef(effectSubscription, target), addQrlToSerializationCtx(effectSubscription, store.$container$);
+    ensureContainsBackRef(effectSubscription, target), (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer) && addQrlToSerializationCtx(effectSubscription, store.$container$);
 }
 
 function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
@@ -6730,7 +6989,7 @@ function _deserialize(rawStateData, element) {
 }
 
 function getObjectById(id, stateData) {
-    return "string" == typeof id && (id = parseInt(id, 10)), assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`), 
+    return "string" == typeof id && (id = parseInt(id, 10)), isDev && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`), 
     stateData[id];
 }
 
@@ -6877,7 +7136,7 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
             return symbolRef;
         }
         if (containerEl && setContainer(containerEl), "" === chunk) {
-            assertDefined(_containerEl, "Sync QRL must have container element");
+            isDev && assertDefined(_containerEl, "Sync QRL must have container element");
             const hash = _containerEl.getAttribute("q:instance");
             const qFuncs = getQFuncs(_containerEl.ownerDocument, hash);
             return qrl.resolved = symbolRef = qFuncs[Number(symbol)];
@@ -6954,7 +7213,7 @@ const _qrlSync = function(fn, serializedFn) {
 
 const componentQrl = componentQrl => {
     function QwikComponent(props, key, flags = 0) {
-        assertQrl(componentQrl), assertNumber(flags, "The Qwik Component was not invoked correctly");
+        isDev && assertQrl(componentQrl), isDev && assertNumber(flags, "The Qwik Component was not invoked correctly");
         const finalKey = componentQrl.$hash$.slice(0, 4) + ":" + (key || "");
         const InnerCmp = () => {};
         return InnerCmp[SERIALIZABLE_STATE] = [ componentQrl ], _jsxSplit(InnerCmp, props, null, props.children, 0, finalKey);
@@ -7333,10 +7592,10 @@ const useVisibleTaskQrl = (qrl, opts) => {
     if (val) {
         return void (64 & val.$flags$ || isServerPlatform() || (val.$flags$ |= 64, useRegisterTaskEvents(val, eagerness)));
     }
-    assertQrl(qrl);
-    const task = new Task(9, i, iCtx.$hostElement$, qrl, void 0, null);
-    set(task), useRegisterTaskEvents(task, eagerness), isServerPlatform() || (qrl.resolved || qrl.resolve(), 
-    markVNodeDirty(iCtx.$container$, iCtx.$hostElement$, 1));
+    let flags;
+    assertQrl(qrl), isServerPlatform() ? flags = 1 : (flags = 9, qrl.resolve(), markVNodeDirty(iCtx.$container$, iCtx.$hostElement$, 1));
+    const task = new Task(flags, i, iCtx.$hostElement$, qrl, void 0, null);
+    set(task), useRegisterTaskEvents(task, eagerness);
 };
 
 const useRegisterTaskEvents = (task, eagerness) => {