@lwrjs/everywhere 0.12.0-alpha.3 → 0.12.0-alpha.31

package/build/__generated_site_amd_modules__/1/module/amd/1/l/en-US/mi/lwc/v/{5_2_1/s/ccc2929f679182183c24024e0efea4c0 → 6_3_4/s/5c26ade60a97bb24c64d3829320b13f6}/lwc.js

@@ -1,10 +1,10 @@
-LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
+LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
 
   /**
-   * Copyright (C) 2023 salesforce.com, inc.
+   * Copyright (c) 2024 Salesforce, Inc.
    */
   /**
-   * Copyright (C) 2023 salesforce.com, inc.
+   * Copyright (c) 2024 Salesforce, Inc.
    */
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -12,21 +12,40 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
+  /**
+   *
+   * @param value
+   * @param msg
+   */
   function invariant(value, msg) {
     if (!value) {
       throw new Error(`Invariant Violation: ${msg}`);
     }
   }
+  /**
+   *
+   * @param value
+   * @param msg
+   */
   function isTrue$1(value, msg) {
     if (!value) {
       throw new Error(`Assert Violation: ${msg}`);
     }
   }
+  /**
+   *
+   * @param value
+   * @param msg
+   */
   function isFalse$1(value, msg) {
     if (value) {
       throw new Error(`Assert Violation: ${msg}`);
     }
   }
+  /**
+   *
+   * @param msg
+   */
   function fail(msg) {
     throw new Error(msg);
   }
@@ -39,31 +58,50 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   });
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * Copyright (c) 2024, Salesforce, 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 {
+    /** Detached {@linkcode Object.assign}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign MDN Reference}. */
     assign,
+    /** Detached {@linkcode Object.create}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create MDN Reference}. */
     create,
+    /** Detached {@linkcode Object.defineProperties}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties MDN Reference}. */
     defineProperties,
+    /** Detached {@linkcode Object.defineProperty}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty MDN Reference}. */
     defineProperty,
+    /** Detached {@linkcode Object.entries}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries MDN Reference}. */
     entries,
+    /** Detached {@linkcode Object.freeze}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze MDN Reference}. */
     freeze,
+    /** Detached {@linkcode Object.getOwnPropertyDescriptor}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor MDN Reference}. */
     getOwnPropertyDescriptor: getOwnPropertyDescriptor$1,
+    /** Detached {@linkcode Object.getOwnPropertyDescriptors}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors MDN Reference}. */
     getOwnPropertyDescriptors,
+    /** Detached {@linkcode Object.getOwnPropertyNames}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames MDN Reference}. */
     getOwnPropertyNames: getOwnPropertyNames$1,
+    /** Detached {@linkcode Object.getPrototypeOf}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf MDN Reference}. */
     getPrototypeOf: getPrototypeOf$1,
+    /** Detached {@linkcode Object.hasOwnProperty}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty MDN Reference}. */
     hasOwnProperty: hasOwnProperty$1,
+    /** Detached {@linkcode Object.isFrozen}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen MDN Reference}. */
     isFrozen,
+    /** Detached {@linkcode Object.keys}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys MDN Reference}. */
     keys,
+    /** Detached {@linkcode Object.seal}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal MDN Reference}. */
     seal,
+    /** Detached {@linkcode Object.setPrototypeOf}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf MDN Reference}. */
     setPrototypeOf
   } = Object;
+  /** Detached {@linkcode Array.isArray}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray MDN Reference}. */
   const {
     isArray: isArray$1
   } = Array;
+  // For some reason, JSDoc don't get picked up for multiple renamed destructured constants (even
+  // though it works fine for one, e.g. isArray), so comments for these are added to the export
+  // statement, rather than this declaration.
   const {
     concat: ArrayConcat$1,
     copyWithin: ArrayCopyWithin,
@@ -86,7 +124,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     sort: ArraySort,
     splice: ArraySplice,
     unshift: ArrayUnshift,
-    forEach
+    forEach // Weird anomaly!
   } = Array.prototype;
   // The type of the return value of Array.prototype.every is `this is T[]`. However, once this
   // Array method is pulled out of the prototype, the function is now referencing `this` where
@@ -94,12 +132,21 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   //
   // Exposing this helper function is the closest we can get to preserving the usage patterns
   // of Array.prototype methods used elsewhere in the codebase.
+  /**
+   * Wrapper for {@linkcode Array.prototype.every} that correctly preserves the type predicate in the
+   * return value; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every MDN Reference}.
+   * @param arr Array to test.
+   * @param predicate A function to execute for each element of the array.
+   * @returns Whether all elements in the array pass the test provided by the predicate.
+   */
   function arrayEvery(arr, predicate) {
     return ArrayEvery.call(arr, predicate);
   }
+  /** Detached {@linkcode String.fromCharCode}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode MDN Reference}. */
   const {
     fromCharCode: StringFromCharCode
   } = String;
+  // No JSDocs here - see comment for Array.prototype
   const {
     charCodeAt: StringCharCodeAt,
     replace: StringReplace,
@@ -107,52 +154,124 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     slice: StringSlice,
     toLowerCase: StringToLowerCase
   } = String.prototype;
+  /**
+   * Determines whether the argument is `undefined`.
+   * @param obj Value to test
+   * @returns `true` if the value is `undefined`.
+   */
   function isUndefined$1(obj) {
     return obj === undefined;
   }
+  /**
+   * Determines whether the argument is `null`.
+   * @param obj Value to test
+   * @returns `true` if the value is `null`.
+   */
   function isNull(obj) {
     return obj === null;
   }
+  /**
+   * Determines whether the argument is `true`.
+   * @param obj Value to test
+   * @returns `true` if the value is `true`.
+   */
   function isTrue(obj) {
     return obj === true;
   }
+  /**
+   * Determines whether the argument is `false`.
+   * @param obj Value to test
+   * @returns `true` if the value is `false`.
+   */
   function isFalse(obj) {
     return obj === false;
   }
+  /**
+   * Determines whether the argument is a boolean.
+   * @param obj Value to test
+   * @returns `true` if the value is a boolean.
+   */
   function isBoolean(obj) {
     return typeof obj === 'boolean';
   }
+  /**
+   * Determines whether the argument is a function.
+   * @param obj Value to test
+   * @returns `true` if the value is a function.
+   */
+  // Replacing `Function` with a narrower type that works for all our use cases is tricky...
+  // eslint-disable-next-line @typescript-eslint/ban-types
   function isFunction$1(obj) {
     return typeof obj === 'function';
   }
+  /**
+   * Determines whether the argument is an object or null.
+   * @param obj Value to test
+   * @returns `true` if the value is an object or null.
+   */
   function isObject(obj) {
     return typeof obj === 'object';
   }
+  /**
+   * Determines whether the argument is a string.
+   * @param obj Value to test
+   * @returns `true` if the value is a string.
+   */
   function isString(obj) {
     return typeof obj === 'string';
   }
+  /**
+   * Determines whether the argument is a number.
+   * @param obj Value to test
+   * @returns `true` if the value is a number.
+   */
   function isNumber(obj) {
     return typeof obj === 'number';
   }
+  /** Does nothing! 🚀 */
   function noop() {
     /* Do nothing */
   }
   const OtS$1 = {}.toString;
