@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,59 @@
+export declare const mongodbConfig: ({
+    channelName: string;
+    module: {
+        versionRange: string;
+        filePath: string;
+        name: "mongodb";
+    };
+    functionQuery: {
+        expressionName: "insert" | "update" | "remove";
+        kind: "Callback";
+    };
+} | {
+    channelName: string;
+    module: {
+        versionRange: string;
+        filePath: string;
+        name: "mongodb";
+    };
+    functionQuery: {
+        methodName: string;
+        kind: "Async";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        versionRange: string;
+        filePath: string;
+        name: "mongodb";
+    };
+    functionQuery: {
+        methodName: string;
+        kind: "Callback";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        versionRange: string;
+        filePath: string;
+        name: "mongodb";
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Callback";
+        methodName?: undefined;
+    };
+})[];
+export declare const mongodbChannels: {
+    readonly MONGODB_COMMAND: "orchestrion:mongodb:command";
+    readonly MONGODB_CHECKOUT: "orchestrion:mongodb:checkout";
+    readonly MONGODB_V3_INSERT: "orchestrion:mongodb:v3_insert";
+    readonly MONGODB_V3_UPDATE: "orchestrion:mongodb:v3_update";
+    readonly MONGODB_V3_REMOVE: "orchestrion:mongodb:v3_remove";
+    readonly MONGODB_V3_COMMAND: "orchestrion:mongodb:v3_command";
+    readonly MONGODB_V3_QUERY: "orchestrion:mongodb:v3_query";
+    readonly MONGODB_V3_GET_MORE: "orchestrion:mongodb:v3_get_more";
+};
+//# sourceMappingURL=mongodb.d.ts.map

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

@@ -0,0 +1,40 @@
+export declare const mongooseConfig: ({
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "mongoose";
+        versionRange: ">=5.9.7 <9.7.0";
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Auto";
+    };
+} | {
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "mongoose";
+        versionRange: ">=5.9.7 <9.7.0";
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Sync";
+    };
+})[];
+export declare const mongooseChannels: {
+    readonly MONGOOSE_QUERY_EXEC: "orchestrion:mongoose:query_exec";
+    readonly MONGOOSE_AGGREGATE_EXEC: "orchestrion:mongoose:aggregate_exec";
+    readonly MONGOOSE_MODEL_SAVE: "orchestrion:mongoose:model_save";
+    readonly MONGOOSE_MODEL_INSERT_MANY: "orchestrion:mongoose:model_insert_many";
+    readonly MONGOOSE_MODEL_BULK_WRITE: "orchestrion:mongoose:model_bulk_write";
+    readonly MONGOOSE_MODEL_REMOVE: "orchestrion:mongoose:model_remove";
+    readonly MONGOOSE_MODEL_AGGREGATE: "orchestrion:mongoose:model_aggregate";
+};
+/**
+ * Fully-qualified names of the context-capture channels, derived from the
+ * same method list the transform config uses so the two can't drift. The
+ * subscriber subscribes to all of them uniformly to stash the build-time
+ * parent span (see `mongooseChannels` for the span-creating channels).
+ */
+export declare const MONGOOSE_CONTEXT_CAPTURE_CHANNELS: string[];
+//# sourceMappingURL=mongoose.d.ts.map

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

@@ -0,0 +1,16 @@
+export declare const mysqlConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Auto";
+    };
+}[];
+export declare const mysqlChannels: {
+    readonly MYSQL_QUERY: "orchestrion:mysql:query";
+};
+//# sourceMappingURL=mysql.d.ts.map

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

@@ -0,0 +1,18 @@
+export declare const mysql2Config: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Callback";
+    };
+}[];
+export declare const mysql2Channels: {
+    readonly MYSQL2_QUERY: "orchestrion:mysql2:query";
+    readonly MYSQL2_EXECUTE: "orchestrion:mysql2:execute";
+};
+//# sourceMappingURL=mysql2.d.ts.map

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

