@depup/sentry__server-utils 10.67.0-depup.0 → 10.68.0-depup.0

package/build/types/orchestrion/config/subscribe-injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe-injection.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/subscribe-injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,sCAAsC,CAAC;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,EAAE,GAAG,qBAAqB,EAAE,CAsB/F"}

package/build/types/orchestrion/config/tedious.d.ts

@@ -9,4 +9,5 @@ export declare const tediousChannels: {
     readonly TEDIOUS_PREPARE: "orchestrion:tedious:prepare";
     readonly TEDIOUS_EXECUTE: "orchestrion:tedious:execute";
 };
+export declare const tediousSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=tedious.d.ts.map

package/build/types/orchestrion/config/tedious.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/tedious.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAgBhD,eAAO,MAAM,aAAa,EAAE,qBAAqB,EAI9C,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;CAQlB,CAAC"}
+{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/tedious.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAiBhD,eAAO,MAAM,aAAa,EAAE,qBAAqB,EAI9C,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;CAQlB,CAAC;AAEX,eAAO,MAAM,yBAAyB,yBAAuC,CAAC"}

package/build/types/orchestrion/config/vercel-ai.d.ts

@@ -9,4 +9,5 @@ export declare const vercelAiChannels: {
     readonly VERCEL_AI_EXECUTE_TOOL_CALL: "orchestrion:ai:executeToolCall";
     readonly VERCEL_AI_RESOLVE_LANGUAGE_MODEL: "orchestrion:ai:resolveLanguageModel";
 };
+export declare const vercelAiSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=vercel-ai.d.ts.map

package/build/types/orchestrion/config/vercel-ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAEhD,eAAO,MAAM,cAAc,yBAsBQ,CAAC;AAEpC,eAAO,MAAM,gBAAgB;;;;;;;;CAcnB,CAAC"}
+{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,cAAc,yBAsBQ,CAAC;AAEpC,eAAO,MAAM,gBAAgB;;;;;;;;CAcnB,CAAC;AA+BX,eAAO,MAAM,0BAA0B,yBAAwC,CAAC"}

package/build/types/orchestrion/index.d.ts

@@ -23,10 +23,12 @@ import { postgresJsChannelIntegration } from '../integrations/tracing-channel/po
 import { tediousChannelIntegration } from '../integrations/tracing-channel/tedious';
 import { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai';
 import { expressChannelIntegration } from '../integrations/tracing-channel/express';
+import { firebaseChannelIntegration } from '../integrations/tracing-channel/firebase';
 export { detectOrchestrionSetup, isOrchestrionInjected } from './detect';
+export { registerOrchestrionChannelIntegration } from './registerChannelIntegration';
 export { nestjsChannels } from './config/nestjs';
 export { remixChannels } from './config/remix';
-export { amqplibChannelIntegration, anthropicChannelIntegration, awsChannelIntegration, dataloaderChannelIntegration, genericPoolChannelIntegration, googleGenAIChannelIntegration, graphqlChannelIntegration, hapiChannelIntegration, koaChannelIntegration, ioredisChannelIntegration, kafkajsChannelIntegration, knexChannelIntegration, langChainChannelIntegration, langGraphChannelIntegration, lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysqlChannelIntegration, mysql2ChannelIntegration, openaiChannelIntegration, postgresChannelIntegration, postgresJsChannelIntegration, tediousChannelIntegration, vercelAiChannelIntegration, expressChannelIntegration, };
+export { amqplibChannelIntegration, anthropicChannelIntegration, awsChannelIntegration, dataloaderChannelIntegration, genericPoolChannelIntegration, googleGenAIChannelIntegration, graphqlChannelIntegration, hapiChannelIntegration, koaChannelIntegration, ioredisChannelIntegration, kafkajsChannelIntegration, knexChannelIntegration, langChainChannelIntegration, langGraphChannelIntegration, lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysqlChannelIntegration, mysql2ChannelIntegration, openaiChannelIntegration, postgresChannelIntegration, postgresJsChannelIntegration, tediousChannelIntegration, vercelAiChannelIntegration, expressChannelIntegration, firebaseChannelIntegration, };
 export type { KoaChannelIntegrationOptions } from '../integrations/tracing-channel/koa';
 export type { IORedisChannelIntegrationOptions, IORedisResponseHook } from '../integrations/tracing-channel/ioredis';
 export type { PostgresJsChannelIntegrationOptions } from '../integrations/tracing-channel/postgres-js';
@@ -98,11 +100,7 @@ export declare const channelIntegrations: {
     readonly langGraphIntegration: (options?: import("@sentry/core").LangGraphOptions | undefined) => import("@sentry/core").Integration & {
         name: "LangGraph";
     };
-    readonly vercelAiIntegration: (options?: {
-        recordInputs?: boolean;
-        recordOutputs?: boolean;
-        enableTruncation?: boolean;
-    } | undefined) => import("@sentry/core").Integration & {
+    readonly vercelAiIntegration: (options?: import("..").VercelAiOptions | undefined) => import("@sentry/core").Integration & {
         name: "VercelAI";
     };
     readonly amqplibIntegration: () => import("@sentry/core").Integration & {
@@ -132,5 +130,8 @@ export declare const channelIntegrations: {
     readonly awsIntegration: () => import("@sentry/core").Integration & {
         name: "Aws";
     };
+    readonly firebaseIntegration: () => import("@sentry/core").Integration & {
+        name: "Firebase";
+    };
 };
 //# sourceMappingURL=index.d.ts.map

package/build/types/orchestrion/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/index.ts"],"names":[],"mappings":"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"}

package/build/types/orchestrion/registerChannelIntegration.d.ts

@@ -0,0 +1,33 @@
+import type { Integration } from '@sentry/core';
+/**
+ * Register an orchestrion channel-subscriber integration from an instrumented
+ * module. This is the runtime target of the snippet the subscribe-injection
+ * transform splices into each transformed package (see
+ * `bundler/subscribeInjection.ts`), so a bundler-only SDK (e.g.
+ * `@sentry/cloudflare`, running in workerd where requires can't be
+ * monkey-patched) wires up subscribers with no runtime module hook.
+ *
+ * It does two things, covering the two disjoint timing cases:
+ *
+ * 1. Stores the factory on the global orchestrion marker under `name`, so a
+ *    later `init()` (a fresh isolate, or a client created after this module
+ *    loads) picks it up via `getDefaultIntegrations()`.
+ * 2. If a client already exists, registers the integration on it right away.
+ *    This is what makes the mechanism robust against module load order:
+ *    bundler-only SDKs call `init()` per request, but a package like `mysql`
+ *    loads its instrumented file lazily on first use, i.e. AFTER that request's
+ *    `init()` already snapshotted the marker. Without the live add, the first
+ *    request that touches such a package would publish to a channel nobody
+ *    subscribed to yet.
+ *
+ * `addIntegration` dedupes by integration name and only runs `setupOnce` once,
+ * so storing AND live-adding never double-subscribes.
+ *
+ * The marker is a `Map` keyed by `name` (the factory's export name) so a package
+ * split across several instrumented files (e.g. `pg`'s JS and native clients, or
+ * openai's per-resource `.js`/`.mjs` files) registers its one subscriber once,
+ * no matter how many of its files land in the bundle. `.set` on the shared key
+ * is idempotent.
+ */
+export declare function registerOrchestrionChannelIntegration(name: string, integrationFn: () => Integration): void;
+//# sourceMappingURL=registerChannelIntegration.d.ts.map

package/build/types/orchestrion/registerChannelIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerChannelIntegration.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/registerChannelIntegration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,WAAW,GAAG,IAAI,CAI1G"}

package/build/types/vercel-ai/index.d.ts

@@ -1,4 +1,4 @@
-type VercelAiOptions = {
+export interface VercelAiOptions {
     /**
      * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
      * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
@@ -16,12 +16,11 @@ type VercelAiOptions = {
      * Defaults to `true`.
      */
     enableTruncation?: boolean;
-};
+}
 /**
  * Auto-instrument the `ai` SDK's native telemetry tracing channel (ai >= 7).
  */
 export declare const vercelAiIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
     name: "VercelAI";
 };
-export {};
 //# sourceMappingURL=index.d.ts.map

package/build/types/vercel-ai/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/index.ts"],"names":[],"mappings":"AAIA,KAAK,eAAe,GAAG;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAoBF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAoBD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

package/build/types-ts3.8/index.d.ts

@@ -17,7 +17,7 @@ export { RedisDiagnosticChannelResponseHook } from './redis/redis-dc-subscriber'
 export { defaultDbStatementSerializer } from './redis/redis-statement-serializer';
 export { bindTracingChannelToSpan } from './tracing-channel';
 export { SentryTracingChannel, TracingChannelLifeCycleOptions, TracingChannelBindingHandle, TracingChannelPayloadWithSpan, } from './tracing-channel';
-export { vercelAiIntegration } from './vercel-ai';
 export { InstrumentationConfig } from './orchestrion';
+export { vercelAiIntegration, VercelAiOptions } from './vercel-ai';
 export { fastifyIntegration, handleFastifyError, instrumentFastify, } from './integrations/tracing-channel/fastify';
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/fastify/index.d.ts

@@ -49,8 +49,8 @@ interface FastifyIntegrationOptions {
  * })
  * ```
  */
-export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration & {
-    name: string;
+export declare const fastifyIntegration: (args_0?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration & {
+    name: "Fastify";
 };
 /**
  * @deprecated This export is deprecated and will not longer be exposed in the next major version.

package/build/types-ts3.8/integrations/tracing-channel/fastify/utils.d.ts

@@ -1,5 +1,5 @@
 import { FastifyReply, FastifyRequest } from './types';
-export declare const INTEGRATION_NAME = "Fastify";
+export declare const INTEGRATION_NAME: "Fastify";
 /**
  * Default function to determine if an error should be sent to Sentry
  *

package/build/types-ts3.8/integrations/tracing-channel/firebase/firestore-types.d.ts

@@ -0,0 +1,38 @@
+export interface FirebaseOptions {
+    [key: string]: unknown;
+    apiKey?: string;
+    projectId?: string;
+    appId?: string;
+    messagingSenderId?: string;
+    storageBucket?: string;
+}
+export interface FirebaseApp {
+    name: string;
+    options: FirebaseOptions;
+}
+export interface FirestoreSettings {
+    host?: string;
+}
+interface FirestoreLike {
+    app: FirebaseApp;
+    toJSON: () => {
+        settings?: FirestoreSettings;
+    };
+}
+export interface DocumentReference {
+    id: string;
+    firestore: FirestoreLike;
+    type: string;
+    path: string;
+    parent: CollectionReference | null;
+}
+export interface CollectionReference {
+    id: string;
+    firestore: FirestoreLike;
+    type: string;
+    path: string;
+    parent: DocumentReference | null;
+}
+export type FirestoreReference = CollectionReference | DocumentReference;
+export {};
+//# sourceMappingURL=firestore-types.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/firebase/firestore.d.ts

@@ -0,0 +1,18 @@
+import { Span } from '@sentry/core';
+import { FirestoreReference, FirestoreSettings } from './firestore-types';
+/**
+ * Opens the inactive `db.query` span for a Firestore operation. `bindTracingChannelToSpan` makes it the
+ * active span for the traced call and ends it when the call settles. Mirrors the OTel integration's span,
+ * with a distinct `auto.firebase.orchestrion.firestore` origin.
+ */
+export declare function startFirestoreSpan(spanName: string, reference: FirestoreReference): Span;
+/**
+ * Gets the server address and port attributes from the Firestore settings.
+ * It's best effort to extract the address and port from the settings, especially for IPv6.
+ * @param settings - The Firestore settings containing host information.
+ */
+export declare function getPortAndAddress(settings: FirestoreSettings): {
+    address?: string;
+    port?: number;
+};
+//# sourceMappingURL=firestore.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/firebase/functions.d.ts

@@ -0,0 +1,15 @@
+interface FunctionsChannelContext {
+    arguments: unknown[];
+    self?: unknown;
+}
+/**
+ * Rewrap the handler argument of a firebase-functions `onX(...)` registration so the returned cloud
+ * function opens a `SERVER` span (and error boundary) each time it's invoked. Runs as the tracing
+ * channel's `start` subscriber, before orchestrion forwards the (mutated) arguments to the real call.
+ *
+ * The registration call itself is trivial and synchronous, so — unlike the firestore path — this does
+ * not bind a span to the channel; it only uses the channel as an injection point.
+ */
+export declare function wrapFunctionsRegistration(data: FunctionsChannelContext, triggerType: string): void;
+export {};
+//# sourceMappingURL=functions.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/firebase/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven firebase integration.
+ *
+ * Subscribes to the `orchestrion:@firebase/firestore:*` and `orchestrion:firebase-functions:*`
+ * diagnostics_channels the orchestrion code transform injects into firestore's `addDoc`/`getDocs`/
+ * `setDoc`/`deleteDoc` and firebase-functions' `onX` registration functions, emitting spans identical
+ * to the OTel integration — with a distinct `auto.firebase.orchestrion.*` origin. Requires the
+ * orchestrion runtime hook or bundler plugin — wire it up via `experimentalUseDiagnosticsChannelInjection()`.
+ *
+ * @experimental
+ */
+export declare const firebaseChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Firebase";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/firebase/instrumentation.d.ts

@@ -0,0 +1,2 @@
+export declare function instrumentFirebase(): void;
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/vercel-ai.d.ts

@@ -3,11 +3,7 @@
  * - v7 via native `ai:telemetry` tracing channel
  * - v4, v5 & v6 via orchestrion `orchestrion:ai:*` channels
  */
-export declare const vercelAiChannelIntegration: (options?: {
-    recordInputs?: boolean;
-    recordOutputs?: boolean;
-    enableTruncation?: boolean;
-} | undefined) => import("@sentry/core").Integration & {
+export declare const vercelAiChannelIntegration: (options?: import("../..").VercelAiOptions | undefined) => import("@sentry/core").Integration & {
     name: "VercelAI";
 };
 //# sourceMappingURL=vercel-ai.d.ts.map

package/build/types-ts3.8/orchestrion/bundler/esbuild.d.ts

@@ -6,9 +6,8 @@ import { PluginOptions } from './options';
  * Use when bundling a Node app with esbuild. For unbundled Node processes use the
  * runtime hook instead (`node --import @sentry/node/orchestrion app.js`).
  *
- * esbuild does not flatten nested `plugins` arrays, so this returns a single
- * plugin that strips instrumented packages from an `external` denylist before
- * delegating to the upstream transform.
+ * Instrumented packages marked as `external` never pass through the code
+ * transform, so a build warning is emitted for them.
  *
  * @example
  * ```ts

package/build/types-ts3.8/orchestrion/bundler/options.d.ts

@@ -15,7 +15,41 @@ export type PluginOptions = {
      * Defaults to `true`.
      */
     shouldInjectDiagnostics?: boolean;
+    /**
+     * Inject a small marker-push into each instrumented module that imports only
+     * that package's channel-subscriber factory and pushes it onto
+     * `globalThis.__SENTRY_ORCHESTRION__.integrations`. A bundler-only SDK reads
+     * the marker at `init()` and instantiates the collected factories, so every
+     * transformed package's subscriber is wired up with no runtime module hook.
+     *
+     * Because each site imports a single named factory, it tree-shakes: a bundle
+     * carries subscriber code only for the packages actually transformed into it.
+     *
+     * This is what lets a bundler-only SDK (e.g. `@sentry/cloudflare`, which runs
+     * in workerd where requires can't be monkey-patched) record channel spans,
+     * but it is bundler-agnostic: any orchestrion bundler plugin can enable it.
+     * Leave it off for SDKs that wire the integrations up through a static import
+     * instead (e.g. `@sentry/node`'s `experimentalUseDiagnosticsChannelInjection()`),
+     * so the subscribers aren't registered twice.
+     *
+     * Defaults to `false`.
+     */
+    injectChannelSubscribers?: boolean;
 };
+/**
+ * Whether an "external" config entry covers an instrumented module: an exact
+ * package name (`'mysql'`) or a subpath (`'mysql/lib/...'`) — the transform may
+ * target exactly the file a subpath entry externalizes. Mirrors the matching in
+ * `withoutInstrumentedExternals`.
+ */
+export declare function externalEntryMatchesModule(entry: string, moduleName: string): boolean;
+/**
+ * Warning emitted when a bundler config externalizes packages that orchestrion
+ * needs to transform. An externalized dependency is resolved from
+ * `node_modules` at runtime and never passes through the code transform, so
+ * its diagnostics_channel calls are silently never injected.
+ */
+export declare function externalizedModulesWarning(externalizedModules: string[]): string;
 /**
  * The `@apm-js-collab/code-transformer-bundler-plugins` options shared by every
  * orchestrion bundler plugin.

package/build/types-ts3.8/orchestrion/bundler/subscribeInjection.d.ts

@@ -0,0 +1,13 @@
+import { PluginOptions } from './options';
+/**
+ * The `instrumentations` + `customTransforms` a bundler plugin passes to
+ * {@link orchestrionTransformOptions} to enable the marker-push subscribe
+ * injection used by bundler-only SDKs (e.g. `@sentry/cloudflare`).
+ *
+ * The `SUBSCRIBE_INJECTIONS` configs ride alongside the real channel-publishing
+ * configs, and `injectSubscribe` runs on each matched module, so every
+ * transformed package self-registers its subscriber on the global marker
+ * without a runtime module hook.
+ */
+export declare function subscribeInjectionOptions(): Pick<PluginOptions, 'instrumentations' | 'customTransforms'>;
+//# sourceMappingURL=subscribeInjection.d.ts.map

package/build/types-ts3.8/orchestrion/bundler/webpack.d.ts

@@ -1,6 +1,8 @@
 import { InstrumentationConfig } from '..';
 import codeTransformerWebpack from '@apm-js-collab/code-transformer-bundler-plugins/webpack';
 import { PluginOptions } from './options';
+export { serializeInstrumentations } from '@apm-js-collab/code-transformer-bundler-plugins/core';
+export { SerializableInstrumentationConfig } from '@apm-js-collab/code-transformer-bundler-plugins/core';
 /** Absolute path to the code-transform loader (a webpack loader; also usable as a Turbopack loader). */
 export declare function getOrchestrionLoaderPath(): string;
 /**
@@ -13,7 +15,10 @@ export declare function getTracingHooksDirectory(): string;
 /** The central instrumentation config, to pass as the loader's `instrumentations` option. */
 export declare function getSentryInstrumentations(): InstrumentationConfig[];
 /**
- * The code-transform webpack plugin, pre-fed the instrumentation config
+ * The code-transform webpack plugin, pre-fed the instrumentation config.
+ *
+ * Instrumented packages marked as `externals` never pass through the code
+ * transform, so a compilation warning is emitted for them.
  */
 export declare function sentryOrchestrionWebpackPlugin(options?: PluginOptions): ReturnType<typeof codeTransformerWebpack>;
 //# sourceMappingURL=webpack.d.ts.map

package/build/types-ts3.8/orchestrion/channels.d.ts

@@ -99,6 +99,21 @@ export declare const CHANNELS: {
     readonly GOOGLE_GENAI_EMBED_CONTENT: "orchestrion:@google/genai:embed-content";
     readonly GOOGLE_GENAI_CHAT: "orchestrion:@google/genai:chat";
     readonly GENERIC_POOL_ACQUIRE: "orchestrion:generic-pool:acquire";
+    readonly FIREBASE_FIRESTORE_ADD_DOC: "orchestrion:@firebase/firestore:add-doc";
+    readonly FIREBASE_FIRESTORE_GET_DOCS: "orchestrion:@firebase/firestore:get-docs";
+    readonly FIREBASE_FIRESTORE_SET_DOC: "orchestrion:@firebase/firestore:set-doc";
+    readonly FIREBASE_FIRESTORE_DELETE_DOC: "orchestrion:@firebase/firestore:delete-doc";
+    readonly FIREBASE_FUNCTIONS_HTTP_REQUEST: "orchestrion:firebase-functions:http-request";
+    readonly FIREBASE_FUNCTIONS_HTTP_CALL: "orchestrion:firebase-functions:http-call";
+    readonly FIREBASE_FUNCTIONS_FIRESTORE_CREATED: "orchestrion:firebase-functions:firestore-created";
+    readonly FIREBASE_FUNCTIONS_FIRESTORE_UPDATED: "orchestrion:firebase-functions:firestore-updated";
+    readonly FIREBASE_FUNCTIONS_FIRESTORE_DELETED: "orchestrion:firebase-functions:firestore-deleted";
+    readonly FIREBASE_FUNCTIONS_FIRESTORE_WRITTEN: "orchestrion:firebase-functions:firestore-written";
+    readonly FIREBASE_FUNCTIONS_SCHEDULER: "orchestrion:firebase-functions:scheduler";
+    readonly FIREBASE_FUNCTIONS_STORAGE_FINALIZED: "orchestrion:firebase-functions:storage-finalized";
+    readonly FIREBASE_FUNCTIONS_STORAGE_ARCHIVED: "orchestrion:firebase-functions:storage-archived";
+    readonly FIREBASE_FUNCTIONS_STORAGE_DELETED: "orchestrion:firebase-functions:storage-deleted";
+    readonly FIREBASE_FUNCTIONS_STORAGE_METADATA_UPDATED: "orchestrion:firebase-functions:storage-metadata-updated";
     readonly EXPRESS_HANDLE: "orchestrion:express:handle";
     readonly ROUTER_HANDLE: "orchestrion:router:handle";
     readonly EXPRESS_REGISTER: "orchestrion:express:register";

package/build/types-ts3.8/orchestrion/config/amqplib.d.ts

@@ -1,3 +1,4 @@
+import { InstrumentationConfig } from '..';
 export declare const amqplibConfig: ({
     channelName: string;
     module: {
@@ -63,4 +64,5 @@ export declare const amqplibChannels: {
     readonly AMQPLIB_NACK_ALL: "orchestrion:amqplib:nackAll";
     readonly AMQPLIB_CONNECT: "orchestrion:amqplib:connect";
 };
+export declare const amqplibSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=amqplib.d.ts.map

package/build/types-ts3.8/orchestrion/config/anthropic-ai.d.ts

@@ -1,3 +1,4 @@
+import { InstrumentationConfig } from '..';
 export declare const anthropicAiConfig: ({
     channelName: string;
     module: {
@@ -28,4 +29,5 @@ export declare const anthropicAiChannels: {
     readonly ANTHROPIC_MODELS: "orchestrion:@anthropic-ai/sdk:models";
     readonly ANTHROPIC_MESSAGES_STREAM: "orchestrion:@anthropic-ai/sdk:messages-stream";
 };
+export declare const anthropicAiSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=anthropic-ai.d.ts.map

package/build/types-ts3.8/orchestrion/config/aws-sdk.d.ts

@@ -1,3 +1,4 @@
+import { InstrumentationConfig } from '@apm-js-collab/code-transformer';
 export declare const awsSdkConfig: {
     channelName: string;
     module: {
@@ -16,4 +17,5 @@ export declare const awsSdkChannels: {
     readonly AWS_SMITHY_CLIENT_SEND: "orchestrion:@smithy/smithy-client:send";
     readonly AWS_SDK_SMITHY_CLIENT_SEND: "orchestrion:@aws-sdk/smithy-client:send";
 };
+export declare const awsSdkSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=aws-sdk.d.ts.map

package/build/types-ts3.8/orchestrion/config/channel-integration-definitions.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Build-time metadata mapping each instrumented package (orchestrion
+ * `module.name`) to the channel-subscriber integration that consumes the
+ * channels injected into it — by the `exportName` it is published under from
+ * `@sentry/server-utils/orchestrion`.
+ *
+ * Kept in a separate, factory-free module on purpose: the subscribe-injection
+ * transform (reachable from every orchestrion bundler plugin) reads this to
+ * generate the tiny snippet it injects into each instrumented file, and must
+ * not drag any subscriber code — or its `@sentry/core` span machinery — into
+ * the plugin's own build to do so.
+ *
+ * `exportName` must be a named export of `@sentry/server-utils/orchestrion`.
+ * `modules` must match `module.name` values in `SENTRY_INSTRUMENTATIONS` — e.g.
+ * `postgresChannelIntegration` covers both `pg` and `pg-pool`, and
+ * `redisChannelIntegration` both `redis` and `@redis/client`.
+ *
+ * `redis`, `ioredis` and `dataloader` are included even though they're not in
+ * the node SDK's `channelIntegrations` (they only partially replace an OTel
+ * integration there): in a bundler-only runtime like Cloudflare Workers there
+ * is no OTel integration to coordinate with, so subscribing whenever the
+ * package is bundled is unconditionally correct.
+ */
+export declare const CHANNEL_INTEGRATION_DEFINITIONS: readonly [
+    {
+        readonly exportName: "postgresChannelIntegration";
+        readonly modules: readonly [
+            "pg",
+            "pg-pool"
+        ];
+    },
+    {
+        readonly exportName: "postgresJsChannelIntegration";
+        readonly modules: readonly [
+            "postgres"
+        ];
+    },
+    {
+        readonly exportName: "mysqlChannelIntegration";
+        readonly modules: readonly [
+            "mysql"
+        ];
+    },
+    {
+        readonly exportName: "mysql2ChannelIntegration";
+        readonly modules: readonly [
+            "mysql2"
+        ];
+    },
+    {
+        readonly exportName: "genericPoolChannelIntegration";
+        readonly modules: readonly [
+            "generic-pool"
+        ];
+    },
+    {
+        readonly exportName: "lruMemoizerChannelIntegration";
+        readonly modules: readonly [
+            "lru-memoizer"
+        ];
+    },
+    {
+        readonly exportName: "openaiChannelIntegration";
+        readonly modules: readonly [
+            "openai"
+        ];
+    },
+    {
+        readonly exportName: "anthropicChannelIntegration";
+        readonly modules: readonly [
+            "@anthropic-ai/sdk"
+        ];
+    },
+    {
+        readonly exportName: "googleGenAIChannelIntegration";
+        readonly modules: readonly [
+            "@google/genai"
+        ];
+    },
+    {
+        readonly exportName: "vercelAiChannelIntegration";
+        readonly modules: readonly [
+            "ai"
+        ];
+    },
+    {
+        readonly exportName: "amqplibChannelIntegration";
+        readonly modules: readonly [
+            "amqplib"
+        ];
+    },
+    {
+        readonly exportName: "hapiChannelIntegration";
+        readonly modules: readonly [
+            "@hapi/hapi"
+        ];
+    },
+    {
+        readonly exportName: "expressChannelIntegration";
+        readonly modules: readonly [
+            "express",
+            "router"
+        ];
+    },
+    {
+        readonly exportName: "graphqlChannelIntegration";
+        readonly modules: readonly [
+            "graphql"
+        ];
+    },
+    {
+        readonly exportName: "kafkajsChannelIntegration";
+        readonly modules: readonly [
+            "kafkajs"
+        ];
+    },
+    {
+        readonly exportName: "redisChannelIntegration";
+        readonly modules: readonly [
+            "redis",
+            "@redis/client"
+        ];
+    },
+    {
+        readonly exportName: "ioredisChannelIntegration";
+        readonly modules: readonly [
+            "ioredis"
+        ];
+    },
+    {
+        readonly exportName: "dataloaderChannelIntegration";
+        readonly modules: readonly [
+            "dataloader"
+        ];
+    }
+];
+/** Look up the subscriber export name for an instrumented package, if any. */
+export declare function subscriberExportForModule(moduleName: string): string | undefined;
+//# sourceMappingURL=channel-integration-definitions.d.ts.map

package/build/types-ts3.8/orchestrion/config/dataloader.d.ts

@@ -1,3 +1,4 @@
+import { InstrumentationConfig } from '..';
 export declare const dataloaderConfig: ({
     channelName: string;
     module: {
@@ -43,4 +44,5 @@ export declare const dataloaderChannels: {
     readonly DATALOADER_CLEAR: "orchestrion:dataloader:clear";
     readonly DATALOADER_CLEAR_ALL: "orchestrion:dataloader:clearAll";
 };
+export declare const dataloaderSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=dataloader.d.ts.map

package/build/types-ts3.8/orchestrion/config/express.d.ts

@@ -1,3 +1,4 @@
+import { InstrumentationConfig } from '..';
 export declare const expressConfig: ({
     channelName: string;
     module: {
@@ -27,4 +28,5 @@ export declare const expressChannels: {
     readonly EXPRESS_REGISTER: "orchestrion:express:register";
     readonly ROUTER_REGISTER: "orchestrion:router:register";
 };
+export declare const expressSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=express.d.ts.map