getsentry · mydea · Jul 16, 2026 · Jul 17, 2026 · Jul 17, 2026 · Jul 17, 2026
@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {

@@ -49,7 +49,7 @@ describe('orchestrion mysql instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -54,7 +54,7 @@ describe('orchestrion pg instrumentation (Bun)', () => {
  // with the expected SQL
  expect(line).toContain('statement=SELECT 1 AS solution');
  // injected banner ran at bundle boot
- expect(line).toContain('"bundler":true');
+ expect(line).toContain('"bundler":[]');
  } finally {
  if (outfile) {
  rmSync(dirname(outfile), { recursive: true, force: true });

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before ioredis creates its native TracingChannels on import.
- await Promise.resolve();
-
  const { default: Redis } = await import('ioredis-5');
  const redisClient = new Redis({ host: '127.0.0.1', port: 6382, lazyConnect: true });
 

@@ -10,10 +10,6 @@ const CONNECT_CONFIG = {
 };
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before mysql2 publishes on its native TracingChannels.
- await Promise.resolve();
-
  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
  // MySQL keeps finalizing for a short window after the healthcheck passes and drops early handshakes,
  // so this retries a real connect. It runs outside an active span, so the connect stays uninstrumented.

@@ -1,10 +1,6 @@
 import * as Sentry from '@sentry/node';
 
 async function run() {
- // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
- // is registered before node-redis eagerly creates its native TracingChannels on require().
- await Promise.resolve();
-
  const { createClient } = await import('redis-5-tracing');
  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6381 } }).connect();
 

@@ -44,7 +44,7 @@ import {
 } from '@sentry/server-utils/orchestrion/config';
 
 const BUNDLER_MARKER_BANNER =
- ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=true;';
+ ';(globalThis.__SENTRY_ORCHESTRION__=(globalThis.__SENTRY_ORCHESTRION__||{})).bundler=[];';
 
 // Minimal shape of Bun's `PluginBuilder` that we touch. Typed locally instead
 // of depending on `bun-types`, which would pull Bun's globals.
@@ -57,7 +57,7 @@ interface BunPluginBuilder {
  * with the central `SENTRY_INSTRUMENTATIONS`. The plugin injects
  * `diagnostics_channel.tracingChannel` calls into the instrumented libraries as
  * `bun build` bundles them, and injects a banner that sets
- * `globalThis.__SENTRY_ORCHESTRION__.bundler = true` when the bundle boots
+ * `globalThis.__SENTRY_ORCHESTRION__.bundler = []` when the bundle boots
  *
  * Pass the result to `Bun.build({ plugins: [...] })`.
  *

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -927,6 +927,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public on(hook: 'stopUIProfiler', callback: () => void): () => void;
 
+ /**
+ * A hook that is called when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ *
+ * The callback receives the name of the instrumented module.
+ *
+ * @returns {() => void} A function that, when executed, removes the registered callback.
+ */
+ public on(hook: 'orchestrion.module-runtime-injected', callback: (moduleName: string) => void): () => void;
+
  /**
  * Register a hook on this client.
  */
@@ -1188,6 +1198,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
  */
  public emit(hook: 'stopUIProfiler'): void;
 
+ /**
+ * Emit a hook event when the orchestrion runtime hook injects diagnostics
+ * channels into a module as it is loaded.
+ */
+ public emit(hook: 'orchestrion.module-runtime-injected', moduleName: string): void;
+
  /**
  * Emit a hook that was previously registered via `on()`.
  */

diff --git a/packages/core/src/utils/worldwide.ts b/packages/core/src/utils/worldwide.ts
@@ -64,6 +64,14 @@ export type InternalGlobal = {
  /** Empty array signifies bundler plugin ran */
  bundler?: string[];
  };
+ /**
+ * Bridge set by the SDK during `init` so that build-time (bundler) injected modules can announce
+ * themselves the moment they load. Bundlers that transform modules but provide no runtime boot hook
+ * (e.g. Turbopack, which only takes loaders) prepend a prologue to each instrumented module that
+ * calls this with the module name; the bridge emits `orchestrion.module-runtime-injected` so channel
+ * subscribers get wired up before the module publishes. Mirrors the runtime module hook's own event.
+ */
+ __SENTRY_ORCHESTRION_ON_INJECT__?: (moduleName: string) => void;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

@@ -1,15 +1,9 @@
 import { debug } from '@sentry/core';
 import * as path from 'path';
-import { getOrchestrionLoaderPath, getSentryInstrumentations } from '@sentry/server-utils/orchestrion/webpack';
+import { getSentryOrchestrionLoaderPath } from '@sentry/server-utils/orchestrion/webpack';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
-import type {
- JSONValue,
- NextConfigObject,
- SentryBuildOptions,
- TurbopackMatcherWithRule,
- TurbopackOptions,
-} from '../types';
+import type { NextConfigObject, SentryBuildOptions, TurbopackMatcherWithRule, TurbopackOptions } from '../types';
 import { supportsNativeDebugIds, supportsTurbopackRuleCondition } from '../util';
 import { generateValueInjectionRules } from './generateValueInjectionRules';
 
@@ -58,6 +52,10 @@ export function constructTurbopackConfig({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ // Mark the bundler injection path as active at boot (before `Sentry.init()`), so
+ // `isOrchestrionInjected()` is reliable even without the runtime hook. Individual modules add
+ // themselves to this list as they load; see the orchestrion loader's injected prologue.
+ injectOrchestrionBundlerMarker: !!userSentryOptions?._experimental?.useDiagnosticsChannelInjection,
  });
 
  for (const { matcher, rule } of valueInjectionRules) {
@@ -138,13 +136,9 @@ function maybeAddOrchestrionRule(
  matcher: '*.{js,mjs,cjs}',
  rule: {
  condition: 'node',
- loaders: [
- {
- loader: getOrchestrionLoaderPath(),
- // `instrumentations` is JSON-serializable
- options: { instrumentations: getSentryInstrumentations() as unknown as JSONValue[] },
- },
- ],
+ // The Sentry loader reads the instrumentation config itself and appends a self-registration
+ // prologue to each transformed module, so it needs no `options` — use the string shortcut.
+ loaders: [getSentryOrchestrionLoaderPath()],
  },
  });
 }

@@ -12,11 +12,13 @@ export function generateValueInjectionRules({
  nextJsVersion,
  tunnelPath,
  vercelCronsConfig,
+ injectOrchestrionBundlerMarker,
 }: {
  routeManifest?: RouteManifest;
  nextJsVersion?: string;
  tunnelPath?: string;
  vercelCronsConfig?: VercelCronsConfig;
+ injectOrchestrionBundlerMarker?: boolean;
 }): TurbopackMatcherWithRule[] {
  const rules: TurbopackMatcherWithRule[] = [];
  const isomorphicValues: Record<string, JSONValue> = {};
@@ -45,6 +47,15 @@ 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 };

@@ -1574,4 +1574,30 @@ describe('safelyAddTurbopackRule', () => {
  });
  });
  });