@@ -0,0 +1,24 @@
+import { InstrumentationConfig } from '..';
+/**
+ * NestJS is different from the other instrumentations here. It's a standalone
+ * metaframework SDK (`@sentry/nestjs`), so its channel LISTENER lives in that
+ * package rather than in `server-utils`. Only the code-transform config (and
+ * the channel names below) live here, so `@nestjs/*` is transformed whenever
+ * orchestrion is enabled, same as every other library.
+ *
+ * `@sentry/nestjs` imports {@link nestjsChannels} to subscribe, and picks the
+ * channel-vs-OTel path based on the global injection flag.
+ */
+export declare const nestjsConfig: InstrumentationConfig[];
+export declare const nestjsChannels: {
+    readonly NESTJS_APP_CREATION: "orchestrion:@nestjs/core:nestFactoryCreate";
+    readonly NESTJS_ROUTER_CONTEXT: "orchestrion:@nestjs/core:routerExecutionContextCreate";
+    readonly NESTJS_INJECTABLE: "orchestrion:@nestjs/common:injectableDecorator";
+    readonly NESTJS_CATCH: "orchestrion:@nestjs/common:catchDecorator";
+    readonly NESTJS_SCHEDULE_CRON: "orchestrion:@nestjs/schedule:cronDecorator";
+    readonly NESTJS_SCHEDULE_INTERVAL: "orchestrion:@nestjs/schedule:intervalDecorator";
+    readonly NESTJS_SCHEDULE_TIMEOUT: "orchestrion:@nestjs/schedule:timeoutDecorator";
+    readonly NESTJS_ONEVENT: "orchestrion:@nestjs/event-emitter:onEventDecorator";
+    readonly NESTJS_PROCESSOR: "orchestrion:@nestjs/bullmq:processorDecorator";
+};
+//# sourceMappingURL=nestjs.d.ts.map

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

@@ -0,0 +1,18 @@
+export declare const openaiConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Auto";
+    };
+}[];
+export declare const openaiChannels: {
+    readonly OPENAI_CHAT: "orchestrion:openai:chat";
+    readonly OPENAI_EMBEDDINGS: "orchestrion:openai:embeddings";
+};
+//# sourceMappingURL=openai.d.ts.map

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

@@ -0,0 +1,33 @@
+export declare const pgConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Auto";
+        expressionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Auto";
+        className?: undefined;
+        methodName?: undefined;
+    };
+})[];
+export declare const pgChannels: {
+    readonly PG_QUERY: "orchestrion:pg:query";
+    readonly PG_CONNECT: "orchestrion:pg:connect";
+    readonly PGPOOL_CONNECT: "orchestrion:pg-pool:connect";
+};
+//# sourceMappingURL=pg.d.ts.map

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

@@ -0,0 +1,9 @@
+import { InstrumentationConfig } from '..';
+export declare const postgresJsConfig: InstrumentationConfig[];
+export declare const postgresJsChannels: {
+    readonly POSTGRESJS_HANDLE: "orchestrion:postgres:handle";
+    readonly POSTGRESJS_CONNECTION: "orchestrion:postgres:connection";
+    readonly POSTGRESJS_EXECUTE: "orchestrion:postgres:execute";
+    readonly POSTGRESJS_CONNECT: "orchestrion:postgres:connect";
+};
+//# sourceMappingURL=postgres.d.ts.map

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

@@ -0,0 +1,4 @@
+import { InstrumentationConfig } from '..';
+export declare const prismaConfig: InstrumentationConfig[];
+export declare const prismaChannels: {};
+//# sourceMappingURL=prisma.d.ts.map

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

@@ -0,0 +1,4 @@
+import { InstrumentationConfig } from '..';
+export declare const reactRouterConfig: InstrumentationConfig[];
+export declare const reactRouterChannels: {};
+//# sourceMappingURL=react-router.d.ts.map

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

@@ -0,0 +1,37 @@
+export declare const redisConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Sync";
+        className?: undefined;
+        methodName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Async";
+        expressionName?: undefined;
+    };
+})[];
+export declare const redisChannels: {
+    readonly REDIS_COMMAND: "orchestrion:redis:command";
+    readonly NODE_REDIS_COMMAND: "orchestrion:@redis/client:command";
+    readonly NODE_REDIS_EXECUTOR: "orchestrion:@redis/client:executor";
+    readonly NODE_REDIS_CONNECT: "orchestrion:@redis/client:connect";
+    readonly NODE_REDIS_MULTI: "orchestrion:@redis/client:multi";
+    readonly NODE_REDIS_PIPELINE: "orchestrion:@redis/client:pipeline";
+    readonly NODE_REDIS_BATCH: "orchestrion:@redis/client:batch";
+};
+//# sourceMappingURL=redis.d.ts.map

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

