fix(nextjs): Seed Turbopack orchestrion marker merge-safely

The Turbopack value-injection seeded `__SENTRY_ORCHESTRION__` by assigning a
fresh `{ bundler: [] }` object, replacing any existing marker. Unlike the Bun
banner and `buildInjectPrologue`, this was not merge-safe, so a hybrid
runtime+bundler setup could wipe already-recorded runtime module names before
integrations read them.

The value-injection loader can only emit plain assignments, so it now accepts an
optional raw `prefixCode` and the marker is injected as a merge-safe snippet that
only creates the global/`bundler` array when absent.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mydea

packages/nextjs/src/config/loaders/valueInjectionLoader.ts

@@ -2,6 +2,10 @@ import type { LoaderThis } from './types';
 
 export type ValueInjectionLoaderOptions = {
   values: Record<string, unknown>;
+  // Raw JS prepended before the value assignments. Unlike `values` (plain `globalThis[key] = ...`
+  // assignments), this is emitted verbatim, so it can run merge-safe logic that a plain assignment
+  // can't express (e.g. seeding a global without clobbering an existing one).
+  prefixCode?: string;
 };
 
 /**
@@ -154,7 +158,7 @@ function findDirectiveTerminator(userCode: string, startIndex: number): number |
  */
 export default function valueInjectionLoader(this: LoaderThis<ValueInjectionLoaderOptions>, userCode: string): string {
   // We know one or the other will be defined, depending on the version of webpack being used
-  const { values } = 'getOptions' in this ? this.getOptions() : this.query;
+  const { values, prefixCode } = 'getOptions' in this ? this.getOptions() : this.query;
 
   // We do not want to cache injected values across builds
   this.cacheable(false);
@@ -163,6 +167,7 @@ export default function valueInjectionLoader(this: LoaderThis<ValueInjectionLoad
   const injectedCode =
     // eslint-disable-next-line prefer-template
     ';' +
+    (prefixCode ?? '') +
     Object.entries(values)
       .map(([key, value]) => `globalThis["${key}"] = ${JSON.stringify(value)};`)
       .join('');

packages/nextjs/src/config/turbopack/generateValueInjectionRules.ts

@@ -4,6 +4,14 @@ import type { RouteManifest } from '../manifest/types';
 import type { JSONValue, TurbopackMatcherWithRule } from '../types';
 import { getPackageModules, supportsTurbopackRuleCondition } from '../util';
 
+// Marks the bundler (build-time) orchestrion injection as active at boot, without clobbering any
+// marker an earlier injector already set. It only creates `__SENTRY_ORCHESTRION__`/`.bundler` if
+// absent, so in a hybrid setup the runtime hook's `runtime` list (and any module already recorded by
+// the per-module loader prologue) survives. Mirrors the merge-safe pattern of the Bun banner and
+// `buildInjectPrologue`. Emitted as a single line so it never shifts the module's source-map mappings.
+const ORCHESTRION_BUNDLER_MARKER =
+  ';(function(){try{var g=(globalThis.__SENTRY_ORCHESTRION__=globalThis.__SENTRY_ORCHESTRION__||{});g.bundler=g.bundler||[];}catch(e){}})();';
+
 /**
  * Generate the value injection rules for client and server in turbopack config.
  */
@@ -47,15 +55,6 @@ export function generateValueInjectionRules({
   // Use process.cwd() to get the project directory at build time
   serverValues.__SENTRY_SERVER_MODULES__ = getPackageModules(process.cwd());
 
-  // Mark the bundler (build-time) orchestrion injection as active at boot. This runs at the top of the
-  // server `instrumentation` file — before `Sentry.init()` and before the runtime hook — so
-  // `isOrchestrionInjected()` is reliable for bundler-only setups too. Turbopack has no plugin/boot
-  // hook to emit the full transformed-module list the way the webpack plugin does, so we seed an empty
-  // array here; each transformed module then appends itself as it loads (see the orchestrion loader).
-  if (injectOrchestrionBundlerMarker) {
-    serverValues.__SENTRY_ORCHESTRION__ = { bundler: [] };
-  }
-
   if (Object.keys(isomorphicValues).length > 0) {
     clientValues = { ...clientValues, ...isomorphicValues };
     serverValues = { ...serverValues, ...isomorphicValues };
@@ -96,6 +95,11 @@ export function generateValueInjectionRules({
             loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
             options: {
               values: serverValues,
+              // Runs at the top of the server `instrumentation` file — before `Sentry.init()` — so
+              // `isOrchestrionInjected()` is reliable for bundler-only setups too. Turbopack has no
+              // plugin/boot hook to emit the full transformed-module list the way the webpack plugin
+              // does; each transformed module appends itself as it loads (see the orchestrion loader).
+              ...(injectOrchestrionBundlerMarker ? { prefixCode: ORCHESTRION_BUNDLER_MARKER } : {}),
             },
           },
         ],

packages/nextjs/test/config/turbopack/generateValueInjectionRules.test.ts

@@ -71,22 +71,31 @@ describe('generateValueInjectionRules', () => {
   });
 
   describe('orchestrion bundler marker', () => {
+    function getServerLoaderOptions(result: ReturnType<typeof generateValueInjectionRules>): {
+      values: Record<string, unknown>;
+      prefixCode?: string;
+    } {
+      const serverRule = result.find(rule => rule.matcher === '**/instrumentation.*');
+      return (serverRule?.rule as { loaders: [{ options: { values: Record<string, unknown>; prefixCode?: string } }] })
+        .loaders[0].options;
+    }
+
     it('does not inject the orchestrion marker by default', () => {
-      const result = generateValueInjectionRules({});
+      const options = getServerLoaderOptions(generateValueInjectionRules({}));
 
-      const serverRule = result.find(rule => rule.matcher === '**/instrumentation.*');
-      const values = (serverRule?.rule as { loaders: [{ options: { values: Record<string, unknown> } }] }).loaders[0]
-        .options.values;
-      expect(values).not.toHaveProperty('__SENTRY_ORCHESTRION__');
+      expect(options.values).not.toHaveProperty('__SENTRY_ORCHESTRION__');
+      expect(options).not.toHaveProperty('prefixCode');
     });
 
-    it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
-      const result = generateValueInjectionRules({ injectOrchestrionBundlerMarker: true });
+    it('seeds the bundler marker merge-safely at boot when injectOrchestrionBundlerMarker is set', () => {
+      const options = getServerLoaderOptions(generateValueInjectionRules({ injectOrchestrionBundlerMarker: true }));
 
-      const serverRule = result.find(rule => rule.matcher === '**/instrumentation.*');
-      const values = (serverRule?.rule as { loaders: [{ options: { values: Record<string, unknown> } }] }).loaders[0]
-        .options.values;
-      expect(values.__SENTRY_ORCHESTRION__).toEqual({ bundler: [] });
+      // The marker must not be a plain assignment (which would clobber an existing marker), so it is
+      // never emitted as a `values` entry.
+      expect(options.values).not.toHaveProperty('__SENTRY_ORCHESTRION__');
+      // It only creates the global if absent, preserving a runtime injector's `runtime` list.
+      expect(options.prefixCode).toContain('globalThis.__SENTRY_ORCHESTRION__=globalThis.__SENTRY_ORCHESTRION__||{}');
+      expect(options.prefixCode).toContain('g.bundler=g.bundler||[]');
     });
   });
 

packages/nextjs/test/config/valueInjectionLoader.test.ts

@@ -219,6 +219,40 @@ describe.each([[clientConfigLoaderThis], [instrumentationLoaderThis]])('valueInj
   });
 });
 
+describe('valueInjectionLoader prefixCode', () => {
+  const prefixLoaderThis = {
+    ...defaultLoaderThis,
+    resourcePath: './instrumentation.js',
+    getOptions() {
+      return {
+        values: { foo: 'bar' },
+        prefixCode: ';globalThis.__MARKER__ = globalThis.__MARKER__ || {};',
+      };
+    },
+  } satisfies LoaderThis<ValueInjectionLoaderOptions>;
+
+  it('emits prefixCode verbatim before the value assignments', () => {
+    const userCode = "import * as Sentry from '@sentry/nextjs';\nSentry.init();";
+
+    const result = valueInjectionLoader.call(prefixLoaderThis, userCode);
+
+    const prefixIndex = result.indexOf('globalThis.__MARKER__ = globalThis.__MARKER__ || {};');
+    const valueIndex = result.indexOf('globalThis["foo"] = "bar";');
+
+    expect(prefixIndex).toBeGreaterThanOrEqual(0);
+    expect(valueIndex).toBeGreaterThan(prefixIndex);
+  });
+
+  it('does not emit any prefix when prefixCode is omitted', () => {
+    const userCode = "import * as Sentry from '@sentry/nextjs';\nSentry.init();";
+
+    const result = valueInjectionLoader.call(clientConfigLoaderThis, userCode);
+
+    expect(result).toContain(';globalThis["foo"] = "bar";');
+    expect(result).not.toContain('__MARKER__');
+  });
+});
+
 describe('findInjectionIndexAfterDirectives', () => {
   it('returns the position immediately after the last directive', () => {
     const userCode = '"use strict";\n"use client";\nimport React from \'react\';';