+  /**
+   * Converts the argument to a string, safely accounting for objects with "null" prototype.
+   * Note that `toString(null)` returns `"[object Null]"` rather than `"null"`.
+   * @param obj Value to convert to a string.
+   * @returns String representation of the value.
+   */
   function toString$1(obj) {
-    if (obj && obj.toString) {
+    if (obj?.toString) {
       // Arrays might hold objects with "null" prototype So using
       // Array.prototype.toString directly will cause an error Iterate through
       // all the items and handle individually.
       if (isArray$1(obj)) {
+        // This behavior is slightly different from Array#toString:
+        // 1. Array#toString calls `this.join`, rather than Array#join
+        // Ex: arr = []; arr.join = () => 1; arr.toString() === 1; toString(arr) === ''
+        // 2. Array#toString delegates to Object#toString if `this.join` is not a function
+        // Ex: arr = []; arr.join = 'no'; arr.toString() === '[object Array]; toString(arr) = ''
+        // 3. Array#toString converts null/undefined to ''
+        // Ex: arr = [null, undefined]; arr.toString() === ','; toString(arr) === '[object Null],undefined'
+        // 4. Array#toString converts recursive references to arrays to ''
+        // Ex: arr = [1]; arr.push(arr, 2); arr.toString() === '1,,2'; toString(arr) throws
+        // Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString
         return ArrayJoin.call(ArrayMap.call(obj, toString$1), ',');
       }
       return obj.toString();
     } else if (typeof obj === 'object') {
+      // This catches null and returns "[object Null]". Weird, but kept for backwards compatibility.
       return OtS$1.call(obj);
     } else {
-      return obj + '';
+      return String(obj);
     }
   }
+  /**
+   * Gets the property descriptor for the given object and property key. Similar to
+   * {@linkcode Object.getOwnPropertyDescriptor}, but looks up the prototype chain.
+   * @param o Value to get the property descriptor for
+   * @param p Property key to get the descriptor for
+   * @returns The property descriptor for the given object and property key.
+   */
   function getPropertyDescriptor(o, p) {
     do {
       const d = getOwnPropertyDescriptor$1(o, p);
@@ -173,16 +292,25 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   // It's a bit annoying to do have to do this manually, but this makes the file tree-shakeable,
   // passing the `verify-treeshakeable.js` test.
   const LOWEST_API_VERSION = 58 /* APIVersion.V58_244_SUMMER_23 */;
+  /**
+   *
+   * @param apiVersionFeature
+   * @param apiVersion
+   */
   function isAPIFeatureEnabled(apiVersionFeature, apiVersion) {
     switch (apiVersionFeature) {
       case 0 /* APIFeature.LOWERCASE_SCOPE_TOKENS */:
       case 1 /* APIFeature.TREAT_ALL_PARSE5_ERRORS_AS_ERRORS */:
         return apiVersion >= 59 /* APIVersion.V59_246_WINTER_24 */;
-      case 2 /* APIFeature.USE_FRAGMENTS_FOR_LIGHT_DOM_SLOTS */:
       case 3 /* APIFeature.DISABLE_OBJECT_REST_SPREAD_TRANSFORMATION */:
       case 4 /* APIFeature.SKIP_UNNECESSARY_REGISTER_DECORATORS */:
       case 5 /* APIFeature.USE_COMMENTS_FOR_FRAGMENT_BOOKENDS */:
+      case 2 /* APIFeature.USE_FRAGMENTS_FOR_LIGHT_DOM_SLOTS */:
         return apiVersion >= 60 /* APIVersion.V60_248_SPRING_24 */;
+      case 8 /* APIFeature.ENABLE_ELEMENT_INTERNALS_AND_FACE */:
+      case 7 /* APIFeature.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE */:
+      case 6 /* APIFeature.USE_LIGHT_DOM_SLOT_FORWARDING */:
+        return apiVersion >= 61 /* APIVersion.V61_250_SUMMER_24 */;
     }
   }
 
@@ -226,18 +354,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   // This includes aria-* attributes as well as the special non-ARIA "for" attribute
   const ID_REFERENCING_ATTRIBUTES_SET = /*@__PURE__*/new Set(['aria-activedescendant', 'aria-controls', 'aria-describedby', 'aria-details', 'aria-errormessage', 'aria-flowto', 'aria-labelledby', 'aria-owns', 'for']);
 
-  /*
-   * Copyright (c) 2018, 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
-   */
-  // See browser support for globalThis:
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
-  /* istanbul ignore next */
-  // @ts-ignore
-  const _globalThis = typeof globalThis === 'object' ? globalThis : window;
-
   /*
    * Copyright (c) 2023, Salesforce.com, inc.
    * All rights reserved.
@@ -268,6 +384,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * Map associating previously transformed HTML property into HTML attribute.
    */
   const CACHED_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/new Map();
+  /**
+   *
+   * @param propName
+   */
   function htmlPropertyToAttribute(propName) {
     const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
     if (!isUndefined$1(ariaAttributeName)) {
@@ -300,6 +420,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * Map associating previously transformed kabab-case attributes into camel-case props.
    */
   const CACHED_KEBAB_CAMEL_MAPPING = /*@__PURE__@*/new Map();
+  /**
+   *
+   * @param attrName
+   */
   function kebabCaseToCamelCase(attrName) {
     let result = CACHED_KEBAB_CAMEL_MAPPING.get(attrName);
     if (isUndefined$1(result)) {
@@ -316,44 +440,47 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // Increment whenever the LWC template compiler changes
-  const LWC_VERSION = "5.2.1";
+  const LWC_VERSION = "6.3.4";
   const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-  /** version: 5.2.1 */
+  /** version: 6.3.4 */
 
   /**
-   * Copyright (C) 2023 salesforce.com, inc.
+   * Copyright (c) 2024 Salesforce, Inc.
    */
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * Copyright (c) 2024, Salesforce, 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
    */
   // When deprecating a feature flag, ensure that it is also no longer set in the application. For
   // example, in core, the flag should be removed from LwcPermAndPrefUtilImpl.java
+  /** List of all feature flags available, with the default value `null`. */
   const features = {
     PLACEHOLDER_TEST_FLAG: null,
-    ENABLE_FORCE_NATIVE_SHADOW_MODE_FOR_TEST: null,
-    ENABLE_MIXED_SHADOW_MODE: null,
-    ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE: null,
+    DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE: null,
     ENABLE_WIRE_SYNC_EMIT: null,
     DISABLE_LIGHT_DOM_UNSCOPED_CSS: null,
     ENABLE_FROZEN_TEMPLATE: null,
     ENABLE_LEGACY_SCOPE_TOKENS: null,
-    ENABLE_FORCE_SHADOW_MIGRATE_MODE: null
+    ENABLE_FORCE_SHADOW_MIGRATE_MODE: null,
+    ENABLE_EXPERIMENTAL_SIGNALS: null
   };
-  // eslint-disable-next-line no-restricted-properties
-  if (!_globalThis.lwcRuntimeFlags) {
-    Object.defineProperty(_globalThis, 'lwcRuntimeFlags', {
+  if (!globalThis.lwcRuntimeFlags) {
+    Object.defineProperty(globalThis, 'lwcRuntimeFlags', {
       value: create(null)
     });
   }
-  // eslint-disable-next-line no-restricted-properties
-  const flags = _globalThis.lwcRuntimeFlags;
+  /** Feature flags that have been set. */
+  const flags = globalThis.lwcRuntimeFlags;
   /**
    * Set the value at runtime of a given feature flag. This method only be invoked once per feature
    * flag. It is meant to be used during the app initialization.
+   * @param name Name of the feature flag to set
+   * @param value Whether the feature flag should be enabled
+   * @throws Will throw if a non-boolean value is provided when running in production.
+   * @example setFeatureFlag("DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE", true)
    */
   function setFeatureFlag(name, value) {
     if (!isBoolean(value)) {
@@ -391,6 +518,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * Set the value at runtime of a given feature flag. This method should only be used for testing
    * purposes. It is a no-op when invoked in production mode.
+   * @param name Name of the feature flag to enable or disable
+   * @param value Whether the feature flag should be enabled
+   * @example setFeatureFlag("DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE", true)
    */
   function setFeatureFlagForTest(name, value) {
     // This may seem redundant, but `process.env.NODE_ENV === 'test-karma-lwc'` is replaced by Karma tests
@@ -398,10 +528,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       setFeatureFlag(name, value);
     }
   }
-  /** version: 5.2.1 */
+  /** version: 6.3.4 */
 
   /**
-   * Copyright (C) 2023 salesforce.com, inc.
+   * Copyright (c) 2024 Salesforce, Inc.
    */
 
   /*
@@ -423,8 +553,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   const reportingControl = {
     /**
      * Attach a new reporting control (aka dispatcher).
-     *
-     * @param dispatcher - reporting control
+     * @param dispatcher reporting control
      */
     attachDispatcher(dispatcher) {
       enabled$1 = true;
@@ -465,7 +594,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * Report to the current dispatcher, if there is one.
    * @param reportingEventId
-   * @param payload - data to report
+   * @param payload data to report
    */
   function report(reportingEventId, payload) {
     if (enabled$1) {
@@ -527,7 +656,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * Copyright (c) 2024, Salesforce, 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
@@ -535,7 +664,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   const alreadyLoggedMessages = new Set();
   // Only used in LWC's Karma tests
   if (process.env.NODE_ENV === 'test-karma-lwc') {
-    // @ts-ignore
     window.__lwcResetAlreadyLoggedMessages = () => {
       alreadyLoggedMessages.clear();
     };
@@ -628,6 +756,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     observe(job) {
       const inceptionReactiveRecord = currentReactiveObserver;
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
       currentReactiveObserver = this;
       let error;
       try {
@@ -676,6 +805,78 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       // we keep track of observing records where the observing record was added to so we can do some clean up later on
       ArrayPush$1.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 (isUndefined$1(signalTracker)) {
+      signalTracker = new SignalTracker();
+      TargetToSignalTrackerMap.set(target, signalTracker);
+    }
+    return signalTracker;
+  }
+  function subscribeToSignal(target, signal, update) {
+    const signalTracker = getSignalTracker(target);
+    if (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 (isFunction$1(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();
+    }
   }
   function componentValueMutated(vm, key) {
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
@@ -683,10 +884,24 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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.
     {
-      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 && isObject(target) && !isNull(target) && 'value' in target && 'subscribe' in target && isFunction$1(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) {
@@ -723,6 +938,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     }
     if (nextTickCallbackQueue.length === 0) {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       Promise.resolve().then(flushCallbackQueue);
     }
     ArrayPush$1.call(nextTickCallbackQueue, callback);
@@ -733,6 +949,14 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
   }
+  function shouldUseNativeCustomElementLifecycle(ctor) {
+    if (lwcRuntimeFlags.DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      // temporary "kill switch"
+      return false;
+    }
+    const apiVersion = getComponentAPIVersion(ctor);
+    return isAPIFeatureEnabled(7 /* APIFeature.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE */, apiVersion);
+  }
   // Borrowed from Vue template compiler.
   // https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
   const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
@@ -779,6 +1003,16 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       throw new ReferenceError();
     }
   }
+  function shouldBeFormAssociated(Ctor) {
+    const ctorFormAssociated = Boolean(Ctor.formAssociated);
+    const apiVersion = getComponentAPIVersion(Ctor);
+    const apiFeatureEnabled = isAPIFeatureEnabled(8 /* APIFeature.ENABLE_ELEMENT_INTERNALS_AND_FACE */, apiVersion);
+    if (process.env.NODE_ENV !== 'production' && ctorFormAssociated && !apiFeatureEnabled) {
+      const tagName = getComponentRegisteredName(Ctor);
+      logWarnOnce(`Component <${tagName}> set static formAssociated to true, but form ` + `association is not enabled because the API version is ${apiVersion}. To enable form association, ` + `update the LWC component API version to 61 or above. https://lwc.dev/guide/versioning`);
+    }
+    return ctorFormAssociated && apiFeatureEnabled;
+  }
 
   /*
    * Copyright (c) 2020, salesforce.com, inc.
@@ -788,14 +1022,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    */
   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 isFunction$1(obj) && hasOwnProperty$1.call(obj, '__circular__');
   }
-  var _a, _b;
-  const instrumentDef = (_a = _globalThis.__lwc_instrument_cmp_def) !== null && _a !== void 0 ? _a : noop;
-  const instrumentInstance = (_b = _globalThis.__lwc_instrument_cmp_instance) !== null && _b !== void 0 ? _b : noop;
 
   /*
    * Copyright (c) 2023, salesforce.com, inc.
@@ -803,37 +1034,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  // Apply ARIA string reflection behavior to a prototype.
-  // This is deliberately kept separate from @lwc/aria-reflection. @lwc/aria-reflection is a global polyfill that is
-  // needed for backwards compatibility in LEX, whereas `applyAriaReflection` is designed to only apply to our own
-  // LightningElement/BaseBridgeElement prototypes.
-  function applyAriaReflection(prototype) {
-    for (const propName of keys(AriaPropNameToAttrNameMap)) {
-      const attrName = AriaPropNameToAttrNameMap[propName];
-      if (isUndefined$1(getOwnPropertyDescriptor$1(prototype, propName))) {
-        // Note that we need to call this.{get,set,has,remove}Attribute rather than dereferencing
-        // from Element.prototype, because these methods are overridden in LightningElement.
-        defineProperty(prototype, propName, {
-          get() {
-            return this.getAttribute(attrName);
-          },
-          set(newValue) {
-            // TODO [#3284]: there is disagreement between browsers and the spec on how to treat undefined
-            // Our historical behavior is to only treat null as removing the attribute
-            // See also https://github.com/w3c/aria/issues/1858
-            if (isNull(newValue)) {
-              this.removeAttribute(attrName);
-            } else {
-              this.setAttribute(attrName, newValue);
-            }
-          },
-          // configurable and enumerable to allow it to be overridden – this mimics Safari's/Chrome's behavior
-          configurable: true,
-          enumerable: true
-        });
-      }
-    }
-  }
+  const instrumentDef = globalThis.__lwc_instrument_cmp_def ?? noop;
+  const instrumentInstance = globalThis.__lwc_instrument_cmp_instance ?? noop;
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -846,6 +1048,43 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   const HTMLElementConstructor = typeof HTMLElement !== 'undefined' ? HTMLElement : function () {};
   const HTMLElementPrototype = HTMLElementConstructor.prototype;
 
+  /*
+   * 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
+   */
+  // Apply ARIA string reflection behavior to a prototype.
+  // This is deliberately kept separate from @lwc/aria-reflection. @lwc/aria-reflection is a global polyfill that is
+  // needed for backwards compatibility in LEX, whereas this is designed to only apply to our own
+  // LightningElement/BaseBridgeElement prototypes.
+  // Note we only need to handle ARIA reflections that aren't already in Element.prototype
+  const ariaReflectionPolyfillDescriptors = create(null);
+  for (const [propName, attrName] of entries(AriaPropNameToAttrNameMap)) {
+    if (isUndefined$1(getPropertyDescriptor(HTMLElementPrototype, propName))) {
+      // Note that we need to call this.{get,set,has,remove}Attribute rather than dereferencing
+      // from Element.prototype, because these methods are overridden in LightningElement.
+      ariaReflectionPolyfillDescriptors[propName] = {
+        get() {
+          return this.getAttribute(attrName);
+        },
+        set(newValue) {
+          // TODO [#3284]: there is disagreement between browsers and the spec on how to treat undefined
+          // Our historical behavior is to only treat null as removing the attribute
+          // See also https://github.com/w3c/aria/issues/1858
+          if (isNull(newValue)) {
+            this.removeAttribute(attrName);
+          } else {
+            this.setAttribute(attrName, newValue);
+          }
+        },
+        // configurable and enumerable to allow it to be overridden – this mimics Safari's/Chrome's behavior
+        configurable: true,
+        enumerable: true
+      };
+    }
+  }
+
   /*
    * Copyright (c) 2018, salesforce.com, inc.
    * All rights reserved.
@@ -892,7 +1131,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  /* eslint @lwc/lwc-internal/no-production-assert: "off" */
   function generateDataDescriptor(options) {
     return assign({
       configurable: true,
@@ -1039,7 +1277,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
             logError('The `addEventListener` method on ShadowRoot does not support any options.', getAssociatedVMIfPresent(this));
           }
           // Typescript does not like it when you treat the `arguments` object as an array
-          // @ts-ignore type-mismatch
+          // @ts-expect-error type-mismatch
           return originalAddEventListener.apply(this, arguments);
         }
       })
@@ -1088,34 +1326,12 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
             logError('The `addEventListener` method in `LightningElement` does not support any options.', getAssociatedVMIfPresent(this));
           }
           // Typescript does not like it when you treat the `arguments` object as an array
-          // @ts-ignore type-mismatch
+          // @ts-expect-error type-mismatch
           return originalAddEventListener.apply(this, arguments);
         }
       })
     };
   }
-  function getLightningElementPrototypeRestrictionsDescriptors(proto) {
-    assertNotProd(); // this method should never leak to prod
-    const originalDispatchEvent = proto.dispatchEvent;
-    return {
-      dispatchEvent: generateDataDescriptor({
-        value(event) {
-          const vm = getAssociatedVM(this);
-          if (!isNull(event) && isObject(event)) {
-            const {
-              type
-            } = event;
-            if (!/^[a-z][a-z0-9_]*$/.test(type)) {
-              logError(`Invalid event type "${type}" dispatched in element ${getComponentTag(vm)}.` + ` Event name must start with a lowercase letter and followed only lowercase` + ` letters, numbers, and underscores`, vm);
-            }
-          }
-          // Typescript does not like it when you treat the `arguments` object as an array
-          // @ts-ignore type-mismatch
-          return originalDispatchEvent.apply(this, arguments);
-        }
-      })
-    };
-  }
   // This routine will prevent access to certain properties on a shadow root instance to guarantee
   // that all components will work fine in IE11 and other browsers without shadow dom support.
   function patchShadowRootWithRestrictions(sr) {
@@ -1126,9 +1342,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     const elmProto = getPrototypeOf$1(elm);
     setPrototypeOf(elm, create(elmProto, restrictionsDescriptors));
   }
-  function patchLightningElementPrototypeWithRestrictions(proto) {
-    defineProperties(proto, getLightningElementPrototypeRestrictionsDescriptors(proto));
-  }
   function updateComponentValue(vm, key, newValue) {
     const {
       cmpFields
@@ -1505,7 +1718,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       valueMutated(originalTarget, key);
       return true;
     }
-    /*LWC compiler v5.2.1*/
+    /*LWC compiler v6.3.4*/
   }
   const getterMap = new WeakMap();
   const setterMap = new WeakMap();
@@ -1598,7 +1811,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       /* istanbul ignore next */
       return false;
     }
-    /*LWC compiler v5.2.1*/
+    /*LWC compiler v6.3.4*/
   }
   function extract(objectOrArray) {
     if (isArray(objectOrArray)) {
@@ -1784,6 +1997,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * EXPERIMENTAL: This function implements an unwrap mechanism that
    * works for observable membrane objects. This API is subject to
    * change or being removed.
+   * @param value
    */
   function unwrap(value) {
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
@@ -1852,6 +2066,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         }
         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
@@ -1896,6 +2111,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * that a Custom Element can support (including AOM properties), which
    * determines what kind of capabilities the Base Lightning Element should support. When producing the new descriptors
    * for the Base Lightning Element, it also include the reactivity bit, so the standard property is reactive.
+   * @param propName
+   * @param descriptor
    */
   function createBridgeToElementDescriptor(propName, descriptor) {
     const {
@@ -1950,8 +2167,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * This class is the base class for any LWC element.
    * Some elements directly extends this class, others implement it via inheritance.
-   **/
-  // @ts-ignore
+   */
+  // @ts-expect-error When exported, it will conform, but we need to build it first!
   const LightningElement = function () {
     // This should be as performant as possible, while any initialization should be done lazily
     if (isNull(vmBeingConstructed)) {
@@ -1975,7 +2192,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       } = vm.renderer;
       assertInstanceOfHTMLElement(vm.elm, `Component creation requires a DOM element to be associated to ${vm}.`);
     }
-    const component = this;
     setPrototypeOf(elm, bridge.prototype);
     vm.component = this;
     // Locker hooks assignment. When the LWC engine run with Locker, Locker intercepts all the new
@@ -1994,7 +2210,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     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);
@@ -2039,69 +2255,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       logError(`this.${methodOrPropName} should not be called during the construction of the custom element for ${getComponentTag(vm)} because the element is not yet in the DOM or has no children yet.`);
     }
   }
-  // List of properties on ElementInternals that are formAssociated can be found in the spec:
-  // https://html.spec.whatwg.org/multipage/custom-elements.html#form-associated-custom-elements
-  const formAssociatedProps = new Set(['setFormValue', 'form', 'setValidity', 'willValidate', 'validity', 'validationMessage', 'checkValidity', 'reportValidity', 'labels']);
-  // Verify that access to a form-associated property of the ElementInternals proxy has formAssociated set in the LWC.
-  function verifyPropForFormAssociation(propertyKey, isFormAssociated) {
-    if (isString(propertyKey) && formAssociatedProps.has(propertyKey) && !isFormAssociated) {
-      //Note this error message mirrors Chrome and Firefox error messages, in Safari the error is slightly different.
-      throw new DOMException(`Failed to execute '${propertyKey}' on 'ElementInternals': The target element is not a form-associated custom element.`);
-    }
-  }
-  const elementInternalsAccessorAllowList = new Set(['shadowRoot', 'role', ...formAssociatedProps]);
-  // Prevent access to properties not defined in the HTML spec in case browsers decide to
-  // provide new APIs that provide access to form associated properties.
-  // This can be removed along with UpgradeableConstructor.
-  function isAllowedElementInternalAccessor(propertyKey) {
-    let isAllowedAccessor = false;
-    // As of this writing all ElementInternal property keys as described in the spec are implemented with strings
-    // in Chrome, Firefox, and Safari
-    if (isString(propertyKey)) {
-      // Allow list is based on HTML spec:
-      // https://html.spec.whatwg.org/multipage/custom-elements.html#the-elementinternals-interface
-      isAllowedAccessor = elementInternalsAccessorAllowList.has(propertyKey) || /^aria/.test(propertyKey);
-      if (!isAllowedAccessor && process.env.NODE_ENV !== 'production') {
-        logWarn('Only properties defined in the ElementInternals HTML spec are available.');
-      }
-    }
-    return isAllowedAccessor;
-  }
-  // Wrap all ElementInternal objects in a proxy to prevent form association when `formAssociated` is not set on an LWC.
-  // This is needed because the 1UpgradeableConstructor1 always sets `formAssociated=true`, which means all
-  // ElementInternal objects will have form-associated properties set when an LWC is placed in a form.
-  // We are doing this to guard against customers taking a dependency on form elements being associated to ElementInternals
-  // when 'formAssociated' has not been set on the LWC.
-  function createElementInternalsProxy(elementInternals, isFormAssociated) {
-    const elementInternalsProxy = new Proxy(elementInternals, {
-      set(target, propertyKey, newValue) {
-        if (isAllowedElementInternalAccessor(propertyKey)) {
-          // Verify that formAssociated is set for form associated properties
-          verifyPropForFormAssociation(propertyKey, isFormAssociated);
-          return Reflect.set(target, propertyKey, newValue);
-        }
-        // As of this writing ElementInternals do not have non-string properties that can be set.
-        return false;
-      },
-      get(target, propertyKey) {
-        if (
-        // Pass through Object.prototype methods such as toString()
-        hasOwnProperty$1.call(Object.prototype, propertyKey) ||
-        // As of this writing, ElementInternals only uses Symbol.toStringTag which is called
-        // on Object.hasOwnProperty invocations
-        Symbol.for('Symbol.toStringTag') === propertyKey ||
-        // ElementInternals allow listed properties
-        isAllowedElementInternalAccessor(propertyKey)) {
-          // Verify that formAssociated is set for form associated properties
-          verifyPropForFormAssociation(propertyKey, isFormAssociated);
-          const propertyValue = Reflect.get(target, propertyKey);
-          return isFunction$1(propertyValue) ? propertyValue.bind(target) : propertyValue;
-        }
-      }
-    });
-    return elementInternalsProxy;
-  }
-  // @ts-ignore
+  // Type assertion because we need to build the prototype before it satisfies the interface.
   LightningElement.prototype = {
     constructor: LightningElement,
     dispatchEvent(event) {
@@ -2254,19 +2408,18 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       const vm = getAssociatedVM(this);
       const {
         elm,
-        def: {
-          formAssociated
-        },
+        apiVersion,
         renderer: {
           attachInternals
         }
       } = vm;
+      if (!isAPIFeatureEnabled(8 /* APIFeature.ENABLE_ELEMENT_INTERNALS_AND_FACE */, apiVersion)) {
+        throw new Error(`The attachInternals API is only supported in API version 61 and above. ` + `The current version is ${apiVersion}. ` + `To use this API, update the LWC component API version. https://lwc.dev/guide/versioning`);
+      }
       if (vm.shadowMode === 1 /* ShadowMode.Synthetic */) {
-        throw new Error('attachInternals API is not supported in light DOM or synthetic shadow.');
+        throw new Error('attachInternals API is not supported in synthetic shadow.');
       }
-      const internals = attachInternals(elm);
-      // #TODO[2970]: remove proxy once `UpgradeableConstructor` has been removed
-      return createElementInternalsProxy(internals, Boolean(formAssociated));
+      return attachInternals(elm);
     },
     get isConnected() {
       const vm = getAssociatedVM(this);
@@ -2378,6 +2531,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       if (process.env.NODE_ENV !== 'production') {
         warnIfInvokedDuringConstruction(vm, 'childNodes');
       }
+      // getChildNodes returns a NodeList, which has `item(index: number): Node | null`.
+      // NodeListOf<T> extends NodeList, but claims to not return null. That seems inaccurate,
+      // but these are built-in types, so ultimately not our problem.
       return renderer.getChildNodes(vm.elm);
     },
     get firstChild() {
@@ -2462,11 +2618,17 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   for (const propName in HTMLElementOriginalDescriptors) {
     lightningBasedDescriptors[propName] = createBridgeToElementDescriptor(propName, HTMLElementOriginalDescriptors[propName]);
   }
-  defineProperties(LightningElement.prototype, lightningBasedDescriptors);
   // Apply ARIA reflection to LightningElement.prototype, on both the browser and server.
   // This allows `this.aria*` property accessors to work from inside a component, and to reflect `aria-*` attrs.
   // Note this works regardless of whether the global ARIA reflection polyfill is applied or not.
-  applyAriaReflection(LightningElement.prototype);
+  {
+    // In the browser, we use createBridgeToElementDescriptor, so we can get the normal reactivity lifecycle for
+    // aria* properties
+    for (const [propName, descriptor] of entries(ariaReflectionPolyfillDescriptors)) {
+      lightningBasedDescriptors[propName] = createBridgeToElementDescriptor(propName, descriptor);
+    }
+  }
+  defineProperties(LightningElement.prototype, lightningBasedDescriptors);
   defineProperty(LightningElement, 'CustomElementConstructor', {
     get() {
       // If required, a runtime-specific implementation must be defined.
@@ -2474,15 +2636,13 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     },
     configurable: true
   });
-  if (process.env.NODE_ENV !== 'production') {
-    patchLightningElementPrototypeWithRestrictions(LightningElement.prototype);
-  }
   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);
@@ -2501,11 +2661,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    */
   const AdapterToTokenMap = new Map();
   function createContextProviderWithRegister(adapter, registerContextProvider) {
-    let adapterContextToken = AdapterToTokenMap.get(adapter);
-    if (!isUndefined$1(adapterContextToken)) {
+    if (AdapterToTokenMap.has(adapter)) {
       throw new Error(`Adapter already has a context provider.`);
     }
-    adapterContextToken = guid();
+    const adapterContextToken = guid();
     AdapterToTokenMap.set(adapter, adapterContextToken);
     const providers = new WeakSet();
     return (elmOrComponent, options) => {
@@ -2610,6 +2769,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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
@@ -2624,7 +2784,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       ro.observe(() => config = configCallback(component));
       // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
       // TODO: dev-mode validation of config based on the adapter.configSchema
-      // @ts-ignore it is assigned in the observe() callback
+      // @ts-expect-error it is assigned in the observe() callback
       callbackWhenConfigIsReady(config);
     };
     return {
@@ -2708,7 +2868,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       });
     }
     return {
-      // @ts-ignore the boundary protection executes sync, connector is always defined
+      // @ts-expect-error the boundary protection executes sync, connector is always defined
       connector,
       computeConfigAndUpdate,
       resetConfigWatcher: () => ro.reset()
@@ -2769,6 +2929,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
           connector.connect();
           if (!lwcRuntimeFlags.ENABLE_WIRE_SYNC_EMIT) {
             if (hasDynamicParams) {
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
               Promise.resolve().then(computeConfigAndUpdate);
               return;
             }
@@ -2824,8 +2985,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
           }
           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);
@@ -2902,8 +3064,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     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);
@@ -2931,9 +3094,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   /**
-   * @wire decorator to wire fields and methods to a wire adapter in
+   * The @wire decorator wires fields and methods to a wire adapter in
    * LWC Components. This function implements the internals of this
    * decorator.
+   * @param _adapter
+   * @param _config
    */
   function wire(_adapter, _config) {
     if (process.env.NODE_ENV !== 'production') {
@@ -3041,6 +3206,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * INTERNAL: This function can only be invoked by compiled code. The compiler
    * will prevent this function from being imported by user-land code.
+   * @param Ctor
+   * @param meta
    */
   function registerDecorators(Ctor, meta) {
     const proto = Ctor.prototype;
@@ -3202,7 +3369,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   let warned = false;
   // Only used in LWC's Karma tests
   if (process.env.NODE_ENV === 'test-karma-lwc') {
-    // @ts-ignore
     window.__lwcResetWarnedOnVersionMismatch = () => {
       warned = false;
     };
@@ -3236,6 +3402,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * INTERNAL: This function can only be invoked by compiled code. The compiler
    * will prevent this function from being imported by userland code.
+   * @param tpl
    */
   function registerTemplate(tpl) {
     if (process.env.NODE_ENV !== 'production') {
@@ -3249,6 +3416,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
    * libraries to sanitize vulnerable attributes.
+   * @param tagName
+   * @param namespaceUri
+   * @param attrName
+   * @param attrValue
    */
   function sanitizeAttribute(tagName, namespaceUri, attrName, attrValue) {
     // locker-service patches this function during runtime to sanitize vulnerable attributes. When
@@ -3321,7 +3492,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         if (!isUndefined$1(superAttributeChangedCallback)) {
           // delegate unknown attributes to the super.
           // Typescript does not like it when you treat the `arguments` object as an array
-          // @ts-ignore type-mismatch
+          // @ts-expect-error type-mismatch
           superAttributeChangedCallback.apply(this, arguments);
         }
         return;
@@ -3347,7 +3518,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
   function HTMLBridgeElementFactory(SuperClass, publicProperties, methods, observedFields, proto, hasCustomSuperClass) {
     const HTMLBridgeElement = class extends SuperClass {
-      /*LWC compiler v5.2.1*/
+      /*LWC compiler v6.3.4*/
     };
     // generating the hash table for attributes to avoid duplicate fields and facilitate validation
     // and false positives in case of inheritance.
@@ -3372,7 +3543,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         // and can break tooling that expects it to be iterable or defined, e.g. Jest:
         // https://github.com/jestjs/jest/blob/b4c9587/packages/pretty-format/src/plugins/DOMElement.ts#L95
         // It also doesn't make sense to override e.g. "constructor".
-        .filter(propName => !(propName in HTMLElementPrototype)));
+        .filter(propName => !(propName in HTMLElementPrototype) && !(propName in ariaReflectionPolyfillDescriptors)));
         for (const propName of nonPublicPropertiesToWarnOn) {
           if (ArrayIndexOf.call(publicProperties, propName) === -1) {
             descriptors[propName] = createAccessorThatWarns(propName);
@@ -3442,21 +3613,19 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     defineProperties(HTMLBridgeElement.prototype, descriptors);
     return HTMLBridgeElement;
   }
-  const BaseBridgeElement = HTMLBridgeElementFactory(HTMLElementConstructor, getOwnPropertyNames$1(HTMLElementOriginalDescriptors), [], [], null, false);
-  {
-    // This ARIA reflection only really makes sense in the browser. On the server, there is no `renderedCallback()`,
-    // so you cannot do e.g. `this.template.querySelector('x-child').ariaBusy = 'true'`. So we don't need to expose
-    // ARIA props outside the LightningElement
-    //
-    // Apply ARIA reflection to HTMLBridgeElement.prototype. This allows `elm.aria*` property accessors to work from
-    // outside a component, and to reflect `aria-*` attrs. This is especially important because the template compiler
-    // compiles aria-* attrs on components to aria* props.
-    // Note this works regardless of whether the global ARIA reflection polyfill is applied or not.
-    //
-    // Also note that we apply this to BaseBridgeElement.prototype to avoid excessively redefining property
-    // accessors inside the HTMLBridgeElementFactory.
-    applyAriaReflection(BaseBridgeElement.prototype);
-  }
+  // We do some special handling of non-standard ARIA props like ariaLabelledBy as well as props without (as of this
+  // writing) broad cross-browser support like ariaBrailleLabel. This is so the reflection works correctly and preserves
+  // backwards compatibility with the previous global polyfill approach.
+  //
+  // The goal here is to expose `elm.aria*` property accessors to work from outside a component, and to reflect `aria-*`
+  // attrs. This is especially important because the template compiler compiles aria-* attrs on components to aria* props.
+  // Note this works regardless of whether the global ARIA reflection polyfill is applied or not.
+  //
+  // Also note this ARIA reflection only really makes sense in the browser. On the server, there is no
+  // `renderedCallback()`, so you cannot do e.g. `this.template.querySelector('x-child').ariaBusy = 'true'`. So we don't
+  // need to expose ARIA props outside the LightningElement
+  const basePublicProperties = [...getOwnPropertyNames$1(HTMLElementOriginalDescriptors), ...getOwnPropertyNames$1(ariaReflectionPolyfillDescriptors)];
+  const BaseBridgeElement = HTMLBridgeElementFactory(HTMLElementConstructor, basePublicProperties, [], [], null, false);
   freeze(BaseBridgeElement);
   seal(BaseBridgeElement.prototype);
 
@@ -3756,6 +3925,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       if (!isUndefined$1(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 (!isUndefined$1(ctorRenderMode) && ctorRenderMode !== 'light' && ctorRenderMode !== 'shadow') {
         logError(`Invalid value for static property renderMode: '${ctorRenderMode}'. renderMode must be either 'light' or 'shadow'.`);
       }
@@ -3801,6 +3974,12 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     let shadowSupportMode = superDef.shadowSupportMode;
     if (!isUndefined$1(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 (!isUndefined$1(ctorRenderMode)) {
@@ -3846,6 +4025,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
    * subject to change or being removed.
+   * @param ctor
    */
   function isComponentConstructor(ctor) {
     if (!isFunction$1(ctor)) {
@@ -3919,6 +4099,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
    * subject to change or being removed.
+   * @param Ctor
    */
   function getComponentDef(Ctor) {
     const def = getComponentInternalDef(Ctor);
@@ -4133,6 +4314,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * If the component that is currently being rendered uses scoped styles,
    * this returns the unique token for that scoped stylesheet. Otherwise
    * it returns null.
+   * @param owner
+   * @param legacy
    */
   // TODO [#3733]: remove support for legacy scope tokens
   function getScopeTokenClass(owner, legacy) {
@@ -4140,13 +4323,14 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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) || null;
+    return context.hasScopedStyles && (legacy ? cmpTemplate?.legacyStylesheetToken : cmpTemplate?.stylesheetToken) || null;
   }
   /**
    * This function returns the host style token for a custom element if it
    * exists. Otherwise it returns null.
    *
    * A host style token is applied to the component if scoped styles are used.
+   * @param vnode
    */
   function getStylesheetTokenHost(vnode) {
     const {
@@ -4223,6 +4407,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   function isVScopedSlotFragment(vnode) {
     return vnode.type === 6 /* VNodeType.ScopedSlotFragment */;
   }
+  function isVStatic(vnode) {
+    return vnode.type === 4 /* VNodeType.Static */;
+  }
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -4276,6 +4463,26 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     }
   }
+  function patchSlotAssignment(oldVnode, vnode, renderer) {
+    const {
+      slotAssignment
+    } = vnode;
+    if (oldVnode?.slotAssignment === slotAssignment) {
+      return;
+    }
+    const {
+      elm
+    } = vnode;
+    const {
+      setAttribute,
+      removeAttribute
+    } = renderer;
+    if (isUndefined$1(slotAssignment) || isNull(slotAssignment)) {
+      removeAttribute(elm, 'slot');
+    } else {
+      setAttribute(elm, 'slot', slotAssignment);
+    }
+  }
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -4347,6 +4554,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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 = isString(className) ? className : className + '';
     let map = classNameToClassMap[className];
     if (map) {
@@ -4441,11 +4650,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * 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 (isUndefined$1(on)) {
       return;
     }
@@ -4597,13 +4805,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
   /**
    * Given an array of static parts, do all the mounting required for these parts.
-   *
-   * @param root - the root element
-   * @param vnode - the parent VStatic
-   * @param renderer - the renderer to use
-   * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
+   * @param root the root element
+   * @param vnode the parent VStatic
+   * @param renderer the renderer to use
    */
-  function applyStaticParts(root, vnode, renderer, mount) {
+  function mountStaticParts(root, vnode, renderer) {
     const {
       parts,
       owner
@@ -4611,20 +4817,45 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     if (isUndefined$1(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) {
+    const {
+      parts: currParts,
+      owner: currPartsOwner
+    } = n2;
+    if (isUndefined$1(currParts)) {
+      return;
+    }
+    const {
+      parts: prevParts
+    } = n1;
+    if (process.env.NODE_ENV !== 'production') {
+      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.
@@ -4640,7 +4871,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
   }
   function patch(n1, n2, parent, renderer) {
-    var _a, _b;
     if (n1 === n2) {
       return;
     }
@@ -4676,15 +4906,14 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         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
@@ -4703,11 +4932,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         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;
     }
   }
@@ -4789,9 +5018,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     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;
@@ -4819,13 +5050,16 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         elm[KEY__SHADOW_STATIC] = true;
       }
     }
+    // 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
+      owner,
+      ctor
     } = vnode;
     const {
       createCustomElement
@@ -4846,7 +5080,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     // compiler may generate tagnames with uppercase letters so - for backwards
     // compatibility, we lower case the tagname here.
     const normalizedTagname = sel.toLowerCase();
-    const elm = createCustomElement(normalizedTagname, upgradeCallback);
+    const useNativeLifecycle = shouldUseNativeCustomElementLifecycle(ctor);
+    const isFormAssociated = shouldBeFormAssociated(ctor);
+    const elm = createCustomElement(normalizedTagname, upgradeCallback, useNativeLifecycle, isFormAssociated);
     vnode.elm = elm;
     vnode.vm = vm;
     linkNodeToShadow(elm, owner, renderer);
@@ -4858,7 +5094,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     insertNode(elm, parent, anchor, renderer);
     if (vm) {
       {
-        if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+        if (!useNativeLifecycle) {
           if (process.env.NODE_ENV !== 'production') {
             // With synthetic lifecycle callbacks, it's possible for elements to be removed without the engine
             // noticing it (e.g. `appendChild` the same host element twice). This test ensures we don't regress.
@@ -5063,6 +5299,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     patchStyleAttribute(oldVnode, vnode, renderer);
     patchAttributes(oldVnode, vnode, renderer);
     patchProps(oldVnode, vnode, renderer);
+    patchSlotAssignment(oldVnode, vnode, renderer);
     // The `refs` object is blown away in every re-render, so we always need to re-apply them
     applyRefs(vnode, vnode.owner);
   }
@@ -5103,22 +5340,20 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
   }
   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,
@@ -5173,6 +5408,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * With the delimiters removed, the contents are marked dynamic so they are diffed correctly.
    *
    * This function is used for slotted VFragments to avoid the text delimiters interfering with slotting functionality.
+   * @param children
    */
   function flattenFragmentsInChildren(children) {
     const flattenedChildren = [];
@@ -5231,7 +5467,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     return vm;
   }
   function allocateInSlot(vm, children, owner) {
-    var _a, _b;
     const {
       cmpSlots: {
         slotAssignments: oldSlotsMapping
@@ -5245,8 +5480,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         continue;
       }
       let slotName = '';
-      if (isVBaseElement(vnode)) {
-        slotName = (_b = (_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : '';
+      if (isVBaseElement(vnode) || isVStatic(vnode)) {
+        slotName = vnode.slotAssignment ?? '';
       } else if (isVScopedSlotFragment(vnode)) {
         slotName = vnode.slotName;
       }
@@ -5254,6 +5489,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       // 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] || [];
       ArrayPush$1.call(vnodes, vnode);
@@ -5502,7 +5738,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       elm: undefined,
       fragment,
       owner,
-      parts
+      parts,
+      slotAssignment: undefined
     };
     return vnode;
   }
@@ -5545,7 +5782,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       });
     }
     const {
-      key
+      key,
+      slotAssignment
     } = data;
     const vnode = {
       type: 2 /* VNodeType.Element */,
@@ -5554,7 +5792,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       children,
       elm: undefined,
       key,
-      owner: vmBeingRendered
+      owner: vmBeingRendered,
+      slotAssignment
     };
     return vnode;
   }
@@ -5579,6 +5818,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       assert.isTrue(isObject(data), `s() 2nd argument data must be an object.`);
       assert.isTrue(isArray$1(children), `h() 3rd argument children must be an array.`);
     }
+    const vmBeingRendered = getVMBeingRendered();
+    const {
+      renderMode,
+      apiVersion
+    } = vmBeingRendered;
     if (!isUndefined$1(slotset) && !isUndefined$1(slotset.slotAssignments) && !isUndefined$1(slotset.slotAssignments[slotName]) && slotset.slotAssignments[slotName].length !== 0) {
       const newChildren = [];
       const slotAssignments = slotset.slotAssignments[slotName];
@@ -5598,7 +5842,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
           }
           // If the passed slot content is factory, evaluate it and add the produced vnodes
           if (assignedNodeIsScopedSlot) {
-            const vmBeingRenderedInception = getVMBeingRendered();
             // Evaluate in the scope of the slot content's owner
             // if a slotset is provided, there will always be an owner. The only case where owner is
             // undefined is for root components, but root components cannot accept slotted content
@@ -5613,22 +5856,34 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
                 ArrayPush$1.call(newChildren, vnode.factory(data.slotData, data.key));
               });
             } finally {
-              setVMBeingRendered(vmBeingRenderedInception);
+              setVMBeingRendered(vmBeingRendered);
             }
           } else {
+            // This block is for standard slots (non-scoped slots)
+            let clonedVNode;
+            if (renderMode === 0 /* RenderMode.Light */ && isAPIFeatureEnabled(6 /* APIFeature.USE_LIGHT_DOM_SLOT_FORWARDING */, apiVersion) && (isVBaseElement(vnode) || isVStatic(vnode)) &&
+            // We only need to copy the vnodes when the slot assignment changes, copying every time causes issues with
+            // disconnected/connected callback firing.
+            vnode.slotAssignment !== data.slotAssignment) {
+              // When the light DOM slot assignment (slot attribute) changes we can't use the same reference
+              // 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 = {
+                ...vnode,
+                slotAssignment: data.slotAssignment
+              };
+            }
             // If the slot content is standard type, the content is static, no additional
             // processing needed on the vnode
-            ArrayPush$1.call(newChildren, vnode);
+            ArrayPush$1.call(newChildren, clonedVNode ?? vnode);
           }
         }
       }
       children = newChildren;
     }
-    const vmBeingRendered = getVMBeingRendered();
     const {
-      renderMode,
-      shadowMode,
-      apiVersion
+      shadowMode
     } = vmBeingRendered;
     if (renderMode === 0 /* RenderMode.Light */) {
       // light DOM slots - backwards-compatible behavior uses flattening, new behavior uses fragments
@@ -5668,7 +5923,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     }
     const {
-      key
+      key,
+      slotAssignment
     } = data;
     let elm, aChildren, vm;
     const vnode = {
@@ -5678,6 +5934,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       children,
       elm,
       key,
+      slotAssignment,
       ctor: Ctor,
       owner: vmBeingRendered,
       mode: 'open',
@@ -5760,6 +6017,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
   /**
    * [f]lattening
+   * @param items
    */
   function f(items) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5881,6 +6139,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
    *
    * TODO [#3331]: remove usage of lwc:dynamic in 246
+   * @param sel
+   * @param Ctor
+   * @param data
+   * @param children
    */
   function ddc(sel, Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5899,6 +6161,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
   /**
    * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+   * @param Ctor
+   * @param data
+   * @param children
    */
   function dc(Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5926,13 +6191,13 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * to the engine that a particular collection of children must be diffed using the slow
    * algo based on keys due to the nature of the list. E.g.:
    *
-   *   - slot element's children: the content of the slot has to be dynamic when in synthetic
-   *                              shadow mode because the `vnode.children` might be the slotted
-   *                              content vs default content, in which case the size and the
-   *                              keys are not matching.
-   *   - children that contain dynamic components
-   *   - children that are produced by iteration
-   *
+   * - slot element's children: the content of the slot has to be dynamic when in synthetic
+   * shadow mode because the `vnode.children` might be the slotted
+   * content vs default content, in which case the size and the
+   * keys are not matching.
+   * - children that contain dynamic components
+   * - children that are produced by iteration
+   * @param vnodes
    */
   function sc(vnodes) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5956,6 +6221,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   };
   /**
    * Sets the sanitizeHtmlContentHook.
+   * @param newHookImpl
    */
   function setSanitizeHtmlContentHook(newHookImpl) {
     sanitizeHtmlContentHook = newHookImpl;
@@ -6068,7 +6334,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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) {
@@ -6078,7 +6344,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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);
     }
   }
 
@@ -6102,7 +6368,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       cmpSlots
     } = vm;
     for (const slotName in cmpSlots.slotAssignments) {
-      // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
       assert.isTrue(isArray$1(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${toString$1(cmpSlots.slotAssignments[slotName])} for slot "${slotName}" in ${vm}.`);
     }
   }
@@ -6121,9 +6386,27 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     }
   }
+  // This should be a no-op outside of LWC's Karma tests, where it's not needed
+  let registerFragmentCache = noop;
+  // Only used in LWC's Karma tests
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
+    // Keep track of fragmentCaches, so we can clear them in LWC's Karma tests
+    const fragmentCaches = [];
+    registerFragmentCache = fragmentCache => {
+      fragmentCaches.push(fragmentCache);
+    };
+    window.__lwcResetFragmentCaches = () => {
+      for (const fragmentCache of fragmentCaches) {
+        for (const key of keys(fragmentCache)) {
+          delete fragmentCache[key];
+        }
+      }
+    };
+  }
   function buildParseFragmentFn(createFragmentFn) {
     return (strings, ...keys) => {
       const cache = create(null);
+      registerFragmentCache(cache);
       return function () {
         const {
           context: {
@@ -6144,11 +6427,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         if (hasStyleToken && isSyntheticShadow) {
           cacheKey |= 2 /* FragmentCache.SHADOW_MODE_SYNTHETIC */;
         }
-        if (hasLegacyToken) {
-          // This isn't strictly required for prod, but it's required for our karma tests
-          // since the lwcRuntimeFlag may change over time
-          cacheKey |= 4 /* FragmentCache.HAS_LEGACY_SCOPE_TOKEN */;
-        }
         if (!isUndefined$1(cache[cacheKey])) {
           return cache[cacheKey];
         }
@@ -6201,7 +6479,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   });
   function evaluateTemplate(vm, html) {
     if (process.env.NODE_ENV !== 'production') {
-      assert.isTrue(isFunction$1(html), `evaluateTemplate() second argument must be an imported template instead of ${toString$1(html)}`);
       // in dev-mode, we support hot swapping of templates, which means that
       // the component instance might be attempting to use an old version of
       // the template, while internally, we have a replacement for it.
@@ -6226,6 +6503,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       tro.observe(() => {
         // Reset the cache memoizer for template when needed.
         if (html !== cmpTemplate) {
+          // Check that the template was built by the compiler.
+          if (!isTemplateRegistered(html)) {
+            throw new TypeError(`Invalid template returned by the render() method on ${vm.tagName}. It must return an imported template (e.g.: \`import html from "./${vm.def.name}.html"\`), instead, it has returned: ${toString$1(html)}.`);
+          }
           if (process.env.NODE_ENV !== 'production') {
             validateLightDomTemplate(html, vm);
           }
@@ -6237,10 +6518,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
             // and snabbdom just rely on the IDs.
             resetComponentRoot(vm);
           }
-          // Check that the template was built by the compiler.
-          if (!isTemplateRegistered(html)) {
-            throw new TypeError(`Invalid template returned by the render() method on ${vm}. It must return an imported template (e.g.: \`import html from "./${vm.def.name}.html"\`), instead, it has returned: ${toString$1(html)}.`);
-          }
           vm.cmpTemplate = html;
           // Create a brand new template cache for the swapped templated.
           context.tplCache = create(null);
@@ -6417,6 +6694,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * INTERNAL: This function can only be invoked by compiled code. The compiler
    * will prevent this function from being imported by userland code.
+   * @param Ctor
+   * @param metadata
    */
   function registerComponent(
   // We typically expect a LightningElementConstructor, but technically you can call this with anything
@@ -6435,16 +6714,14 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     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 (isUndefined$1(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,
@@ -6464,11 +6741,30 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     });
   }
+  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') {
       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;
@@ -6499,7 +6795,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2023, Salesforce.com, inc.
+   * Copyright (c) 2024, Salesforce, 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
@@ -6545,11 +6841,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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);
@@ -6560,7 +6853,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   // old vnode.children is removed from the DOM.
   function removeVM(vm) {
     if (process.env.NODE_ENV !== 'production') {
-      if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      if (!shouldUseNativeCustomElementLifecycle(vm.component.constructor)) {
         // With native lifecycle, we cannot be certain that connectedCallback was called before a component
         // was removed from the VDOM. If the component is disconnected, then connectedCallback will not fire
         // in native mode, although it will fire in synthetic mode due to appendChild triggering it.
@@ -6640,7 +6933,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       vm.debugInfo = 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 */;
@@ -6728,45 +7021,44 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       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) {
+    if (
     // 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) {
+    process.env.NODE_ENV === 'test-karma-lwc' && process.env.FORCE_NATIVE_SHADOW_MODE_FOR_TEST ||
+    // hydration only supports native shadow
+    isTrue(hydrated)) {
       return 0 /* ShadowMode.Native */;
     }
     const {
       isSyntheticShadowDefined
     } = renderer;
     let shadowMode;
-    // If ENABLE_FORCE_SHADOW_MIGRATE_MODE is true, then ShadowMode.Synthetic here will mean "force-migrate" mode.
     if (isSyntheticShadowDefined || lwcRuntimeFlags.ENABLE_FORCE_SHADOW_MIGRATE_MODE) {
       if (def.renderMode === 0 /* RenderMode.Light */) {
         // ShadowMode.Native implies "not synthetic shadow" which is consistent with how
         // everything defaults to native when the synthetic shadow polyfill is unavailable.
         shadowMode = 0 /* ShadowMode.Native */;
-      } else if (lwcRuntimeFlags.ENABLE_MIXED_SHADOW_MODE || def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
-        if (def.shadowSupportMode === "any" /* ShadowSupportMode.Any */ || def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
+      } else if (def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
+        shadowMode = 0 /* ShadowMode.Native */;
+      } else {
+        const shadowAncestor = getNearestShadowAncestor(owner);
+        if (!isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
+          // Transitive support for native Shadow DOM. A component in native mode
+          // transitively opts all of its descendants into native.
           shadowMode = 0 /* ShadowMode.Native */;
         } else {
-          const shadowAncestor = getNearestShadowAncestor(owner);
-          if (!isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
-            // Transitive support for native Shadow DOM. A component in native mode
-            // transitively opts all of its descendants into native.
-            shadowMode = 0 /* ShadowMode.Native */;
-          } else {
-            // Synthetic if neither this component nor any of its ancestors are configured
-            // to be native.
-            shadowMode = 1 /* ShadowMode.Synthetic */;
-          }
+          // Synthetic if neither this component nor any of its ancestors are configured
+          // to be native.
+          shadowMode = 1 /* ShadowMode.Synthetic */;
         }
-      } else {
-        shadowMode = 1 /* ShadowMode.Synthetic */;
       }
     } else {
       // Native if the synthetic shadow polyfill is unavailable.
@@ -6775,7 +7067,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     return shadowMode;
   }
   function assertIsVM(obj) {
-    if (isNull(obj) || !isObject(obj) || !('renderRoot' in obj)) {
+    if (!isObject(obj) || isNull(obj) || !('renderRoot' in obj)) {
       throw new TypeError(`${obj} is not a VM.`);
     }
   }
@@ -6874,7 +7166,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         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 */);
@@ -6900,7 +7192,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     // This test only makes sense in the browser, with synthetic lifecycle, and when reporting is enabled or
     // we're in dev mode. This is to detect a particular issue with synthetic lifecycle.
-    if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE && (process.env.NODE_ENV !== 'production' || isReportingEnabled())) {
+    if (!shouldUseNativeCustomElementLifecycle(vm.component.constructor) && (process.env.NODE_ENV !== 'production' || isReportingEnabled())) {
       if (!vm.renderer.isConnected(vm.elm)) {
         if (process.env.NODE_ENV !== 'production') {
           logWarnOnce(`Element <${vm.tagName}> ` + `fired a \`connectedCallback\` and rendered, but was not connected to the DOM. ` + `Please ensure all components are actually connected to the DOM, e.g. using ` + `\`document.body.appendChild(element)\`. This will not be supported in future versions of ` + `LWC and could cause component errors. For details, see: https://sfdc.co/synthetic-lifecycle`);
@@ -6978,6 +7270,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * need to continue into its children because by attempting to disconnect the
    * custom element itself will trigger the removal of anything slotted or anything
    * defined on its shadow.
+   * @param vnodes
    */
   function recursivelyDisconnectChildren(vnodes) {
     for (let i = 0, len = vnodes.length; i < len; i += 1) {
@@ -7097,18 +7390,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   function runFormAssociatedCustomElementCallback(vm, faceCb) {
     const {
       renderMode,
-      shadowMode,
-      def: {
-        formAssociated
-      }
+      shadowMode
     } = vm;
-    // Technically the UpgradableConstructor always sets `static formAssociated = true` but silently fail here to match browser behavior.
-    if (isUndefined$1(formAssociated) || isFalse(formAssociated)) {
-      if (process.env.NODE_ENV !== 'production') {
-        logWarn(`Form associated lifecycle methods must have the 'static formAssociated' value set in the component's prototype chain.`);
-      }
-      return;
-    }
     if (shadowMode === 1 /* ShadowMode.Synthetic */ && renderMode !== 0 /* RenderMode.Light */) {
       throw new Error('Form associated lifecycle methods are not available in synthetic shadow. Please use native shadow or light DOM.');
     }
@@ -7170,12 +7453,12 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   // See: https://sfdc.co/synthetic-aria
   //
   // Use the unpatched native getElementById/querySelectorAll rather than the synthetic one
-  const getElementById = _globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID];
-  const querySelectorAll = _globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL];
+  const getElementById = globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID];
+  const querySelectorAll = globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL];
   // This is a "handoff" from synthetic-shadow to engine-core – we want to clean up after ourselves
   // so nobody else can misuse these global APIs.
-  delete _globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID];
-  delete _globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL];
+  delete globalThis[KEY__NATIVE_GET_ELEMENT_BY_ID];
+  delete globalThis[KEY__NATIVE_QUERY_SELECTOR_ALL];
   function isSyntheticShadowRootInstance(rootNode) {
     return rootNode !== document && isTrue(rootNode.synthetic);
   }
@@ -7363,7 +7646,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       setValueType = 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
@@ -7384,7 +7667,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
           throw new Error('detect-non-standard-aria.ts loaded before @lwc/aria-reflection');
         }
       }
-      // @ts-ignore
       const {
         get,
         set
@@ -7448,7 +7730,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     runRenderedCallback(vm);
   }
   function hydrateNode(node, vnode, renderer) {
-    var _a, _b;
     let hydratedNode;
     switch (vnode.type) {
       case 0 /* VNodeType.Text */:
@@ -7468,10 +7749,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         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);
@@ -7516,7 +7797,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     return _attrName => true;
   }
   function hydrateText(node, vnode, renderer) {
-    var _a;
     if (!hasCorrectNodeType(vnode, node, 3 /* EnvNodeTypes.TEXT */, renderer)) {
       return handleMismatch(node, vnode, renderer);
     }
@@ -7528,12 +7808,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     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);
     }
@@ -7549,7 +7828,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     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;
   }
@@ -7558,7 +7837,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       return handleMismatch(elm, vnode, renderer);
     }
     vnode.elm = elm;
-    applyStaticParts(elm, vnode, renderer, true);
+    mountStaticParts(elm, vnode, renderer);
     return elm;
   }
   function hydrateFragment(elm, vnode, renderer) {
@@ -7595,9 +7874,10 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       if (!isUndefined$1(props) && !isUndefined$1(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), {
+          vnode.data = {
+            ...vnode.data,
             props: cloneAndOmitKey(props, 'innerHTML')
-          });
+          };
         } else {
           if (process.env.NODE_ENV !== 'production') {
             logWarn(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: innerHTML values do not match for element, will recover from the difference`, owner);
@@ -7641,7 +7921,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       defineCustomElement,
       getTagName
     } = renderer;
-    defineCustomElement(StringToLowerCase.call(getTagName(elm)));
+    const isFormAssociated = shouldBeFormAssociated(ctor);
+    defineCustomElement(StringToLowerCase.call(getTagName(elm)), isFormAssociated);
     const vm = createVM(elm, ctor, renderer, {
       mode,
       owner,
@@ -7844,11 +8125,15 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         const classNames = ArrayFilter.call(classTokens, token => !isNull(token));
         className = ArrayJoin.call(classNames, ' ');
       } else if (!isUndefined$1(classMap)) {
-        classMap = Object.assign(Object.assign(Object.assign({}, classMap), !isNull(scopedToken) ? {
-          [scopedToken]: true
-        } : {}), !isNull(stylesheetTokenHost) ? {
-          [stylesheetTokenHost]: true
-        } : {});
+        classMap = {
+          ...classMap,
+          ...(!isNull(scopedToken) ? {
+            [scopedToken]: true
+          } : {}),
+          ...(!isNull(stylesheetTokenHost) ? {
+            [stylesheetTokenHost]: true
+          } : {})
+        };
       } else {
         // The order of the className should be scopedToken stylesheetTokenHost
         const classTokens = [scopedToken, stylesheetTokenHost];
@@ -8053,7 +8338,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       const originalArrayMethod = getOriginalArrayMethod(prop);
       stylesheets[prop] = function arrayMutationWarningWrapper() {
         reportTemplateViolation('stylesheets');
-        // @ts-ignore
+        // @ts-expect-error can't properly determine the right `this`
         return originalArrayMethod.apply(this, arguments);
       };
     }
@@ -8199,6 +8484,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
    * This API is subject to change or being removed.
+   * @param elm
    */
   function getComponentConstructor(elm) {
     let ctor = null;
@@ -8223,6 +8509,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * EXPERIMENTAL: This function allows you to create a reactive readonly
    * membrane around any object value. This API is subject to change or
    * being removed.
+   * @param obj
    */
   function readonly(obj) {
     if (process.env.NODE_ENV !== 'production') {
@@ -8233,7 +8520,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     return getReadOnlyProxy(obj);
   }
-  /** version: 5.2.1 */
+  /** version: 6.3.4 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -8243,8 +8530,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    */
   /**
    * Displays the header for a custom element.
-   *
-   * @param ce the custom element
+   * @param ce The custom element to get the header for.
    * @param componentInstance component instance associated with the custom element.
    */
   function getHeaderForCustomElement(ce, componentInstance) {
@@ -8304,9 +8590,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   function init() {
-    const devtoolsFormatters = _globalThis.devtoolsFormatters || [];
+    const devtoolsFormatters = globalThis.devtoolsFormatters || [];
     ArrayPush$1.call(devtoolsFormatters, LightningElementFormatter);
-    _globalThis.devtoolsFormatters = devtoolsFormatters;
+    globalThis.devtoolsFormatters = devtoolsFormatters;
   }
   if (process.env.NODE_ENV !== 'production') {
     init();
@@ -8331,7 +8617,6 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   //
   // Only used in LWC's Karma tests
   if (process.env.NODE_ENV === 'test-karma-lwc') {
-    // @ts-ignore
     window.__lwcResetGlobalStylesheets = () => {
       stylesheetCache.clear();
     };
@@ -8448,80 +8733,82 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  const cachedConstructors = new Map();
-  const elementsUpgradedOutsideLWC = new WeakSet();
-  let elementBeingUpgradedByLWC = false;
-  const lifecycleCallbacks = lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE ? {
+  const LIFECYCLE_CALLBACKS = {
     connectedCallback: connectRootElement,
     disconnectedCallback: disconnectRootElement,
     formAssociatedCallback: runFormAssociatedCallback,
     formDisabledCallback: runFormDisabledCallback,
     formResetCallback: runFormResetCallback,
     formStateRestoreCallback: runFormStateRestoreCallback
-  } : undefined;
+  };
+  const cachedConstructors = new Map();
+  const nativeLifecycleElementsToUpgradedByLWC = new WeakMap();
+  let elementBeingUpgradedByLWC = false;
   // Creates a constructor that is intended to be used directly as a custom element, except that the upgradeCallback is
   // passed in to the constructor so LWC can reuse the same custom element constructor for multiple components.
   // Another benefit is that only LWC can create components that actually do anything – if you do
   // `customElements.define('x-foo')`, then you don't have access to the upgradeCallback, so it's a dummy custom element.
   // This class should be created once per tag name.
-  const createUpgradableConstructor = () => {
+  const createUpgradableConstructor = isFormAssociated => {
     // TODO [#2972]: this class should expose observedAttributes as necessary
     class UpgradableConstructor extends HTMLElement {
-      constructor(upgradeCallback) {
+      constructor(upgradeCallback, useNativeLifecycle) {
         super();
+        if (useNativeLifecycle) {
+          // When in native lifecycle mode, we need to keep track of instances that were created outside LWC
+          // (i.e. not created by `lwc.createElement()`). If the element uses synthetic lifecycle, then we don't
+          // need to track this.
+          nativeLifecycleElementsToUpgradedByLWC.set(this, elementBeingUpgradedByLWC);
+        }
         // If the element is not created using lwc.createElement(), e.g. `document.createElement('x-foo')`,
-        // then elementBeingUpgraded will be false
+        // then elementBeingUpgradedByLWC will be false
         if (elementBeingUpgradedByLWC) {
           upgradeCallback(this);
-        } else if (!isUndefined$1(lifecycleCallbacks)) {
-          // If this element has any lifecycle callbacks, then we need to keep track of
-          // instances that were created outside LWC (i.e. not created by `lwc.createElement()`).
-          // If the element has no connected or disconnected callbacks, then we don't need to track this.
-          elementsUpgradedOutsideLWC.add(this);
-          // TODO [#2970]: LWC elements cannot be upgraded via new Ctor()
-          // Do we want to support this? Throw an error? Currently for backwards compat it's a no-op.
-        }
-      }
-      /*LWC compiler v5.2.1*/
-    }
-    UpgradableConstructor.formAssociated = true;
-    // Do not unnecessarily add a connectedCallback/disconnectedCallback/etc., as it introduces perf overhead
-    // See: https://github.com/salesforce/lwc/pull/3162#issuecomment-1311851174
-    if (!isUndefined$1(lifecycleCallbacks)) {
-      for (const [propName, callback] of entries(lifecycleCallbacks)) {
-        UpgradableConstructor.prototype[propName] = function () {
-          if (!elementsUpgradedOutsideLWC.has(this)) {
-            callback(this);
-          }
-        };
+        }
+        // TODO [#2970]: LWC elements cannot be upgraded via new Ctor()
+        // Do we want to support this? Throw an error? Currently for backwards compat it's a no-op.
       }
+      /*LWC compiler v6.3.4*/
+    }
+    UpgradableConstructor.formAssociated = isFormAssociated;
+    for (const [propName, callback] of entries(LIFECYCLE_CALLBACKS)) {
+      UpgradableConstructor.prototype[propName] = function () {
+        // If the element is in the WeakMap (i.e. it's marked as native lifecycle), and if it was upgraded by LWC,
+        // then it can use native lifecycle
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          callback(this);
+        }
+      };
     }
     return UpgradableConstructor;
   };
-  function getUpgradableConstructor(tagName) {
+  function getUpgradableConstructor(tagName, isFormAssociated) {
     let UpgradableConstructor = cachedConstructors.get(tagName);
     if (isUndefined$1(UpgradableConstructor)) {
       if (!isUndefined$1(customElements.get(tagName))) {
         throw new Error(`Unexpected tag name "${tagName}". This name is a registered custom element, preventing LWC to upgrade the element.`);
       }
-      UpgradableConstructor = createUpgradableConstructor();
+      UpgradableConstructor = createUpgradableConstructor(isFormAssociated);
       customElements.define(tagName, UpgradableConstructor);
       cachedConstructors.set(tagName, UpgradableConstructor);
     }
     return UpgradableConstructor;
   }
-  const createCustomElement = (tagName, upgradeCallback) => {
-    const UpgradableConstructor = getUpgradableConstructor(tagName);
+  const createCustomElement = (tagName, upgradeCallback, useNativeLifecycle, isFormAssociated) => {
+    const UpgradableConstructor = getUpgradableConstructor(tagName, isFormAssociated);
     elementBeingUpgradedByLWC = true;
     try {
-      return new UpgradableConstructor(upgradeCallback);
+      if (UpgradableConstructor.formAssociated !== isFormAssociated) {
+        throw new Error(`<${tagName}> was already registered with formAssociated=${UpgradableConstructor.formAssociated}. It cannot be re-registered with formAssociated=${isFormAssociated}. Please rename your component to have a different name than <${tagName}>`);
+      }
+      return new UpgradableConstructor(upgradeCallback, useNativeLifecycle);
     } finally {
       elementBeingUpgradedByLWC = false;
     }
   };
 
   /*
-   * Copyright (c) 2023, Salesforce.com, inc.
+   * Copyright (c) 2024, Salesforce, 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
@@ -8530,16 +8817,18 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * A factory function that produces a renderer.
    * Renderer encapsulates operations that are required to render an LWC component into the underlying
    * runtime environment. In the case of @lwc/enigne-dom, it is meant to be used in a DOM environment.
-   * Example usage:
+   * @param baseRenderer Either null or the base renderer imported from 'lwc'.
+   * @returns The created renderer
+   * @example
    * import { renderer, rendererFactory } from 'lwc';
    * const customRenderer = rendererFactory(renderer);
-   *
-   * @param baseRenderer Either null or the base renderer imported from 'lwc'.
    */
   function rendererFactory(baseRenderer) {
+    // Type assertion because this is replaced by rollup with an object, not a string.
+    // See `injectInlineRenderer` in /scripts/rollup/rollup.config.js
     const renderer = function (exports) {
       /**
-       * Copyright (C) 2023 salesforce.com, inc.
+       * Copyright (c) 2024 Salesforce, Inc.
        */
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -8547,21 +8836,40 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
        * SPDX-License-Identifier: MIT
        * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
        */
+      /**
+       *
+       * @param value
+       * @param msg
+       */
       function invariant(value, msg) {
         if (!value) {
           throw new Error(`Invariant Violation: ${msg}`);
         }
       }
+      /**
+       *
+       * @param value
+       * @param msg
+       */
       function isTrue$1(value, msg) {
         if (!value) {
           throw new Error(`Assert Violation: ${msg}`);
         }
       }
+      /**
+       *
+       * @param value
+       * @param msg
+       */
       function isFalse$1(value, msg) {
         if (value) {
           throw new Error(`Assert Violation: ${msg}`);
         }
       }
+      /**
+       *
+       * @param msg
+       */
       function fail(msg) {
         throw new Error(msg);
       }
@@ -8572,13 +8880,23 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         isFalse: isFalse$1,
         isTrue: isTrue$1
       });
+      /**
+       * Determines whether the argument is `undefined`.
+       * @param obj Value to test
+       * @returns `true` if the value is `undefined`.
+       */
       function isUndefined(obj) {
         return obj === undefined;
       }
+      /**
+       * Determines whether the argument is `null`.
+       * @param obj Value to test
+       * @returns `true` if the value is `null`.
+       */
       function isNull(obj) {
         return obj === null;
       }
-      /** version: 5.2.1 */
+      /** version: 6.3.4 */
 
       /*
        * Copyright (c) 2023, salesforce.com, inc.
@@ -8598,7 +8916,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
           this.setNewContext = setNewContext;
           this.setDisconnectedCallback = setDisconnectedCallback;
         }
-        /*LWC compiler v5.2.1*/
+        /*LWC compiler v6.3.4*/
       }
       function registerContextConsumer(elm, adapterContextToken, subscriptionPayload) {
         dispatchEvent(elm, new WireContextSubscriptionEvent(adapterContextToken, subscriptionPayload));
@@ -8857,6 +9175,18 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     return vm;
   }
+  /**
+   * Replaces an existing DOM node with an LWC component.
+   * @param element The existing node in the DOM that where the root component should be attached.
+   * @param Ctor The LWC class to use as the root component.
+   * @param props Any props for the root component as part of initial client-side rendering. The props must be identical to those passed to renderComponent during SSR.
+   * @throws Throws when called with invalid parameters.
+   * @example
+   * import { hydrateComponent } from 'lwc';
+   * import App from 'x/App';
+   * const elm = document.querySelector('x-app');
+   * hydrateComponent(elm, App, { name: 'Hello World' });
+   */
   function hydrateComponent(element, Ctor, props = {}) {
     if (!(element instanceof Element)) {
       throw new TypeError(`"hydrateComponent" expects a valid DOM element as the first parameter but instead received ${element}.`);
@@ -8877,7 +9207,8 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         defineCustomElement,
         getTagName
       } = renderer;
-      defineCustomElement(StringToLowerCase.call(getTagName(element)));
+      const isFormAssociated = shouldBeFormAssociated(Ctor);
+      defineCustomElement(StringToLowerCase.call(getTagName(element)), isFormAssociated);
       const vm = createVMWithProps(element, Ctor, props);
       hydrateRoot(vm);
     } catch (e) {
@@ -8902,17 +9233,15 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * This function builds a Web Component class from a LWC constructor so it can be
    * registered as a new element via customElements.define() at any given time.
-   *
-   * @deprecated since version 1.3.11
-   *
+   * @param Ctor LWC constructor to build
+   * @returns A Web Component class
    * @example
-   * ```
    * import { buildCustomElementConstructor } from 'lwc';
    * import Foo from 'ns/foo';
    * const WC = buildCustomElementConstructor(Foo);
    * customElements.define('x-foo', WC);
    * const elm = document.createElement('x-foo');
-   * ```
+   * @deprecated since version 1.3.11
    */
   function deprecatedBuildCustomElementConstructor(Ctor) {
     if (process.env.NODE_ENV !== 'production') {
@@ -8927,6 +9256,13 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       renderer.remove(childNodes[i], node);
     }
   }
+  /**
+   * The real `buildCustomElementConstructor`. Should not be accessible to external users!
+   * @internal
+   * @param Ctor LWC constructor to build
+   * @returns A Web Component class
+   * @see {@linkcode deprecatedBuildCustomElementConstructor}
+   */
   function buildCustomElementConstructor(Ctor) {
     var _a;
     const HtmlPrototype = getComponentHtmlPrototype(Ctor);
@@ -8978,8 +9314,23 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       attributeChangedCallback(name, oldValue, newValue) {
         attributeChangedCallback.call(this, name, oldValue, newValue);
       }
-      /*LWC compiler v5.2.1*/
-    }, _a.observedAttributes = observedAttributes, _a;
+      formAssociatedCallback() {
+        runFormAssociatedCallback(this);
+      }
+      formDisabledCallback() {
+        runFormDisabledCallback(this);
+      }
+      formResetCallback() {
+        runFormResetCallback(this);
+      }
+      formStateRestoreCallback() {
+        runFormStateRestoreCallback(this);
+      }
+      /*LWC compiler v6.3.4*/
+    }, _a.observedAttributes = observedAttributes,
+    // Note CustomElementConstructor is not upgraded by LWC and inherits directly from HTMLElement which means it calls the native
+    // attachInternals API.
+    _a.formAssociated = Boolean(Ctor.formAssociated), _a;
   }
 
   /*
@@ -9003,7 +9354,13 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     }
     return node; // for convenience
   }
-  if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+  let monkeyPatched = false;
+  function monkeyPatchDomAPIs() {
+    if (monkeyPatched) {
+      // don't double-patch
+      return;
+    }
+    monkeyPatched = true;
     // Monkey patching Node methods to be able to detect the insertions and removal of root elements
     // created via createElement.
     const {
@@ -9033,18 +9390,25 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       }
     });
   }
+  // For some reason, JSDOC says "options.is" is a syntax error. And we can't disable the rule using
+  // `eslint-disable-next-line` because that gets included in the JSDOC, so we need this workaround.
+  /* eslint-disable jsdoc/valid-types */
   /**
    * EXPERIMENTAL: This function is almost identical to document.createElement with the slightly
    * difference that in the options, you can pass the `is` property set to a Constructor instead of
    * just a string value. The intent is to allow the creation of an element controlled by LWC without
    * having to register the element as a custom element.
-   *
+   * @param sel The tagname of the element to create
+   * @param options Control the behavior of the created element
+   * @param options.is The LWC component that the element should be
+   * @param options.mode What kind of shadow root to use
+   * @returns The created HTML element
+   * @throws Throws when called with invalid parameters.
    * @example
-   * ```
    * const el = createElement('x-foo', { is: FooCtor });
-   * ```
    */
-  function createElement(sel, options) {
+  function createElement( /* eslint-enable jsdoc/valid-types */
+  sel, options) {
     if (!isObject(options) || isNull(options)) {
       throw new TypeError(`"createElement" function expects an object as second parameter but received "${toString$1(options)}".`);
     }
@@ -9059,8 +9423,13 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
     // passing `sel` as a camel-case, which makes them invalid custom elements name
     // the following line guarantees that this does not leaks beyond this point.
     const tagName = StringToLowerCase.call(sel);
+    const apiVersion = getComponentAPIVersion(Ctor);
+    const useNativeCustomElementLifecycle =
+    // temporary "kill switch"
+    !lwcRuntimeFlags.DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE && isAPIFeatureEnabled(7 /* APIFeature.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE */, apiVersion);
+    const isFormAssociated = shouldBeFormAssociated(Ctor);
     // the custom element from the registry is expecting an upgrade callback
-    /**
+    /*
      * Note: if the upgradable constructor does not expect, or throw when we new it
      * with a callback as the first argument, we could implement a more advanced
      * mechanism that only passes that argument if the constructor is known to be
@@ -9072,13 +9441,15 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
         mode: options.mode !== 'closed' ? 'open' : 'closed',
         owner: null
       });
-      if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      if (!useNativeCustomElementLifecycle) {
+        // Monkey-patch on-demand, because if there are no components on the page using an old API
+        // version, then we don't want to monkey patch at all
+        monkeyPatchDomAPIs();
         ConnectingSlot.set(elm, connectRootElement);
         DisconnectingSlot.set(elm, disconnectRootElement);
       }
     };
-    const element = createCustomElement(tagName, upgradeCallback);
-    return element;
+    return createCustomElement(tagName, upgradeCallback, useNativeCustomElementLifecycle, isFormAssociated);
   }
 
   /*
@@ -9093,6 +9464,9 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   /**
    * EXPERIMENTAL: The purpose of this function is to detect shadowed nodes. THIS API WILL BE REMOVED
    * ONCE LOCKER V1 IS NO LONGER SUPPORTED.
+   * @param node Node to check
+   * @returns `true` if the the node is shadowed
+   * @example isNodeShadowed(document.querySelector('my-component'))
    */
   function isNodeShadowed(node) {
     if (isFalse(node instanceof _Node)) {
@@ -9134,12 +9508,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
   }
   /**
    * This static getter builds a Web Component class from a LWC constructor so it can be registered
-   * as a new element via customElements.define() at any given time. E.g.:
-   *
-   *      import Foo from 'ns/foo';
-   *      customElements.define('x-foo', Foo.CustomElementConstructor);
-   *      const elm = document.createElement('x-foo');
-   *
+   * as a new element via customElements.define() at any given time.
+   * @example
+   * import Foo from 'ns/foo';
+   * customElements.define('x-foo', Foo.CustomElementConstructor);
+   * const elm = document.createElement('x-foo');
    */
   defineProperty(LightningElement, 'CustomElementConstructor', {
     get() {
@@ -9165,6 +9538,11 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
+  /**
+   * Creates a context provider, given a wire adapter constructor.
+   * @param adapter The wire adapter to create a context provider for.
+   * @returns A new context provider.
+   */
   function createContextProvider(adapter) {
     return createContextProviderWithRegister(adapter, registerContextProvider);
   }
@@ -9181,7 +9559,7 @@ LWR.define('lwc/v/5_2_1', ['exports'], (function (exports) { 'use strict';
       });
     });
   }
-  /** version: 5.2.1 */
+  /** version: 6.3.4 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;