@@ -0,0 +1,9 @@
+import { InstrumentationConfig } from '..';
+export declare const remixConfig: InstrumentationConfig[];
+export declare const remixChannels: {
+    readonly REMIX_REQUEST_HANDLER: "orchestrion:@remix-run/server-runtime:requestHandler";
+    readonly REMIX_MATCH_SERVER_ROUTES: "orchestrion:@remix-run/server-runtime:matchServerRoutes";
+    readonly REMIX_CALL_ROUTE_LOADER: "orchestrion:@remix-run/server-runtime:callRouteLoader";
+    readonly REMIX_CALL_ROUTE_ACTION: "orchestrion:@remix-run/server-runtime:callRouteAction";
+};
+//# sourceMappingURL=remix.d.ts.map

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

@@ -0,0 +1,12 @@
+import { InstrumentationConfig } from '..';
+export declare const tediousConfig: InstrumentationConfig[];
+export declare const tediousChannels: {
+    readonly TEDIOUS_CONNECT: "orchestrion:tedious:connect";
+    readonly TEDIOUS_EXEC_SQL: "orchestrion:tedious:execSql";
+    readonly TEDIOUS_EXEC_SQL_BATCH: "orchestrion:tedious:execSqlBatch";
+    readonly TEDIOUS_CALL_PROCEDURE: "orchestrion:tedious:callProcedure";
+    readonly TEDIOUS_EXEC_BULK_LOAD: "orchestrion:tedious:execBulkLoad";
+    readonly TEDIOUS_PREPARE: "orchestrion:tedious:prepare";
+    readonly TEDIOUS_EXECUTE: "orchestrion:tedious:execute";
+};
+//# sourceMappingURL=tedious.d.ts.map

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

@@ -0,0 +1,12 @@
+import { InstrumentationConfig } from '..';
+export declare const vercelAiConfig: InstrumentationConfig[];
+export declare const vercelAiChannels: {
+    readonly VERCEL_AI_GENERATE_TEXT: "orchestrion:ai:generateText";
+    readonly VERCEL_AI_STREAM_TEXT: "orchestrion:ai:streamText";
+    readonly VERCEL_AI_GENERATE_OBJECT: "orchestrion:ai:generateObject";
+    readonly VERCEL_AI_EMBED: "orchestrion:ai:embed";
+    readonly VERCEL_AI_EMBED_MANY: "orchestrion:ai:embedMany";
+    readonly VERCEL_AI_EXECUTE_TOOL_CALL: "orchestrion:ai:executeToolCall";
+    readonly VERCEL_AI_RESOLVE_LANGUAGE_MODEL: "orchestrion:ai:resolveLanguageModel";
+};
+//# sourceMappingURL=vercel-ai.d.ts.map

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

@@ -0,0 +1,26 @@
+/**
+ * Whether orchestrion has injected the diagnostics channels into this process,
+ * either by the runtime `--import` hook / init-time registration (`runtime`)
+ * or a bundler plugin (`bundler`). Both injectors set a flag on the
+ * `globalThis.__SENTRY_ORCHESTRION__` marker.
+ *
+ * Use this to avoid wiring up channel-subscriber integrations when nothing
+ * will ever publish to those channels.
+ */
+export declare function isOrchestrionInjected(): boolean;
+/**
+ * Verifies that the diagnostics channels have been injected either by the
+ * runtime `--import` hook (or init-time registration), a bundler plugin, or
+ * both, and warns if not. When at least one injector is active, logs for each
+ * mechanism whether it hooked (a defined array, even empty, means it did) and
+ * which libraries it injected.
+ *
+ * Both injectors being active at once is fine: they operate on disjoint module
+ * sets (a module is either loaded through Node's loader and transformed by the
+ * runtime hook, or inlined by the bundler and transformed by the plugin), so
+ * a single module can't be double-wrapped. A hybrid setup, with some deps
+ * external and runtime-instrumented, others bundled and plugin-instrumented,
+ * is fine.
+ */
+export declare function detectOrchestrionSetup(): void;
+//# sourceMappingURL=detect.d.ts.map

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

