diff --git a/packages/endpoint/README.md b/packages/endpoint/README.md
new file mode 100644
index 0000000000..9c7182d34a
--- /dev/null
+++ b/packages/endpoint/README.md
@@ -0,0 +1,135 @@
+# @datadog/browser-sdk-endpoint
+
+Node.js package for generating self-contained Datadog Browser SDK bundles with embedded remote configuration. Designed for CI/CD pipelines, SSR frameworks, and custom build tooling.
+
+## Installation
+
+```bash
+npm install @datadog/browser-sdk-endpoint
+```
+
+## Usage
+
+### Generate a bundle (CI / build script)
+
+Fetch remote configuration, download the SDK from CDN, and produce a single self-executing IIFE in one call:
+
+```typescript
+import { generateBundle } from '@datadog/browser-sdk-endpoint'
+import { writeFileSync } from 'node:fs'
+
+const bundle = await generateBundle({
+  applicationId: 'your-app-id',
+  remoteConfigurationId: 'your-config-id',
+  variant: 'rum',          // 'rum' | 'rum-slim' | 'logs' | 'rum-and-logs'
+  site: 'datadoghq.com',   // optional, defaults to datadoghq.com
+})
+
+writeFileSync('public/datadog-sdk.js', bundle)
+```
+
+Then in your HTML, set `window.__DD_BASE_CONFIG__` with the fields that belong to the page (not the remote config) before loading the bundle:
+
+```html
+<script>
+  window.__DD_BASE_CONFIG__ = {
+    clientToken: 'your-client-token',
+    site: 'datadoghq.com'
+  }
+</script>
+<script src="/datadog-sdk.js"></script>
+```
+
+The bundle merges `__DD_BASE_CONFIG__` with the embedded remote configuration and calls `DD_RUM.init()` automatically — no additional `init()` call needed in your app code.
+
+### SSR: inject configuration at render time
+
+If you use server-side rendering and want to avoid a separate bundle generation step, you can fetch the remote configuration per request, serialize it to an inline JS expression, and inject it into the HTML response. The SDK is loaded separately; only the configuration is embedded.
+
+```typescript
+import { fetchRemoteConfiguration } from '@datadog/browser-remote-config'
+import { resolveDynamicValues, serializeConfigToJs } from '@datadog/browser-remote-config/node'
+
+// In your SSR handler (Express, Next.js getServerSideProps, etc.)
+const result = await fetchRemoteConfiguration({
+  applicationId: 'your-app-id',
+  remoteConfigurationId: 'your-config-id',
+})
+
+if (result.ok) {
+  const configJs = serializeConfigToJs(resolveDynamicValues(result.value))
+
+  // Inject into <head> before the SDK script tag
+  // configJs is a JS object literal — dynamic values (cookies, DOM, window.*) are
+  // serialized as inline expressions that evaluate in the browser at page load time
+  html += `<script>window.__DD_RC_CONFIG__ = ${configJs}</script>`
+}
+```
+
+Then in your client-side code:
+
+```typescript
+import { datadogRum } from '@datadog/browser-rum'
+
+datadogRum.init({
+  applicationId: 'your-app-id',
+  clientToken: 'your-client-token',
+  site: 'datadoghq.com',
+  ...window.__DD_RC_CONFIG__
+})
+```
+
+`resolveDynamicValues` from the Node entry point serializes `DynamicOption` fields (cookie, JS path, DOM, localStorage) as inline JS expressions rather than evaluating them on the server. Those expressions run against live browser APIs when the `<script>` tag is parsed, so dynamic values like a cookie-based user ID are resolved at the right time.
+
+### Build blocks (advanced)
+
+Use `fetchConfig`, `generateCombinedBundle`, and `downloadSDK` separately for custom pipelines:
+
+```typescript
+import { fetchConfig, generateCombinedBundle } from '@datadog/browser-sdk-endpoint'
+import { resolveDynamicValues, serializeConfigToJs } from '@datadog/browser-remote-config/node'
+import { downloadSDK } from '@datadog/browser-sdk-endpoint'
+
+const configResult = await fetchConfig({
+  applicationId: 'your-app-id',
+  remoteConfigurationId: 'your-config-id',
+})
+
+const configJs = serializeConfigToJs(resolveDynamicValues(configResult.value))
+const sdkCode = await downloadSDK({ variant: 'rum' })
+
+const bundle = generateCombinedBundle({ sdkCode, configJs, variant: 'rum' })
+```
+
+## API
+
+### `generateBundle(options)`
+
+Fetches remote configuration, downloads the SDK from CDN, and returns a combined bundle string.
+
+- `applicationId` (string, required)
+- `remoteConfigurationId` (string, required)
+- `variant` (`'rum' | 'rum-slim' | 'logs' | 'rum-and-logs'`, required)
+- `site` (string, optional) — Datadog site, e.g. `'datadoghq.eu'`
+- `datacenter` (string, optional) — CDN datacenter, e.g. `'us1'`
+
+### `fetchConfig(options)`
+
+Fetches and validates remote configuration. Throws on network error or invalid config ID.
+
+- `applicationId`, `remoteConfigurationId`, `site` — same as above
+
+### `generateCombinedBundle(options)`
+
+Assembles a self-executing IIFE from pre-fetched parts.
+
+- `sdkCode` (string) — SDK source downloaded from CDN
+- `configJs` (string) — serialized config from `serializeConfigToJs`
+- `variant` — SDK variant label embedded in the bundle comment
+- `sdkVersion` (string, optional) — version label embedded in the bundle comment
+
+### `downloadSDK(options)`
+
+Downloads the SDK bundle from the Datadog CDN. Results are cached in memory per variant + datacenter.
+
+- `variant`, `datacenter`, `version` (optional — defaults to the package version)
diff --git a/packages/endpoint/package.json b/packages/endpoint/package.json
new file mode 100644
index 0000000000..1bc0a19a68
--- /dev/null
+++ b/packages/endpoint/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "@datadog/browser-sdk-endpoint",
+  "version": "6.28.0",
+  "license": "Apache-2.0",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@datadog/browser-remote-config": "6.28.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/endpoint/src/bundleGenerator.spec.ts b/packages/endpoint/src/bundleGenerator.spec.ts
new file mode 100644
index 0000000000..b3d73306fa
--- /dev/null
+++ b/packages/endpoint/src/bundleGenerator.spec.ts
@@ -0,0 +1,99 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { generateCombinedBundle } from './bundleGenerator.ts'
+import { INLINE_HELPERS } from './helpers.ts'
+
+const mockSdkCode = 'window.DD_RUM = { init: function(c) { this.config = c; } };'
+
+describe('generateCombinedBundle', () => {
+  it('wraps output in an IIFE', () => {
+    const bundle = generateCombinedBundle({
+      sdkCode: mockSdkCode,
+      configJs: '{ "sessionSampleRate": 24 }',
+      variant: 'rum',
+    })
+    assert.ok(bundle.includes('(function() {'), 'Should contain IIFE start')
+    assert.ok(bundle.includes('})();'), 'Should contain IIFE end')
+    assert.ok(bundle.includes("'use strict';"), 'Should include use strict')
+  })
+
+  it('embeds configJs verbatim without re-serializing', () => {
+    const configJs = '{ "sessionSampleRate": 24, "user": { id: __dd_getJs(\'window.user\') } }'
+    const bundle = generateCombinedBundle({ sdkCode: mockSdkCode, configJs, variant: 'rum' })
+    assert.ok(bundle.includes(configJs), 'Should embed configJs verbatim')
+  })
+
+  it('always includes all six inline helpers', () => {
+    const bundle = generateCombinedBundle({
+      sdkCode: mockSdkCode,
+      configJs: '{ "sessionSampleRate": 100 }',
+      variant: 'rum',
+    })
+    assert.ok(bundle.includes('__dd_getCookie'), 'Should include cookie helper')
+    assert.ok(bundle.includes('__dd_getJs'), 'Should include JS helper')
+    assert.ok(bundle.includes('__dd_getDomText'), 'Should include DOM text helper')
+    assert.ok(bundle.includes('__dd_getDomAttr'), 'Should include DOM attr helper')
+    assert.ok(bundle.includes('__dd_getLocalStorage'), 'Should include localStorage helper')
+    assert.ok(bundle.includes('__dd_extract'), 'Should include extract helper')
+  })
+
+  it('includes variant in header comment', () => {
+    const bundle = generateCombinedBundle({
+      sdkCode: mockSdkCode,
+      configJs: '{}',
+      variant: 'rum-slim',
+    })
+    assert.ok(bundle.includes('SDK Variant: rum-slim'), 'Should include variant in header')
+  })
+
+  it('includes SDK version in header when provided', () => {
+    const bundle = generateCombinedBundle({
+      sdkCode: mockSdkCode,
+      configJs: '{}',
+      variant: 'rum',
+      sdkVersion: '6.28.0',
+    })
+    assert.ok(bundle.includes('SDK Version: 6.28.0'), 'Should include version in header')
+  })
+
+  it('calls DD_RUM.init with the embedded config variable', () => {
+    const bundle = generateCombinedBundle({
+      sdkCode: mockSdkCode,
+      configJs: '{ "sessionSampleRate": 50 }',
+      variant: 'rum',
+    })
+    assert.ok(bundle.includes('window.DD_RUM.init(__DATADOG_REMOTE_CONFIG__)'), 'Should call DD_RUM.init')
+  })
+
+  it('a config with only static values contains no helper calls in the config section', () => {
+    const configJs = '{ "sessionSampleRate": 24, "env": "prod" }'
+    const bundle = generateCombinedBundle({ sdkCode: mockSdkCode, configJs, variant: 'rum' })
+    // helpers are present as function definitions but not called from the config
+    const configSection = bundle.split('var __DATADOG_REMOTE_CONFIG__')[1].split(';')[0]
+    assert.ok(!configSection.includes('__dd_getCookie('), 'Static config should not call cookie helper')
+    assert.ok(!configSection.includes('__dd_getJs('), 'Static config should not call JS helper')
+  })
+
+  it('a config with dynamic values embeds helper calls in the config section', () => {
+    const configJs = '{ "user": { id: __dd_getJs(\'window.user\') } }'
+    const bundle = generateCombinedBundle({ sdkCode: mockSdkCode, configJs, variant: 'rum' })
+    const configSection = bundle.split('var __DATADOG_REMOTE_CONFIG__')[1].split(';')[0]
+    assert.ok(configSection.includes("__dd_getJs('window.user')"), 'Dynamic config should call JS helper')
+  })
+})
+
+describe('INLINE_HELPERS', () => {
+  it('defines all six helper functions', () => {
+    assert.ok(INLINE_HELPERS.includes('function __dd_getCookie'), 'Should define getCookie')
+    assert.ok(INLINE_HELPERS.includes('function __dd_getJs'), 'Should define getJs')
+    assert.ok(INLINE_HELPERS.includes('function __dd_getDomText'), 'Should define getDomText')
+    assert.ok(INLINE_HELPERS.includes('function __dd_getDomAttr'), 'Should define getDomAttr')
+    assert.ok(INLINE_HELPERS.includes('function __dd_getLocalStorage'), 'Should define getLocalStorage')
+    assert.ok(INLINE_HELPERS.includes('function __dd_extract'), 'Should define extract')
+  })
+
+  it('is valid JavaScript', () => {
+    // Wrapping in a function and parsing via Function constructor validates syntax
+    assert.doesNotThrow(() => new Function(INLINE_HELPERS), 'INLINE_HELPERS should be valid JS')
+  })
+})
diff --git a/packages/endpoint/src/bundleGenerator.ts b/packages/endpoint/src/bundleGenerator.ts
new file mode 100644
index 0000000000..eaef70a879
--- /dev/null
+++ b/packages/endpoint/src/bundleGenerator.ts
@@ -0,0 +1,106 @@
+import type { SdkVariant } from './sdkDownloader.ts'
+import { getDefaultVersion, downloadSDK } from './sdkDownloader.ts'
+import { INLINE_HELPERS } from './helpers.ts'
+import { fetchRemoteConfiguration } from '@datadog/browser-remote-config'
+import { resolveDynamicValues, serializeConfigToJs } from '@datadog/browser-remote-config/node'
+
+export type { SdkVariant } from './sdkDownloader.ts'
+
+export interface FetchConfigOptions {
+  applicationId: string
+  remoteConfigurationId: string
+  site?: string
+}
+
+export interface CombineBundleOptions {
+  sdkCode: string
+  configJs: string
+  variant: SdkVariant
+  sdkVersion?: string
+}
+
+export interface GenerateBundleOptions {
+  applicationId: string
+  remoteConfigurationId: string
+  variant: SdkVariant
+  site?: string
+  datacenter?: string
+}
+
+const CONFIG_FETCH_TIMEOUT_MS = 30_000
+const VALID_VARIANTS: SdkVariant[] = ['rum', 'rum-slim', 'logs', 'rum-and-logs']
+
+export async function fetchConfig(options: FetchConfigOptions) {
+  const result = await fetchRemoteConfiguration({
+    applicationId: options.applicationId,
+    remoteConfigurationId: options.remoteConfigurationId,
+    site: options.site,
+    signal: AbortSignal.timeout(CONFIG_FETCH_TIMEOUT_MS),
+  })
+
+  if (!result.ok) {
+    throw new Error(
+      `Failed to fetch remote configuration: ${result.error.message}\n` +
+        `Verify applicationId "${options.applicationId}" and ` +
+        `configId "${options.remoteConfigurationId}" are correct.`
+    )
+  }
+
+  return { ok: true as const, value: result.value }
+}
+
+export function generateCombinedBundle(options: CombineBundleOptions): string {
+  const { sdkCode, configJs, variant, sdkVersion } = options
+  const versionDisplay = sdkVersion ?? 'unknown'
+
+  return `/**
+ * Datadog Browser SDK with Embedded Remote Configuration
+ * SDK Variant: ${variant}
+ * SDK Version: ${versionDisplay}
+ */
+(function() {
+  'use strict';
+
+  // Inline helpers for dynamic value resolution
+  ${INLINE_HELPERS}
+
+  // Embedded remote configuration
+  var __DATADOG_REMOTE_CONFIG__ = ${configJs};
+
+  // SDK bundle (${variant}) from CDN
+  ${sdkCode}
+
+  // Auto-initialize — merge base config (clientToken, site, etc.) set by the page before this script
+  var __DD_CONFIG__ = Object.assign({}, window.__DD_BASE_CONFIG__ || {}, __DATADOG_REMOTE_CONFIG__);
+  if (typeof window !== 'undefined') {
+    if (window.DD_RUM) { window.DD_RUM.init(__DD_CONFIG__); }
+    if (window.DD_LOGS) { window.DD_LOGS.init(__DD_CONFIG__); }
+  }
+})();`
+}
+
+export async function generateBundle(options: GenerateBundleOptions): Promise<string> {
+  if (!options.applicationId || typeof options.applicationId !== 'string') {
+    throw new Error("Option 'applicationId' is required and must be a non-empty string.")
+  }
+  if (!options.remoteConfigurationId || typeof options.remoteConfigurationId !== 'string') {
+    throw new Error("Option 'remoteConfigurationId' is required and must be a non-empty string.")
+  }
+  if (!VALID_VARIANTS.includes(options.variant)) {
+    throw new Error(`Option 'variant' must be 'rum' or 'rum-slim', got '${String(options.variant)}'.`)
+  }
+
+  const configResult = await fetchConfig({
+    applicationId: options.applicationId,
+    remoteConfigurationId: options.remoteConfigurationId,
+    site: options.site,
+  })
+
+  const resolved = resolveDynamicValues(configResult.value)
+  const configJs = serializeConfigToJs(resolved)
+
+  const sdkCode = await downloadSDK({ variant: options.variant, datacenter: options.datacenter })
+  const sdkVersion = getDefaultVersion()
+
+  return generateCombinedBundle({ sdkCode, configJs, variant: options.variant, sdkVersion })
+}
diff --git a/packages/endpoint/src/helpers.ts b/packages/endpoint/src/helpers.ts
new file mode 100644
index 0000000000..fd393f1352
--- /dev/null
+++ b/packages/endpoint/src/helpers.ts
@@ -0,0 +1,11 @@
+/**
+ * Inline browser helper functions embedded in generated bundles.
+ * Minimal vanilla JS — no dependencies, no transpilation needed.
+ */
+export const INLINE_HELPERS = `\
+function __dd_getCookie(n){var m=document.cookie.match(new RegExp('(?:^|; )'+encodeURIComponent(n)+'=([^;]*)'));return m?decodeURIComponent(m[1]):undefined}
+function __dd_getJs(p){try{return p.split('.').reduce(function(o,k){return o[k]},window)}catch(e){return undefined}}
+function __dd_getDomText(s){try{var e=document.querySelector(s);return e?e.textContent:undefined}catch(e){return undefined}}
+function __dd_getDomAttr(s,a){try{var e=document.querySelector(s);return e?e.getAttribute(a):undefined}catch(e){return undefined}}
+function __dd_getLocalStorage(k){try{return localStorage.getItem(k)}catch(e){return undefined}}
+function __dd_extract(v,p){if(v==null)return undefined;var m=new RegExp(p).exec(String(v));return m?m[1]!==undefined?m[1]:m[0]:undefined}`
diff --git a/packages/endpoint/src/index.ts b/packages/endpoint/src/index.ts
new file mode 100644
index 0000000000..52818b35d1
--- /dev/null
+++ b/packages/endpoint/src/index.ts
@@ -0,0 +1,3 @@
+export { generateBundle, generateCombinedBundle, fetchConfig } from './bundleGenerator.ts'
+export type { GenerateBundleOptions, CombineBundleOptions, FetchConfigOptions } from './bundleGenerator.ts'
+export type { SdkVariant } from './sdkDownloader.ts'
diff --git a/packages/endpoint/src/sdkDownloader.ts b/packages/endpoint/src/sdkDownloader.ts
new file mode 100644
index 0000000000..008917e29c
--- /dev/null
+++ b/packages/endpoint/src/sdkDownloader.ts
@@ -0,0 +1,110 @@
+// eslint-disable-next-line local-rules/disallow-side-effects, local-rules/enforce-prod-deps-imports -- Node.js build tool
+import https from 'node:https'
+// eslint-disable-next-line local-rules/disallow-side-effects, local-rules/enforce-prod-deps-imports -- Node.js build tool
+import { createRequire } from 'node:module'
+
+export type SdkVariant = 'rum' | 'rum-slim' | 'logs' | 'rum-and-logs'
+
+// Variants that map to a single CDN file
+const CDN_VARIANTS: Record<Exclude<SdkVariant, 'rum-and-logs'>, string> = {
+  rum: 'rum',
+  'rum-slim': 'rum-slim',
+  logs: 'logs',
+}
+
+export interface DownloadSDKOptions {
+  variant: SdkVariant
+  datacenter?: string
+  version?: string
+}
+
+const CDN_HOST = 'https://www.datadoghq-browser-agent.com'
+const DEFAULT_DATACENTER = 'us1'
+
+const sdkCache = new Map<string, string>()
+
+export function getDefaultVersion(): string {
+  const require = createRequire(import.meta.url)
+  const pkg = require('@datadog/browser-remote-config/package.json') as { version: string }
+  return pkg.version
+}
+
+function getMajorVersion(version: string): number {
+  const major = parseInt(version.split('.')[0], 10)
+  if (isNaN(major)) {
+    throw new Error(`Invalid SDK version format: ${version}`)
+  }
+  return major
+}
+
+export async function downloadSDK(options: SdkVariant | DownloadSDKOptions): Promise<string> {
+  const variant = typeof options === 'string' ? options : options.variant
+  const datacenter = typeof options === 'string' ? DEFAULT_DATACENTER : (options.datacenter ?? DEFAULT_DATACENTER)
+  const version = typeof options === 'string' ? getDefaultVersion() : (options.version ?? getDefaultVersion())
+
+  // rum-and-logs: download both SDKs and concatenate
+  if (variant === 'rum-and-logs') {
+    const [rum, logs] = await Promise.all([
+      downloadSDK({ variant: 'rum', datacenter, version }),
+      downloadSDK({ variant: 'logs', datacenter, version }),
+    ])
+    return `${rum}\n${logs}`
+  }
+
+  const majorVersion = getMajorVersion(version)
+  const cdnVariant = CDN_VARIANTS[variant]
+
+  const cacheKey = `${variant}-${majorVersion}-${datacenter}`
+  const cached = sdkCache.get(cacheKey)
+  if (cached) {
+    return cached
+  }
+
+  const cdnUrl = `${CDN_HOST}/${datacenter}/v${majorVersion}/datadog-${cdnVariant}.js`
+
+  const sdkCode = await new Promise<string>((resolve, reject) => {
+    const request = https.get(cdnUrl, { timeout: 30000 }, (res) => {
+      let data = ''
+
+      if (res.statusCode === 404) {
+        reject(
+          new Error(
+            `SDK bundle not found at ${cdnUrl}\n` +
+              `Check that variant "${variant}" (major version: v${majorVersion}) is correct.\n` +
+              `Full SDK version: ${version}`
+          )
+        )
+        return
+      }
+
+      if (!res.statusCode || res.statusCode >= 400) {
+        reject(new Error(`Failed to download SDK from CDN: HTTP ${res.statusCode}\nURL: ${cdnUrl}`))
+        return
+      }
+
+      res.on('data', (chunk: Buffer | string) => {
+        data += String(chunk)
+      })
+
+      res.on('end', () => {
+        resolve(data)
+      })
+    })
+
+    request.on('error', (error: Error) => {
+      reject(new Error(`Network error downloading SDK from CDN:\nURL: ${cdnUrl}\nError: ${error.message}`))
+    })
+
+    request.on('timeout', () => {
+      request.destroy()
+      reject(new Error(`Timeout downloading SDK from CDN (30s):\nURL: ${cdnUrl}`))
+    })
+  })
+
+  sdkCache.set(cacheKey, sdkCode)
+  return sdkCode
+}
+
+export function clearSdkCache(): void {
+  sdkCache.clear()
+}
diff --git a/packages/endpoint/tsconfig.json b/packages/endpoint/tsconfig.json
new file mode 100644
index 0000000000..3b9078e304
--- /dev/null
+++ b/packages/endpoint/tsconfig.json
@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM"],
+    "types": ["node"],
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": []
+}
diff --git a/packages/remote-config/package.json b/packages/remote-config/package.json
index d6818bbc07..7896becb52 100644
--- a/packages/remote-config/package.json
+++ b/packages/remote-config/package.json
@@ -5,6 +5,11 @@
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "types": "cjs/index.d.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./node": "./src/entries/node.ts",
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "build": "node ../../scripts/build/build-package.ts --modules"
   },
