feat: CSR/SSRv1 context

packages/@lwc/engine-core/src/framework/main.ts

@@ -73,5 +73,5 @@ export { default as wire } from './decorators/wire';
 export { readonly } from './readonly';
 
 export { setFeatureFlag, setFeatureFlagForTest } from '@lwc/features';
-export { setTrustedSignalSet } from '@lwc/shared';
+export { setContextKeys, setTrustedSignalSet, setTrustedContextSet } from '@lwc/shared';
 export type { Stylesheet, Stylesheets } from '@lwc/shared';

packages/@lwc/engine-core/src/framework/modules/context.ts

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2025, 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
+ */
+import {
+    isUndefined,
+    getPrototypeOf,
+    keys,
+    getContextKeys,
+    ArrayFilter,
+    ContextEventName,
+    isTrustedContext,
+} from '@lwc/shared';
+import { type VM } from '../vm';
+import { logErrorOnce } from '../../shared/logger';
+import type { Signal } from '@lwc/signals';
+import type { RendererAPI } from '../renderer';
+import type { ShouldContinueBubbling } from '../wiring/types';
+
+type ContextProvidedCallback = (contextSignal?: Signal<unknown>) => void;
+type ContextVarieties = Map<unknown, Signal<unknown>>;
+
+class ContextConnector<C extends object> {
+    component: C;
+    #renderer: RendererAPI;
+    #providedContextVarieties: ContextVarieties;
+    #elm: HTMLElement;
+
+    constructor(vm: VM, component: C, providedContextVarieties: ContextVarieties) {
+        this.component = component;
+        this.#renderer = vm.renderer;
+        this.#elm = vm.elm;
+        this.#providedContextVarieties = providedContextVarieties;
+    }
+
+    provideContext<V extends object>(
+        contextVariety: V,
+        providedContextSignal: Signal<unknown>
+    ): void {
+        // registerContextProvider is called one time when the component is first provided context.
+        // The component is then listening for consumers to consume the provided context.
+        if (this.#providedContextVarieties.size === 0) {
+            this.#renderer.registerContextProvider(
+                this.#elm,
+                ContextEventName,
+                (payload): ShouldContinueBubbling => {
+                    // This callback is invoked when the provided context is consumed somewhere down
+                    // in the component's subtree.
+                    return payload.setNewContext(this.#providedContextVarieties);
+                }
+            );
+        }
+
+        if (this.#providedContextVarieties.has(contextVariety)) {
+            logErrorOnce(
+                'Multiple contexts of the same variety were provided. Only the first context will be used.'
+            );
+            return;
+        }
+        this.#providedContextVarieties.set(contextVariety, providedContextSignal);
+    }
+
+    consumeContext<V extends object>(
+        contextVariety: V,
+        contextProvidedCallback: ContextProvidedCallback
+    ): void {
+        this.#renderer.registerContextConsumer(this.#elm, ContextEventName, {
+            setNewContext: (providerContextVarieties: ContextVarieties): ShouldContinueBubbling => {
+                // If the provider has the specified context variety, then it is consumed
+                // and true is returned to stop bubbling.
+                if (providerContextVarieties.has(contextVariety)) {
+                    contextProvidedCallback(providerContextVarieties.get(contextVariety));
+                    return true;
+                }
+                // Return false as context has not been found/consumed
+                // and the consumer should continue traversing the context tree
+                return false;
+            },
+        });
+    }
+}
+
+export function connectContext(vm: VM) {
+    const contextKeys = getContextKeys();
+
+    if (isUndefined(contextKeys)) {
+        return;
+    }
+
+    const { connectContext } = contextKeys;
+    const { component } = vm;
+
+    const enumerableKeys = keys(getPrototypeOf(component));
+    const contextfulKeys = ArrayFilter.call(enumerableKeys, (enumerableKey) =>
+        isTrustedContext((component as any)[enumerableKey])
+    );
+
+    if (contextfulKeys.length === 0) {
+        return;
+    }
+
+    const providedContextVarieties: ContextVarieties = new Map();
+
+    for (let i = 0; i < contextfulKeys.length; i++) {
+        (component as any)[contextfulKeys[i]][connectContext](
+            new ContextConnector(vm, component, providedContextVarieties)
+        );
+    }
+}
+
+export function disconnectContext(vm: VM) {
+    const contextKeys = getContextKeys();
+
+    if (!contextKeys) {
+        return;
+    }
+
+    const { disconnectContext } = contextKeys;
+    const { component } = vm;
+
+    const enumerableKeys = keys(getPrototypeOf(component));
+    const contextfulKeys = ArrayFilter.call(enumerableKeys, (enumerableKey) =>
+        isTrustedContext((component as any)[enumerableKey])
+    );
+
+    if (contextfulKeys.length === 0) {
+        return;
+    }
+
+    for (let i = 0; i < contextfulKeys.length; i++) {
+        (component as any)[contextfulKeys[i]][disconnectContext](component);
+    }
+}

