@lwc/engine-core 7.0.0-alpha.0 → 7.0.0

package/dist/framework/base-lightning-element.d.ts

@@ -10,7 +10,7 @@ import { AccessibleElementProperties } from '@lwc/shared';
 import { ShadowSupportMode } from './vm';
 import { Template } from './template';
 import { HTMLElementConstructor } from './base-bridge-element';
-import { TemplateStylesheetFactories } from './stylesheet';
+import { Stylesheets } from './stylesheet';
 export interface LightningElementConstructor {
     new (): LightningElement;
     readonly prototype: LightningElement;
@@ -19,7 +19,7 @@ export interface LightningElementConstructor {
     renderMode?: 'light' | 'shadow';
     formAssociated?: boolean;
     shadowSupportMode?: ShadowSupportMode;
-    stylesheets: TemplateStylesheetFactories;
+    stylesheets: Stylesheets;
 }
 type HTMLElementTheGoodParts = {
     toString: () => string;
@@ -27,10 +27,18 @@ type HTMLElementTheGoodParts = {
 type RefNodes = {
     [name: string]: Element;
 };
+/**
+ * A `LightningElement` will always be attached to an [`HTMLElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement),
+ * rather than the more broad `Element` used by the generic shadow root interface.
+ */
+export interface LightningElementShadowRoot extends ShadowRoot {
+    readonly host: HTMLElement;
+}
 export interface LightningElement extends HTMLElementTheGoodParts, AccessibleElementProperties {
     constructor: LightningElementConstructor;
-    template: ShadowRoot | null;
+    template: LightningElementShadowRoot | null;
     refs: RefNodes | undefined;
+    hostElement: Element;
     render(): Template;
     connectedCallback?(): void;
     disconnectedCallback?(): void;

package/dist/framework/check-version-mismatch.d.ts

@@ -1,5 +1,5 @@
 import { Template } from './template';
-import { StylesheetFactory } from './stylesheet';
+import { Stylesheet } from './stylesheet';
 import { LightningElementConstructor } from './base-lightning-element';
 /**
  * Validate a template, stylesheet, or component to make sure that its compiled version matches
@@ -9,5 +9,5 @@ import { LightningElementConstructor } from './base-lightning-element';
  * @param type
  */
 export declare function checkVersionMismatch(func: Template, type: 'template'): void;
-export declare function checkVersionMismatch(func: StylesheetFactory, type: 'stylesheet'): void;
+export declare function checkVersionMismatch(func: Stylesheet, type: 'stylesheet'): void;
 export declare function checkVersionMismatch(func: LightningElementConstructor, type: 'component'): void;

package/dist/framework/def.d.ts

@@ -41,12 +41,9 @@ export interface ComponentDef {
 export declare function isComponentConstructor(ctor: unknown): ctor is LightningElementConstructor;
 export declare function getComponentInternalDef(Ctor: unknown): ComponentDef;
 export declare function getComponentHtmlPrototype(Ctor: unknown): HTMLElementConstructor;
-declare const enum PropDefType {
-    any = "any"
-}
 interface PropDef {
     config: number;
-    type: PropDefType;
+    type: 'any';
     attr: string;
 }
 type PublicMethod = (...args: any[]) => any;

package/dist/framework/hot-swaps.d.ts

@@ -1,11 +1,11 @@
 import { VM } from './vm';
 import { LightningElementConstructor } from './base-lightning-element';
 import { Template } from './template';
-import { StylesheetFactory } from './stylesheet';
+import { Stylesheet } from './stylesheet';
 export declare function getTemplateOrSwappedTemplate(tpl: Template): Template;
 export declare function getComponentOrSwappedComponent(Ctor: LightningElementConstructor): LightningElementConstructor;
-export declare function getStyleOrSwappedStyle(style: StylesheetFactory): StylesheetFactory;
+export declare function getStyleOrSwappedStyle(style: Stylesheet): Stylesheet;
 export declare function setActiveVM(vm: VM): void;
 export declare function swapTemplate(oldTpl: Template, newTpl: Template): boolean;
 export declare function swapComponent(oldComponent: LightningElementConstructor, newComponent: LightningElementConstructor): boolean;
-export declare function swapStyle(oldStyle: StylesheetFactory, newStyle: StylesheetFactory): boolean;
+export declare function swapStyle(oldStyle: Stylesheet, newStyle: Stylesheet): boolean;

package/dist/framework/main.d.ts

@@ -18,7 +18,9 @@ export { getComponentAPIVersion } from './component';
 export { shouldBeFormAssociated } from './utils';
 export { getComponentConstructor } from './get-component-constructor';
 export type { RendererAPI, LifecycleCallback } from './renderer';
-export type { ConfigValue as WireConfigValue, ContextValue as WireContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, } from './wiring';
+export type { Stylesheets } from './stylesheet';
+export type { Template } from './template';
+export type { ConfigValue as WireConfigValue, ContextConsumer as WireContextConsumer, ContextProvider as WireContextProvider, ContextValue as WireContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, } from './wiring';
 export type { FormRestoreState, FormRestoreReason } from './vm';
 export { LightningElement } from './base-lightning-element';
 export { default as api } from './decorators/api';

package/dist/framework/stylesheet.d.ts

@@ -5,13 +5,12 @@ import { VCustomElement, VNode } from './vnodes';
  * Function producing style based on a host and a shadow selector. This function is invoked by
  * the engine with different values depending on the mode that the component is running on.
  */
-export type StylesheetFactory = (stylesheetToken: string | undefined, useActualHostSelector: boolean, useNativeDirPseudoclass: boolean) => string;
+export type Stylesheet = (stylesheetToken: string | undefined, useActualHostSelector: boolean, useNativeDirPseudoclass: boolean) => string;
 /**
- * The list of stylesheets associated with a template. Each entry is either a StylesheetFactory or a
- * TemplateStylesheetFactory a given stylesheet depends on other external stylesheets (via
- * the @import CSS declaration).
+ * The list of stylesheets associated with a template. Each entry is either a `Stylesheet` or
+ * an array of stylesheets that a given stylesheet depends on via CSS `@import` declarations.
  */
-export type TemplateStylesheetFactories = Array<StylesheetFactory | TemplateStylesheetFactories>;
+export type Stylesheets = Array<Stylesheet | Stylesheets>;
 export declare function updateStylesheetToken(vm: VM, template: Template, legacy: boolean): void;
 export declare function getStylesheetsContent(vm: VM, template: Template): string[];
 /**
@@ -31,4 +30,4 @@ export declare function getScopeTokenClass(owner: VM, legacy: boolean): string |
  */
 export declare function getStylesheetTokenHost(vnode: VCustomElement): string | null;
 export declare function createStylesheet(vm: VM, stylesheets: string[]): VNode[] | null;
-export declare function unrenderStylesheet(stylesheet: StylesheetFactory): void;
+export declare function unrenderStylesheet(stylesheet: Stylesheet): void;

package/dist/framework/template.d.ts

@@ -1,13 +1,13 @@
 import { RenderAPI } from './api';
 import { SlotSet, TemplateCache, VM } from './vm';
-import { TemplateStylesheetFactories } from './stylesheet';
+import { Stylesheets } from './stylesheet';
 import { VNodes } from './vnodes';
 export interface Template {
     (api: RenderAPI, cmp: object, slotSet: SlotSet, cache: TemplateCache): VNodes;
     /** The list of slot names used in the template. */
     slots?: string[];
     /** The stylesheet associated with the template. */
-    stylesheets?: TemplateStylesheetFactories;
+    stylesheets?: Stylesheets;
     /** The string used for synthetic shadow style scoping and light DOM style scoping. */
     stylesheetToken?: string;
     /** Same as the above, but for legacy use cases (pre-LWC v3.0.0) */
@@ -24,4 +24,4 @@ export declare const parseFragment: (strings: string[], ...keys: (string | numbe
 export declare const parseSVGFragment: (strings: string[], ...keys: (string | number)[]) => () => Element;
 export declare function evaluateTemplate(vm: VM, html: Template): VNodes;
 export declare function computeHasScopedStyles(template: Template, vm: VM | undefined): boolean;
-export declare function hasStyles(stylesheets: TemplateStylesheetFactories | undefined | null): stylesheets is TemplateStylesheetFactories;
+export declare function hasStyles(stylesheets: Stylesheets | undefined | null): stylesheets is Stylesheets;

package/dist/framework/utils.d.ts

@@ -1,4 +1,4 @@
-import { StylesheetFactory, TemplateStylesheetFactories } from './stylesheet';
+import { Stylesheet, Stylesheets } from './stylesheet';
 import { LightningElementConstructor } from './base-lightning-element';
 type Callback = () => void;
 export declare const SPACE_CHAR = 32;
@@ -15,7 +15,7 @@ export declare function cloneAndOmitKey(object: {
 }, keyToOmit: string): {
     [key: string]: any;
 };
-export declare function flattenStylesheets(stylesheets: TemplateStylesheetFactories): StylesheetFactory[];
+export declare function flattenStylesheets(stylesheets: Stylesheets): Stylesheet[];
 export declare function assertNotProd(): void;
 export declare function shouldBeFormAssociated(Ctor: LightningElementConstructor): boolean;
 export {};

package/dist/framework/vm.d.ts

@@ -2,10 +2,10 @@ import { APIVersion } from '@lwc/shared';
 import { HostNode, HostElement, RendererAPI } from './renderer';
 import { Template } from './template';
 import { ComponentDef } from './def';
-import { LightningElement, LightningElementConstructor } from './base-lightning-element';
+import { LightningElement, LightningElementConstructor, LightningElementShadowRoot } from './base-lightning-element';
 import { ReactiveObserver } from './mutation-tracker';
 import { VNodes, VCustomElement, VNode, VBaseElement, VStaticPartElement } from './vnodes';
-import { TemplateStylesheetFactories } from './stylesheet';
+import { Stylesheets } from './stylesheet';
 type ShadowRootMode = 'open' | 'closed';
 export interface TemplateCache {
     [key: string]: any;
@@ -29,14 +29,7 @@ export declare const enum ShadowMode {
     Native = 0,
     Synthetic = 1
 }
-export declare const enum ShadowSupportMode {
-    Any = "any",
-    Default = "reset",
-    Native = "native"
-}
-export declare const enum LwcDomMode {
-    Manual = "manual"
-}
+export type ShadowSupportMode = 'any' | 'reset' | 'native';
 export interface Context {
     /** The string used for synthetic shadow DOM and light DOM style scoping. */
     stylesheetToken: string | undefined;
@@ -126,12 +119,12 @@ export interface VM<N = HostNode, E = HostElement> {
     /** The component instance. */
     component: LightningElement;
     /** The custom element shadow root. */
-    shadowRoot: ShadowRoot | null;
+    shadowRoot: LightningElementShadowRoot | null;
     /**
      * The component render root. If the component is a shadow DOM component, it is its shadow
      * root. If the component is a light DOM component it the element itself.
      */
-    renderRoot: ShadowRoot | HostElement;
+    renderRoot: LightningElementShadowRoot | HostElement;
     /** The template reactive observer. */
     tro: ReactiveObserver;
     /**
@@ -160,7 +153,7 @@ export interface VM<N = HostNode, E = HostElement> {
     /**
      * Any stylesheets associated with the component
      */
-    stylesheets: TemplateStylesheetFactories | null;
+    stylesheets: Stylesheets | null;
     /**
      * API version associated with this VM
      */

package/dist/framework/vnodes.d.ts

@@ -27,7 +27,7 @@ export interface BaseVParent {
 export interface BaseVNode {
     type: VNodeType;
     elm: Node | undefined;
-    sel: string | undefined;
+    sel: string;
     key: Key | undefined;
     owner: VM;
 }
@@ -35,6 +35,7 @@ export interface VScopedSlotFragment extends BaseVNode {
     factory: (value: any, key: any) => VFragment;
     type: VNodeType.ScopedSlotFragment;
     slotName: unknown;
+    sel: '__scoped_slot_fragment__';
 }
 export interface VStaticPart {
     readonly type: VStaticPartType;
@@ -56,7 +57,7 @@ export interface VStaticPartText extends VStaticPart {
 export type VStaticPartData = Pick<VElementData, 'on' | 'ref' | 'attrs' | 'style' | 'className'>;
 export interface VStatic extends BaseVNode {
     readonly type: VNodeType.Static;
-    readonly sel: undefined;
+    readonly sel: '__static__';
     readonly key: Key;
     readonly fragment: Element;
     readonly parts: VStaticPart[] | undefined;
@@ -64,7 +65,7 @@ export interface VStatic extends BaseVNode {
     slotAssignment: string | undefined;
 }
 export interface VFragment extends BaseVNode, BaseVParent {
-    sel: undefined;
+    sel: '__fragment__';
     type: VNodeType.Fragment;
     stable: 0 | 1;
     leading: VText | VComment;
@@ -72,15 +73,15 @@ export interface VFragment extends BaseVNode, BaseVParent {
 }
 export interface VText extends BaseVNode {
     type: VNodeType.Text;
-    sel: undefined;
+    sel: '__text__';
     text: string;
     key: undefined;
 }
 export interface VComment extends BaseVNode {
     type: VNodeType.Comment;
-    sel: undefined;
+    sel: '__comment__';
     text: string;
-    key: 'c';
+    key: undefined;
 }
 export interface VBaseElement extends BaseVNode, BaseVParent {
     sel: string;
@@ -117,6 +118,11 @@ export interface VElementData extends VNodeData {
     readonly ref?: string;
     readonly slotData?: any;
     readonly slotAssignment?: string;
+    readonly context?: {
+        lwc?: {
+            dom?: 'manual';
+        };
+    };
 }
 export declare function isVBaseElement(vnode: VNode): vnode is VElement | VCustomElement;
 export declare function isSameVnode(vnode1: VNode, vnode2: VNode): boolean;

package/dist/framework/wiring/index.d.ts

@@ -1,3 +1,3 @@
 export { createContextProviderWithRegister, createContextWatcher } from './context';
-export { ConfigCallback, ConfigValue, ContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, } from './types';
+export { ConfigCallback, ConfigValue, ContextConsumer, ContextProvider, ContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, } from './types';
 export { connectWireAdapters, disconnectWireAdapters, installWireAdapters, storeWiredFieldMeta, storeWiredMethodMeta, } from './wiring';

package/dist/framework/wiring/types.d.ts

@@ -1,20 +1,20 @@
 import type { LightningElement } from '../base-lightning-element';
 import type { HostElement } from '../renderer';
-export type DataCallback = (value: any) => void;
+export type DataCallback<T = any> = (value: T) => void;
 export type ConfigValue = Record<string, any>;
 export type WireAdapterSchemaValue = 'optional' | 'required';
 export type ContextValue = Record<string, any>;
-export interface WireAdapter {
-    update(config: ConfigValue, context?: ContextValue): void;
+export interface WireAdapter<Config extends ConfigValue = ConfigValue, Context extends ContextValue = ContextValue> {
+    update(config: Config, context?: Context): void;
     connect(): void;
     disconnect(): void;
 }
-export interface WireAdapterConstructor {
-    new (callback: DataCallback, sourceContext?: {
+export interface WireAdapterConstructor<Config extends ConfigValue = ConfigValue, Value = any, Context extends ContextValue = ContextValue> {
+    new (callback: DataCallback<Value>, sourceContext?: {
         tagName: string;
-    }): WireAdapter;
-    configSchema?: Record<string, WireAdapterSchemaValue>;
-    contextSchema?: Record<string, WireAdapterSchemaValue>;
+    }): WireAdapter<Config, Context>;
+    configSchema?: Record<keyof Config, WireAdapterSchemaValue>;
+    contextSchema?: Record<keyof Context, WireAdapterSchemaValue>;
 }
 export interface WireDef {
     method?: (data: any) => void;

package/dist/index.cjs.js

@@ -1517,7 +1517,7 @@ function applyShadowMigrateMode(shadowRoot) {
 }
 
 /*
- * 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
@@ -1784,6 +1784,25 @@ LightningElement.prototype = {
         }
         return vm.shadowRoot;
     },
+    get hostElement() {
+        const vm = getAssociatedVM(this);
+        if (!process.env.IS_BROWSER) {
+            shared.assert.fail('this.hostElement is not supported in this environment');
+        }
+        const apiVersion = getComponentAPIVersion(vm.def.ctor);
+        if (!shared.isAPIFeatureEnabled(9 /* APIFeature.ENABLE_THIS_DOT_HOST_ELEMENT */, apiVersion)) {
+            if (process.env.NODE_ENV !== 'production') {
+                logWarnOnce('The `this.hostElement` API within LightningElement is ' +
+                    'only supported in API version 62 and above. Increase the API version to use it.');
+            }
+            // Simulate the old behavior for `this.hostElement` to avoid a breaking change
+            return undefined;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            shared.assert.isTrue(vm.elm instanceof Element, `this.hostElement should be an Element, found: ${vm.elm}`);
+        }
+        return vm.elm;
+    },
     get refs() {
         const vm = getAssociatedVM(this);
         if (isUpdatingTemplate) {
@@ -2460,13 +2479,13 @@ function internalWireFieldDecorator(key) {
  */
 function getClassDescriptorType(descriptor) {
     if (shared.isFunction(descriptor.value)) {
-        return "method" /* DescriptorType.Method */;
+        return 'method';
     }
     else if (shared.isFunction(descriptor.set) || shared.isFunction(descriptor.get)) {
-        return "accessor" /* DescriptorType.Accessor */;
+        return 'accessor';
     }
     else {
-        return "field" /* DescriptorType.Field */;
+        return 'field';
     }
 }
 function validateObservedField(Ctor, fieldName, descriptor) {
@@ -2696,9 +2715,7 @@ function checkVersionMismatch(func, type) {
     const versionMatcher = func.toString().match(shared.LWC_VERSION_COMMENT_REGEX);
     if (!shared.isNull(versionMatcher) && !warned) {
         const version = versionMatcher[1];
-        const [major, minor] = version.split('.');
-        const [expectedMajor, expectedMinor] = shared.LWC_VERSION.split('.');
-        if (major !== expectedMajor || minor !== expectedMinor) {
+        if (version !== shared.LWC_VERSION) {
             warned = true; // only warn once to avoid flooding the console
             // stylesheets and templates do not have user-meaningful names, but components do
             const friendlyName = type === 'component' ? `${type} ${func.name}` : type;
@@ -3331,7 +3348,7 @@ let swappedComponentMap =
 let swappedStyleMap = /*@__PURE__@*/ new WeakMap();
 // The important thing here is the weak values – VMs are transient (one per component instance) and should be GC'ed,
 // so we don't want to create strong references to them.
-// The weak keys are kind of useless, because Templates, LightningElementConstructors, and StylesheetFactories are
+// The weak keys are kind of useless, because Templates, LightningElementConstructors, and Stylesheets are
 // never GC'ed. But maybe they will be someday, so we may as well use weak keys too.
 // The "pure" annotations are so that Rollup knows for sure it can remove these from prod mode
 let activeTemplates = /*@__PURE__@*/ new WeakMultiMap();
@@ -3366,6 +3383,9 @@ function rehydrateHotTemplate(tpl) {
 }
 function rehydrateHotStyle(style) {
     const activeVMs = activeStyles.get(style);
+    if (!activeVMs.size) {
+        return true;
+    }
     unrenderStylesheet(style);
     for (const vm of activeVMs) {
         // if a style definition is swapped, we must reset
@@ -3480,12 +3500,25 @@ function swapTemplate(oldTpl, newTpl) {
 }
 function swapComponent(oldComponent, newComponent) {
     if (process.env.NODE_ENV !== 'production') {
-        if (isComponentConstructor(oldComponent) && isComponentConstructor(newComponent)) {
+        const isOldCtorAComponent = isComponentConstructor(oldComponent);
+        const isNewCtorAComponent = isComponentConstructor(newComponent);
+        if (isOldCtorAComponent && isNewCtorAComponent) {
             swappedComponentMap.set(oldComponent, newComponent);
             return rehydrateHotComponent(oldComponent);
         }
+        else if (isOldCtorAComponent === false && isNewCtorAComponent === true) {
+            throw new TypeError(`Invalid Component: Attempting to swap a non-component with a component`);
+        }
+        else if (isOldCtorAComponent === true && isNewCtorAComponent === false) {
+            throw new TypeError(`Invalid Component: Attempting to swap a component with a non-component`);
+        }
         else {
-            throw new TypeError(`Invalid Component`);
+            // The dev-server relies on the presence of registerComponent() as a way to determine a
+            // component module. However, the compiler cannot definitively add registerComponent()
+            // transformation only to a component constructor. Hence the dev-server may attempt to
+            // hot swap javascript modules that look like a component and should not cause the app
+            // to fail. To allow that, this api ignores such hot swap attempts.
+            return false;
         }
     }
     return false;
@@ -3548,13 +3581,13 @@ function createComponentDef(Ctor) {
             logError(`Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
         }
         if (!shared.isUndefined(ctorShadowSupportMode) &&
-            ctorShadowSupportMode !== "any" /* ShadowSupportMode.Any */ &&
-            ctorShadowSupportMode !== "reset" /* ShadowSupportMode.Default */ &&
-            ctorShadowSupportMode !== "native" /* ShadowSupportMode.Native */) {
+            ctorShadowSupportMode !== 'any' &&
+            ctorShadowSupportMode !== 'reset' &&
+            ctorShadowSupportMode !== 'native') {
             logError(`Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
         }
         // TODO [#3971]: Completely remove shadowSupportMode "any"
-        if (ctorShadowSupportMode === "any" /* ShadowSupportMode.Any */) {
+        if (ctorShadowSupportMode === 'any') {
             logWarn(`Invalid value 'any' for static property shadowSupportMode. 'any' is deprecated and will be removed in a future release--use 'native' instead.`);
         }
         if (!shared.isUndefined(ctorRenderMode) &&
@@ -3588,8 +3621,7 @@ function createComponentDef(Ctor) {
     if (!shared.isUndefined(ctorShadowSupportMode)) {
         shadowSupportMode = ctorShadowSupportMode;
         if (isReportingEnabled() &&
-            (shadowSupportMode === "any" /* ShadowSupportMode.Any */ ||
-                shadowSupportMode === "native" /* ShadowSupportMode.Native */)) {
+            (shadowSupportMode === 'any' || shadowSupportMode === 'native')) {
             report("ShadowSupportModeUsage" /* ReportingEventId.ShadowSupportModeUsage */, {
                 tagName: Ctor.name,
                 mode: shadowSupportMode,
@@ -3704,7 +3736,7 @@ const lightingElementDef = {
     propsConfig: EmptyObject,
     methods: EmptyObject,
     renderMode: 1 /* RenderMode.Shadow */,
-    shadowSupportMode: "reset" /* ShadowSupportMode.Default */,
+    shadowSupportMode: 'reset',
     formAssociated: undefined,
     wire: EmptyObject,
     bridge: BaseBridgeElement,
@@ -3728,7 +3760,7 @@ function getComponentDef(Ctor) {
         // avoid leaking the reference to the public props descriptors
         publicProps[key] = {
             config: propsConfig[key] || 0, // a property by default
-            type: "any" /* PropDefType.any */, // no type inference for public services
+            type: 'any', // no type inference for public services
             attr: shared.htmlPropertyToAttribute(key),
         };
     }
@@ -4705,14 +4737,14 @@ function applyStyleScoping(elm, owner, renderer) {
 }
 function applyDomManual(elm, vnode) {
     const { owner, data: { context }, } = vnode;
-    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && context?.lwc?.dom === "manual" /* LwcDomMode.Manual */) {
+    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && context?.lwc?.dom === 'manual') {
         elm.$domManual$ = true;
     }
 }
 function applyElementRestrictions(elm, vnode) {
     if (process.env.NODE_ENV !== 'production') {
         const isSynthetic = vnode.owner.shadowMode === 1 /* ShadowMode.Synthetic */;
-        const isPortal = vnode.type === 2 /* VNodeType.Element */ && vnode.data.context?.lwc?.dom === "manual" /* LwcDomMode.Manual */;
+        const isPortal = vnode.type === 2 /* VNodeType.Element */ && vnode.data.context?.lwc?.dom === 'manual';
         const isLight = vnode.owner.renderMode === 0 /* RenderMode.Light */;
         patchElementWithRestrictions(elm, {
             isPortal,
@@ -5089,7 +5121,7 @@ function ssf(slotName, factory) {
         factory,
         owner: getVMBeingRendered(),
         elm: undefined,
-        sel: undefined,
+        sel: '__scoped_slot_fragment__',
         key: undefined,
         slotName,
     };
@@ -5100,7 +5132,7 @@ function st(fragmentFactory, key, parts) {
     const fragment = fragmentFactory(parts);
     const vnode = {
         type: 4 /* VNodeType.Static */,
-        sel: undefined,
+        sel: '__static__',
         key,
         elm: undefined,
         fragment,
@@ -5118,7 +5150,7 @@ function fr(key, children, stable) {
     const trailing = useCommentNodes ? co('') : t('');
     return {
         type: 5 /* VNodeType.Fragment */,
-        sel: undefined,
+        sel: '__fragment__',
         key,
         elm: undefined,
         children: [leading, ...children, trailing],
@@ -5235,7 +5267,16 @@ function s(slotName, data, children, slotset) {
                         // to the vnode because the current way the diffing algo works, it will replace the original reference
                         // to the host element with a new one. This means the new element will be mounted and immediately unmounted.
                         // Creating a copy of the vnode to preserve a reference to the previous host element.
-                        clonedVNode = { ...vnode, slotAssignment: data.slotAssignment };
+                        if (shared.isUndefined(vnode.elm)) {
+                            // vnode.elm is undefined during initial render.
+                            // We don't need to clone at this point because it doesn't need to be unmounted.
+                            vnode.slotAssignment = data.slotAssignment;
+                        }
+                        else {
+                            // Clone when the vnode.elm is defined to ensure we don't lose reference to the previous element.
+                            // This is specifically for slot forwarding.
+                            clonedVNode = { ...vnode, slotAssignment: data.slotAssignment };
+                        }
                     }
                     // If the slot content is standard type, the content is static, no additional
                     // processing needed on the vnode
@@ -5403,10 +5444,10 @@ function f(items) {
 }
 // [t]ext node
 function t(text) {
-    let sel, key, elm;
+    let key, elm;
     return {
         type: 0 /* VNodeType.Text */,
-        sel,
+        sel: '__text__',
         text,
         elm,
         key,
@@ -5415,13 +5456,13 @@ function t(text) {
 }
 // [co]mment node
 function co(text) {
-    let sel, elm;
+    let elm, key;
     return {
         type: 1 /* VNodeType.Comment */,
-        sel,
+        sel: '__comment__',
         text,
         elm,
-        key: 'c',
+        key,
         owner: getVMBeingRendered(),
     };
 }
@@ -6522,7 +6563,7 @@ function computeShadowMode(def, owner, renderer, hydrated) {
             // everything defaults to native when the synthetic shadow polyfill is unavailable.
             shadowMode = 0 /* ShadowMode.Native */;
         }
-        else if (def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
+        else if (def.shadowSupportMode === 'native') {
             shadowMode = 0 /* ShadowMode.Native */;
         }
         else {
@@ -7317,7 +7358,7 @@ function hydrateElement(elm, vnode, renderer) {
     vnode.elm = elm;
     const { owner } = vnode;
     const { context } = vnode.data;
-    const isDomManual = Boolean(!shared.isUndefined(context) && !shared.isUndefined(context.lwc) && context.lwc.dom === "manual" /* LwcDomMode.Manual */);
+    const isDomManual = Boolean(!shared.isUndefined(context) && !shared.isUndefined(context.lwc) && context.lwc.dom === 'manual');
     if (isDomManual) {
         // it may be that this element has lwc:inner-html, we need to diff and in case are the same,
         // remove the innerHTML from props so it reuses the existing dom elements.
@@ -7686,6 +7727,7 @@ function haveCompatibleStaticParts(vnode, renderer) {
     if (shared.isUndefined(parts)) {
         return true;
     }
+    const shouldValidateAttr = (data, attrName) => attrName in data;
     // The validation here relies on 2 key invariants:
     // 1. It's never the case that `parts` is undefined on the server but defined on the client (or vice-versa)
     // 2. It's never the case that `parts` has one length on the server but another on the client
@@ -7697,8 +7739,15 @@ function haveCompatibleStaticParts(vnode, renderer) {
             }
             const { data } = part;
             const hasMatchingAttrs = validateAttrs(vnode, elm, data, renderer, () => true);
-            const hasMatchingStyleAttr = validateStyleAttr(vnode, elm, data, renderer);
-            const hasMatchingClass = validateClassAttr(vnode, elm, data, renderer);
+            // Explicitly skip hydration validation when static parts don't contain `style` or `className`.
+            // This means the style/class attributes are either static or don't exist on the element and
+            // cannot be affected by hydration.
+            const hasMatchingStyleAttr = shouldValidateAttr(data, 'style')
+                ? validateStyleAttr(vnode, elm, data, renderer)
+                : true;
+            const hasMatchingClass = shouldValidateAttr(data, 'className')
+                ? validateClassAttr(vnode, elm, data, renderer)
+                : true;
             if (shared.isFalse(hasMatchingAttrs && hasMatchingStyleAttr && hasMatchingClass)) {
                 return false;
             }
@@ -8027,5 +8076,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 7.0.0-alpha.0 */
+/** version: 7.0.0 */
 //# sourceMappingURL=index.cjs.js.map