diff --git a/packages/remote-config/src/entries/node.ts b/packages/remote-config/src/entries/node.ts
new file mode 100644
index 0000000000..9bd9e9c2d1
--- /dev/null
+++ b/packages/remote-config/src/entries/node.ts
@@ -0,0 +1,28 @@
+import {
+  resolveDynamicValues as resolveDynamicValuesFn,
+  fetchRemoteConfiguration,
+  buildEndpoint,
+} from '../remoteConfiguration'
+import { nodeContextItemHandler } from '../nodeResolution'
+
+/**
+ * Resolve dynamic RC values for Node.js code generation.
+ * DynamicOption fields are converted to inline JS expression strings (CodeExpression)
+ * rather than resolved against live browser APIs.
+ */
+export function resolveDynamicValues(
+  configValue: unknown,
+  options: {
+    onCookie?: (value: string | undefined) => void
+    onDom?: (value: string | null | undefined) => void
+    onJs?: (value: unknown) => void
+  } = {}
+): unknown {
+  return resolveDynamicValuesFn(configValue, {
+    ...options,
+    contextItemHandler: nodeContextItemHandler,
+  })
+}
+
+export { serializeConfigToJs } from '../nodeResolution'
+export { fetchRemoteConfiguration, buildEndpoint } from '../remoteConfiguration'
diff --git a/packages/remote-config/src/nodeResolution.spec.ts b/packages/remote-config/src/nodeResolution.spec.ts
new file mode 100644
index 0000000000..132d89ef91
--- /dev/null
+++ b/packages/remote-config/src/nodeResolution.spec.ts
@@ -0,0 +1,170 @@
+import {
+  serializeDynamicValueToJs,
+  nodeContextItemHandler,
+  serializeConfigToJs,
+  CodeExpression,
+} from './nodeResolution'
+import type { ContextItem, DynamicOption } from './remoteConfiguration.types'
+
+describe('serializeDynamicValueToJs', () => {
+  it('should serialize cookie strategy', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'cookie',
+      name: 'user_id',
+    })
+    expect(result).toBe("__dd_getCookie('user_id')")
+  })
+
+  it('should serialize js strategy', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'js',
+      path: 'window.user',
+    })
+    expect(result).toBe("__dd_getJs('window.user')")
+  })
+
+  it('should serialize dom strategy (text content)', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'dom',
+      selector: '[data-env]',
+    })
+    expect(result).toBe("__dd_getDomText('[data-env]')")
+  })
+
+  it('should serialize dom strategy (attribute)', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'dom',
+      selector: '[data-env]',
+      attribute: 'data-env',
+    })
+    expect(result).toBe("__dd_getDomAttr('[data-env]','data-env')")
+  })
+
+  it('should serialize localStorage strategy', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'localStorage',
+      key: 'app_version',
+    })
+    expect(result).toBe("__dd_getLocalStorage('app_version')")
+  })
+
+  it('should wrap expression with extractor when present', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'cookie',
+      name: 'version_string',
+      extractor: { rcSerializedType: 'regex', value: 'v(\\d+)' },
+    })
+    expect(result).toBe("__dd_extract(__dd_getCookie('version_string'),'v(\\\\d+)')")
+  })
+
+  it('should escape special characters in string values', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'cookie',
+      name: 'foo\nbar\u2028baz',
+    })
+    expect(result).toBe("__dd_getCookie('foo\\nbar\\u2028baz')")
+  })
+
+  it('should return "undefined" literal for unknown strategy', () => {
+    const result = serializeDynamicValueToJs({
+      rcSerializedType: 'dynamic',
+      strategy: 'unknown' as any,
+      name: 'foo',
+    } as any)
+    expect(result).toBe('undefined')
+  })
+})
+
+describe('nodeContextItemHandler', () => {
+  const resolve = (v: unknown): unknown => {
+    if (typeof v === 'object' && v !== null && 'strategy' in v) {
+      return { __isCodeExpression: true as const, code: serializeDynamicValueToJs(v as DynamicOption) }
+    }
+    return v
+  }
+
+  it('should convert a single ContextItem to a JS object literal CodeExpression', () => {
+    const items: ContextItem[] = [
+      { key: 'id', value: { rcSerializedType: 'dynamic', strategy: 'js', path: 'window.user' } },
+    ]
+    const result = nodeContextItemHandler(items, resolve) as CodeExpression
+    expect(result.__isCodeExpression).toBe(true)
+    expect(result.code).toContain('"id"')
+    expect(result.code).toContain("__dd_getJs('window.user')")
+  })
+
+  it('should handle multiple keys', () => {
+    const items: ContextItem[] = [
+      { key: 'id', value: { rcSerializedType: 'dynamic', strategy: 'cookie', name: 'uid' } },
+      { key: 'env', value: { rcSerializedType: 'dynamic', strategy: 'js', path: 'window.env' } },
+    ]
+    const result = nodeContextItemHandler(items, resolve) as CodeExpression
+    expect(result.code).toContain("__dd_getCookie('uid')")
+    expect(result.code).toContain("__dd_getJs('window.env')")
+  })
+
+  it('should skip items where value is undefined (malformed ContextItem)', () => {
+    const items = [{ key: 'id', value: undefined as any }]
+    const result = nodeContextItemHandler(items, () => undefined) as CodeExpression
+    expect(result.code).toBe('{}')
+  })
+})
+
+describe('serializeConfigToJs', () => {
+  it('should serialize primitive values', () => {
+    expect(serializeConfigToJs(24)).toBe('24')
+    expect(serializeConfigToJs('hello')).toBe('"hello"')
+    expect(serializeConfigToJs(true)).toBe('true')
+    expect(serializeConfigToJs(null)).toBe('null')
+  })
+
+  it('should inline a CodeExpression as raw code', () => {
+    const expr: CodeExpression = { __isCodeExpression: true, code: "__dd_getJs('window.user')" }
+    expect(serializeConfigToJs(expr)).toBe("__dd_getJs('window.user')")
+  })
+
+  it('should serialize a plain object recursively', () => {
+    const result = serializeConfigToJs({ sessionSampleRate: 24, env: 'prod' })
+    expect(result).toContain('"sessionSampleRate": 24')
+    expect(result).toContain('"env": "prod"')
+  })
+
+  it('should inline CodeExpression values within an object', () => {
+    const config = {
+      sessionSampleRate: 24,
+      user: { __isCodeExpression: true as const, code: "{ id: __dd_getJs('window.user') }" },
+    }
+    const result = serializeConfigToJs(config)
+    expect(result).toContain('"sessionSampleRate": 24')
+    expect(result).toContain('"user": { id: __dd_getJs(\'window.user\') }')
+  })
+
+  it('should serialize arrays', () => {
+    expect(serializeConfigToJs([1, 'two', true])).toBe('[1, "two", true]')
+  })
+
+  it('should return {} for an empty object', () => {
+    expect(serializeConfigToJs({})).toBe('{}')
+  })
+
+  it('should handle a realistic full config with mixed static and dynamic values', () => {
+    const config = {
+      applicationId: 'd717cc88-ced7-4830-a377-14433a5c7bb0',
+      sessionSampleRate: 24,
+      env: 'remote_config_demo',
+      user: { __isCodeExpression: true as const, code: "{ 'id': __dd_getJs('window.user') }" },
+    }
+    const result = serializeConfigToJs(config)
+    expect(result).toContain('"applicationId": "d717cc88-ced7-4830-a377-14433a5c7bb0"')
+    expect(result).toContain('"sessionSampleRate": 24')
+    expect(result).toContain('"env": "remote_config_demo"')
+    expect(result).toContain("\"user\": { 'id': __dd_getJs('window.user') }")
+  })
+})
diff --git a/packages/remote-config/src/nodeResolution.ts b/packages/remote-config/src/nodeResolution.ts
new file mode 100644
index 0000000000..a7c5e03f3a
--- /dev/null
+++ b/packages/remote-config/src/nodeResolution.ts
@@ -0,0 +1,105 @@
+import { display, isIndexableObject } from '@datadog/browser-core'
+import type { DynamicOption, ContextItem } from './remoteConfiguration.types'
+
+// ---------------------------------------------------------------------------
+// CodeExpression — internal marker for raw JS code strings
+// ---------------------------------------------------------------------------
+
+export interface CodeExpression {
+  __isCodeExpression: true
+  code: string
+}
+
+export function codeExpression(code: string): CodeExpression {
+  return { __isCodeExpression: true, code }
+}
+
+export function isCodeExpression(value: unknown): value is CodeExpression {
+  return isIndexableObject(value) && (value as unknown as CodeExpression).__isCodeExpression === true
+}
+
+// ---------------------------------------------------------------------------
+// serializeDynamicValueToJs
+// ---------------------------------------------------------------------------
+
+/**
+ * Serialize a string as a single-quoted JS string literal.
+ * Escapes backslashes, single quotes, and control characters so the result is valid JS.
+ */
+function jsStringLiteral(value: string): string {
+  return `'${value
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')}'`
+}
+
+export function serializeDynamicValueToJs(option: DynamicOption): string {
+  let expr: string
+  switch (option.strategy) {
+    case 'cookie':
+      expr = `__dd_getCookie(${jsStringLiteral(option.name)})`
+      break
+    case 'js':
+      expr = `__dd_getJs(${jsStringLiteral(option.path)})`
+      break
+    case 'dom':
+      expr =
+        option.attribute !== undefined
+          ? `__dd_getDomAttr(${jsStringLiteral(option.selector)},${jsStringLiteral(option.attribute)})`
+          : `__dd_getDomText(${jsStringLiteral(option.selector)})`
+      break
+    case 'localStorage':
+      expr = `__dd_getLocalStorage(${jsStringLiteral(option.key)})`
+      break
+    default:
+      display.error(`Unsupported remote configuration strategy: "${(option as DynamicOption).strategy}"`)
+      return 'undefined'
+  }
+
+  if (option.extractor !== undefined) {
+    expr = `__dd_extract(${expr},${jsStringLiteral(option.extractor.value)})`
+  }
+
+  return expr
+}
+
+// ---------------------------------------------------------------------------
+// nodeContextItemHandler and serializeConfigToJs — implemented in Task 2
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function nodeContextItemHandler(
+  items: ContextItem[],
+  // resolve is intentionally unused — ContextItem values are always DynamicOption,
+  // so we serialize them directly to JS expressions rather than resolving live values.
+  _resolve: (value: unknown) => unknown
+): CodeExpression {
+  const entries = items
+    .map(({ key, value }) => {
+      if (value === undefined) return null
+      return `${JSON.stringify(key)}: ${serializeDynamicValueToJs(value)}`
+    })
+    .filter((entry): entry is string => entry !== null)
+
+  return codeExpression(entries.length ? `{ ${entries.join(', ')} }` : '{}')
+}
+
+export function serializeConfigToJs(config: unknown): string {
+  if (isCodeExpression(config)) {
+    return config.code
+  }
+  if (Array.isArray(config)) {
+    return `[${config.map(serializeConfigToJs).join(', ')}]`
+  }
+  if (isIndexableObject(config)) {
+    const entries = Object.entries(config as Record<string, unknown>).map(
+      ([k, v]) => `${JSON.stringify(k)}: ${serializeConfigToJs(v)}`
+    )
+    return entries.length ? `{ ${entries.join(', ')} }` : '{}'
+  }
+  return JSON.stringify(config)
+}
diff --git a/packages/rum-core/src/domain/configuration/remoteConfiguration.spec.ts b/packages/rum-core/src/domain/configuration/remoteConfiguration.spec.ts
index 69b4044b48..b4b9338612 100644
--- a/packages/rum-core/src/domain/configuration/remoteConfiguration.spec.ts
+++ b/packages/rum-core/src/domain/configuration/remoteConfiguration.spec.ts
@@ -47,12 +47,15 @@ type ResolveRemoteConfigurationProperty<Key, Value> =
 type ResolvedRumRemoteConfiguration = ResolveRemoteConfigurationValue<RumRemoteConfiguration>
 
 // Make sure the RumRemoteConfiguration type is assignable to RumInitConfiguration.
