@lwc/engine-core 6.1.0 → 6.2.0

package/dist/index.cjs.js

@@ -236,6 +236,7 @@ class ReactiveObserver {
     }
     observe(job) {
         const inceptionReactiveRecord = currentReactiveObserver;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         currentReactiveObserver = this;
         let error;
         try {
@@ -285,6 +286,80 @@ class ReactiveObserver {
         // we keep track of observing records where the observing record was added to so we can do some clean up later on
         shared.ArrayPush.call(this.listeners, reactiveObservers);
     }
+    isObserving() {
+        return currentReactiveObserver === this;
+    }
+}
+
+/*
+ * Copyright (c) 2024, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * This map keeps track of objects to signals. There is an assumption that the signal is strongly referenced
+ * on the object which allows the SignalTracker to be garbage collected along with the object.
+ */
+const TargetToSignalTrackerMap = new WeakMap();
+function getSignalTracker(target) {
+    let signalTracker = TargetToSignalTrackerMap.get(target);
+    if (shared.isUndefined(signalTracker)) {
+        signalTracker = new SignalTracker();
+        TargetToSignalTrackerMap.set(target, signalTracker);
+    }
+    return signalTracker;
+}
+function subscribeToSignal(target, signal, update) {
+    const signalTracker = getSignalTracker(target);
+    if (shared.isFalse(signalTracker.seen(signal))) {
+        signalTracker.subscribeToSignal(signal, update);
+    }
+}
+function unsubscribeFromSignals(target) {
+    if (TargetToSignalTrackerMap.has(target)) {
+        const signalTracker = getSignalTracker(target);
+        signalTracker.unsubscribeFromSignals();
+        signalTracker.reset();
+    }
+}
+/**
+ * This class is used to keep track of the signals associated to a given object.
+ * It is used to prevent the LWC engine from subscribing duplicate callbacks multiple times
+ * to the same signal. Additionally, it keeps track of all signal unsubscribe callbacks, handles invoking
+ * them when necessary and discarding them.
+ */
+class SignalTracker {
+    constructor() {
+        this.signalToUnsubscribeMap = new Map();
+    }
+    seen(signal) {
+        return this.signalToUnsubscribeMap.has(signal);
+    }
+    subscribeToSignal(signal, update) {
+        try {
+            const unsubscribe = signal.subscribe(update);
+            if (shared.isFunction(unsubscribe)) {
+                // TODO [#3978]: Evaluate how we should handle the case when unsubscribe is not a function.
+                // Long term we should throw an error or log a warning.
+                this.signalToUnsubscribeMap.set(signal, unsubscribe);
+            }
+        }
+        catch (err) {
+            logWarnOnce(`Attempted to subscribe to an object that has the shape of a signal but received the following error: ${err?.stack ?? err}`);
+        }
+    }
+    unsubscribeFromSignals() {
+        try {
+            this.signalToUnsubscribeMap.forEach((unsubscribe) => unsubscribe());
+        }
+        catch (err) {
+            logWarnOnce(`Attempted to call a signal's unsubscribe callback but received the following error: ${err?.stack ?? err}`);
+        }
+    }
+    reset() {
+        this.signalToUnsubscribeMap.clear();
+    }
 }
 
 /*
@@ -306,10 +381,26 @@ function componentValueMutated(vm, key) {
         valueMutated(vm.component, key);
     }
 }
-function componentValueObserved(vm, key) {
+function componentValueObserved(vm, key, target = {}) {
+    const { component, tro } = vm;
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
     if (process.env.IS_BROWSER) {
-        valueObserved(vm.component, key);
+        valueObserved(component, key);
+    }
+    // The portion of reactivity that's exposed to signals is to subscribe a callback to re-render the VM (templates).
+    // We check check the following to ensure re-render is subscribed at the correct time.
+    //  1. The template is currently being rendered (there is a template reactive observer)
+    //  2. There was a call to a getter to access the signal (happens during vnode generation)
+    if (lwcRuntimeFlags.ENABLE_EXPERIMENTAL_SIGNALS &&
+        shared.isObject(target) &&
+        !shared.isNull(target) &&
+        'value' in target &&
+        'subscribe' in target &&
+        shared.isFunction(target.subscribe) &&
+        // Only subscribe if a template is being rendered by the engine
+        tro.isObserving()) {
+        // Subscribe the template reactive observer's notify method, which will mark the vm as dirty and schedule hydration.
+        subscribeToSignal(component, target, tro.notify.bind(tro));
     }
 }
 function createReactiveObserver(callback) {
@@ -346,6 +437,7 @@ function addCallbackToNextTick(callback) {
         }
     }
     if (nextTickCallbackQueue.length === 0) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         Promise.resolve().then(flushCallbackQueue);
     }
     shared.ArrayPush.call(nextTickCallbackQueue, callback);
@@ -413,6 +505,29 @@ function assertNotProd() {
         throw new ReferenceError();
     }
 }
+// Temporary fix for when the LWC v5 compiler is used in conjunction with a v6+ engine
+// The old compiler format used the "slot" attribute in the `data` bag, whereas the new
+// format uses the special `slotAssignment` key.
+// This should be removed when the LWC v5 compiler is not used anywhere where it could be mismatched
+// with another LWC engine version.
+// TODO [#3974]: remove temporary logic to support v5 compiler + v6+ engine
+function applyTemporaryCompilerV5SlotFix(data) {
+    if (lwcRuntimeFlags.DISABLE_TEMPORARY_V5_COMPILER_SUPPORT) {
+        return data;
+    }
+    const { attrs } = data;
+    if (!shared.isUndefined(attrs)) {
+        const { slot } = attrs;
+        if (!shared.isUndefined(slot) && !shared.isNull(slot)) {
+            return {
+                ...data,
+                attrs: cloneAndOmitKey(attrs, 'slot'),
+                slotAssignment: String(slot),
+            };
+        }
+    }
+    return data;
+}
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -422,15 +537,20 @@ function assertNotProd() {
  */
 function resolveCircularModuleDependency(fn) {
     const module = fn();
-    return (module === null || module === void 0 ? void 0 : module.__esModule) ? module.default : module;
+    return module?.__esModule ? module.default : module;
 }
 function isCircularModuleDependency(obj) {
     return shared.isFunction(obj) && shared.hasOwnProperty.call(obj, '__circular__');
 }
 
-var _a, _b;
-const instrumentDef = (_a = globalThis.__lwc_instrument_cmp_def) !== null && _a !== void 0 ? _a : shared.noop;
-const instrumentInstance = (_b = globalThis.__lwc_instrument_cmp_instance) !== null && _b !== void 0 ? _b : shared.noop;
+/*
+ * Copyright (c) 2023, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const instrumentDef = globalThis.__lwc_instrument_cmp_def ?? shared.noop;
+const instrumentInstance = globalThis.__lwc_instrument_cmp_instance ?? shared.noop;
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1382,6 +1502,7 @@ function initGlobalStylesheet() {
             }
             return promise;
         });
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         Promise.all(promises).then((stylesheetTexts) => {
             // When replaceSync() is called, the entire contents of the constructable stylesheet are replaced
             // with the copied+concatenated styles. This means that any shadow root's adoptedStyleSheets that
@@ -1493,7 +1614,6 @@ const LightningElement = function () {
         const { assertInstanceOfHTMLElement } = vm.renderer;
         assertInstanceOfHTMLElement(vm.elm, `Component creation requires a DOM element to be associated to ${vm}.`);
     }
-    const component = this;
     shared.setPrototypeOf(elm, bridge.prototype);
     vm.component = this;
     // Locker hooks assignment. When the LWC engine run with Locker, Locker intercepts all the new
@@ -1508,7 +1628,7 @@ const LightningElement = function () {
     }
     markLockerLiveObject(this);
     // Linking elm, shadow root and component with the VM.
-    associateVM(component, vm);
+    associateVM(this, vm);
     associateVM(elm, vm);
     if (vm.renderMode === 1 /* RenderMode.Shadow */) {
         vm.renderRoot = doAttachShadow(vm);
@@ -1932,8 +2052,9 @@ function createObservedFieldPropertyDescriptor(key) {
     return {
         get() {
             const vm = getAssociatedVM(this);
-            componentValueObserved(vm, key);
-            return vm.cmpFields[key];
+            const val = vm.cmpFields[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -2044,6 +2165,7 @@ function createConfigWatcher(component, configCallback, callbackWhenConfigIsRead
         if (hasPendingConfig === false) {
             hasPendingConfig = true;
             // collect new config in the micro-task
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             Promise.resolve().then(() => {
                 hasPendingConfig = false;
                 // resetting current reactive params
@@ -2186,6 +2308,7 @@ function installWireAdapters(vm) {
                 connector.connect();
                 if (!lwcRuntimeFlags.ENABLE_WIRE_SYNC_EMIT) {
                     if (hasDynamicParams) {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         Promise.resolve().then(computeConfigAndUpdate);
                         return;
                     }
@@ -2237,8 +2360,9 @@ function createPublicPropertyDescriptor(key) {
                 }
                 return;
             }
-            componentValueObserved(vm, key);
-            return vm.cmpProps[key];
+            const val = vm.cmpProps[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -2311,8 +2435,9 @@ function internalTrackDecorator(key) {
     return {
         get() {
             const vm = getAssociatedVM(this);
-            componentValueObserved(vm, key);
-            return vm.cmpFields[key];
+            const val = vm.cmpFields[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -3147,10 +3272,15 @@ function createComponentDef(Ctor) {
             logError(`Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
         }
         if (!shared.isUndefined(ctorShadowSupportMode) &&
+            ctorShadowSupportMode !== "any" /* ShadowSupportMode.Any */ &&
             ctorShadowSupportMode !== "reset" /* ShadowSupportMode.Default */ &&
             ctorShadowSupportMode !== "native" /* ShadowSupportMode.Native */) {
             logError(`Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
         }
+        // TODO [#3971]: Completely remove shadowSupportMode "any"
+        if (ctorShadowSupportMode === "any" /* ShadowSupportMode.Any */) {
+            logWarn(`Invalid value 'any' for static property shadowSupportMode. 'any' is deprecated and will be removed in a future release--use 'native' instead.`);
+        }
         if (!shared.isUndefined(ctorRenderMode) &&
             ctorRenderMode !== 'light' &&
             ctorRenderMode !== 'shadow') {
@@ -3181,6 +3311,14 @@ function createComponentDef(Ctor) {
     let shadowSupportMode = superDef.shadowSupportMode;
     if (!shared.isUndefined(ctorShadowSupportMode)) {
         shadowSupportMode = ctorShadowSupportMode;
+        if (isReportingEnabled() &&
+            (shadowSupportMode === "any" /* ShadowSupportMode.Any */ ||
+                shadowSupportMode === "native" /* ShadowSupportMode.Native */)) {
+            report("ShadowSupportModeUsage" /* ReportingEventId.ShadowSupportModeUsage */, {
+                tagName: Ctor.name,
+                mode: shadowSupportMode,
+            });
+        }
     }
     let renderMode = superDef.renderMode;
     if (!shared.isUndefined(ctorRenderMode)) {
@@ -3500,7 +3638,7 @@ function getNearestShadowComponent(vm) {
 function getScopeTokenClass(owner, legacy) {
     const { cmpTemplate, context } = owner;
     return ((context.hasScopedStyles &&
-        (legacy ? cmpTemplate === null || cmpTemplate === void 0 ? void 0 : cmpTemplate.legacyStylesheetToken : cmpTemplate === null || cmpTemplate === void 0 ? void 0 : cmpTemplate.stylesheetToken)) ||
+        (legacy ? cmpTemplate?.legacyStylesheetToken : cmpTemplate?.stylesheetToken)) ||
         null);
 }
 /**
@@ -3627,7 +3765,7 @@ function patchAttributes(oldVnode, vnode, renderer) {
 }
 function patchSlotAssignment(oldVnode, vnode, renderer) {
     const { slotAssignment } = vnode;
-    if ((oldVnode === null || oldVnode === void 0 ? void 0 : oldVnode.slotAssignment) === slotAssignment) {
+    if (oldVnode?.slotAssignment === slotAssignment) {
         return;
     }
     const { elm } = vnode;
@@ -3704,6 +3842,8 @@ function getMapFromClassName(className) {
         return EmptyObject;
     }
     // computed class names must be string
+    // This will throw if className is a symbol or null-prototype object
+    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
     className = shared.isString(className) ? className : className + '';
     let map = classNameToClassMap[className];
     if (map) {
@@ -3784,9 +3924,8 @@ function patchStyleAttribute(oldVnode, vnode, renderer) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 function applyEventListeners(vnode, renderer) {
-    var _a;
     const { elm } = vnode;
-    const on = (_a = vnode.data) === null || _a === void 0 ? void 0 : _a.on;
+    const on = vnode.data?.on;
     if (shared.isUndefined(on)) {
         return;
     }
@@ -3921,7 +4060,7 @@ function traverseAndSetElements(root, parts, renderer) {
  * @param renderer - the renderer to use
  * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
  */
-function applyStaticParts(root, vnode, renderer, mount) {
+function mountStaticParts(root, vnode, renderer) {
     // On the server, we don't support ref (because it relies on renderedCallback), nor do we
     // support event listeners (no interactivity), so traversing parts makes no sense
     if (!process.env.IS_BROWSER) {
@@ -3931,20 +4070,46 @@ function applyStaticParts(root, vnode, renderer, mount) {
     if (shared.isUndefined(parts)) {
         return;
     }
-    // This adds `part.elm` to each `part`. We have to do this on every mount/patch because the `parts`
+    // This adds `part.elm` to each `part`. We have to do this on every mount because the `parts`
     // array is recreated from scratch every time, so each `part.elm` is now undefined.
-    // TODO [#3800]: avoid calling traverseAndSetElements on every re-render
     traverseAndSetElements(root, parts, renderer);
     // Currently only event listeners and refs are supported for static vnodes
     for (const part of parts) {
-        if (mount) {
-            // Event listeners only need to be applied once when mounting
-            applyEventListeners(part, renderer);
-        }
+        // Event listeners only need to be applied once when mounting
+        applyEventListeners(part, renderer);
         // Refs must be updated after every render due to refVNodes getting reset before every render
         applyRefs(part, owner);
     }
 }
+/**
+ * Mounts elements to the newly generated VStatic node
+ *
+ * @param n1 - the previous VStatic vnode
+ * @param n2 - the current VStatic vnode
+ */
+function patchStaticParts(n1, n2) {
+    // On the server, we don't support ref (because it relies on renderedCallback), nor do we
+    // support event listeners (no interactivity), so traversing parts makes no sense
+    if (!process.env.IS_BROWSER) {
+        return;
+    }
+    const { parts: currParts, owner: currPartsOwner } = n2;
+    if (shared.isUndefined(currParts)) {
+        return;
+    }
+    const { parts: prevParts } = n1;
+    if (process.env.NODE_ENV !== 'production') {
+        shared.assert.isTrue(currParts.length === prevParts?.length, 'Expected static parts to be the same for the same element. This is an error with the LWC framework itself.');
+    }
+    for (let i = 0; i < currParts.length; i++) {
+        const part = currParts[i];
+        // Patch only occurs if the vnode is newly generated, which means the part.elm is always undefined
+        // Since the vnode and elements are the same we can safely assume that prevParts[i].elm is defined.
+        part.elm = prevParts[i].elm;
+        // Refs must be updated after every render due to refVNodes getting reset before every render
+        applyRefs(part, currPartsOwner);
+    }
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3961,7 +4126,6 @@ function patchChildren(c1, c2, parent, renderer) {
     }
 }
 function patch(n1, n2, parent, renderer) {
-    var _a, _b;
     if (n1 === n2) {
         return;
     }
@@ -3994,15 +4158,14 @@ function patch(n1, n2, parent, renderer) {
             patchFragment(n1, n2, parent, renderer);
             break;
         case 2 /* VNodeType.Element */:
-            patchElement(n1, n2, (_a = n2.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            patchElement(n1, n2, n2.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
-            patchCustomElement(n1, n2, parent, (_b = n2.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            patchCustomElement(n1, n2, parent, n2.data.renderer ?? renderer);
             break;
     }
 }
 function mount(node, parent, renderer, anchor) {
-    var _a, _b;
     switch (node.type) {
         case 0 /* VNodeType.Text */:
             // VText has no special capability, fallback to the owner's renderer
@@ -4021,11 +4184,11 @@ function mount(node, parent, renderer, anchor) {
             break;
         case 2 /* VNodeType.Element */:
             // If the vnode data has a renderer override use it, else fallback to owner's renderer
-            mountElement(node, parent, anchor, (_a = node.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            mountElement(node, parent, anchor, node.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
             // If the vnode data has a renderer override use it, else fallback to owner's renderer
-            mountCustomElement(node, parent, anchor, (_b = node.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            mountCustomElement(node, parent, anchor, node.data.renderer ?? renderer);
             break;
     }
 }
@@ -4087,11 +4250,11 @@ function mountElement(vnode, parent, anchor, renderer) {
     mountVNodes(vnode.children, elm, renderer, null);
 }
 function patchStatic(n1, n2, renderer) {
-    const elm = (n2.elm = n1.elm);
+    n2.elm = n1.elm;
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(n1, n2, renderer);
     // The `refs` object is blown away in every re-render, so we always need to re-apply them
-    applyStaticParts(elm, n2, renderer, false);
+    patchStaticParts(n1, n2);
 }
 function patchElement(n1, n2, renderer) {
     const elm = (n2.elm = n1.elm);
@@ -4114,7 +4277,7 @@ function mountStatic(vnode, parent, anchor, renderer) {
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(null, vnode, renderer);
     insertNode(elm, parent, anchor, renderer);
-    applyStaticParts(elm, vnode, renderer, true);
+    mountStaticParts(elm, vnode, renderer);
 }
 function mountCustomElement(vnode, parent, anchor, renderer) {
     const { sel, owner, ctor } = vnode;
@@ -4376,17 +4539,15 @@ function applyStyleScoping(elm, owner, renderer) {
     }
 }
 function applyDomManual(elm, vnode) {
-    var _a;
     const { owner, data: { context }, } = vnode;
-    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && ((_a = context === null || context === void 0 ? void 0 : context.lwc) === null || _a === void 0 ? void 0 : _a.dom) === "manual" /* LwcDomMode.Manual */) {
+    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && context?.lwc?.dom === "manual" /* LwcDomMode.Manual */) {
         elm.$domManual$ = true;
     }
 }
 function applyElementRestrictions(elm, vnode) {
-    var _a, _b;
     if (process.env.NODE_ENV !== 'production') {
         const isSynthetic = vnode.owner.shadowMode === 1 /* ShadowMode.Synthetic */;
-        const isPortal = vnode.type === 2 /* VNodeType.Element */ && ((_b = (_a = vnode.data.context) === null || _a === void 0 ? void 0 : _a.lwc) === null || _b === void 0 ? void 0 : _b.dom) === "manual" /* LwcDomMode.Manual */;
+        const isPortal = vnode.type === 2 /* VNodeType.Element */ && vnode.data.context?.lwc?.dom === "manual" /* LwcDomMode.Manual */;
         const isLight = vnode.owner.renderMode === 0 /* RenderMode.Light */;
         patchElementWithRestrictions(elm, {
             isPortal,
@@ -4493,7 +4654,6 @@ function createViewModelHook(elm, vnode, renderer) {
     return vm;
 }
 function allocateInSlot(vm, children, owner) {
-    var _a;
     const { cmpSlots: { slotAssignments: oldSlotsMapping }, } = vm;
     const cmpSlotsMapping = shared.create(null);
     // Collect all slots into cmpSlotsMapping
@@ -4504,7 +4664,7 @@ function allocateInSlot(vm, children, owner) {
         }
         let slotName = '';
         if (isVBaseElement(vnode) || isVStatic(vnode)) {
-            slotName = (_a = vnode.slotAssignment) !== null && _a !== void 0 ? _a : '';
+            slotName = vnode.slotAssignment ?? '';
         }
         else if (isVScopedSlotFragment(vnode)) {
             slotName = vnode.slotName;
@@ -4513,6 +4673,7 @@ function allocateInSlot(vm, children, owner) {
         // but elm.setAttribute('slot', Symbol(1)) is an error.
         // the following line also throws same error for symbols
         // Similar for Object.create(null)
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
         const normalizedSlotName = '' + slotName;
         const vnodes = (cmpSlotsMapping[normalizedSlotName] =
             cmpSlotsMapping[normalizedSlotName] || []);
@@ -4819,6 +4980,8 @@ function h(sel, data, children = EmptyArray) {
             }
         });
     }
+    // TODO [#3974]: remove temporary logic to support v5 compiler + v6+ engine
+    data = applyTemporaryCompilerV5SlotFix(data);
     const { key, slotAssignment } = data;
     const vnode = {
         type: 2 /* VNodeType.Element */,
@@ -4855,6 +5018,8 @@ function s(slotName, data, children, slotset) {
     }
     const vmBeingRendered = getVMBeingRendered();
     const { renderMode, apiVersion } = vmBeingRendered;
+    // TODO [#3974]: remove temporary logic to support v5 compiler + v6+ engine
+    data = applyTemporaryCompilerV5SlotFix(data);
     if (!shared.isUndefined(slotset) &&
         !shared.isUndefined(slotset.slotAssignments) &&
         !shared.isUndefined(slotset.slotAssignments[slotName]) &&
@@ -4906,11 +5071,11 @@ function s(slotName, data, children, slotset) {
                         // to the vnode because the current way the diffing algo works, it will replace the original reference
                         // to the host element with a new one. This means the new element will be mounted and immediately unmounted.
                         // Creating a copy of the vnode to preserve a reference to the previous host element.
-                        clonedVNode = Object.assign(Object.assign({}, vnode), { slotAssignment: data.slotAssignment });
+                        clonedVNode = { ...vnode, slotAssignment: data.slotAssignment };
                     }
                     // If the slot content is standard type, the content is static, no additional
                     // processing needed on the vnode
-                    shared.ArrayPush.call(newChildren, clonedVNode !== null && clonedVNode !== void 0 ? clonedVNode : vnode);
+                    shared.ArrayPush.call(newChildren, clonedVNode ?? vnode);
                 }
             }
         }
@@ -4958,6 +5123,8 @@ function c(sel, Ctor, data, children = EmptyArray) {
             });
         }
     }
+    // TODO [#3974]: remove temporary logic to support v5 compiler + v6+ engine
+    data = applyTemporaryCompilerV5SlotFix(data);
     const { key, slotAssignment } = data;
     let elm, aChildren, vm;
     const vnode = {
@@ -5367,7 +5534,7 @@ function logGlobalOperationStart(opId, vm) {
         start(markName);
     }
     if (isProfilerEnabled) {
-        currentDispatcher(opId, 0 /* Phase.Start */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+        currentDispatcher(opId, 0 /* Phase.Start */, vm?.tagName, vm?.idx, vm?.renderMode, vm?.shadowMode);
     }
 }
 function logGlobalOperationEnd(opId, vm) {
@@ -5377,7 +5544,7 @@ function logGlobalOperationEnd(opId, vm) {
         end(opName, markName);
     }
     if (isProfilerEnabled) {
-        currentDispatcher(opId, 1 /* Phase.Stop */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+        currentDispatcher(opId, 1 /* Phase.Stop */, vm?.tagName, vm?.idx, vm?.renderMode, vm?.shadowMode);
     }
 }
 
@@ -5399,7 +5566,6 @@ function validateSlots(vm) {
     assertNotProd(); // this method should never leak to prod
     const { cmpSlots } = vm;
     for (const slotName in cmpSlots.slotAssignments) {
-        // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
         shared.assert.isTrue(shared.isArray(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${shared.toString(cmpSlots.slotAssignments[slotName])} for slot "${slotName}" in ${vm}.`);
     }
 }
@@ -5697,16 +5863,14 @@ Ctor, metadata) {
     return Ctor;
 }
 function getComponentRegisteredTemplate(Ctor) {
-    var _a;
-    return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.tmpl;
+    return registeredComponentMap.get(Ctor)?.tmpl;
 }
 function getComponentRegisteredName(Ctor) {
-    var _a;
-    return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.sel;
+    return registeredComponentMap.get(Ctor)?.sel;
 }
 function getComponentAPIVersion(Ctor) {
     const metadata = registeredComponentMap.get(Ctor);
-    const apiVersion = metadata === null || metadata === void 0 ? void 0 : metadata.apiVersion;
+    const apiVersion = metadata?.apiVersion;
     if (shared.isUndefined(apiVersion)) {
         // This should only occur in our Karma tests; in practice every component
         // is registered, and so this code path should not get hit. But to be safe,
@@ -5724,11 +5888,27 @@ function getTemplateReactiveObserver(vm) {
         }
     });
 }
+function resetTemplateObserverAndUnsubscribe(vm) {
+    const { tro, component } = vm;
+    tro.reset();
+    // Unsubscribe every time the template reactive observer is reset.
+    if (lwcRuntimeFlags.ENABLE_EXPERIMENTAL_SIGNALS) {
+        unsubscribeFromSignals(component);
+    }
+}
 function renderComponent(vm) {
     if (process.env.NODE_ENV !== 'production') {
         shared.assert.invariant(vm.isDirty, `${vm} is not dirty.`);
     }
-    vm.tro.reset();
+    // The engine should only hold a subscription to a signal if it is rendered in the template.
+    // Because of the potential presence of conditional rendering logic, we unsubscribe on each render
+    // in the scenario where it is present in one condition but not the other.
+    // For example:
+    // 1. There is an lwc:if=true conditional where the signal is present on the template.
+    // 2. The lwc:if changes to false and the signal is no longer present on the template.
+    // If the signal is still subscribed to, the template will re-render when it receives a notification
+    // from the signal, even though we won't be using the new value.
+    resetTemplateObserverAndUnsubscribe(vm);
     const vnodes = invokeComponentRenderMethod(vm);
     vm.isDirty = false;
     vm.isScheduled = false;
@@ -5803,9 +5983,8 @@ function appendVM(vm) {
 function resetComponentStateWhenRemoved(vm) {
     const { state } = vm;
     if (state !== 2 /* VMState.disconnected */) {
-        const { tro } = vm;
         // Making sure that any observing record will not trigger the rehydrated on this vm
-        tro.reset();
+        resetTemplateObserverAndUnsubscribe(vm);
         runDisconnectedCallback(vm);
         // Spec: https://dom.spec.whatwg.org/#concept-node-remove (step 14-15)
         runChildNodesDisconnectedCallback(vm);
@@ -5889,7 +6068,7 @@ function createVM(elm, ctor, renderer, options) {
         vm.debugInfo = shared.create(null);
     }
     vm.stylesheets = computeStylesheets(vm, def.ctor);
-    const computedShadowMode = computeShadowMode(def, vm.owner, renderer);
+    const computedShadowMode = computeShadowMode(def, vm.owner, renderer, hydrated);
     if (lwcRuntimeFlags.ENABLE_FORCE_SHADOW_MIGRATE_MODE) {
         vm.shadowMode = 0 /* ShadowMode.Native */;
         vm.shadowMigrateMode = computedShadowMode === 1 /* ShadowMode.Synthetic */;
@@ -5976,16 +6155,21 @@ function computeShadowAndRenderMode(Ctor, renderer) {
     const def = getComponentInternalDef(Ctor);
     const { renderMode } = def;
     // Assume null `owner` - this is what happens in hydration cases anyway
-    const shadowMode = computeShadowMode(def, /* owner */ null, renderer);
+    // Also assume we are not in hydration mode for this exported API
+    const shadowMode = computeShadowMode(def, /* owner */ null, renderer, false);
     return { renderMode, shadowMode };
 }
-function computeShadowMode(def, owner, renderer) {
+function computeShadowMode(def, owner, renderer, hydrated) {
     // Force the shadow mode to always be native. Used for running tests with synthetic shadow patches
     // on, but components running in actual native shadow mode
     if (process.env.NODE_ENV !== 'production' &&
         lwcRuntimeFlags.ENABLE_FORCE_NATIVE_SHADOW_MODE_FOR_TEST) {
         return 0 /* ShadowMode.Native */;
     }
+    if (shared.isTrue(hydrated)) {
+        // hydration only supports native shadow
+        return 0 /* ShadowMode.Native */;
+    }
     const { isSyntheticShadowDefined } = renderer;
     let shadowMode;
     if (isSyntheticShadowDefined || lwcRuntimeFlags.ENABLE_FORCE_SHADOW_MIGRATE_MODE) {
@@ -6113,7 +6297,7 @@ function flushRehydrationQueue() {
             logGlobalOperationEnd(8 /* OperationId.GlobalRehydrate */);
             // re-throwing the original error will break the current tick, but since the next tick is
             // already scheduled, it should continue patching the rest.
-            throw error; // eslint-disable-line no-unsafe-finally
+            throw error;
         }
     }
     logGlobalOperationEnd(8 /* OperationId.GlobalRehydrate */);
@@ -6586,7 +6770,7 @@ function checkAndReportViolation(elm, prop, isSetter, setValue) {
         setValueType = shared.isNull(setValue) ? 'null' : typeof setValue;
     }
     report("NonStandardAriaReflection" /* ReportingEventId.NonStandardAriaReflection */, {
-        tagName: vm === null || vm === void 0 ? void 0 : vm.tagName,
+        tagName: vm?.tagName,
         propertyName: prop,
         isSetter,
         setValueType,
@@ -6664,7 +6848,6 @@ function hydrateVM(vm) {
     runRenderedCallback(vm);
 }
 function hydrateNode(node, vnode, renderer) {
-    var _a, _b;
     let hydratedNode;
     switch (vnode.type) {
         case 0 /* VNodeType.Text */:
@@ -6684,10 +6867,10 @@ function hydrateNode(node, vnode, renderer) {
             hydratedNode = hydrateFragment(node, vnode, renderer);
             break;
         case 2 /* VNodeType.Element */:
-            hydratedNode = hydrateElement(node, vnode, (_a = vnode.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            hydratedNode = hydrateElement(node, vnode, vnode.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
-            hydratedNode = hydrateCustomElement(node, vnode, (_b = vnode.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            hydratedNode = hydrateCustomElement(node, vnode, vnode.data.renderer ?? renderer);
             break;
     }
     return renderer.nextSibling(hydratedNode);
@@ -6730,7 +6913,6 @@ function getValidationPredicate(optOutStaticProp) {
     return (_attrName) => true;
 }
 function hydrateText(node, vnode, renderer) {
-    var _a;
     if (!hasCorrectNodeType(vnode, node, 3 /* EnvNodeTypes.TEXT */, renderer)) {
         return handleMismatch(node, vnode, renderer);
     }
@@ -6740,12 +6922,11 @@ function hydrateText(node, vnode, renderer) {
         }
     }
     const { setText } = renderer;
-    setText(node, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    setText(node, vnode.text ?? null);
     vnode.elm = node;
     return node;
 }
 function hydrateComment(node, vnode, renderer) {
-    var _a;
     if (!hasCorrectNodeType(vnode, node, 8 /* EnvNodeTypes.COMMENT */, renderer)) {
         return handleMismatch(node, vnode, renderer);
     }
@@ -6757,7 +6938,7 @@ function hydrateComment(node, vnode, renderer) {
         }
     }
     const { setProperty } = renderer;
-    setProperty(node, NODE_VALUE_PROP, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    setProperty(node, NODE_VALUE_PROP, vnode.text ?? null);
     vnode.elm = node;
     return node;
 }
@@ -6767,7 +6948,7 @@ function hydrateStaticElement(elm, vnode, renderer) {
         return handleMismatch(elm, vnode, renderer);
     }
     vnode.elm = elm;
-    applyStaticParts(elm, vnode, renderer, true);
+    mountStaticParts(elm, vnode, renderer);
     return elm;
 }
 function hydrateFragment(elm, vnode, renderer) {
@@ -6792,7 +6973,10 @@ function hydrateElement(elm, vnode, renderer) {
         if (!shared.isUndefined(props) && !shared.isUndefined(props.innerHTML)) {
             if (getProperty(elm, 'innerHTML') === props.innerHTML) {
                 // Do a shallow clone since VNodeData may be shared across VNodes due to hoist optimization
-                vnode.data = Object.assign(Object.assign({}, vnode.data), { props: cloneAndOmitKey(props, 'innerHTML') });
+                vnode.data = {
+                    ...vnode.data,
+                    props: cloneAndOmitKey(props, 'innerHTML'),
+                };
             }
             else {
                 if (process.env.NODE_ENV !== 'production') {
@@ -7004,7 +7188,11 @@ function validateClassAttr(vnode, elm, renderer) {
             className = shared.ArrayJoin.call(classNames, ' ');
         }
         else if (!shared.isUndefined(classMap)) {
-            classMap = Object.assign(Object.assign(Object.assign({}, classMap), (!shared.isNull(scopedToken) ? { [scopedToken]: true } : {})), (!shared.isNull(stylesheetTokenHost) ? { [stylesheetTokenHost]: true } : {}));
+            classMap = {
+                ...classMap,
+                ...(!shared.isNull(scopedToken) ? { [scopedToken]: true } : {}),
+                ...(!shared.isNull(stylesheetTokenHost) ? { [stylesheetTokenHost]: true } : {}),
+            };
         }
         else {
             // The order of the className should be scopedToken stylesheetTokenHost
@@ -7440,5 +7628,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 6.1.0 */
+/** version: 6.2.0 */
 //# sourceMappingURL=index.cjs.js.map