+
+ describe('orchestrion diagnostics-channel injection', () => {
+ it('does not add the orchestrion loader rule by default', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: {},
+ nextJsVersion: '16.0.0',
+ });
+
+ expect(result.rules?.['*.{js,mjs,cjs}']).toBeUndefined();
+ });
+
+ it('adds the Sentry orchestrion loader rule (node server only) when injection is enabled', () => {
+ const result = constructTurbopackConfig({
+ userNextConfig: {},
+ userSentryOptions: { _experimental: { useDiagnosticsChannelInjection: true } },
+ nextJsVersion: '16.0.0',
+ });
+
+ const rule = result.rules?.['*.{js,mjs,cjs}'] as { condition?: unknown; loaders?: unknown[] } | undefined;
+ expect(rule?.condition).toBe('node');
+ // A single loader referenced by path (string shortcut, no options).
+ expect(rule?.loaders).toHaveLength(1);
+ expect(typeof rule?.loaders?.[0]).toBe('string');
+ });
+ });
 });
@@ -70,6 +70,26 @@ describe('generateValueInjectionRules', () => {
  });
  });
 
+ describe('orchestrion bundler marker', () => {
+ it('does not inject the orchestrion marker by default', () => {
+ const result = 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__');
+ });
+
+ it('seeds an empty bundler array at boot when injectOrchestrionBundlerMarker is set', () => {
+ const result = 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: [] });
+ });
+ });
+
  describe('with nextJsVersion only', () => {
  it('should generate client and server rules when nextJsVersion is provided', () => {
  const result = generateValueInjectionRules({

@@ -9,19 +9,24 @@ const INTEGRATION_NAME = 'Dataloader' as const;
 export const instrumentDataloader = generateInstrumentOnce(INTEGRATION_NAME, () => new DataloaderInstrumentation());
 
 const _dataloaderIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Decide here, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
- // after the integrations array has already been built, so `isOrchestrionInjected()` is only
- // reliable by `setupOnce`. When the diagnostics channels are injected (runtime hook or bundler
- // plugin), subscribe to them; otherwise fall back to the vendored OTel instrumentation.
- if (isOrchestrionInjected()) {
- dataloaderChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentDataloader();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ dataloaderChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -9,18 +9,24 @@ const INTEGRATION_NAME = 'Knex' as const;
 export const instrumentKnex = generateInstrumentOnce(INTEGRATION_NAME, () => new KnexInstrumentation());
 
 const _knexIntegration = (() => {
+ // Decide in setup/setupOnce, not in the factory: the runtime channel injection runs inside `Sentry.init()`,
+ // after the integrations array has already been built, so `isOrchestrionInjected()` is only
+ // reliable by `setup`. When the diagnostics channels are injected (runtime hook or bundler
+ // plugin), subscribe to them (the channel integration needs the client to register its
+ // injection listener); otherwise fall back to the vendored OTel instrumentation.
+
  return {
  name: INTEGRATION_NAME,
  setupOnce() {
- // Prefer the diagnostics-channel subscriber when orchestrion injected its channels; otherwise
- // fall back to the vendored OTel instrumentation. `isOrchestrionInjected()` is only reliable by
- // `setupOnce` (the runtime injection runs during `Sentry.init()`, after integrations are built).
- if (isOrchestrionInjected()) {
- knexChannelIntegration().setupOnce?.();
- } else {
+ if (!isOrchestrionInjected()) {
  instrumentKnex();
  }
  },
+ setup(client) {
+ if (isOrchestrionInjected()) {
+ knexChannelIntegration().setup?.(client);
+ }
+ },
  };
 }) satisfies IntegrationFn;
 

@@ -57,6 +57,11 @@
  "import": "./build/esm/orchestrion/bundler/esbuild.js",
  "require": "./build/cjs/orchestrion/bundler/esbuild.js"
  },
+ "./orchestrion/turbopack-loader": {
+ "types": "./build/types/orchestrion/bundler/turbopack-loader.d.ts",
+ "import": "./build/esm/orchestrion/bundler/turbopack-loader.js",
+ "require": "./build/cjs/orchestrion/bundler/turbopack-loader.js"
+ },
  "./orchestrion/import-hook": {
  "import": "./build/orchestrion/import-hook.mjs"
  }
@@ -86,6 +91,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types-ts3.8/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types-ts3.8/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  },
  "*": {
@@ -109,6 +117,9 @@
  ],
  "orchestrion/esbuild": [
  "build/types/orchestrion/bundler/esbuild.d.ts"
+ ],
+ "orchestrion/turbopack-loader": [
+ "build/types/orchestrion/bundler/turbopack-loader.d.ts"
  ]
  }
  },

@@ -37,6 +37,9 @@ export default [
  'src/orchestrion/bundler/rollup.ts',
  'src/orchestrion/bundler/webpack.ts',
  'src/orchestrion/bundler/esbuild.ts',
+ // Referenced by absolute path (never imported), so it must be its own entrypoint to land in
+ // build/. Turbopack `require`s it as a loader; see `getSentryOrchestrionLoaderPath`.
+ 'src/orchestrion/bundler/turbopack-loader.ts',
  ],
  packageSpecificConfig: {
  output: {