@@ -0,0 +1,138 @@
+import { amqplibChannelIntegration } from '../integrations/tracing-channel/amqplib';
+import { anthropicChannelIntegration } from '../integrations/tracing-channel/anthropic';
+import { awsChannelIntegration } from '../integrations/tracing-channel/aws-sdk';
+import { dataloaderChannelIntegration } from '../integrations/tracing-channel/dataloader';
+import { genericPoolChannelIntegration } from '../integrations/tracing-channel/generic-pool';
+import { googleGenAIChannelIntegration } from '../integrations/tracing-channel/google-genai';
+import { graphqlChannelIntegration } from '../integrations/tracing-channel/graphql';
+import { hapiChannelIntegration } from '../integrations/tracing-channel/hapi';
+import { koaChannelIntegration } from '../integrations/tracing-channel/koa';
+import { ioredisChannelIntegration } from '../integrations/tracing-channel/ioredis';
+import { kafkajsChannelIntegration } from '../integrations/tracing-channel/kafkajs';
+import { knexChannelIntegration } from '../integrations/tracing-channel/knex';
+import { langChainChannelIntegration } from '../integrations/tracing-channel/langchain';
+import { langGraphChannelIntegration } from '../integrations/tracing-channel/langgraph';
+import { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';
+import { mongodbChannelIntegration } from '../integrations/tracing-channel/mongodb';
+import { mongooseChannelIntegration } from '../integrations/tracing-channel/mongoose';
+import { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';
+import { mysql2ChannelIntegration } from '../integrations/tracing-channel/mysql2';
+import { openaiChannelIntegration } from '../integrations/tracing-channel/openai';
+import { postgresChannelIntegration } from '../integrations/tracing-channel/postgres';
+import { postgresJsChannelIntegration } from '../integrations/tracing-channel/postgres-js';
+import { tediousChannelIntegration } from '../integrations/tracing-channel/tedious';
+import { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai';
+import { expressChannelIntegration } from '../integrations/tracing-channel/express';
+export { detectOrchestrionSetup, isOrchestrionInjected } from './detect';
+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 { KoaChannelIntegrationOptions } from '../integrations/tracing-channel/koa';
+export { IORedisChannelIntegrationOptions, IORedisResponseHook } from '../integrations/tracing-channel/ioredis';
+export { PostgresJsChannelIntegrationOptions } from '../integrations/tracing-channel/postgres-js';
+export { redisChannelIntegration } from '../integrations/tracing-channel/redis';
+export { RedisChannelIntegrationOptions, RedisResponseHook } from '../integrations/tracing-channel/redis';
+export { InstrumentationConfig, CustomTransform } from '@apm-js-collab/code-transformer-bundler-plugins/core';
+export * from '../integrations/tracing-channel/graphql/graphql-types';
+/**
+ * The canonical set of orchestrion diagnostics-channel integrations, keyed by their public
+ * (OTel-parity) factory name.
+ *
+ * Single source of truth: add a new channel integration here and every consumer — the `@sentry/node`
+ * opt-in helper (`experimentalUseDiagnosticsChannelInjection`) and its public
+ * `diagnosticsChannelInjectionIntegrations()` map — picks it up automatically, so there's no separate
+ * list to keep in sync.
+ *
+ * NOTE: `ioredisChannelIntegration` and `redisChannelIntegration` are intentionally NOT here. They
+ * only partially replace the composite OTel `Redis` integration and need the node SDK's redis cache
+ * `responseHook` (which can't live in `server-utils`), so `@sentry/node` wires them up separately.
+ *
+ * Framework SDKs that own their own channel listener (e.g. `@sentry/nestjs`'s `Nest`) are NOT here
+ * either: their transform config is still in `SENTRY_INSTRUMENTATIONS`, but the listener lives in
+ * their package and picks the channel-vs-OTel path itself at `setupOnce`, so it needs no central swap.
+ *
+ * NOTE: `dataloaderChannelIntegration` is also NOT here. Everything in this map is auto-appended to
+ * the default integrations, but the OTel `Dataloader` integration is opt-in (never a default). Like
+ * `@sentry/nestjs`'s `Nest`, its `@sentry/node` factory picks the channel-vs-OTel path itself at
+ * `setupOnce` (via `isOrchestrionInjected()`), so there's nothing for the central swap to do.
+ */
+export declare const channelIntegrations: {
+    readonly postgresIntegration: (options?: {
+        ignoreConnectSpans?: boolean;
+    } | undefined) => import("@sentry/core").Integration & {
+        name: "Postgres";
+    };
+    readonly postgresJsIntegration: (options?: import(".").PostgresJsChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "PostgresJs";
+    };
+    readonly mongoIntegration: () => import("@sentry/core").Integration & {
+        name: "Mongo";
+    };
+    readonly mysqlIntegration: () => import("@sentry/core").Integration & {
+        name: "Mysql";
+    };
+    readonly mysql2Integration: () => import("@sentry/core").Integration & {
+        name: "Mysql2";
+    };
+    readonly genericPoolIntegration: () => import("@sentry/core").Integration & {
+        name: "GenericPool";
+    };
+    readonly mongooseIntegration: () => import("@sentry/core").Integration & {
+        name: "Mongoose";
+    };
+    readonly lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+        name: "LruMemoizer";
+    };
+    readonly openaiIntegration: (options?: import("@sentry/core").OpenAiOptions | undefined) => import("@sentry/core").Integration & {
+        name: "OpenAI";
+    };
+    readonly anthropicIntegration: (options?: import("@sentry/core").AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Anthropic_AI";
+    };
+    readonly googleGenAIIntegration: (options?: import("@sentry/core").GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Google_GenAI";
+    };
+    readonly langChainIntegration: (options?: import("@sentry/core").LangChainOptions | undefined) => import("@sentry/core").Integration & {
+        name: "LangChain";
+    };
+    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 & {
+        name: "VercelAI";
+    };
+    readonly amqplibIntegration: () => import("@sentry/core").Integration & {
+        name: "Amqplib";
+    };
+    readonly hapiIntegration: () => import("@sentry/core").Integration & {
+        name: "Hapi";
+    };
+    readonly koaIntegration: (options?: import(".").KoaChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Koa";
+    };
+    readonly expressIntegration: (options?: import("../integrations/tracing-channel/express/types").ExpressIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Express";
+    };
+    readonly graphqlIntegration: (options?: import("../graphql/graphql-dc-subscriber").GraphqlDiagnosticChannelsOptions) => Pick<import("@sentry/core").Integration & {
+        name: "Graphql";
+    }, Exclude<keyof (import("@sentry/core").Integration & {
+        name: "Graphql";
+    }), "name" | "setupOnce">> & {
+        name: "Graphql";
+        setupOnce: () => void | undefined;
+    };
+    readonly kafkajsIntegration: () => import("@sentry/core").Integration & {
+        name: "Kafka";
+    };
+    readonly tediousIntegration: () => import("@sentry/core").Integration & {
+        name: "Tedious";
+    };
+    readonly awsIntegration: () => import("@sentry/core").Integration & {
+        name: "Aws";
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/orchestrion/runtime/register.d.ts

@@ -0,0 +1,25 @@
+export interface RegisterDiagnosticsChannelInjectionOptions {
+    /**
+     * Absolute directory of the `@apm-js-collab/tracing-hooks` package (forward slashes).
+     *
+     * Needed when SDK code is bundled into an app's server build: the default bare-specifier
+     * require then resolves from the emitted chunk, which fails under isolated installs (pnpm).
+     * Framework SDKs (e.g. `@sentry/nextjs`) resolve the package at build time and pass its
+     * location here; it is loaded through an opaque `createRequire` that bundlers can't trace.
+     */
+    tracingHooksDir?: string;
+}
+/**
+ * Synchronously register the diagnostics-channel injection module hooks.
+ *
+ * This is the single source of truth for the registration logic. It is used by:
+ * - `Sentry.init()` (the Node SDK calls it directly — that's why this module
+ *   must be CJS-compatible / dual-built, so it can be `require()`d synchronously
+ *   before the app's `import`s resolve), and
+ * - `import-hook.mjs`, the side-effecting `--import` entry, which just calls it.
+ *
+ * Libraries imported *after* this call publish the `tracingChannel` events that
+ * the channel-based integrations subscribe to.
+ */
+export declare function registerDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void;
+//# sourceMappingURL=register.d.ts.map

package/build/types-ts3.8/prisma/global.d.ts

@@ -0,0 +1,5 @@
+import { TracingHelper } from './types';
+export declare function getGlobalTracingHelper(): TracingHelper | undefined;
+export declare function setGlobalTracingHelper(helper: TracingHelper): void;
+export declare function clearGlobalTracingHelper(): void;
+//# sourceMappingURL=global.d.ts.map

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

@@ -0,0 +1,45 @@
+export interface PrismaInstrumentationConfig {
+    /**
+     * Span types that should not be traced. Matched against the full span name (e.g. `prisma:client:operation`),
+     * either exactly (string) or by pattern (RegExp).
+     */
+    ignoreSpanTypes?: (string | RegExp)[];
+}
+export interface PrismaOptions {
+    /**
+     * @deprecated This is no longer used, v5 works out of the box.
+     */
+    prismaInstrumentation?: unknown;
+    /**
+     * Configuration for the Prisma tracing helper.
+     */
+    instrumentationConfig?: PrismaInstrumentationConfig;
+}
+/**
+ * Sets up the global Prisma tracing helper that Prisma looks up on `globalThis` to emit tracing data.
+ *
+ * Prisma reads `globalThis.PRISMA_INSTRUMENTATION` (and its versioned variant) to find a "TracingHelper"
+ * which it uses internally to create spans, so it can produce tracing data without depending on
+ * OpenTelemetry. The helper we install here mints spans through Sentry's span APIs. A single helper
+ * serves both Prisma v5 (which calls `createEngineSpan`) and v6/v7 (which call `dispatchEngineSpans`),
+ * so it doesn't blow up on version mismatches.
+ */
+export declare function instrumentPrisma(options?: PrismaOptions): void;
+/**
+ * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
+ * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
+ *
+ * NOTE: This integration works out of the box with Prisma v6, and v7.
+ * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
+ *
+ *    ```
+ *    generator client {
+ *      provider = "prisma-client-js"
+ *      previewFeatures = ["tracing"]
+ *    }
+ *    ```
+ */
+export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Prisma";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/prisma/tracing-helper.d.ts

@@ -0,0 +1,52 @@
+import { Span } from '@sentry/core';
+import { EngineSpan, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
+type Options = {
+    ignoreSpanTypes: (string | RegExp)[];
+};
+type V5EngineSpanEvent = {
+    span: boolean;
+    spans: V5EngineSpan[];
+};
+type V5EngineSpanKind = 'client' | 'internal';
+type V5EngineSpan = {
+    span: boolean;
+    name: string;
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string;
+    start_time: [
+        number,
+        number
+    ];
+    end_time: [
+        number,
+        number
+    ];
+    attributes?: Record<string, string>;
+    links?: {
+        trace_id: string;
+        span_id: string;
+    }[];
+    kind: V5EngineSpanKind;
+};
+/**
+ * This satisifes the TracingHelper interface for Prisma v5 and v6/v7.
+ */
+export declare class ActiveTracingHelper implements TracingHelper {
+    private ignoreSpanTypes;
+    constructor({ ignoreSpanTypes }: Options);
+    isEnabled(): boolean;
+    getTraceParent(span?: Span): string;
+    dispatchEngineSpans(spans: EngineSpan[]): void;
+    /**
+     * Prisma v5 broke the tracing helper interface with the v6 major, replacing `createEngineSpan` with
+     * `dispatchEngineSpans`. We implement the v6/v7 interface (`dispatchEngineSpans`) but also keep this
+     * v5-only method so the same helper doesn't blow up in Prisma 5 users' faces, minting v5 engine spans
+     * through Sentry's span APIs instead of crashing.
+     */
+    createEngineSpan(engineSpanEvent: V5EngineSpanEvent): void;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+export {};
+//# sourceMappingURL=tracing-helper.d.ts.map

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

@@ -0,0 +1,40 @@
+import { Span, SpanAttributes, SpanKindValue, SpanLink, SpanTimeInput } from '@sentry/core';
+export type SpanCallback<R> = (span?: Span, parentSpan?: Span) => R;
+export interface ExtendedSpanOptions {
+    /** The name of the span */
+    name: string;
+    internal?: boolean;
+    /** Whether it propagates context (?=true) */
+    active?: boolean;
+    attributes?: SpanAttributes;
+    kind?: SpanKindValue;
+    links?: SpanLink[];
+    startTime?: SpanTimeInput;
+}
+export type EngineSpanId = string;
+export type HrTime = [
+    number,
+    number
+];
+export type EngineSpanKind = 'client' | 'internal';
+export type EngineSpan = {
+    id: EngineSpanId;
+    parentId: string | null;
+    name: string;
+    startTime: HrTime;
+    endTime: HrTime;
+    kind: EngineSpanKind;
+    attributes?: Record<string, unknown>;
+    links?: EngineSpanId[];
+};
+export interface TracingHelper {
+    isEnabled(): boolean;
+    getTraceParent(span?: Span): string;
+    dispatchEngineSpans(spans: EngineSpan[]): void;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+export interface PrismaInstrumentationGlobalValue {
+    helper?: TracingHelper;
+}
+//# sourceMappingURL=types.d.ts.map