fix: isolate locale properties in createLocalReq

packages/payload/src/utilities/createPayloadRequest.spec.ts

@@ -131,3 +131,66 @@ describe('createPayloadRequest - URL construction', () => {
     expect(mockPayload.logger.error).not.toHaveBeenCalled()
   })
 })
+
+describe('createPayloadRequest - locale isolation', () => {
+  const localizedPayload = {
+    config: {
+      admin: { user: 'users' },
+      serverURL: undefined,
+      i18n: {
+        fallbackLanguage: 'en',
+        supportedLanguages: { en: {} },
+        translations: {},
+      },
+      localization: {
+        defaultLocale: 'en',
+        fallback: true,
+        localeCodes: ['en', 'es'],
+        locales: [{ code: 'en' }, { code: 'es' }],
+      },
+    },
+    logger: {
+      error: vi.fn(),
+    },
+  } as unknown as Payload
+
+  it('should not rewrite the caller req locale when the nested call passes a different locale', async () => {
+    const req = {
+      i18n: { t: (str: string) => str },
+      locale: 'es',
+      payloadDataLoader: {},
+    }
+
+    const result = await createPayloadRequest({ locale: 'en', payload: localizedPayload, req })
+
+    expect(result.locale).toBe('en')
+    expect(req.locale).toBe('es')
+  })
+
+  it('should not rewrite the caller req fallbackLocale when the nested call passes a locale', async () => {
+    const req = {
+      fallbackLocale: false,
+      i18n: { t: (str: string) => str },
+      locale: 'es',
+      payloadDataLoader: {},
+    }
+
+    const result = await createPayloadRequest({ locale: 'en', payload: localizedPayload, req })
+
+    expect(result.fallbackLocale).toBe('en')
+    expect(req.fallbackLocale).toBe(false)
+  })
+
+  it('should fall back to the caller req locale when the nested call passes no locale', async () => {
+    const req = {
+      i18n: { t: (str: string) => str },
+      locale: 'es',
+      payloadDataLoader: {},
+    }
+
+    const result = await createPayloadRequest({ payload: localizedPayload, req })
+
+    expect(result.locale).toBe('es')
+    expect(req.locale).toBe('es')
+  })
+})

packages/payload/src/utilities/createPayloadRequest.ts

@@ -3,7 +3,8 @@ import type { PayloadRequest } from '../types/index.js'
 
 import { getDataLoader } from '../collections/dataloader.js'
 import { getLocalI18n } from '../translations/getLocalI18n.js'
