@qwik.dev/core 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.25-dev+2677279
+ * @qwik.dev/core 2.0.0-beta.27-dev+7fc6984
  * 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
@@ -10,12 +10,13 @@ export { isBrowser, isDev, isServer } from '@qwik.dev/core/build';
 import { p } from '@qwik.dev/core/preloader';
 
 // same as isDev but separate so we can test
-const qDev = globalThis.qDev !== false;
-const qInspector = globalThis.qInspector === true;
-const qSerialize = globalThis.qSerialize !== false;
-const qDynamicPlatform = globalThis.qDynamicPlatform !== false;
-const qTest = globalThis.qTest === true;
-const qRuntimeQrl = globalThis.qRuntimeQrl === true;
+const g = globalThis;
+const qDev = g.qDev !== false;
+const qInspector = g.qInspector === true;
+const qSerialize = g.qSerialize !== false;
+const qDynamicPlatform = g.qDynamicPlatform !== false;
+const qTest = g.qTest === true;
+const qRuntimeQrl = g.qRuntimeQrl === true;
 const seal = (obj) => {
     if (qDev) {
         Object.seal(obj);
@@ -199,7 +200,7 @@ const codeToText = (code, ...parts) => {
             'Only primitive and object literals can be serialized. {{0}}', // 3
             'You can render over a existing q:container. Skipping render().', // 4
             'QRL is not a function', // 5
-            'Dynamic import not found', // 6
+            'Dynamic import {{0}} not found', // 6
             'Unknown type argument', // 7
             `Actual value for useContext({{0}}) can not be found, make sure some ancestor component has set a value using useContextProvider(). In the browser make sure that the context was used during SSR so its state was serialized.`, // 8
             "Invoking 'use*()' method outside of invocation context.", // 9
@@ -1007,7 +1008,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.25-dev+2677279";
+const version = "2.0.0-beta.27-dev+7fc6984";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -1020,6 +1021,8 @@ const createPlatform = () => {
                 if (regSym) {
                     return regSym;
                 }
+                // we never lazy import on the server
+                throw qError(6 /* QError.dynamicImportFailed */, [symbolName]);
             }
             if (!url) {
                 throw qError(14 /* QError.qrlMissingChunk */, [symbolName]);
@@ -1668,28 +1671,6 @@ class SignalImpl {
         return { value: this.$untrackedValue$ };
     }
 }
-const setupSignalValueAccess = (target, effectsProp, valueProp) => {
-    const ctx = tryGetInvokeContext();
-    // We need a container for this
-    // Grab the container if we have access to it
-    if (ctx && (target.$container$ ||= ctx.$container$ || null)) {
-        isDev &&
-            assertTrue(!ctx.$container$ || ctx.$container$ === target.$container$, 'Do not use signals across containers');
-        const effectSubscriber = ctx.$effectSubscriber$;
-        if (effectSubscriber) {
-            // Let's make sure that we have a reference to this effect.
-            // Adding reference is essentially adding a subscription, so if the signal
-            // changes we know who to notify.
-            ensureContainsSubscription((target[effectsProp] ||= new Set()), effectSubscriber);
-            // But when effect is scheduled in needs to be able to know which signals
-            // to unsubscribe from. So we need to store the reference from the effect back
-            // to this signal.
-            ensureContainsBackRef(effectSubscriber, target);
-            addQrlToSerializationCtx(effectSubscriber, target.$container$);
-        }
-    }
-    return target[valueProp];
-};
 
 /** @internal */
 const _CONST_PROPS = Symbol('CONST');
@@ -2185,7 +2166,8 @@ class AsyncJob {
     }
     /** Backward compatible cache method for resource */
     cache() {
-        console.error('useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior.');
+        isDev &&
+            console.error('useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior.');
     }
     get previous() {
         const val = this.$signal$.$untrackedValue$;
@@ -2264,7 +2246,9 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         if ((import.meta.env.TEST ? isServerPlatform() : isServer) &&
             this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */ &&
             this.$untrackedValue$ === NEEDS_COMPUTATION) {
-            throw new Error('During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value.');
+            throw new Error(isDev
+                ? 'During SSR, cannot read .value from clientOnly async signal without an initial value. Use .loading or provide an initial value.'
+                : 'Cannot read .value from clientOnly');
         }
         return this.$untrackedValue$;
     }
@@ -2279,7 +2263,19 @@ class AsyncSignalImpl extends ComputedSignalImpl {
      * `signal.loading ? <Loading /> : signal.value`.
      */
     get loading() {
-        return setupSignalValueAccess(this, '$loadingEffects$', 'untrackedLoading');
+        const val = this.untrackedLoading;
+        const ctx = tryGetInvokeContext();
+        if (ctx && (this.$container$ ||= ctx.$container$ || null)) {
+            isDev &&
+                assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, 'Do not use signals across containers');
+            const effectSubscriber = ctx.$effectSubscriber$;
+            if (effectSubscriber) {
+                ensureContainsSubscription((this.$loadingEffects$ ||= new Set()), effectSubscriber);
+                ensureContainsBackRef(effectSubscriber, this);
+                addQrlToSerializationCtx(effectSubscriber, this.$container$);
+            }
+        }
+        return val;
     }
     set untrackedLoading(value) {
         if (value !== this.$untrackedLoading$) {
@@ -2298,7 +2294,19 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     }
     /** The error that occurred when the signal was resolved. */
     get error() {
-        return setupSignalValueAccess(this, '$errorEffects$', 'untrackedError');
+        const val = this.untrackedError;
+        const ctx = tryGetInvokeContext();
+        if (ctx && (this.$container$ ||= ctx.$container$ || null)) {
+            isDev &&
+                assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, 'Do not use signals across containers');
+            const effectSubscriber = ctx.$effectSubscriber$;
+            if (effectSubscriber) {
+                ensureContainsSubscription((this.$errorEffects$ ||= new Set()), effectSubscriber);
+                ensureContainsBackRef(effectSubscriber, this);
+                addQrlToSerializationCtx(effectSubscriber, this.$container$);
+            }
+        }
+        return val;
     }
     set untrackedError(value) {
         if (value !== this.$untrackedError$) {
@@ -2940,15 +2948,17 @@ const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 class JSXNodeImpl {
     type;
     children;
+    flags;
     toSort;
     key;
     varProps;
     constProps;
     dev;
     _proxy = null;
-    constructor(type, varProps, constProps, children, key, toSort, dev) {
+    constructor(type, varProps, constProps, children, flags, key, toSort, dev) {
         this.type = type;
         this.children = children;
+        this.flags = flags;
         this.toSort = !!toSort;
         this.key = key === null || key === undefined ? null : typeof key === 'string' ? key : '' + key;
         this.varProps = !varProps || isObjectEmpty(varProps) ? EMPTY_OBJ : varProps;
@@ -3027,7 +3037,7 @@ const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 const _jsxSorted = (type, varProps, constProps, children, 
 // TODO use this to know static parts of the tree
 flags, key, dev) => {
-    return new JSXNodeImpl(type, varProps, constProps, children, key, false, dev);
+    return new JSXNodeImpl(type, varProps, constProps, children, flags, key, false, dev);
 };
 /**
  * Create a JSXNode, with the properties split into variable and constant parts, but the variable
@@ -3226,7 +3236,7 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
             }
         }
     }
-    return new JSXNodeImpl(type, varProps, constProps, children, key, toSort || true, dev);
+    return new JSXNodeImpl(type, varProps, constProps, children, flags, key, toSort || true, dev);
 };
 /** @internal @deprecated v1 compat */
 const _jsxC = (type, mutable, _flags, key) => jsx(type, mutable, key);
@@ -3287,7 +3297,7 @@ function h(type, props, ...children) {
 const Fragment = (props) => props.children;
 /** @public */
 const RenderOnce = (props, key) => {
-    return new JSXNodeImpl(Virtual, null, null, props.children, key);
+    return new JSXNodeImpl(Virtual, null, null, props.children, 0, key);
 };
 
 /**
@@ -3547,7 +3557,7 @@ function injectPlaceholderElement(jsx) {
 }
 /** @returns An empty <script> element for adding qwik metadata attributes to */
 function createPlaceholderScriptNode() {
-    return new JSXNodeImpl('script', null, { hidden: '' }, null, null);
+    return new JSXNodeImpl('script', null, { hidden: '' }, null, 0, null);
 }
 
 /**
@@ -3635,7 +3645,7 @@ const _restProps = (props, omit = [], target = {}) => {
             varPropsTarget[key] = varProps[key];
         }
     }
-    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget, null, null));
+    return createPropsProxy(new JSXNodeImpl(null, varPropsTarget, constPropsTarget, null, 0, null));
 };
 
 class DeleteOperation {
@@ -3705,7 +3715,14 @@ const cleanupDestroyable = (destroyable) => {
  * This safely calls an event handler, handling errors and retrying on thrown Promises, and
  * providing extra parameters defined on the elements as arguments (used for loop optimization)
  */
-function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+function runEventHandlerQRL(handler, event, element, ctx) {
+    if (!element.isConnected) {
+        // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
+        return;
+    }
+    if (!ctx) {
+        ctx = newInvokeContextFromDOM(event, element);
+    }
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
     vnode_ensureElementInflated(container, hostElement);
@@ -3770,38 +3787,41 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
     vnode_setProp(vnode, key, originalValue);
     addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, (vnode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
 }
-const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-    const diffContext = {
-        container,
-        journal,
-        cursor,
-        scopedStyleIdPrefix,
-        stack: [],
-        asyncQueue: [],
-        asyncAttributePromises: [],
-        vParent: null,
-        vCurrent: null,
-        vNewNode: null,
-        vSiblings: null,
-        vSiblingsArray: null,
-        vSideBuffer: null,
-        jsxChildren: null,
-        jsxValue: null,
-        jsxIdx: 0,
-        jsxCount: 0,
-        shouldAdvance: true,
-        isCreationMode: false,
-        subscriptionData: {
-            const: new SubscriptionData({
+function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
+    return {
+        $container$: container,
+        $journal$: journal,
+        $cursor$: cursor,
+        $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+        $stack$: [],
+        $asyncQueue$: [],
+        $asyncAttributePromises$: [],
+        $vParent$: null,
+        $vCurrent$: null,
+        $vNewNode$: null,
+        $vSiblings$: null,
+        $vSiblingsArray$: null,
+        $vSideBuffer$: null,
+        $jsxChildren$: null,
+        $jsxValue$: null,
+        $jsxIdx$: 0,
+        $jsxCount$: 0,
+        $shouldAdvance$: true,
+        $isCreationMode$: false,
+        $subscriptionData$: {
+            $const$: new SubscriptionData({
                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                 $isConst$: true,
             }),
-            var: new SubscriptionData({
+            $var$: new SubscriptionData({
                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                 $isConst$: false,
             }),
         },
     };
+}
+const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
+    const diffContext = createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
     ////////////////////////////////
     diff(diffContext, jsxNode, vStartNode);
     const result = drainAsyncQueue(diffContext);
@@ -3821,56 +3841,56 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
 function diff(diffContext, jsxNode, vStartNode) {
     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);
+    diffContext.$vParent$ = vStartNode;
+    diffContext.$vNewNode$ = null;
+    diffContext.$vCurrent$ = vnode_getFirstChild(vStartNode);
     stackPush(diffContext, jsxNode, true);
-    if (diffContext.vParent.flags & 32 /* VNodeFlags.Deleted */) {
+    if (diffContext.$vParent$.flags & 32 /* VNodeFlags.Deleted */) {
         // Ignore diff if the parent is deleted.
         return;
     }
-    while (diffContext.stack.length) {
-        while (diffContext.jsxIdx < diffContext.jsxCount) {
+    while (diffContext.$stack$.length) {
+        while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
             isDev &&
-                assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same");
-            if (typeof diffContext.jsxValue === 'string') {
-                expectText(diffContext, diffContext.jsxValue);
+                assertFalse(diffContext.$vParent$ === diffContext.$vCurrent$, "Parent and current can't be the same");
+            if (typeof diffContext.$jsxValue$ === 'string') {
+                expectText(diffContext, diffContext.$jsxValue$);
             }
-            else if (typeof diffContext.jsxValue === 'number') {
-                expectText(diffContext, String(diffContext.jsxValue));
+            else if (typeof diffContext.$jsxValue$ === 'number') {
+                expectText(diffContext, String(diffContext.$jsxValue$));
             }
-            else if (diffContext.jsxValue && typeof diffContext.jsxValue === 'object') {
-                if (isJSXNode(diffContext.jsxValue)) {
-                    const type = diffContext.jsxValue.type;
+            else if (diffContext.$jsxValue$ && typeof diffContext.$jsxValue$ === 'object') {
+                if (isJSXNode(diffContext.$jsxValue$)) {
+                    const type = diffContext.$jsxValue$.type;
                     if (typeof type === 'string') {
                         expectNoTextNode(diffContext);
-                        expectElement(diffContext, diffContext.jsxValue, type);
-                        const hasDangerousInnerHTML = (diffContext.jsxValue.constProps &&
-                            _hasOwnProperty.call(diffContext.jsxValue.constProps, dangerouslySetInnerHTML)) ||
-                            _hasOwnProperty.call(diffContext.jsxValue.varProps, dangerouslySetInnerHTML);
+                        expectElement(diffContext, diffContext.$jsxValue$, type);
+                        const hasDangerousInnerHTML = (diffContext.$jsxValue$.constProps &&
+                            _hasOwnProperty.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML)) ||
+                            _hasOwnProperty.call(diffContext.$jsxValue$.varProps, dangerouslySetInnerHTML);
                         if (hasDangerousInnerHTML) {
                             expectNoChildren(diffContext, false);
                         }
                         else {
-                            descend(diffContext, diffContext.jsxValue.children, true);
+                            descend(diffContext, diffContext.$jsxValue$.children, true);
                         }
                     }
                     else if (typeof type === 'function') {
                         if (type === Fragment) {
                             expectNoTextNode(diffContext);
-                            expectVirtual(diffContext, "F" /* VirtualType.Fragment */, diffContext.jsxValue.key);
-                            descend(diffContext, diffContext.jsxValue.children, true);
+                            expectVirtual(diffContext, "F" /* VirtualType.Fragment */, diffContext.$jsxValue$.key);
+                            descend(diffContext, diffContext.$jsxValue$.children, true);
                         }
                         else if (type === Slot) {
                             expectNoTextNode(diffContext);
                             if (!expectSlot(diffContext)) {
                                 // nothing to project, so try to render the Slot default content.
-                                descend(diffContext, diffContext.jsxValue.children, true);
+                                descend(diffContext, diffContext.$jsxValue$.children, true);
                             }
                         }
                         else if (type === Projection) {
                             expectProjection(diffContext);
-                            descend(diffContext, diffContext.jsxValue.children, true, 
+                            descend(diffContext, diffContext.$jsxValue$.children, true, 
                             // special case for projection, we don't want to expect no children
                             // because the projection's children are not removed
                             false);
@@ -3888,30 +3908,30 @@ function diff(diffContext, jsxNode, vStartNode) {
                         }
                     }
                 }
-                else if (Array.isArray(diffContext.jsxValue)) {
-                    descend(diffContext, diffContext.jsxValue, false);
+                else if (Array.isArray(diffContext.$jsxValue$)) {
+                    descend(diffContext, diffContext.$jsxValue$, false);
                 }
-                else if (isSignal(diffContext.jsxValue)) {
+                else if (isSignal(diffContext.$jsxValue$)) {
                     expectVirtual(diffContext, "S" /* VirtualType.WrappedSignal */, null);
-                    const unwrappedSignal = diffContext.jsxValue instanceof WrappedSignalImpl
-                        ? diffContext.jsxValue.$unwrapIfSignal$()
-                        : diffContext.jsxValue;
-                    const signals = diffContext.vCurrent?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.VNODE */)?.backRef;
+                    const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl
+                        ? diffContext.$jsxValue$.$unwrapIfSignal$()
+                        : diffContext.$jsxValue$;
+                    const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.VNODE */)?.backRef;
                     let hasUnwrappedSignal = signals?.has(unwrappedSignal);
                     if (signals && unwrappedSignal instanceof WrappedSignalImpl) {
                         hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
                     }
                     if (!hasUnwrappedSignal) {
-                        const vHost = (diffContext.vNewNode || diffContext.vCurrent);
-                        descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, "." /* EffectProperty.VNODE */, diffContext.container)), true);
+                        const vHost = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+                        descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, "." /* EffectProperty.VNODE */, diffContext.$container$)), true);
                     }
                 }
-                else if (isPromise(diffContext.jsxValue)) {
+                else if (isPromise(diffContext.$jsxValue$)) {
                     expectVirtual(diffContext, "A" /* VirtualType.Awaited */, null);
-                    diffContext.asyncQueue.push(diffContext.jsxValue, diffContext.vNewNode || diffContext.vCurrent);
+                    diffContext.$asyncQueue$.push(diffContext.$jsxValue$, diffContext.$vNewNode$ || diffContext.$vCurrent$);
                 }
             }
-            else if (diffContext.jsxValue === SkipRender) ;
+            else if (diffContext.$jsxValue$ === SkipRender) ;
             else {
                 expectText(diffContext, '');
             }
@@ -3931,35 +3951,35 @@ function resolveSignalAndDescend(diffContext, fn) {
         if (isPromise(e)) {
             // The thrown promise will resolve when the signal is ready, then retry fn() with retry logic
             const retryPromise = e.then(() => retryOnPromise(fn));
-            diffContext.asyncQueue.push(retryPromise, diffContext.vNewNode || diffContext.vCurrent);
+            diffContext.$asyncQueue$.push(retryPromise, diffContext.$vNewNode$ || diffContext.$vCurrent$);
             return null;
         }
         throw e;
     }
 }
 function advance(diffContext) {
-    if (!diffContext.shouldAdvance) {
-        diffContext.shouldAdvance = true;
+    if (!diffContext.$shouldAdvance$) {
+        diffContext.$shouldAdvance$ = true;
         return;
     }
-    diffContext.jsxIdx++;
-    if (diffContext.jsxIdx < diffContext.jsxCount) {
-        diffContext.jsxValue = diffContext.jsxChildren[diffContext.jsxIdx];
+    diffContext.$jsxIdx$++;
+    if (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
+        diffContext.$jsxValue$ = diffContext.$jsxChildren$[diffContext.$jsxIdx$];
     }
-    else if (diffContext.stack.length > 0 &&
-        diffContext.stack[diffContext.stack.length - 1] === false) {
+    else if (diffContext.$stack$.length > 0 &&
+        diffContext.$stack$[diffContext.$stack$.length - 1] === false) {
         // this was special `descendVNode === false` so pop and try again
         return ascend(diffContext);
     }
-    if (diffContext.vNewNode !== null) {
+    if (diffContext.$vNewNode$ !== null) {
         // We have a new Node.
         // This means that the `vCurrent` was deemed not useful and we inserted in front of it.
         // This means that the next node we should look at is the `vCurrent` so just clear the
         // vNewNode  and try again.
-        diffContext.vNewNode = null;
+        diffContext.$vNewNode$ = null;
     }
     else {
-        diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
+        diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
     }
 }
 /**
@@ -3990,69 +4010,69 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
     stackPush(diffContext, children, descendVNode);
     if (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 = false;
+            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$ = false;
 }
 function ascend(diffContext) {
-    const descendVNode = diffContext.stack.pop(); // boolean: descendVNode
+    const descendVNode = diffContext.$stack$.pop(); // boolean: descendVNode
     if (descendVNode) {
-        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();
-    diffContext.jsxIdx = diffContext.stack.pop();
-    diffContext.jsxChildren = 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();
+    diffContext.$jsxIdx$ = diffContext.$stack$.pop();
+    diffContext.$jsxChildren$ = diffContext.$stack$.pop();
     advance(diffContext);
 }
 function stackPush(diffContext, children, descendVNode) {
-    diffContext.stack.push(diffContext.jsxChildren, diffContext.jsxIdx, diffContext.jsxCount, diffContext.jsxValue);
+    diffContext.$stack$.push(diffContext.$jsxChildren$, diffContext.$jsxIdx$, diffContext.$jsxCount$, diffContext.$jsxValue$);
     if (descendVNode) {
-        diffContext.stack.push(diffContext.vParent, diffContext.vCurrent, diffContext.vNewNode, diffContext.vSiblingsArray, diffContext.vSiblings, diffContext.vSideBuffer, diffContext.isCreationMode);
+        diffContext.$stack$.push(diffContext.$vParent$, diffContext.$vCurrent$, diffContext.$vNewNode$, diffContext.$vSiblingsArray$, diffContext.$vSiblings$, diffContext.$vSideBuffer$, diffContext.$isCreationMode$);
     }
-    diffContext.stack.push(descendVNode);
+    diffContext.$stack$.push(descendVNode);
     if (Array.isArray(children)) {
-        diffContext.jsxIdx = 0;
-        diffContext.jsxCount = children.length;
-        diffContext.jsxChildren = children;
-        diffContext.jsxValue = diffContext.jsxCount > 0 ? children[0] : null;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxCount$ = children.length;
+        diffContext.$jsxChildren$ = children;
+        diffContext.$jsxValue$ = diffContext.$jsxCount$ > 0 ? children[0] : null;
     }
     else if (children === undefined) {
         // no children
-        diffContext.jsxIdx = 0;
-        diffContext.jsxValue = null;
-        diffContext.jsxChildren = null;
-        diffContext.jsxCount = 0;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxValue$ = null;
+        diffContext.$jsxChildren$ = null;
+        diffContext.$jsxCount$ = 0;
     }
     else {
-        diffContext.jsxIdx = 0;
-        diffContext.jsxValue = children;
-        diffContext.jsxChildren = null;
-        diffContext.jsxCount = 1;
+        diffContext.$jsxIdx$ = 0;
+        diffContext.$jsxValue$ = children;
+        diffContext.$jsxChildren$ = null;
+        diffContext.$jsxCount$ = 1;
     }
 }
 function getInsertBefore(diffContext) {
-    if (diffContext.vNewNode) {
-        return diffContext.vCurrent;
+    if (diffContext.$vNewNode$) {
+        return diffContext.$vCurrent$;
     }
     else {
-        return peekNextSibling(diffContext.vCurrent);
+        return peekNextSibling(diffContext.$vCurrent$);
     }
 }
 /////////////////////////////////////////////////////////////////////////////
@@ -4061,7 +4081,7 @@ function getInsertBefore(diffContext) {
 function descendContentToProject(diffContext, children, host) {
     const projectionChildren = Array.isArray(children) ? children : [children];
     const createProjectionJSXNode = (slotName) => {
-        return new JSXNodeImpl(Projection, null, null, [], slotName);
+        return new JSXNodeImpl(Projection, null, null, [], 0, slotName);
     };
     const projections = [];
     if (host) {
@@ -4104,32 +4124,32 @@ function descendContentToProject(diffContext, children, host) {
     descend(diffContext, projections, true);
 }
 function expectProjection(diffContext) {
-    const jsxNode = diffContext.jsxValue;
+    const jsxNode = diffContext.$jsxValue$;
     const slotName = jsxNode.key;
     // console.log('expectProjection', JSON.stringify(slotName));
     // The parent is the component and it should have our portal.
-    diffContext.vCurrent = vnode_getProp(diffContext.vParent, slotName, (id) => vnode_locate(diffContext.container.rootVNode, id));
+    diffContext.$vCurrent$ = vnode_getProp(diffContext.$vParent$, slotName, (id) => vnode_locate(diffContext.$container$.rootVNode, id));
     // if projection is marked as deleted then we need to create a new one
-    diffContext.vCurrent =
-        diffContext.vCurrent && diffContext.vCurrent.flags & 32 /* VNodeFlags.Deleted */
+    diffContext.$vCurrent$ =
+        diffContext.$vCurrent$ && diffContext.$vCurrent$.flags & 32 /* VNodeFlags.Deleted */
             ? null
-            : diffContext.vCurrent;
-    if (diffContext.vCurrent == null) {
-        diffContext.vNewNode = vnode_newVirtual();
+            : diffContext.$vCurrent$;
+    if (diffContext.$vCurrent$ == null) {
+        diffContext.$vNewNode$ = vnode_newVirtual();
         // you may be tempted to add the projection into the current parent, but
         // that is wrong. We don't yet know if the projection will be projected, so
         // we should leave it unattached.
         // vNewNode[VNodeProps.parent] = vParent;
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        isDev && vnode_setProp(diffContext.vNewNode, 'q:code', 'expectProjection');
-        vnode_setProp(diffContext.vNewNode, QSlot, slotName);
-        diffContext.vNewNode.slotParent = diffContext.vParent;
-        vnode_setProp(diffContext.vParent, slotName, diffContext.vNewNode);
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        isDev && vnode_setProp(diffContext.$vNewNode$, 'q:code', 'expectProjection');
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotName);
+        diffContext.$vNewNode$.slotParent = diffContext.$vParent$;
+        vnode_setProp(diffContext.$vParent$, slotName, diffContext.$vNewNode$);
     }
 }
 function expectSlot(diffContext) {
-    const vHost = vnode_getProjectionParentComponent(diffContext.vParent);
+    const vHost = vnode_getProjectionParentComponent(diffContext.$vParent$);
     const slotNameKey = getSlotNameKey(diffContext, vHost);
     const vProjectedNode = vHost
         ? vnode_getProp(vHost, slotNameKey, 
@@ -4139,64 +4159,65 @@ function expectSlot(diffContext) {
         )
         : null;
     if (vProjectedNode == null) {
-        diffContext.vNewNode = vnode_newVirtual();
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+        diffContext.$vNewNode$ = vnode_newVirtual();
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
         return false;
     }
-    else if (vProjectedNode === diffContext.vCurrent) ;
+    else if (vProjectedNode === diffContext.$vCurrent$) ;
     else {
         // move from q:template to the target node
         const oldParent = vProjectedNode.parent;
-        diffContext.vNewNode = vProjectedNode;
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
-        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
+        diffContext.$vNewNode$ = vProjectedNode;
+        vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
+            vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        vnode_inflateProjectionTrailingText(diffContext.$journal$, diffContext.$vNewNode$);
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
             vnode_isElementVNode(oldParent) &&
             !oldParent.firstChild &&
             vnode_getElementName(oldParent) === QTemplate) {
-            vnode_remove(diffContext.journal, oldParent.parent, oldParent, true);
+            vnode_remove(diffContext.$journal$, oldParent.parent, oldParent, true);
         }
     }
     return true;
 }
 function getSlotNameKey(diffContext, vHost) {
-    const jsxNode = diffContext.jsxValue;
+    const jsxNode = diffContext.$jsxValue$;
     const constProps = jsxNode.constProps;
     if (constProps && typeof constProps == 'object' && _hasOwnProperty.call(constProps, 'name')) {
         const constValue = constProps.name;
         if (vHost && constValue instanceof WrappedSignalImpl) {
-            return trackSignalAndAssignHost(constValue, vHost, ":" /* EffectProperty.COMPONENT */, diffContext.container);
+            return trackSignalAndAssignHost(constValue, vHost, ":" /* EffectProperty.COMPONENT */, diffContext.$container$);
         }
     }
     return directGetPropsProxyProp(jsxNode, 'name') || QDefaultSlot;
 }
 function cleanupSideBuffer(diffContext) {
-    if (diffContext.vSideBuffer) {
+    if (diffContext.$vSideBuffer$) {
         // Remove all nodes in the side buffer as they are no longer needed
-        for (const vNode of diffContext.vSideBuffer.values()) {
+        for (const vNode of diffContext.$vSideBuffer$.values()) {
             if (vNode.flags & 32 /* VNodeFlags.Deleted */) {
                 continue;
             }
-            cleanup(diffContext.container, diffContext.journal, vNode, diffContext.cursor);
-            vnode_remove(diffContext.journal, diffContext.vParent, vNode, true);
+            cleanup(diffContext.$container$, diffContext.$journal$, vNode, diffContext.$cursor$);
+            vnode_remove(diffContext.$journal$, diffContext.$vParent$, vNode, true);
         }
-        diffContext.vSideBuffer.clear();
-        diffContext.vSideBuffer = null;
+        diffContext.$vSideBuffer$.clear();
+        diffContext.$vSideBuffer$ = null;
     }
-    diffContext.vCurrent = null;
+    diffContext.$vCurrent$ = null;
 }
 function drainAsyncQueue(diffContext) {
-    while (diffContext.asyncQueue.length) {
-        const jsxNode = diffContext.asyncQueue.shift();
-        const vHostNode = diffContext.asyncQueue.shift();
+    while (diffContext.$asyncQueue$.length) {
+        const jsxNode = diffContext.$asyncQueue$.shift();
+        const vHostNode = diffContext.$asyncQueue$.shift();
         if (isPromise(jsxNode)) {
             return jsxNode
                 .then((jsxNode) => {
@@ -4204,7 +4225,7 @@ function drainAsyncQueue(diffContext) {
                 return drainAsyncQueue(diffContext);
             })
                 .catch((e) => {
-                diffContext.container.handleError(e, vHostNode);
+                diffContext.$container$.handleError(e, vHostNode);
                 return drainAsyncQueue(diffContext);
             });
         }
@@ -4213,8 +4234,8 @@ function drainAsyncQueue(diffContext) {
         }
     }
     // Wait for all async attribute promises to complete, then check for more work
-    if (diffContext.asyncAttributePromises.length) {
-        const promises = diffContext.asyncAttributePromises.splice(0);
+    if (diffContext.$asyncAttributePromises$.length) {
+        const promises = diffContext.$asyncAttributePromises$.splice(0);
         return Promise.all(promises).then(() => {
             // After attributes are set, check if there's more work in the queue
             return drainAsyncQueue(diffContext);
@@ -4222,42 +4243,42 @@ function drainAsyncQueue(diffContext) {
     }
 }
 function cleanupDiffContext(diffContext) {
-    diffContext.journal = null;
-    diffContext.cursor = null;
+    diffContext.$journal$ = null;
+    diffContext.$cursor$ = null;
 }
 function expectNoChildren(diffContext, removeDOM = true) {
-    const vFirstChild = diffContext.vCurrent && vnode_getFirstChild(diffContext.vCurrent);
+    const vFirstChild = diffContext.$vCurrent$ && vnode_getFirstChild(diffContext.$vCurrent$);
     if (vFirstChild !== null) {
         let vChild = vFirstChild;
         while (vChild) {
-            cleanup(diffContext.container, diffContext.journal, vChild, diffContext.cursor);
+            cleanup(diffContext.$container$, diffContext.$journal$, vChild, diffContext.$cursor$);
             vChild = vChild.nextSibling;
         }
-        vnode_truncate(diffContext.journal, diffContext.vCurrent, vFirstChild, removeDOM);
+        vnode_truncate(diffContext.$journal$, diffContext.$vCurrent$, vFirstChild, removeDOM);
     }
 }
 /** Expect no more nodes - Any nodes which are still at cursor, need to be removed. */
 function expectNoMore(diffContext) {
     isDev &&
-        assertFalse(diffContext.vParent === diffContext.vCurrent, "Parent and current can't be the same");
-    if (diffContext.vCurrent !== null) {
-        while (diffContext.vCurrent) {
-            const toRemove = diffContext.vCurrent;
-            diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
-            if (diffContext.vParent === toRemove.parent) {
-                cleanup(diffContext.container, diffContext.journal, toRemove, diffContext.cursor);
+        assertFalse(diffContext.$vParent$ === diffContext.$vCurrent$, "Parent and current can't be the same");
+    if (diffContext.$vCurrent$ !== null) {
+        while (diffContext.$vCurrent$) {
+            const toRemove = diffContext.$vCurrent$;
+            diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+            if (diffContext.$vParent$ === toRemove.parent) {
+                cleanup(diffContext.$container$, diffContext.$journal$, toRemove, diffContext.$cursor$);
                 // If we are diffing projection than the parent is not the parent of the node.
                 // If that is the case we don't want to remove the node from the parent.
-                vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
+                vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
             }
         }
     }
 }
 function expectNoTextNode(diffContext) {
-    if (diffContext.vCurrent !== null && vnode_isTextVNode(diffContext.vCurrent)) {
-        const toRemove = diffContext.vCurrent;
-        diffContext.vCurrent = peekNextSibling(diffContext.vCurrent);
-        vnode_remove(diffContext.journal, diffContext.vParent, toRemove, true);
+    if (diffContext.$vCurrent$ !== null && vnode_isTextVNode(diffContext.$vCurrent$)) {
+        const toRemove = diffContext.$vCurrent$;
+        diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+        vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
     }
 }
 function createNewElement(diffContext, jsx, elementName, currentFile) {
@@ -4270,7 +4291,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
         for (const key in constProps) {
             let value = constProps[key];
             if (isHtmlAttributeAnEventName(key)) {
-                registerEventHandlers(key, value, element, diffContext.vNewNode, diffContext);
+                registerEventHandlers(key, value, element, diffContext.$vNewNode$, diffContext);
                 continue;
             }
             if (key === 'ref') {
@@ -4290,14 +4311,14 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
                 }
             }
             if (isSignal(value)) {
-                const vHost = diffContext.vNewNode;
+                const vHost = diffContext.$vNewNode$;
                 const signal = value;
-                value = retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, diffContext.container, diffContext.subscriptionData.const));
+                value = retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, diffContext.$container$, diffContext.$subscriptionData$.$const$));
             }
             if (isPromise(value)) {
-                const vHost = diffContext.vNewNode;
-                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.scopedStyleIdPrefix), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
-                diffContext.asyncAttributePromises.push(attributePromise);
+                const vHost = diffContext.$vNewNode$;
+                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.$scopedStyleIdPrefix$), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
+                diffContext.$asyncAttributePromises$.push(attributePromise);
                 continue;
             }
             if (key === dangerouslySetInnerHTML) {
@@ -4317,22 +4338,22 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
                 element.value = escapeHTML(value || '');
                 continue;
             }
-            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.scopedStyleIdPrefix), (diffContext.vNewNode.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
+            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.$scopedStyleIdPrefix$), (diffContext.$vNewNode$.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
         }
     }
     const key = jsx.key;
     if (key) {
-        diffContext.vNewNode.key = key;
+        diffContext.$vNewNode$.key = key;
     }
     // append class attribute if styleScopedId exists and there is no class attribute
-    if (diffContext.scopedStyleIdPrefix) {
+    if (diffContext.$scopedStyleIdPrefix$) {
         const classAttributeExists = _hasOwnProperty.call(jsx.varProps, 'class') ||
             (jsx.constProps && _hasOwnProperty.call(jsx.constProps, 'class'));
         if (!classAttributeExists) {
-            element.setAttribute('class', diffContext.scopedStyleIdPrefix);
+            element.setAttribute('class', diffContext.$scopedStyleIdPrefix$);
         }
     }
-    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$);
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
     const scopedKebabName = key.slice(2);
@@ -4365,33 +4386,34 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
     // window and document events need attrs so qwik loader can find them
     // TODO only do these when not already present
     if (key.charAt(2) !== 'e') {
-        vnode_setAttr(diffContext.journal, vnode, key, '');
+        vnode_setAttr(diffContext.$journal$, vnode, key, '');
     }
     registerQwikLoaderEvent(diffContext, scopedKebabName);
 }
 function createElementWithNamespace(diffContext, elementName) {
-    const domParentVNode = vnode_getDomParentVNode(diffContext.vParent, true);
+    const domParentVNode = vnode_getDomParentVNode(diffContext.$vParent$, true);
     const namespaceData = getNewElementNamespaceData(domParentVNode, elementName);
-    const currentDocument = import.meta.env.TEST ? diffContext.container.document : document;
+    const currentDocument = import.meta.env.TEST ? diffContext.$container$.document : document;
     const element = namespaceData.elementNamespaceFlag === 0 /* VNodeFlags.NS_html */
         ? currentDocument.createElement(elementName)
         : currentDocument.createElementNS(namespaceData.elementNamespace, elementName);
-    diffContext.vNewNode = vnode_newElement(element, elementName);
-    diffContext.vNewNode.flags |= namespaceData.elementNamespaceFlag;
+    diffContext.$vNewNode$ = vnode_newElement(element, elementName);
+    diffContext.$vNewNode$.flags |= namespaceData.elementNamespaceFlag;
     return element;
 }
 function expectElement(diffContext, jsx, elementName) {
-    if (diffContext.isCreationMode) {
+    if (diffContext.$isCreationMode$) {
         createNewElement(diffContext, jsx, elementName, null);
     }
     else {
-        const isElementVNode = diffContext.vCurrent && vnode_isElementVNode(diffContext.vCurrent);
-        const isSameElementName = isElementVNode && elementName === vnode_getElementName(diffContext.vCurrent);
+        const isElementVNode = diffContext.$vCurrent$ && vnode_isElementVNode(diffContext.$vCurrent$);
+        const isSameElementName = isElementVNode &&
+            elementName === vnode_getElementName(diffContext.$vCurrent$);
         const jsxKey = jsx.key;
-        const currentKey = isElementVNode && diffContext.vCurrent.key;
+        const currentKey = isElementVNode && diffContext.$vCurrent$.key;
         if (!isSameElementName || jsxKey !== currentKey) {
             const sideBufferKey = getSideBufferKey(elementName, jsxKey);
-            if (moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.vParent)) {
+            if (moveOrCreateKeyedNode(diffContext, elementName, jsxKey, sideBufferKey, diffContext.$vParent$)) {
                 createNewElement(diffContext, jsx, elementName, null);
             }
         }
@@ -4402,15 +4424,15 @@ function expectElement(diffContext, jsx, elementName) {
     }
     // reconcile attributes
     const jsxProps = jsx.varProps;
-    const vNode = (diffContext.vNewNode || diffContext.vCurrent);
+    const vNode = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
     if (jsxProps) {
         diffProps(diffContext, vNode, jsxProps, (isDev && getFileLocationFromJsx(jsx.dev)) || null);
     }
 }
 function diffProps(diffContext, vnode, newAttrs, currentFile) {
-    if (!diffContext.isCreationMode) {
+    if (!diffContext.$isCreationMode$) {
         // inflate only resumed vnodes
-        vnode_ensureElementInflated(diffContext.container, vnode);
+        vnode_ensureElementInflated(diffContext.$container$, vnode);
     }
     const oldAttrs = vnode.props;
     // Actual diffing logic
@@ -4483,29 +4505,29 @@ const patchProperty = (diffContext, vnode, key, value, currentFile) => {
             return;
         }
         if (currentEffect) {
-            clearEffectSubscription(diffContext.container, currentEffect);
+            clearEffectSubscription(diffContext.$container$, currentEffect);
         }
         const vHost = vnode;
-        value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.container, diffContext.subscriptionData.var));
+        value = retryOnPromise(() => trackSignalAndAssignHost(unwrappedSignal, vHost, key, diffContext.$container$, diffContext.$subscriptionData$.$var$));
     }
     else {
         if (currentEffect) {
-            clearEffectSubscription(diffContext.container, currentEffect);
+            clearEffectSubscription(diffContext.$container$, currentEffect);
         }
     }
     if (isPromise(value)) {
         const vHost = vnode;
         const attributePromise = value.then((resolvedValue) => {
-            setAttribute(diffContext.journal, vHost, key, resolvedValue, diffContext.scopedStyleIdPrefix, originalValue);
+            setAttribute(diffContext.$journal$, vHost, key, resolvedValue, diffContext.$scopedStyleIdPrefix$, originalValue);
         });
-        diffContext.asyncAttributePromises.push(attributePromise);
+        diffContext.$asyncAttributePromises$.push(attributePromise);
         return;
     }
-    setAttribute(diffContext.journal, vnode, key, value, diffContext.scopedStyleIdPrefix, originalValue);
+    setAttribute(diffContext.$journal$, vnode, key, value, diffContext.$scopedStyleIdPrefix$, originalValue);
 };
 function registerQwikLoaderEvent(diffContext, eventName) {
     const qWindow = import.meta.env.TEST
-        ? diffContext.container.document.defaultView
+        ? diffContext.$container$.document.defaultView
         : window;
     if (qWindow) {
         (qWindow._qwikEv ||= []).push(eventName);
@@ -4513,35 +4535,35 @@ function registerQwikLoaderEvent(diffContext, eventName) {
 }
 function retrieveChildWithKey(diffContext, nodeName, key) {
     let vNodeWithKey = null;
-    if (diffContext.vSiblings === null) {
+    if (diffContext.$vSiblings$ === null) {
         // check if the current node is the one we are looking for
-        const vCurrent = diffContext.vCurrent;
+        const vCurrent = diffContext.$vCurrent$;
         if (vCurrent) {
             const name = vnode_isElementVNode(vCurrent) ? vnode_getElementName(vCurrent) : null;
             const vKey = getKey(vCurrent) ||
-                getComponentHash(vCurrent, diffContext.container.$getObjectById$);
+                getComponentHash(vCurrent, diffContext.$container$.$getObjectById$);
             if (vKey === key && name === nodeName) {
                 return vCurrent;
             }
         }
         // it is not materialized; so materialize it.
-        diffContext.vSiblings = new Map();
-        diffContext.vSiblingsArray = [];
-        let vNode = diffContext.vCurrent;
+        diffContext.$vSiblings$ = new Map();
+        diffContext.$vSiblingsArray$ = [];
+        let vNode = diffContext.$vCurrent$;
         while (vNode) {
             const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
             const vKey = getKey(vNode) ||
-                getComponentHash(vNode, diffContext.container.$getObjectById$);
+                getComponentHash(vNode, diffContext.$container$.$getObjectById$);
             if (vNodeWithKey === null && vKey == key && name == nodeName) {
                 vNodeWithKey = vNode;
             }
             else {
                 if (vKey === null) {
-                    diffContext.vSiblingsArray.push(name, vNode);
+                    diffContext.$vSiblingsArray$.push(name, vNode);
                 }
                 else {
                     // we only add the elements which we did not find yet.
-                    diffContext.vSiblings.set(getSideBufferKey(name, vKey), vNode);
+                    diffContext.$vSiblings$.set(getSideBufferKey(name, vKey), vNode);
                 }
             }
             vNode = vNode.nextSibling;
@@ -4549,20 +4571,20 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
     }
     else {
         if (key === null) {
-            for (let i = 0; i < diffContext.vSiblingsArray.length; i += 2) {
-                if (diffContext.vSiblingsArray[i] === nodeName) {
-                    vNodeWithKey = diffContext.vSiblingsArray[i + 1];
-                    diffContext.vSiblingsArray.splice(i, 2);
+            for (let i = 0; i < diffContext.$vSiblingsArray$.length; i += 2) {
+                if (diffContext.$vSiblingsArray$[i] === nodeName) {
+                    vNodeWithKey = diffContext.$vSiblingsArray$[i + 1];
+                    diffContext.$vSiblingsArray$.splice(i, 2);
                     break;
                 }
             }
         }
         else {
             const siblingsKey = getSideBufferKey(nodeName, key);
-            const sibling = diffContext.vSiblings.get(siblingsKey);
+            const sibling = diffContext.$vSiblings$.get(siblingsKey);
             if (sibling) {
                 vNodeWithKey = sibling;
-                diffContext.vSiblings.delete(siblingsKey);
+                diffContext.$vSiblings$.delete(siblingsKey);
             }
         }
     }
@@ -4571,32 +4593,32 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
 }
 function collectSideBufferSiblings(diffContext, targetNode) {
     if (!targetNode) {
-        if (diffContext.vCurrent) {
-            const name = vnode_isElementVNode(diffContext.vCurrent)
-                ? vnode_getElementName(diffContext.vCurrent)
+        if (diffContext.$vCurrent$) {
+            const name = vnode_isElementVNode(diffContext.$vCurrent$)
+                ? vnode_getElementName(diffContext.$vCurrent$)
                 : null;
-            const vKey = getKey(diffContext.vCurrent) ||
-                getComponentHash(diffContext.vCurrent, diffContext.container.$getObjectById$);
+            const vKey = getKey(diffContext.$vCurrent$) ||
+                getComponentHash(diffContext.$vCurrent$, diffContext.$container$.$getObjectById$);
             if (vKey != null) {
                 const sideBufferKey = getSideBufferKey(name, vKey);
-                diffContext.vSideBuffer ||= new Map();
-                diffContext.vSideBuffer.set(sideBufferKey, diffContext.vCurrent);
-                diffContext.vSiblings?.delete(sideBufferKey);
+                diffContext.$vSideBuffer$ ||= new Map();
+                diffContext.$vSideBuffer$.set(sideBufferKey, diffContext.$vCurrent$);
+                diffContext.$vSiblings$?.delete(sideBufferKey);
             }
         }
         return;
     }
     // Walk from vCurrent up to the target node and collect all keyed siblings
-    let vNode = diffContext.vCurrent;
+    let vNode = diffContext.$vCurrent$;
     while (vNode && vNode !== targetNode) {
         const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
         const vKey = getKey(vNode) ||
-            getComponentHash(vNode, diffContext.container.$getObjectById$);
+            getComponentHash(vNode, diffContext.$container$.$getObjectById$);
         if (vKey != null) {
             const sideBufferKey = getSideBufferKey(name, vKey);
-            diffContext.vSideBuffer ||= new Map();
-            diffContext.vSideBuffer.set(sideBufferKey, vNode);
-            diffContext.vSiblings?.delete(sideBufferKey);
+            diffContext.$vSideBuffer$ ||= new Map();
+            diffContext.$vSideBuffer$.set(sideBufferKey, vNode);
+            diffContext.$vSiblings$?.delete(sideBufferKey);
         }
         vNode = vNode.nextSibling;
     }
@@ -4609,8 +4631,8 @@ function getSideBufferKey(nodeName, key) {
 }
 function deleteFromSideBuffer(diffContext, nodeName, key) {
     const sbKey = getSideBufferKey(nodeName, key);
-    if (sbKey && diffContext.vSideBuffer?.has(sbKey)) {
-        diffContext.vSideBuffer.delete(sbKey);
+    if (sbKey && diffContext.$vSideBuffer$?.has(sbKey)) {
+        diffContext.$vSideBuffer$.delete(sbKey);
         return true;
     }
     return false;
@@ -4628,40 +4650,40 @@ function deleteFromSideBuffer(diffContext, nodeName, key) {
  */
 function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey, parentForInsert, addCurrentToSideBufferOnSideInsert) {
     // 1) Try to find the node among upcoming siblings
-    diffContext.vNewNode = retrieveChildWithKey(diffContext, nodeName, lookupKey);
-    if (diffContext.vNewNode) {
+    diffContext.$vNewNode$ = retrieveChildWithKey(diffContext, nodeName, lookupKey);
+    if (diffContext.$vNewNode$) {
         if (!sideBufferKey) {
-            vnode_insertBefore(diffContext.journal, parentForInsert, diffContext.vNewNode, diffContext.vCurrent);
+            vnode_insertBefore(diffContext.$journal$, parentForInsert, diffContext.$vNewNode$, diffContext.$vCurrent$);
         }
-        diffContext.vCurrent = diffContext.vNewNode;
-        diffContext.vNewNode = null;
+        diffContext.$vCurrent$ = diffContext.$vNewNode$;
+        diffContext.$vNewNode$ = null;
         return false;
     }
     // 2) Try side buffer
     if (sideBufferKey != null) {
-        const buffered = diffContext.vSideBuffer?.get(sideBufferKey) || null;
+        const buffered = diffContext.$vSideBuffer$?.get(sideBufferKey) || null;
         if (buffered) {
-            diffContext.vSideBuffer.delete(sideBufferKey);
-            if (addCurrentToSideBufferOnSideInsert && diffContext.vCurrent) {
-                const currentKey = getKey(diffContext.vCurrent) ||
-                    getComponentHash(diffContext.vCurrent, diffContext.container.$getObjectById$);
+            diffContext.$vSideBuffer$.delete(sideBufferKey);
+            if (addCurrentToSideBufferOnSideInsert && diffContext.$vCurrent$) {
+                const currentKey = getKey(diffContext.$vCurrent$) ||
+                    getComponentHash(diffContext.$vCurrent$, diffContext.$container$.$getObjectById$);
                 if (currentKey != null) {
-                    const currentName = vnode_isElementVNode(diffContext.vCurrent)
-                        ? vnode_getElementName(diffContext.vCurrent)
+                    const currentName = vnode_isElementVNode(diffContext.$vCurrent$)
+                        ? vnode_getElementName(diffContext.$vCurrent$)
                         : null;
                     const currentSideKey = getSideBufferKey(currentName, currentKey);
                     if (currentSideKey != null) {
-                        diffContext.vSideBuffer ||= new Map();
-                        diffContext.vSideBuffer.set(currentSideKey, diffContext.vCurrent);
+                        diffContext.$vSideBuffer$ ||= new Map();
+                        diffContext.$vSideBuffer$.set(currentSideKey, diffContext.$vCurrent$);
                     }
                 }
             }
             // Only move if the node is not already in the correct position
-            if (buffered !== diffContext.vCurrent) {
-                vnode_insertBefore(diffContext.journal, parentForInsert, buffered, diffContext.vCurrent);
+            if (buffered !== diffContext.$vCurrent$) {
+                vnode_insertBefore(diffContext.$journal$, parentForInsert, buffered, diffContext.$vCurrent$);
             }
-            diffContext.vCurrent = buffered;
-            diffContext.vNewNode = null;
+            diffContext.$vCurrent$ = buffered;
+            diffContext.$vNewNode$ = null;
             return false;
         }
     }
@@ -4670,8 +4692,8 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
 }
 function expectVirtual(diffContext, type, jsxKey) {
     const checkKey = type === "F" /* VirtualType.Fragment */;
-    const currentKey = getKey(diffContext.vCurrent);
-    const currentIsVirtual = diffContext.vCurrent && vnode_isVirtualVNode(diffContext.vCurrent);
+    const currentKey = getKey(diffContext.$vCurrent$);
+    const currentIsVirtual = diffContext.$vCurrent$ && vnode_isVirtualVNode(diffContext.$vCurrent$);
     const isSameNode = currentIsVirtual && currentKey === jsxKey && (checkKey ? !!jsxKey : true);
     if (isSameNode) {
         // All is good.
@@ -4679,53 +4701,61 @@ function expectVirtual(diffContext, type, jsxKey) {
         return;
     }
     // For fragments without a key, always create a new virtual node (ensures rerender semantics)
-    if (jsxKey === null || diffContext.isCreationMode) {
-        vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-        diffContext.vNewNode.key = jsxKey;
-        isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    if (jsxKey === null || diffContext.$isCreationMode$) {
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        diffContext.$vNewNode$.key = jsxKey;
+        isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
         return;
     }
-    if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, true)) {
-        vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-        diffContext.vNewNode.key = jsxKey;
-        isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
+    if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.$vParent$, true)) {
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        diffContext.$vNewNode$.key = jsxKey;
+        isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
     }
 }
 function expectComponent(diffContext, component) {
     const componentMeta = component[SERIALIZABLE_STATE];
-    let host = (diffContext.vNewNode || diffContext.vCurrent);
-    const jsxNode = diffContext.jsxValue;
+    let host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+    const jsxNode = diffContext.$jsxValue$;
     if (componentMeta) {
         const jsxProps = jsxNode.props;
         // QComponent
         let shouldRender = false;
         const [componentQRL] = componentMeta;
         const componentHash = componentQRL.$hash$;
-        const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
+        const vNodeComponentHash = getComponentHash(host, diffContext.$container$.$getObjectById$);
         const lookupKey = jsxNode.key || componentHash;
         const vNodeLookupKey = getKey(host) || vNodeComponentHash;
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const hashesAreEqual = componentHash === vNodeComponentHash;
-        if (!lookupKeysAreEqual) {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+        if (lookupKeysAreEqual) {
+            if (hashesAreEqual) {
+                deleteFromSideBuffer(diffContext, null, lookupKey);
+            }
+            else {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                host = diffContext.$vNewNode$;
                 shouldRender = true;
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
-        }
-        else if (!hashesAreEqual || !jsxNode.key) {
-            insertNewComponent(diffContext, host, componentQRL, jsxProps);
-            host = diffContext.vNewNode;
-            shouldRender = true;
         }
         else {
-            // delete the key from the side buffer if it is the same component
-            deleteFromSideBuffer(diffContext, null, lookupKey);
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.$vParent$)) {
+                insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                shouldRender = true;
+            }
+            host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
         }
         if (host) {
-            const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.container.$getObjectById$);
+            const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.$container$.$getObjectById$);
             if (!shouldRender) {
-                shouldRender ||= handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.$container$);
+                // if props changed but key is null we need to insert a new component, because we need to execute hooks etc
+                if (propsChanged && jsxNode.key == null) {
+                    insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                    host = diffContext.$vNewNode$;
+                    shouldRender = true;
+                }
+                shouldRender ||= propsChanged;
             }
             if (shouldRender) {
                 // Assign the new QRL instance to the host.
@@ -4736,7 +4766,7 @@ function expectComponent(diffContext, component) {
                  * cleanup run. Now we found it and want to reuse it, so we need to mark it as not deleted.
                  */
                 host.flags &= -33 /* VNodeFlags.Deleted */;
-                markVNodeDirty(diffContext.container, host, 4 /* ChoreBits.COMPONENT */, diffContext.cursor);
+                markVNodeDirty(diffContext.$container$, host, 4 /* ChoreBits.COMPONENT */, diffContext.$cursor$);
             }
         }
         descendContentToProject(diffContext, jsxNode.children, host);
@@ -4745,18 +4775,18 @@ function expectComponent(diffContext, component) {
         const lookupKey = jsxNode.key;
         const vNodeLookupKey = getKey(host);
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
-        const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
+        const vNodeComponentHash = getComponentHash(host, diffContext.$container$.$getObjectById$);
         const isInlineComponent = vNodeComponentHash == null;
-        if ((host && !isInlineComponent) || lookupKey == null) {
+        if ((host && !isInlineComponent) || !host) {
             insertNewInlineComponent(diffContext);
-            host = diffContext.vNewNode;
+            host = diffContext.$vNewNode$;
         }
         else if (!lookupKeysAreEqual) {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.$vParent$)) {
                 // We did not find the inline component, create it.
                 insertNewInlineComponent(diffContext);
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
+            host = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
         }
         else {
             // delete the key from the side buffer if it is the same component
@@ -4771,44 +4801,44 @@ function expectComponent(diffContext, component) {
                     : true)) {
                 componentHost = componentHost.parent || vnode_getProjectionParentComponent(componentHost);
             }
-            const jsxOutput = executeComponent(diffContext.container, host, (componentHost || diffContext.container.rootVNode), component, jsxNode.props);
-            diffContext.asyncQueue.push(jsxOutput, host);
+            const jsxOutput = executeComponent(diffContext.$container$, host, (componentHost || diffContext.$container$.rootVNode), component, jsxNode.props);
+            diffContext.$asyncQueue$.push(jsxOutput, host);
         }
     }
 }
 function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     if (host) {
-        clearAllEffects(diffContext.container, host);
+        clearAllEffects(diffContext.$container$, host);
     }
-    vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-    const jsxNode = diffContext.jsxValue;
-    isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "C" /* VirtualType.Component */);
-    vnode_setProp(diffContext.vNewNode, OnRenderProp, componentQRL);
-    vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxProps);
-    diffContext.vNewNode.key = jsxNode.key;
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    const jsxNode = diffContext.$jsxValue$;
+    isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* VirtualType.Component */);
+    vnode_setProp(diffContext.$vNewNode$, OnRenderProp, componentQRL);
+    vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxProps);
+    diffContext.$vNewNode$.key = jsxNode.key;
 }
 function insertNewInlineComponent(diffContext) {
-    vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
-    const jsxNode = diffContext.jsxValue;
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    const jsxNode = diffContext.$jsxValue$;
     isDev &&
-        vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
-    vnode_setProp(diffContext.vNewNode, ELEMENT_PROPS, jsxNode.props);
+        vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
+    vnode_setProp(diffContext.$vNewNode$, ELEMENT_PROPS, jsxNode.props);
     if (jsxNode.key) {
-        diffContext.vNewNode.key = jsxNode.key;
+        diffContext.$vNewNode$.key = jsxNode.key;
     }
 }
 function expectText(diffContext, text) {
-    if (diffContext.vCurrent !== null) {
-        const type = vnode_getType(diffContext.vCurrent);
+    if (diffContext.$vCurrent$ !== null) {
+        const type = vnode_getType(diffContext.$vCurrent$);
         if (type === 3 /* Text */) {
-            if (text !== vnode_getText(diffContext.vCurrent)) {
-                vnode_setText(diffContext.journal, diffContext.vCurrent, text);
+            if (text !== vnode_getText(diffContext.$vCurrent$)) {
+                vnode_setText(diffContext.$journal$, diffContext.$vCurrent$, text);
                 return;
             }
             return;
         }
     }
-    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newText((import.meta.env.TEST ? diffContext.container.document : document).createTextNode(text), text)), diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text), text)), diffContext.$vCurrent$);
 }
 /**
  * Retrieve the key from the VNode.
@@ -5739,7 +5769,7 @@ function walkCursor(cursor, options) {
             return;
         }
         // Check time budget (only for DOM, not SSR)
-        if (!isRunningOnServer && !import.meta.env.TEST) {
+        if (isBrowser) {
             const elapsed = performance.now() - startTime;
             if (elapsed >= timeBudget) {
                 // Schedule continuation as macrotask to actually yield to browser
@@ -5781,10 +5811,27 @@ function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
         return null;
     }
     partitionDirtyChildren(dirtyChildren, currentVNode);
+    // Scan dirtyChildren directly instead of going through getNextVNode.
+    // getNextVNode follows the child's parent/slotParent pointer, which for Projection nodes
+    // points to the DOM insertion location rather than currentVNode — that would scan the
+    // wrong dirtyChildren array and potentially cause infinite loops.
+    // const len = dirtyChildren.length;
+    // for (let i = 0; i < len; i++) {
+    //   const child = dirtyChildren[i];
+    //   if (child.dirty & ChoreBits.DIRTY_MASK) {
+    //     currentVNode.nextDirtyChildIndex = (i + 1) % len;
+    //     setCursorPosition(container, cursorData, child);
+    //     return child;
+    //   }
+    // }
+    // // No dirty child found — clean up
+    // currentVNode.dirty &= ~ChoreBits.CHILDREN;
+    // currentVNode.dirtyChildren = null;
     currentVNode.nextDirtyChildIndex = 0;
     const next = getNextVNode(dirtyChildren[0], cursor);
     setCursorPosition(container, cursorData, next);
     return next;
+    // return null;
 }
 /**
  * Partitions dirtyChildren array so non-projections come first, projections last. Uses in-place
@@ -5813,14 +5860,14 @@ function getNextVNode(vNode, cursor) {
         }
         return null;
     }
-    // Prefer parent if it's dirty, otherwise try slotParent
+    // Prefer slotParent (logical owner) for Projections, fall back to parent
     let parent = null;
-    if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
-        parent = vNode.parent;
-    }
-    else if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
+    if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
         parent = vNode.slotParent;
     }
+    else if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
+        parent = vNode.parent;
+    }
     if (!parent) {
         if (cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
@@ -5992,7 +6039,9 @@ function propagatePath(target) {
         const parent = reusablePath[i + 1] || target;
         parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(child);
+        if (!parent.dirtyChildren.includes(child)) {
+            parent.dirtyChildren.push(child);
+        }
     }
 }
 /**
@@ -6001,7 +6050,7 @@ function propagatePath(target) {
  */
 function propagateToCursorRoot(vNode, cursorRoot) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const isDirty = current.dirty & 127 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
@@ -6026,7 +6075,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
             }
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     throwErrorAndStop('Cursor root not found in current path!');
@@ -6037,7 +6086,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
  */
 function findAndPropagateToBlockingCursor(vNode) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const currentIsCursor = isCursor(current);
         if (currentIsCursor) {
@@ -6046,7 +6095,7 @@ function findAndPropagateToBlockingCursor(vNode) {
             return true;
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     return false;
@@ -6080,7 +6129,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if ((isRealDirty ? prevDirty & 127 /* ChoreBits.DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
         return;
     }
-    const parent = vNode.parent || vNode.slotParent;
+    const parent = vNode.slotParent || vNode.parent;
     // If cursorRoot is provided, propagate up to it
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
         propagateToCursorRoot(vNode, cursorRoot);
@@ -6092,7 +6141,9 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
             parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         }
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(vNode);
+        if (!parent.dirtyChildren.includes(vNode)) {
+            parent.dirtyChildren.push(vNode);
+        }
         if (isRealDirty && vNode.dirtyChildren) {
             // this node is maybe an ancestor of the current cursor position
             // if so we must restart from here
@@ -6103,7 +6154,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                 if (cursorPosition) {
                     // find the ancestor of the cursor position that is current vNode
                     while (cursorPosition !== cursor) {
-                        cursorPosition = cursorPosition.parent || cursorPosition.slotParent;
+                        cursorPosition = cursorPosition.slotParent || cursorPosition.parent;
                         if (cursorPosition === vNode) {
                             // set cursor position to this node
                             cursorData.position = vNode;
@@ -6137,6 +6188,20 @@ const fastGetter = (prototype, name) => {
             return this[name];
         });
 };
+/**
+ * Creates a cached fast property accessor by pulling the native getter from the prototype chain.
+ * The getter is resolved lazily on the first call and then reused, bypassing prototype lookups on
+ * every subsequent access.
+ */
+const createFastGetter = (propName) => {
+    let getter = null;
+    return (node) => {
+        if (!getter) {
+            getter = fastGetter(node, propName);
+        }
+        return getter.call(node);
+    };
+};
 
 /**
  * @file
@@ -6487,7 +6552,7 @@ function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     // Depth first traversal
     if (vnode_isTextVNode(vNode)) {
-        // Text nodes don't have subscriptions or children;
+        callback?.(vNode, null);
         return;
     }
     let vParent = null;
@@ -6635,11 +6700,6 @@ const vnode_getDomSibling = (vNode, nextDirection, descend) => {
     }
     return null;
 };
-const vnode_ensureInflatedIfText = (journal, vNode) => {
-    if (vnode_isTextVNode(vNode)) {
-        vnode_ensureTextInflated(journal, vNode);
-    }
-};
 const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     const flags = textVNode.flags;
@@ -6965,7 +7025,9 @@ const vnode_findInsertBefore = (journal, parent, insertBefore) => {
     else {
         adjustedInsertBefore = insertBefore;
     }
-    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+    adjustedInsertBefore &&
+        vnode_isTextVNode(adjustedInsertBefore) &&
+        vnode_ensureTextInflated(journal, adjustedInsertBefore);
     return adjustedInsertBefore;
 };
 const vnode_connectSiblings = (parent, vNode, vNext) => {
@@ -7029,6 +7091,45 @@ const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild)
         vnode_remove(journal, currentParent, newChild, false);
     }
 };
+/**
+ * When a projection vnode is about to be repositioned (moved in the vnode tree), its trailing text
+ * node must be inflated before the projection is unlinked from its current sibling chain.
+ * `vnode_ensureTextInflated` relies on `vnode_getDomSibling` to locate adjacent text nodes and
+ * decide which one is "last" (i.e. the one that gets to reuse the shared SSR DOM `Text` node). Once
+ * the projection is unlinked, its `nextSibling` becomes `null`, so `getDomSibling` can no longer
+ * cross the boundary to find a trailing sibling such as an empty-string text node — causing
+ * `isLastNode` to be `true` prematurely and corrupting the shared DOM text node. Inflating the
+ * trailing text node while the siblings are still connected gives it its own fresh DOM node and
+ * avoids the corruption.
+ *
+ * Example:
+ *
+ * ```
+ * <Component>
+ *   <button>
+ *     <InlineComponent>
+ *       <span>
+ *         "*"
+ *       </span>
+ *     </InlineComponent>
+ *     <Projection> // <-- this projection when unlinked from the siblings will cause the "test" text node to be considered the last node without inflating it
+ *       "test" // <-- this text node is sharing the same DOM node with the ""
+ *     </Projection>
+ *     "" <-- this text node is sharing the same DOM node with the "test"
+ *   </button>
+ * </Component>
+ * ```
+ */
+const vnode_inflateProjectionTrailingText = (journal, projection) => {
+    // Follow lastChild through any inner virtual wrappers to reach the actual trailing text node.
+    let last = projection;
+    while (last && vnode_isVirtualVNode(last)) {
+        last = last.lastChild;
+    }
+    if (last && vnode_isTextVNode(last) && (last.flags & 8 /* VNodeFlags.Inflated */) === 0) {
+        vnode_ensureTextInflated(journal, last);
+    }
+};
 const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
     if (vnode_isElementOrTextVNode(newChild)) {
         vnode_insertElementBefore(journal, parent, newChild, insertBefore);
@@ -7219,13 +7320,7 @@ const fastGetAttribute = (element, key) => {
     }
     return _fastGetAttribute.call(element, key);
 };
-let _fastNodeType = null;
-const fastNodeType = (node) => {
-    if (!_fastNodeType) {
-        _fastNodeType = fastGetter(node, 'nodeType');
-    }
-    return _fastNodeType.call(node);
-};
+const fastNodeType = createFastGetter('nodeType');
 const fastIsTextOrElement = (node) => {
     const type = fastNodeType(node);
     return type === /* Node.TEXT_NODE */ 3 || type === /* Node.ELEMENT_NODE */ 1;
@@ -7286,13 +7381,7 @@ function getNodeAfterCommentNode(node, commentValue, nextSibling, firstChild) {
     }
     return null;
 }
-let _fastParentNode = null;
-const fastParentNode = (node) => {
-    if (!_fastParentNode) {
-        _fastParentNode = fastGetter(node, 'parentNode');
-    }
-    return _fastParentNode.call(node);
-};
+const fastParentNode = createFastGetter('parentNode');
 let _fastFirstChild = null;
 const fastFirstChild = (node) => {
     if (!_fastFirstChild) {
@@ -7304,34 +7393,9 @@ const fastFirstChild = (node) => {
     }
     return node;
 };
-let _fastNamespaceURI = null;
-const fastNamespaceURI = (element) => {
-    if (!_fastNamespaceURI) {
-        _fastNamespaceURI = fastGetter(element, 'namespaceURI');
-    }
-    return _fastNamespaceURI.call(element);
-};
-let _fastNodeName = null;
-const fastNodeName = (element) => {
-    if (!_fastNodeName) {
-        _fastNodeName = fastGetter(element, 'nodeName');
-    }
-    return _fastNodeName.call(element);
-};
-let _fastOwnerDocument = null;
-const fastOwnerDocument = (node) => {
-    if (!_fastOwnerDocument) {
-        _fastOwnerDocument = fastGetter(node, 'ownerDocument');
-    }
-    return _fastOwnerDocument.call(node);
-};
-const hasQStyleAttribute = (element) => {
-    return (element.nodeName === 'STYLE' &&
-        (element.hasAttribute(QScopedStyle) || element.hasAttribute(QStyle)));
-};
-const hasPropsSeparator = (element) => {
-    return element.hasAttribute(Q_PROPS_SEPARATOR);
-};
+const fastNamespaceURI = createFastGetter('namespaceURI');
+const fastNodeName = createFastGetter('nodeName');
+const fastOwnerDocument = createFastGetter('ownerDocument');
 const materializeFromDOM = (vParent, firstChild, vData) => {
     let vFirstChild = null;
     const skipElements = () => {
@@ -7600,11 +7664,12 @@ const isLowercase = (ch) => /* `a` */ 97 <= ch && ch <= 122; /* `z` */
 function shouldSkipElement(element) {
     return (
     // Skip over elements that don't have a props separator. They are not rendered by Qwik.
-    !hasPropsSeparator(element) ||
+    !element.hasAttribute(Q_PROPS_SEPARATOR) ||
         // We pretend that style element's don't exist as they can get moved out.
         // skip over style elements, as those need to be moved to the head
         // and are not included in the counts.
-        hasQStyleAttribute(element));
+        (element.nodeName === 'STYLE' &&
+            (element.hasAttribute(QScopedStyle) || element.hasAttribute(QStyle))));
 }
 const stack = [];
 function materializeFromVNodeData(vParent, vData, element, child) {
@@ -8572,7 +8637,7 @@ const allocate = (container, typeId, value) => {
         case 28 /* TypeIds.FormData */:
             return new FormData();
         case 29 /* TypeIds.JSXNode */:
-            return new JSXNodeImpl(null, null, null, null, null);
+            return new JSXNodeImpl(null, null, null, null, 0, null);
         case 12 /* TypeIds.BigInt */:
             return BigInt(value);
         case 17 /* TypeIds.Set */:
@@ -8785,13 +8850,13 @@ const _fnSignal = (fn, args, fnStr) => {
  */
 class Serializer {
     $serializationContext$;
-    rootIdx = 0;
-    forwardRefs = [];
-    forwardRefsId = 0;
-    promises = new Set();
-    s11nWeakRefs = new Map();
-    parent;
-    qrlMap = new Map();
+    $rootIdx$ = 0;
+    $forwardRefs$ = [];
+    $forwardRefsId$ = 0;
+    $promises$ = new Set();
+    $s11nWeakRefs$ = new Map();
+    $parent$;
+    $qrlMap$ = new Map();
     $writer$;
     constructor($serializationContext$) {
         this.$serializationContext$ = $serializationContext$;
@@ -8862,7 +8927,7 @@ class Serializer {
     }
     getSeenRefOrOutput(value, index, keepWeak) {
         let seen = this.$serializationContext$.getSeenRef(value);
-        const forwardRefIdx = !keepWeak && this.s11nWeakRefs.get(value);
+        const forwardRefIdx = !keepWeak && this.$s11nWeakRefs$.get(value);
         if (!seen) {
             if (keepWeak) {
                 // we're testing a weakref, so don't mark it as seen yet
@@ -8874,14 +8939,14 @@ class Serializer {
                 seen = this.$serializationContext$.$addRoot$(value, true);
             }
             else {
-                return this.$serializationContext$.$markSeen$(value, this.parent, index);
+                return this.$serializationContext$.$markSeen$(value, this.$parent$, index);
             }
         }
         // Now that we saw it a second time, make sure it's a root
         if (seen.$parent$) {
             // Note, this means it was output before so we always need a backref
             // Special case: we're a root so instead of adding a backref, we replace ourself
-            if (!this.parent) {
+            if (!this.$parent$) {
                 this.$serializationContext$.$promoteToRoot$(seen, index);
                 value = this.$serializationContext$.$roots$[index];
             }
@@ -8891,13 +8956,13 @@ class Serializer {
         }
         // Check if there was a weakref to us
         if (typeof forwardRefIdx === 'number') {
-            this.forwardRefs[forwardRefIdx] = seen.$index$;
-            this.s11nWeakRefs.delete(value);
+            this.$forwardRefs$[forwardRefIdx] = seen.$index$;
+            this.$s11nWeakRefs$.delete(value);
         }
         // Now we know it's a root and we should output a RootRef
         const rootIdx = value instanceof SerializationBackRef ? value.$path$ : seen.$index$;
         // But make sure we do output ourselves
-        if (!this.parent && rootIdx === index) {
+        if (!this.$parent$ && rootIdx === index) {
             return seen;
         }
         this.output(1 /* TypeIds.RootRef */, rootIdx);
@@ -8979,7 +9044,7 @@ class Serializer {
                                 // not a sync QRL, replace all parts with string references
                                 data = `${this.$serializationContext$.$addRoot$(chunk)}#${this.$serializationContext$.$addRoot$(symbol)}${captures ? '#' + captures : ''}`;
                                 // Since we map QRLs to strings, we need to keep track of this secondary mapping
-                                const existing = this.qrlMap.get(data);
+                                const existing = this.$qrlMap$.get(data);
                                 if (existing) {
                                     // We encountered the same QRL again, make it a root
                                     const ref = this.$serializationContext$.$addRoot$(existing);
@@ -8987,7 +9052,7 @@ class Serializer {
                                     return;
                                 }
                                 else {
-                                    this.qrlMap.set(data, value);
+                                    this.$qrlMap$.set(data, value);
                                 }
                             }
                             else {
@@ -9022,11 +9087,11 @@ class Serializer {
                     else {
                         const newSeenRef = this.getSeenRefOrOutput(value, index);
                         if (newSeenRef) {
-                            const oldParent = this.parent;
-                            this.parent = newSeenRef;
+                            const oldParent = this.$parent$;
+                            this.$parent$ = newSeenRef;
                             // separate function for readability
                             this.writeObjectValue(value);
-                            this.parent = oldParent;
+                            this.$parent$ = oldParent;
                         }
                     }
                     break;
@@ -9084,8 +9149,8 @@ class Serializer {
             }
             else {
                 // We replace ourselves with this value
-                const index = this.parent.$index$;
-                this.parent = this.parent.$parent$;
+                const index = this.$parent$.$index$;
+                this.$parent$ = this.$parent$.$parent$;
                 this.writeValue(result, index);
             }
         }
@@ -9300,8 +9365,8 @@ class Serializer {
                 }
                 else if (value.$resolved$) {
                     // We replace ourselves with this value
-                    const index = this.parent.$index$;
-                    this.parent = this.parent.$parent$;
+                    const index = this.$parent$.$index$;
+                    this.$parent$ = this.$parent$.$parent$;
                     this.writeValue(value.$value$, index);
                 }
                 else {
@@ -9325,12 +9390,12 @@ class Serializer {
         else if (value instanceof SerializationWeakRef) {
             const obj = value.$obj$;
             // This will return a fake SeenRef if it's not been seen before
-            if (this.getSeenRefOrOutput(obj, this.parent.$index$, true)) {
-                let forwardRefId = this.s11nWeakRefs.get(obj);
+            if (this.getSeenRefOrOutput(obj, this.$parent$.$index$, true)) {
+                let forwardRefId = this.$s11nWeakRefs$.get(obj);
                 if (forwardRefId === undefined) {
-                    forwardRefId = this.forwardRefsId++;
-                    this.s11nWeakRefs.set(obj, forwardRefId);
-                    this.forwardRefs[forwardRefId] = -1;
+                    forwardRefId = this.$forwardRefsId$++;
+                    this.$s11nWeakRefs$.set(obj, forwardRefId);
+                    this.$forwardRefs$[forwardRefId] = -1;
                 }
                 this.output(2 /* TypeIds.ForwardRef */, forwardRefId);
             }
@@ -9343,56 +9408,56 @@ class Serializer {
         }
     }
     resolvePromise(promise, classCreator) {
-        const forwardRefId = this.forwardRefsId++;
+        const forwardRefId = this.$forwardRefsId$++;
         promise
             .then((resolvedValue) => {
-            this.promises.delete(promise);
-            this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(true, resolvedValue));
+            this.$promises$.delete(promise);
+            this.$forwardRefs$[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(true, resolvedValue));
         })
             .catch((err) => {
-            this.promises.delete(promise);
-            this.forwardRefs[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(false, err));
+            this.$promises$.delete(promise);
+            this.$forwardRefs$[forwardRefId] = this.$serializationContext$.$addRoot$(classCreator(false, err));
         });
-        this.promises.add(promise);
+        this.$promises$.add(promise);
         return forwardRefId;
     }
     async outputRoots() {
         this.$writer$.write(BRACKET_OPEN);
         const { $roots$ } = this.$serializationContext$;
-        while (this.rootIdx < $roots$.length || this.promises.size) {
-            if (this.rootIdx !== 0) {
+        while (this.$rootIdx$ < $roots$.length || this.$promises$.size) {
+            if (this.$rootIdx$ !== 0) {
                 this.$writer$.write(COMMA);
             }
             let separator = false;
-            for (; this.rootIdx < $roots$.length; this.rootIdx++) {
+            for (; this.$rootIdx$ < $roots$.length; this.$rootIdx$++) {
                 if (separator) {
                     this.$writer$.write(COMMA);
                 }
                 else {
                     separator = true;
                 }
-                this.writeValue($roots$[this.rootIdx], this.rootIdx);
+                this.writeValue($roots$[this.$rootIdx$], this.$rootIdx$);
             }
-            if (this.promises.size) {
+            if (this.$promises$.size) {
                 try {
-                    await Promise.race(this.promises);
+                    await Promise.race(this.$promises$);
                 }
                 catch {
                     // ignore rejections, they will be serialized as rejected promises
                 }
             }
         }
-        if (this.forwardRefs.length) {
-            let lastIdx = this.forwardRefs.length - 1;
-            while (lastIdx >= 0 && this.forwardRefs[lastIdx] === -1) {
+        if (this.$forwardRefs$.length) {
+            let lastIdx = this.$forwardRefs$.length - 1;
+            while (lastIdx >= 0 && this.$forwardRefs$[lastIdx] === -1) {
                 lastIdx--;
             }
             if (lastIdx >= 0) {
                 this.$writer$.write(COMMA);
                 this.$writer$.write(14 /* TypeIds.ForwardRefs */ + COMMA);
-                const out = lastIdx === this.forwardRefs.length - 1
-                    ? this.forwardRefs
-                    : this.forwardRefs.slice(0, lastIdx + 1);
+                const out = lastIdx === this.$forwardRefs$.length - 1
+                    ? this.$forwardRefs$
+                    : this.$forwardRefs$.slice(0, lastIdx + 1);
                 // We could also implement RLE of -1 values
                 this.outputArray(out, true, (value) => {
                     this.$writer$.write(String(value));
@@ -9807,7 +9872,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                         appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue);
                     }
                 }
-                const innerHTML = ssr.openElement(type, jsx.key, jsx.varProps, jsx.constProps, options.currentStyleScoped, qwikInspectorAttrValue);
+                const innerHTML = ssr.openElement(type, jsx.key, jsx.varProps, jsx.constProps, options.currentStyleScoped, qwikInspectorAttrValue, !!(jsx.flags & 4 /* JSXNodeFlags.HasCapturedProps */));
                 if (innerHTML) {
                     ssr.htmlNode(innerHTML);
                 }
@@ -10120,7 +10185,7 @@ const isResourceReturn = (obj) => {
 };
 
 /** @internal */
-function setEvent(serializationCtx, key, rawValue, isLoopElement) {
+function setEvent(serializationCtx, key, rawValue, hasMovedCaptures) {
     let value = null;
     const qrls = rawValue;
     const appendToValue = (valueToAppend) => {
@@ -10133,7 +10198,7 @@ function setEvent(serializationCtx, key, rawValue, isLoopElement) {
          *
          * For internal qrls (starting with `_`) we assume that they do the right thing.
          */
-        if (!qrl.$symbol$.startsWith('_') && (qrl.$captures$?.length || isLoopElement)) {
+        if (!qrl.$symbol$.startsWith('_') && (qrl.$captures$?.length || hasMovedCaptures)) {
             qrl = createQRL(null, '_run', _run, null, [qrl]);
         }
         return qrlToString(serializationCtx, qrl);
@@ -10147,7 +10212,7 @@ function setEvent(serializationCtx, key, rawValue, isLoopElement) {
             }
             else if (qrl != null) {
                 // nested arrays etc.
-                const nestedValue = setEvent(serializationCtx, key, qrl, isLoopElement);
+                const nestedValue = setEvent(serializationCtx, key, qrl, hasMovedCaptures);
                 if (nestedValue) {
                     appendToValue(nestedValue);
                 }
@@ -10377,7 +10442,7 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             let owner = d[0];
             if (owner === _UNINITIALIZED) {
-                owner = new JSXNodeImpl(Fragment, d[1], d[2], null, null);
+                owner = new JSXNodeImpl(Fragment, d[1], d[2], null, 0, null);
                 owner._proxy = propsProxy;
             }
             propsProxy[_OWNER] = owner;
@@ -10910,12 +10975,12 @@ class DomContainer extends _SharedContainer {
     qManifestHash;
     rootVNode;
     document;
-    $rawStateData$;
     $storeProxyMap$ = new WeakMap();
     $qFuncs$;
     $instanceHash$;
     $forwardRefs$ = null;
     vNodeLocate = (id) => vnode_locate(this.rootVNode, id);
+    $rawStateData$;
     $stateData$;
     $styleIds$ = null;
     constructor(element) {