fix(server-utils): defer integration-factory read in orchestrion injected snippet

The build-time snippet injected into each instrumented module passed the
integration factory by reference (`orchestrionModuleInjected('@flue/runtime',
flueIntegration)`), reading the binding the instant that module evaluated. For a
provided-module integration like Flue — which `@sentry/*/vite` imports back into
its own instrumented package — this closes an import cycle and crashes the worker
at startup with "Cannot access 'flueIntegration' before initialization". Wrapping
it in an arrow (`() => flueIntegration()`) defers the read until the stored thunk
runs (at `init()`), which is what breaks the cycle; the consumer still gets an
Integration from `factory()`.

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

Author: mydea

packages/server-utils/src/orchestrion/bundler/moduleInjectedTransform.ts

@@ -76,7 +76,14 @@ function moduleInjectedSnippet(
     ? `import { ${bindings} } from ${JSON.stringify(importSpecifier)};`
     : `const { ${bindings} } = require(${JSON.stringify(importSpecifier)});`;
 
-  const args = exportName ? `${JSON.stringify(moduleName)}, ${exportName}` : JSON.stringify(moduleName);
+  // `exportName` is itself an integration factory, invoked inside the arrow (`() => exportName()`), so
+  // `orchestrionModuleInjected`'s consumer still gets an Integration back from calling the stored
+  // thunk. The point of the arrow is to defer the read of the `exportName` binding to when that thunk
+  // runs (at `init()`), instead of reading it by reference the moment this snippet evaluates. A
+  // provided-module integration (e.g. `flueIntegration`) is imported back into its own instrumented
+  // package by `@sentry/*/vite`, so a direct reference here would close an import cycle and touch the
+  // binding in its TDZ ("Cannot access '…' before initialization"); deferring the read breaks that.
+  const args = exportName ? `${JSON.stringify(moduleName)}, () => ${exportName}()` : JSON.stringify(moduleName);
   return `${importStmt}\n${MODULE_INJECTED_SINK} = orchestrionModuleInjected(${args});`;
 }
 

packages/server-utils/test/orchestrion/moduleInjectedTransform.test.ts

@@ -82,7 +82,7 @@ describe('module-injected transform', () => {
     // The helper is called with the REAL module name, so no reverse lookup is
     // needed at runtime and the lazy-subscription event matches what channel
     // integrations wait for.
-    expect(result!.code).toContain('orchestrionModuleInjected("mysql", mysqlIntegration)');
+    expect(result!.code).toContain('orchestrionModuleInjected("mysql", () => mysqlIntegration())');
     // The result is assigned to a global. `@sentry/server-utils` is `sideEffects: false` and the
     // helper returns `void`, so a bare call statement is one a bundler can prove droppable.
     // rollup >= 4.63.0 removes it, leaving the module instrumented but unsubscribed.
@@ -107,7 +107,7 @@ describe('module-injected transform', () => {
       /import\s*\{\s*orchestrionModuleInjected,\s*postgresIntegration\s*\}\s*from\s*["']@sentry\/server-utils["']/,
     );
     expect(result!.code).not.toContain('@sentry/core');
-    expect(result!.code).toContain('orchestrionModuleInjected("pg", postgresIntegration)');
+    expect(result!.code).toContain('orchestrionModuleInjected("pg", () => postgresIntegration())');
   });
 
   it('injects a helper-only snippet for a module with no subscriber factory', () => {
@@ -157,7 +157,7 @@ describe('module-injected transform', () => {
     expect(result!.code).toMatch(
       /const\s*\{\s*orchestrionModuleInjected,\s*redisIntegration\s*\}\s*=\s*require\(["']@sentry\/server-utils["']\)/,
     );
-    expect(result!.code).toContain('orchestrionModuleInjected("ioredis", redisIntegration)');
+    expect(result!.code).toContain('orchestrionModuleInjected("ioredis", () => redisIntegration())');
     // The library publishes its own channels, so nothing else is injected: no
     // diagnostics_channel import, no channel declaration, no function wrapper.
     expect(result!.code).not.toContain('diagnostics_channel');
@@ -173,7 +173,7 @@ describe('module-injected transform', () => {
     expect(result!.code).toMatch(
       /import\s*\{\s*orchestrionModuleInjected,\s*vercelAIIntegration\s*\}\s*from\s*["']@sentry\/server-utils["']/,
     );
-    expect(result!.code).toContain('orchestrionModuleInjected("ai", vercelAIIntegration)');
+    expect(result!.code).toContain('orchestrionModuleInjected("ai", () => vercelAIIntegration())');
     expect(result!.code).not.toContain('diagnostics_channel');
     expect(result!.code).not.toContain('tr_ch_apm');
   });

packages/server-utils/test/orchestrion/webpack-loader.test.ts

@@ -65,7 +65,7 @@ describe('orchestrion webpack/Turbopack loader', () => {
     expect(code).toMatch(
       /const\s*\{\s*orchestrionModuleInjected,\s*mysqlIntegration\s*\}\s*=\s*require\(["']@sentry\/server-utils["']\)/,
     );
-    expect(code).toContain('orchestrionModuleInjected("mysql", mysqlIntegration)');
+    expect(code).toContain('orchestrionModuleInjected("mysql", () => mysqlIntegration())');
   });
 
   it('honors a fixed importSpecifier option', () => {
@@ -116,7 +116,7 @@ describe('orchestrion webpack/Turbopack loader', () => {
     expect(error).toBeNull();
     expect(code).toContain('orchestrion:@mastra/core:mastraConstructor');
     expect(code).toContain('import {orchestrionModuleInjected, mastraIntegration} from "@sentry/server-utils"');
-    expect(code).toContain('orchestrionModuleInjected("@mastra/core", mastraIntegration)');
+    expect(code).toContain('orchestrionModuleInjected("@mastra/core", () => mastraIntegration())');
   });
 
   it('transforms a hashed `.mjs` `@mastra/core` chunk that contains `class Mastra`', () => {
@@ -127,7 +127,7 @@ describe('orchestrion webpack/Turbopack loader', () => {
     expect(error).toBeNull();
     expect(code).toContain('orchestrion:@mastra/core:mastraConstructor');
     expect(code).toContain('import {orchestrionModuleInjected, mastraIntegration} from "@sentry/server-utils"');
-    expect(code).toContain('orchestrionModuleInjected("@mastra/core", mastraIntegration)');
+    expect(code).toContain('orchestrionModuleInjected("@mastra/core", () => mastraIntegration())');
   });
 
   it('does not transform the stable Mastra re-export that does not contain the class', () => {