-import { sanitizeFallbackLocale } from '../utilities/sanitizeFallbackLocale.js'
+import { isolateObjectProperty } from './isolateObjectProperty.js'
+import { sanitizeFallbackLocale } from './sanitizeFallbackLocale.js'
 
 function getRequestContext(
   req: Partial<PayloadRequest> = { context: null } as unknown as PayloadRequest,
@@ -108,55 +109,64 @@ export const createPayloadRequest: CreatePayloadRequest = async ({
   urlSuffix,
   user,
 }): Promise<PayloadRequest> => {
+  // A nested Local API call with an explicit `locale` must not rewrite the
+  // caller's req: `beforeChange` merges submitted data into per-locale fields
+  // based on `req.locale` after hooks/validation have awaited, so a mutated
+  // `req.locale` corrupts the parent operation's data (see #18246). Isolate
+  // both locale properties; the nested operation still sees its own locale
+  // through the returned request.
+  const localReq = isolateObjectProperty(req, ['locale', 'fallbackLocale'])
+
   const localization = payload.config?.localization
 
   if (localization) {
     const locale = localeArg === '*' ? 'all' : localeArg
     const defaultLocale = localization.defaultLocale
-    const localeCandidate = locale || req?.locale || req?.query?.locale
+    const localeCandidate = locale || localReq?.locale || localReq?.query?.locale
 
-    req.locale =
+    localReq.locale =
       localeCandidate && typeof localeCandidate === 'string' ? localeCandidate : defaultLocale
 
     const sanitizedFallback = sanitizeFallbackLocale({
       fallbackLocale: fallbackLocale!,
-      locale: req.locale,
+      locale: localReq.locale,
       localization,
     })
 
-    req.fallbackLocale = sanitizedFallback!
+    localReq.fallbackLocale = sanitizedFallback!
   }
 
   const i18n =
-    req?.i18n ||
+    localReq?.i18n ||
     (await getLocalI18n({ config: payload.config, language: payload.config.i18n.fallbackLanguage }))
 
-  if (!req.headers) {
-    req.headers = new Headers()
+  if (!localReq.headers) {
+    localReq.headers = new Headers()
   }
 
-  req.context = getRequestContext(req, context)
-  req.payloadAPI = req?.payloadAPI || 'local'
-  req.payload = payload
-  req.i18n = i18n
-  req.t = i18n.t
-  req.user = user === undefined ? (req?.user ?? null) : user
+  localReq.context = getRequestContext(localReq, context)
+  localReq.payloadAPI = localReq?.payloadAPI || 'local'
+  localReq.payload = payload
+  localReq.i18n = i18n
+  localReq.t = i18n.t
+  localReq.user = user === undefined ? (localReq?.user ?? null) : user
 
   // Ensure user.collection is set for auth-related access control
   // TODO (4.0): Instead of silently falling back, throw an error if user.collection is missing
-  if (req.user && !req.user.collection) {
-    req.user = { ...req.user, collection: payload.config.admin.user }
+  if (localReq.user && !localReq.user.collection) {
+    localReq.user = { ...localReq.user, collection: payload.config.admin.user }
   }
 
-  req.payloadDataLoader = req?.payloadDataLoader || getDataLoader(req as PayloadRequest)
-  req.routeParams = req?.routeParams || {}
-  req.query = req?.query || {}
+  localReq.payloadDataLoader =
+    localReq?.payloadDataLoader || getDataLoader(localReq as PayloadRequest)
+  localReq.routeParams = localReq?.routeParams || {}
+  localReq.query = localReq?.query || {}
 
   if (typeof depth !== 'undefined') {
-    req.query.depth = depth
+    localReq.query.depth = depth
   }
 
-  attachFakeURLProperties(req, urlSuffix)
+  attachFakeURLProperties(localReq, urlSuffix)
 
-  return req as PayloadRequest
+  return localReq as PayloadRequest
 }

packages/payload/src/utilities/isolateObjectProperty.spec.ts

@@ -59,6 +59,52 @@ describe('isolateObjectProperty', () => {
     })
   })
 
+  describe('spread and enumeration', () => {
+    it('should include an isolated property set on the proxy in a spread', () => {
+      const original: Record<string, any> = { b: 2 }
+      const proxy = isolateObjectProperty(original, 'a')
+
+      proxy.a = 100
+
+      expect({ ...proxy }).toEqual({ a: 100, b: 2 })
+      expect(original).toEqual({ b: 2 })
+    })
+
+    it('should include isolated properties in Object.keys and entries', () => {
+      const original = { a: 1, b: 2 }
+      const proxy = isolateObjectProperty(original, 'a')
+
+      proxy.a = 100
+
+      expect(Object.keys(proxy).sort()).toEqual(['a', 'b'])
+      expect(Object.fromEntries(Object.entries(proxy))).toEqual({ a: 100, b: 2 })
+    })
+
+    it('should report an enumerable, configurable descriptor for an isolated property not on the original', () => {
+      const original: Record<string, any> = { b: 2 }
+      const proxy = isolateObjectProperty(original, 'a')
+
+      proxy.a = 100
+
+      expect(Object.getOwnPropertyDescriptor(proxy, 'a')).toEqual({
+        configurable: true,
+        enumerable: true,
+        value: 100,
+        writable: true,
+      })
+    })
+
+    it('should not include a deleted isolated property in a spread', () => {
+      const original: Record<string, any> = { a: 1, b: 2 }
+      const proxy = isolateObjectProperty(original, 'a')
+
+      delete proxy.a
+
+      expect({ ...proxy }).toEqual({ b: 2 })
+      expect(Object.keys(proxy)).toEqual(['b'])
+    })
+  })
+
   describe('private field access (Node 24+ compatibility)', () => {
     /**
      * Class with private fields to test that the proxy correctly handles
@@ -126,5 +172,33 @@ describe('isolateObjectProperty', () => {
       expect(proxy.headers).toBeInstanceOf(Headers)
       expect(proxy.headers.get('content-type')).toBe('application/json')
     })
+
+    it('should allow calling methods that access private fields', () => {
+      class ObjectWithPrivateMethod {
+        #privateValue: string
+
+        constructor(value: string) {
+          this.#privateValue = value
+        }
+
+        getValue(): string {
+          return this.#privateValue
+        }
+      }
+
+      const original = new ObjectWithPrivateMethod('secret')
+      const proxy = isolateObjectProperty(original, 'nonExistentKey' as keyof typeof original)
+
+      // This would throw "Cannot read private member" if the method ran with the proxy as receiver
+      expect(proxy.getValue()).toBe('secret')
+    })
+
+    it('should allow calling Request.text() on a proxied request', async () => {
+      const request = new Request('https://example.com', { method: 'POST', body: 'hello' })
+      const proxy = isolateObjectProperty(request, 'nonExistentKey' as keyof typeof request)
+
+      // Undici reads the private #state field; with the proxy as receiver this throws
+      await expect(proxy.text()).resolves.toBe('hello')
+    })
   })
 })

packages/payload/src/utilities/isolateObjectProperty.ts

@@ -21,11 +21,54 @@ export function isolateObjectProperty<T extends object>(object: T, key: (keyof T
         return Reflect.get(delegate, p, receiver)
       }
       // Use target as receiver to preserve private field access (e.g., Request#headers in Node 24+)
-      return Reflect.get(target, p, target)
+      const value = Reflect.get(target, p, target)
+      // Methods must run against the target: invoked as proxy.method(), `this`
+      // would be the proxy and private field access (e.g., Request#text reading
+      // #state in undici) throws "Cannot read private member".
+      if (typeof value === 'function') {
+        return value.bind(target)
+      }
+      return value
+    },
+    getOwnPropertyDescriptor(target, p) {
+      if (keys.includes(p as keyof T)) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(delegate, p)
+
+        if (descriptor) {
+          const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, p)
+
+          // A key held only in the delegate is not an own property of the
+          // target, so it can only be reported as configurable. Keep the
+          // target's configurability when it also holds the key.
+          return {
+            ...descriptor,
+            configurable: targetDescriptor ? targetDescriptor.configurable : true,
+          }
+        }
+
+        const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, p)
+
+        // An isolated key missing from the delegate counts as absent,
+        // unless the target holds it as non-configurable, which a proxy
+        // is not allowed to hide.
+        return targetDescriptor && !targetDescriptor.configurable ? targetDescriptor : undefined
+      }
+      return Reflect.getOwnPropertyDescriptor(target, p)
     },
     has(target, p) {
       return Reflect.has(keys.includes(p as keyof T) ? delegate : target, p)
     },
+    ownKeys(target) {
+      const targetKeys = Reflect.ownKeys(target)
+
+      // Extra keys can only be reported when the target is extensible,
+      // otherwise the result must match the target's keys exactly.
+      if (!Object.isExtensible(target)) {
+        return targetKeys
+      }
+
+      return [...targetKeys, ...Reflect.ownKeys(delegate).filter((k) => !targetKeys.includes(k))]
+    },
     set(target, p, newValue, _receiver) {
       if (keys.includes(p as keyof T)) {
         // in case of transactionID we must ignore any receiver, because