packages/@lwc/engine-core/src/framework/renderer.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-import type { WireContextSubscriptionPayload } from './wiring';
+import type { WireContextSubscriptionCallback, WireContextSubscriptionPayload } from './wiring';
 
 export type HostNode = any;
 export type HostElement = any;
@@ -76,6 +76,11 @@ export interface RendererAPI {
     ) => E;
     defineCustomElement: (tagName: string, isFormAssociated: boolean) => void;
     ownerDocument(elm: E): Document;
+    registerContextProvider: (
+        element: E,
+        adapterContextToken: string,
+        onContextSubscription: WireContextSubscriptionCallback
+    ) => void;
     registerContextConsumer: (
         element: E,
         adapterContextToken: string,

packages/@lwc/engine-core/src/framework/vm.ts

@@ -49,6 +49,7 @@ import { flushMutationLogsForVM, getAndFlushMutationLogs } from './mutation-logg
 import { connectWireAdapters, disconnectWireAdapters, installWireAdapters } from './wiring';
 import { VNodeType, isVFragment } from './vnodes';
 import { isReportingEnabled, report, ReportingEventId } from './reporting';
+import { connectContext, disconnectContext } from './modules/context';
 import type { VNodes, VCustomElement, VNode, VBaseElement, VStaticPartElement } from './vnodes';
 import type { ReactiveObserver } from './mutation-tracker';
 import type {
@@ -702,6 +703,10 @@ export function runConnectedCallback(vm: VM) {
     if (hasWireAdapters(vm)) {
         connectWireAdapters(vm);
     }
+
+    // Setup context before connected callback is executed
+    connectContext(vm);
+
     const { connectedCallback } = vm.def;
     if (!isUndefined(connectedCallback)) {
         logOperationStart(OperationId.ConnectedCallback, vm);
@@ -751,6 +756,7 @@ function runDisconnectedCallback(vm: VM) {
     if (process.env.NODE_ENV !== 'production') {
         assert.isTrue(vm.state !== VMState.disconnected, `${vm} must be inserted.`);
     }
+    disconnectContext(vm);
     if (isFalse(vm.isDirty)) {
         // this guarantees that if the component is reused/reinserted,
         // it will be re-rendered because we are disconnecting the reactivity

packages/@lwc/engine-core/src/framework/wiring/context.ts

@@ -54,9 +54,12 @@ export function createContextProviderWithRegister(
                         consumerDisconnectedCallback(consumer);
                     }
                 };
-                setDisconnectedCallback(disconnectCallback);
+                setDisconnectedCallback?.(disconnectCallback);
 
                 consumerConnectedCallback(consumer);
+                // Return true as the context is always consumed here and the consumer should
+                // stop bubbling.
+                return true;
             }
         );
     };
@@ -91,6 +94,9 @@ export function createContextWatcher(
                 // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
                 // TODO: dev-mode validation of config based on the adapter.contextSchema
                 callbackWhenContextIsReady(newContext);
+                // Return true as the context is always consumed here and the consumer should
+                // stop bubbling.
+                return true;
             },
             setDisconnectedCallback(disconnectCallback: () => void) {
                 // adds this callback into the disconnect bucket so it gets disconnected from parent

packages/@lwc/engine-core/src/framework/wiring/types.ts

@@ -59,13 +59,15 @@ export interface WireDebugInfo {
     wasDataProvisionedForConfig: boolean;
 }
 
+export type ShouldContinueBubbling = boolean;
+
 export type WireContextSubscriptionCallback = (
     subscriptionPayload: WireContextSubscriptionPayload
-) => void;
+) => ShouldContinueBubbling;
 
 export interface WireContextSubscriptionPayload {
-    setNewContext(newContext: ContextValue): void;
-    setDisconnectedCallback(disconnectCallback: () => void): void;
+    setNewContext(newContext: ContextValue): ShouldContinueBubbling;
+    setDisconnectedCallback?(disconnectCallback: () => void): void;
 }
 
 export interface ContextConsumer {

packages/@lwc/engine-core/src/shared/logger.ts

@@ -51,6 +51,10 @@ export function logError(message: string, vm?: VM) {
     log('error', message, vm, false);
 }
 
+export function logErrorOnce(message: string, vm?: VM) {
+    log('error', message, vm, true);
+}
+
 export function logWarn(message: string, vm?: VM) {
     log('warn', message, vm, false);
 }

packages/@lwc/engine-dom/src/index.ts

@@ -30,7 +30,9 @@ export {
     isComponentConstructor,
     parseFragment,
     parseSVGFragment,
+    setContextKeys,
     setTrustedSignalSet,
+    setTrustedContextSet,
     swapComponent,
     swapStyle,
     swapTemplate,

packages/@lwc/engine-dom/src/renderer/context.ts

@@ -16,8 +16,8 @@ import type {
 
 export class WireContextSubscriptionEvent extends CustomEvent<undefined> {
     // These are initialized on the constructor via defineProperties.
-    public readonly setNewContext!: (newContext: WireContextValue) => void;
-    public readonly setDisconnectedCallback!: (disconnectCallback: () => void) => void;
+    public readonly setNewContext!: (newContext: WireContextValue) => boolean;
+    public readonly setDisconnectedCallback?: (disconnectCallback: () => void) => void;
 
     constructor(
         adapterToken: string,
@@ -56,11 +56,15 @@ export function registerContextProvider(
     onContextSubscription: WireContextSubscriptionCallback
 ) {
     addEventListener(elm, adapterContextToken, ((evt: WireContextSubscriptionEvent) => {
-        evt.stopImmediatePropagation();
         const { setNewContext, setDisconnectedCallback } = evt;
-        onContextSubscription({
-            setNewContext,
-            setDisconnectedCallback,
-        });
+        // If context subscription is successful, stop event propagation
+        if (
+            onContextSubscription({
+                setNewContext,
+                setDisconnectedCallback,
+            })
+        ) {
+            evt.stopImmediatePropagation();
+        }
     }) as EventListener);
 }

packages/@lwc/engine-server/src/context.ts

@@ -26,7 +26,7 @@ export function createContextProvider(adapter: WireAdapterConstructor) {
     return createContextProviderWithRegister(adapter, registerContextProvider);
 }
 
-function registerContextProvider(
+export function registerContextProvider(
     elm: HostElement | LightningElement,
     adapterContextToken: string,
     onContextSubscription: WireContextSubscriptionCallback
@@ -57,10 +57,10 @@ export function registerContextConsumer(
             const subscribeToProvider =
                 currentNode[HostContextProvidersKey].get(adapterContextToken);
             if (!isUndefined(subscribeToProvider)) {
-                subscribeToProvider(subscriptionPayload);
-                // If we find a provider, we shouldn't continue traversing
-                // looking for another provider.
-                break;
+                // If context subscription is successful, stop traversing to locate a provider
+                if (subscribeToProvider(subscriptionPayload)) {
+                    break;
+                }
             }
         }
 

packages/@lwc/engine-server/src/index.ts

@@ -29,6 +29,9 @@ export {
     isComponentConstructor,
     parseFragment,
     parseFragment as parseSVGFragment,
+    setTrustedSignalSet,
+    setTrustedContextSet,
+    setContextKeys,
 } from '@lwc/engine-core';
 
 // Engine-server public APIs -----------------------------------------------------------------------

packages/@lwc/engine-server/src/renderer.ts

@@ -35,7 +35,7 @@ import {
     startTrackingMutations,
     stopTrackingMutations,
 } from './utils/mutation-tracking';
-import { registerContextConsumer } from './context';
+import { registerContextConsumer, registerContextProvider } from './context';
 import type { HostNode, HostElement, HostAttribute, HostChildNode } from './types';
 import type { LifecycleCallback } from '@lwc/engine-core';
 
@@ -509,6 +509,7 @@ export const renderer = {
     insertStylesheet,
     assertInstanceOfHTMLElement,
     ownerDocument,
+    registerContextProvider,
     registerContextConsumer,
     attachInternals,
     defineCustomElement: getUpgradableElement,