+// 'user' and 'context' are excluded: in RumRemoteConfiguration they are ContextItem[] arrays
+// (resolved to array types), but in RumInitConfiguration they are User and Context objects.
+// The mapping between these shapes is handled by the bundle generator, not by direct assignment.
 type Assert<T extends true> = T
 export type _ = Assert<
-  ResolvedRumRemoteConfiguration & {
+  Omit<ResolvedRumRemoteConfiguration, 'user' | 'context'> & {
     // clientToken is not part of the remote configuration but required in init configuration
     clientToken: string
-  } extends RumInitConfiguration
+  } extends Omit<RumInitConfiguration, 'globalContext'>
     ? true
     : false
 >
diff --git a/tsconfig.default.json b/tsconfig.default.json
index 1170dbfce4..c510d13fef 100644
--- a/tsconfig.default.json
+++ b/tsconfig.default.json
@@ -18,6 +18,9 @@
     "scripts",
     "test/envUtils.ts",
 
+    // Files included in ./packages/endpoint/tsconfig.json
+    "packages/endpoint",
+
     // Files included in ./test/e2e/tsconfig.json
     "test/e2e",
     "test/lib",
diff --git a/tsconfig.json b/tsconfig.json
index 013707afb2..80066487c6 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,6 +3,7 @@
   "references": [
     { "path": "./tsconfig.default.json" },
     { "path": "./tsconfig.scripts.json" },
+    { "path": "./packages/endpoint/tsconfig.json" },
     { "path": "./developer-extension/tsconfig.json" },
     { "path": "./test/e2e/tsconfig.json" },
     { "path": "./test/performance/tsconfig.json" }
diff --git a/yarn.lock b/yarn.lock
index a2efdfa7ee..e26bf0e997 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -299,7 +299,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@datadog/browser-remote-config@workspace:packages/remote-config":
+"@datadog/browser-remote-config@npm:6.28.0, @datadog/browser-remote-config@workspace:packages/remote-config":
   version: 0.0.0-use.local
   resolution: "@datadog/browser-remote-config@workspace:packages/remote-config"
   dependencies:
@@ -444,6 +444,14 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@datadog/browser-sdk-endpoint@workspace:packages/endpoint":
+  version: 0.0.0-use.local
+  resolution: "@datadog/browser-sdk-endpoint@workspace:packages/endpoint"
+  dependencies:
+    "@datadog/browser-remote-config": "npm:6.28.0"
+  languageName: unknown
+  linkType: soft
+
 "@datadog/browser-worker@workspace:packages/worker":
   version: 0.0.0-use.local
   resolution: "@datadog/browser-worker@workspace:packages/worker"
