@depup/sentry__server-utils 10.67.0-depup.0

package/build/types-ts3.8/integrations/tracing-channel/kafkajs/spans.d.ts

@@ -0,0 +1,38 @@
+import { Span, SpanAttributes, SpanLink } from '@sentry/core';
+import { KafkaMessage, Message } from './types';
+interface ConsumerSpanOptions {
+    topic: string;
+    message: KafkaMessage | undefined;
+    operationType: string;
+    attributes: SpanAttributes;
+    links?: SpanLink[];
+}
+/**
+ * Reads a header value off a kafkajs message as a string. kafkajs delivers headers as `Buffer`s (or
+ * arrays of them), so we normalize to a string before handing them to Sentry's trace helpers.
+ */
+export declare function getHeaderAsString(headers: KafkaMessage['headers'], key: string): string | undefined;
+/**
+ * Builds a span link to the producer span carried in the message headers, mirroring the upstream
+ * behavior of linking each batch-processed message to its originating producer span.
+ */
+export declare function getLinksFromHeaders(headers: KafkaMessage['headers']): SpanLink[] | undefined;
+/** Starts an inactive consumer (process/receive) span carrying the kafkajs messaging attributes. */
+export declare function startConsumerSpan({ topic, message, operationType, links, attributes }: ConsumerSpanOptions): Span;
+/** Starts an inactive producer span and propagates its trace into the message headers. */
+export declare function startProducerSpan(topic: string, message: Message): Span;
+/**
+ * Marks all `spans` with the error status and `error.type` derived from a settle-time `reason`,
+ * WITHOUT ending them. Mirrors the vendored `endSpansOnPromise` catch block. The producer path (which
+ * receives discrete `error`/`asyncEnd` channel events) applies the error on `error` and ends on
+ * `asyncEnd`; the consumer path folds this into `endSpansOnPromise`.
+ */
+export declare function applyErrorToSpans(spans: Span[], reason: unknown): void;
+/**
+ * Resolves once `promise` settles, applying the error status to all `spans` on failure and ending
+ * them regardless. Used by the consumer path, which invokes the user callback directly (and so holds a
+ * real promise). Verbatim from the vendored `endSpansOnPromise`.
+ */
+export declare function endSpansOnPromise<T>(spans: Span[], promise: Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=spans.d.ts.map

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

@@ -0,0 +1,40 @@
+export interface Message {
+    key?: Buffer | string | null;
+    value: Buffer | string | null;
+    partition?: number;
+    headers?: Record<string, Buffer | string | (Buffer | string)[] | undefined>;
+    timestamp?: string;
+}
+export type KafkaMessage = {
+    [key: string]: unknown;
+} & Message;
+/** A single `{ topic, messages }` entry of a `sendBatch({ topicMessages })` call. */
+export interface TopicMessages {
+    topic: string;
+    messages: Message[];
+}
+/** The `sendBatch`/`send` argument shape after kafkajs normalizes `send` into `sendBatch`. */
+export interface ProducerBatch {
+    topicMessages?: TopicMessages[];
+}
+export interface EachMessagePayload {
+    topic: string;
+    partition: number;
+    message: KafkaMessage;
+}
+export interface Batch {
+    topic: string;
+    partition: number;
+    messages: KafkaMessage[];
+}
+export interface EachBatchPayload {
+    batch: Batch;
+}
+export type EachMessageHandler = (payload: EachMessagePayload) => Promise<void>;
+export type EachBatchHandler = (payload: EachBatchPayload) => Promise<void>;
+/** The `consumer.run(config)` argument shape; only the two callbacks are read/swapped. */
+export interface ConsumerRunConfig {
+    eachMessage?: EachMessageHandler | null;
+    eachBatch?: EachBatchHandler | null;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * EXPERIMENTAL - orchestrion-driven knex integration.
+ *
+ * Subscribes to the `orchestrion:knex:*` diagnostics_channels that the orchestrion code transform
+ * injects into knex's `Runner.query` (span) and `Client.queryBuilder`/`schemaBuilder`/`raw` (parent-span
+ * bookkeeping). Requires the orchestrion runtime hook or bundler plugin to be active.
+ */
+export declare const knexChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Knex";
+};
+//# sourceMappingURL=knex.d.ts.map

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

@@ -0,0 +1,14 @@
+export interface KoaChannelIntegrationOptions {
+    /** Ignore layers of the specified types (`'middleware'` and/or `'router'`). */
+    ignoreLayersType?: Array<'middleware' | 'router'>;
+}
+/**
+ * EXPERIMENTAL — orchestrion-driven koa integration. Subscribes to the
+ * `orchestrion:koa:use` channel injected into `Application.prototype.use` and
+ * wraps each registered middleware/router layer in a span-creating proxy.
+ * Requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const koaChannelIntegration: (options?: KoaChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Koa";
+};
+//# sourceMappingURL=koa.d.ts.map

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

@@ -0,0 +1,10 @@
+import { LangChainOptions } from '@sentry/core';
+/**
+ * EXPERIMENTAL — orchestrion-driven LangChain integration. Subscribes to the diagnostics_channels
+ * injected into `@langchain/core`'s `BaseChatModel` (to inject the Sentry callback handler) and into
+ * `@langchain/openai`'s embedding methods, so it requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const langChainChannelIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangChain";
+};
+//# sourceMappingURL=langchain.d.ts.map

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

@@ -0,0 +1,10 @@
+import { LangGraphOptions } from '@sentry/core';
+/**
+ * EXPERIMENTAL — orchestrion-driven LangGraph integration. Subscribes to the diagnostics_channels
+ * injected into `@langchain/langgraph`'s `StateGraph.compile` and `createReactAgent`, so it requires
+ * the orchestrion runtime hook or bundler plugin.
+ */
+export declare const langGraphChannelIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangGraph";
+};
+//# sourceMappingURL=langgraph.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/lru-memoizer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven lru-memoizer integration. Subscribes to
+ * `orchestrion:lru-memoizer:load` (injected into `lru-memoizer/lib/async.js`'s
+ * `memoizedFunction`). Creates no spans; only re-runs the memoized callback with the
+ * caller's scope. Requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const lruMemoizerChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "LruMemoizer";
+};
+//# sourceMappingURL=lru-memoizer.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * EXPERIMENTAL: orchestrion-driven mongodb integration.
+ *
+ * Reproduces the vendored `@opentelemetry/instrumentation-mongodb` span shape
+ * (legacy db/net semantic conventions, `mongodb.<op>` names, scrubbed
+ * `db.statement`) via the `orchestrion:mongodb:*` diagnostics_channels
+ * injected by the orchestrion code transform.
+ */
+export declare const mongodbChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongo";
+};
+//# sourceMappingURL=mongodb.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * EXPERIMENTAL: orchestrion-driven mongoose integration.
+ *
+ * Reproduces the vendored `@opentelemetry/instrumentation-mongoose` span
+ * shape (legacy db/net semantic conventions, `mongoose.<Model>.<op>` names,
+ * build-time span parenting) via the `orchestrion:mongoose:*`
+ * diagnostics_channels injected into mongoose `< 9.7` by the orchestrion
+ * code transform. For mongoose `>= 9.7` it also drives the native
+ * diagnostics_channel subscription, so this single integration covers every
+ * supported version once it replaces the OTel one.
+ */
+export declare const mongooseChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongoose";
+};
+//# sourceMappingURL=mongoose.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven mysql integration.
+ *
+ * Subscribes to the `orchestrion:mysql:query` diagnostics_channel that the
+ * orchestrion code transform injects into `mysql/lib/Connection.js`'s
+ * `Connection.prototype.query`. Requires the orchestrion runtime hook or
+ * bundler plugin to be active — wire that up via `_experimentalSetupOrchestrion`.
+ */
+export declare const mysqlChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Mysql";
+};
+//# sourceMappingURL=mysql.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * Orchestrion-driven mysql2 integration.
+ *
+ * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library
+ * via diagnostics-channel injection. See {@link instrumentMysql2} for how the two mysql2 version
+ * ranges are covered.
+ *
+ * Known limitation vs. the OTel integration it replaces: the callback-less streaming form
+ * (`connection.query(sql).on('result', ...)`) is not traced — see the `mysql2` orchestrion config for
+ * why. The callback and promise forms (the common case) are fully instrumented.
+ */
+export declare const mysql2ChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Mysql2";
+};
+//# sourceMappingURL=mysql2.d.ts.map

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

@@ -0,0 +1,10 @@
+import { OpenAiOptions } from '@sentry/core';
+/**
+ * EXPERIMENTAL — orchestrion-driven OpenAI integration. Subscribes to the `orchestrion:openai:*`
+ * diagnostics_channels injected into `openai`'s `create` methods (chat completions, responses, embeddings,
+ * conversations), so it requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const openaiChannelIntegration: (options?: OpenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "OpenAI";
+};
+//# sourceMappingURL=openai.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/postgres-js.d.ts

@@ -0,0 +1,26 @@
+import { PostgresConnectionContext, Span } from '@sentry/core';
+export interface PostgresJsChannelIntegrationOptions {
+    /**
+     * Only create spans when there's already an active parent span. Defaults to
+     * `true`, matching the OTel `postgresJsIntegration`.
+     */
+    requireParentSpan?: boolean;
+    /**
+     * Hook to modify the query span before the query runs. Receives the span, the
+     * sanitized SQL, and (when resolvable) the connection context.
+     */
+    requestHook?: (span: Span, sanitizedSqlQuery: string, postgresConnectionContext?: PostgresConnectionContext) => void;
+}
+/**
+ * EXPERIMENTAL — orchestrion-driven postgres.js (`postgres` v3.x) integration.
+ *
+ * Subscribes to the `orchestrion:postgres:handle` / `:connection` / `:execute` /
+ * `:connect` diagnostics channels injected into postgres.js' `Query.prototype.handle`
+ * and `Connection`/`execute`/`connect` (in `src/*` and `cjs/src/*`) and creates db
+ * spans matching the OTel `postgresJsIntegration`. Requires the orchestrion runtime
+ * hook or bundler plugin.
+ */
+export declare const postgresJsChannelIntegration: (options?: PostgresJsChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "PostgresJs";
+};
+//# sourceMappingURL=postgres-js.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * EXPERIMENTAL: orchestrion-driven `pg` (node-postgres) integration.
+ *
+ * Subscribes to the `orchestrion:pg:query`/`:connect` and
+ * `orchestrion:pg-pool:connect` diagnostics_channels that the orchestrion code
+ * transform injects into `pg`'s `Client.prototype.query`/`connect`
+ * and `pg-pool`'s `Pool.prototype.connect`. Requires the orchestrion runtime
+ * hook or bundler plugin to be active.
+ */
+export declare const postgresChannelIntegration: (options?: {
+    ignoreConnectSpans?: boolean;
+} | undefined) => import("@sentry/core").Integration & {
+    name: "Postgres";
+};
+//# sourceMappingURL=postgres.d.ts.map

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

@@ -0,0 +1,16 @@
+import { Span } from '@sentry/core';
+/** Mirrors `@opentelemetry/instrumentation-redis`' response hook. Not called for failed commands. */
+export type RedisResponseHook = (span: Span, command: string, args: Array<string | Buffer>, result: unknown) => void;
+export interface RedisChannelIntegrationOptions {
+    responseHook?: RedisResponseHook;
+}
+/**
+ * EXPERIMENTAL — orchestrion-driven redis integration for `redis` v2-v3 and
+ * node-redis v4/v5 `<5.12.0` (`@redis/client`). Covers single commands, `connect`,
+ * and multi/pipeline batches, fully replacing `@opentelemetry/instrumentation-redis`.
+ * Requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const redisChannelIntegration: (options?: RedisChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "RedisChannel";
+};
+//# sourceMappingURL=redis.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * EXPERIMENTAL - orchestrion-driven tedious integration.
+ *
+ * Subscribes to the `orchestrion:tedious:*` diagnostics_channels that the orchestrion code transform
+ * injects into tedious's `Connection` request methods (each traced as one db span) and `Connection.connect`
+ * (active-database bookkeeping). Requires the orchestrion runtime hook or bundler plugin to be active.
+ */
+export declare const tediousChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Tedious";
+};
+//# sourceMappingURL=tedious.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * Auto-instrument the `ai` SDK. Supported are:
+ * - 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 & {
+    name: "VercelAI";
+};
+//# sourceMappingURL=vercel-ai.d.ts.map

package/build/types-ts3.8/mongodb/mongodb-span.d.ts

@@ -0,0 +1,66 @@
+import { Span, SpanAttributes } from '@sentry/core';
+/**
+ * The db/collection namespace mongodb (v4+) passes to `Connection.command`
+ */
+export interface MongodbNamespace {
+    db: string;
+    collection?: string;
+}
+interface V4Command {
+    documents?: unknown[];
+    cursors?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Replaces every leaf value in the command object with '?', keeping keys
+ * and Mongo operators. hides PII and improves grouping. Reproduced from
+ * the OTel instrumentation.
+ */
+export declare function serializeDbStatement(commandObj: Record<string, unknown>): string;
+/**
+ * Build span attributes for a mongodb v4+ command from the connection
+ * context, namespace and command.
+ */
+export declare function getV4SpanAttributes(connectionCtx: {
+    address?: string;
+} | undefined, ns: MongodbNamespace, command: V4Command | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/**
+ * Shared attribute builder used by both the v3 topology path and the v4+
+ * connection path.
+ */
+export declare function getSpanAttributes(dbName: string | undefined, dbCollection: string | undefined, host: string | undefined, port: string | undefined, commandObj: Record<string, unknown> | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/** The v3 driver topology, from which host/port are read (mongodb 3.x). */
+export interface MongoV3Topology {
+    s?: {
+        options?: {
+            host?: string;
+            port?: number;
+        };
+        host?: string;
+        port?: number;
+    };
+    description?: {
+        address?: string;
+    };
+}
+/**
+ * Determine the operation name for a mongodb v3 `command` from the command
+ * document, mirroring the vendored instrumentation. Returns `undefined` for
+ * commands it doesn't classify (e.g. `endSessions`).
+ */
+export declare function getV3CommandOperation(command: Record<string, unknown>): string | undefined;
+/**
+ * Build span attributes for a mongodb v3 operation from the topology,
+ * namespace string and command.
+ */
+export declare function getV3SpanAttributes(ns: string, topology: MongoV3Topology | undefined, command: Record<string, unknown> | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/**
+ * Start a mongodb client span with the legacy (pre-stable) db/net semantic
+ * conventions.
+ *
+ * `op: 'db'` is set explicitly rather than relying on `inferDbSpanData`,
+ * to support platforms that lack it (ie, Deno).
+ */
+export declare function startMongoSpan(attributes: SpanAttributes): Span;
+export {};
+//# sourceMappingURL=mongodb-span.d.ts.map

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

@@ -0,0 +1,13 @@
+export { MongooseLegacyCollection, StartMongooseLegacySpanOptions } from './mongoose-legacy-span';
+export { startMongooseLegacySpan } from './mongoose-legacy-span';
+/**
+ * Auto-instrument the [mongoose](https://www.npmjs.com/package/mongoose) library via its native
+ * `node:diagnostics_channel` tracing channels (mongoose >= 9.7).
+ *
+ * On older mongoose versions the channels are never published to, so this integration is inert and
+ * the IITM-based patcher (gated to `< 9.7.0`) handles instrumentation instead.
+ */
+export declare const mongooseIntegration: () => import("@sentry/core").Integration & {
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/mongoose/mongoose-dc-subscriber.d.ts

@@ -0,0 +1,63 @@
+import { TracingChannel } from 'node:diagnostics_channel';
+export declare const MONGOOSE_DC_CHANNEL_QUERY = "mongoose:query";
+export declare const MONGOOSE_DC_CHANNEL_AGGREGATE = "mongoose:aggregate";
+export declare const MONGOOSE_DC_CHANNEL_MODEL_SAVE = "mongoose:model:save";
+export declare const MONGOOSE_DC_CHANNEL_MODEL_INSERT_MANY = "mongoose:model:insertMany";
+export declare const MONGOOSE_DC_CHANNEL_MODEL_BULK_WRITE = "mongoose:model:bulkWrite";
+export declare const MONGOOSE_DC_CHANNEL_CURSOR_NEXT = "mongoose:cursor:next";
+/**
+ * Shape of the context object mongoose >= 9.7.0 publishes on its tracing
+ * channels (mongoose's `TracingContext`, see `types/tracing.d.ts`).
+ *
+ * Node's `tracePromise` mutates this same object with `result`/`error` once the
+ * operation settles, which `bindTracingChannelToSpan` reads in its lifecycle
+ * handlers — hence both are declared optional here.
+ *
+ * Unlike redis/ioredis, mongoose does NOT pre-sanitize the payload, so `args`
+ * carries the raw user query. We redact it before emitting `db.query.text`.
+ */
+export interface MongooseTracingData {
+    operation: string;
+    /** Absent for connection-level `aggregate()` calls, which have no model/collection. */
+    collection?: string;
+    database?: string;
+    serverAddress?: string;
+    serverPort?: number;
+    /** Cursor channels only: the cursor's fetch batch size and tailable flag. */
+    batchSize?: number;
+    tailable?: boolean;
+    /**
+     * Operation-specific arguments. `filter` (queries/cursors) and `pipeline`
+     * (aggregations) carry the query shape; `docs`/`ops` carry batch payloads.
+     */
+    args?: {
+        filter?: unknown;
+        pipeline?: unknown;
+        docs?: unknown;
+        ops?: unknown;
+        [key: string]: unknown;
+    };
+    result?: unknown;
+    error?: Error;
+}
+/**
+ * Platform-provided factory that creates a native tracing channel for the given name. The
+ * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
+ * which propagates the active span through the runtime's async context.
+ *
+ * Node passes `node:diagnostics_channel`'s `tracingChannel` directly.
+ */
+export type MongooseTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/**
+ * Subscribe Sentry span handlers to mongoose's diagnostics-channel events
+ * (`mongoose:query`, `:aggregate`, `:model:save`, `:model:insertMany`,
+ * `:model:bulkWrite`, `:cursor:next`), published by mongoose >= 9.7.0.
+ *
+ * On older mongoose versions the channels are never published to, so the
+ * subscribers are inert — there is no double-instrumentation against the
+ * IITM-based vendored patcher, which is gated to `< 9.7.0`.
+ *
+ * Idempotent: subsequent calls are a no-op.
+ */
+export declare function subscribeMongooseDiagnosticChannels(tracingChannel: MongooseTracingChannelFactory): void;
+//# sourceMappingURL=mongoose-dc-subscriber.d.ts.map

package/build/types-ts3.8/mongoose/mongoose-legacy-span.d.ts

@@ -0,0 +1,29 @@
+import { Span } from '@sentry/core';
+/** The subset of mongoose's `Collection` that the legacy span shape reads. */
+export interface MongooseLegacyCollection {
+    name?: string;
+    conn?: {
+        name?: string;
+        user?: string;
+        host?: string;
+        port?: number;
+    };
+}
+export interface StartMongooseLegacySpanOptions {
+    collection: MongooseLegacyCollection | undefined;
+    modelName: string | undefined;
+    operation: string;
+    /** Span origin: distinguishes the OTel/IITM caller from orchestrion */
+    origin: string;
+    parentSpan?: Span;
+}
+/**
+ * Start a mongoose client span with the legacy (pre-stable) db/net semantic
+ * conventions.
+ *
+ * Shared by the vendored OTel/IITM instrumentation (`@sentry/node`) and the
+ * orchestrion channel subscriber so the two emit an identical span shape,
+ * differing only by `origin`.
+ */
+export declare function startMongooseLegacySpan({ collection, modelName, operation, origin, parentSpan, }: StartMongooseLegacySpanOptions): Span;
+//# sourceMappingURL=mongoose-legacy-span.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Auto-instrument the [mysql2](https://www.npmjs.com/package/mysql2) library via its native
+ * `node:diagnostics_channel` tracing channels (mysql2 >= 3.20.0).
+ *
+ * On older mysql2 versions the channels are never published to, so this integration is inert and
+ * the vendored OTel instrumentation (gated to `< 3.20.0`) handles instrumentation instead.
+ */
+export declare const mysql2Integration: () => import("@sentry/core").Integration & {
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/mysql2/mysql2-dc-subscriber.d.ts

@@ -0,0 +1,59 @@
+import { TracingChannel } from 'node:diagnostics_channel';
+export declare const MYSQL2_DC_CHANNEL_QUERY = "mysql2:query";
+export declare const MYSQL2_DC_CHANNEL_EXECUTE = "mysql2:execute";
+export declare const MYSQL2_DC_CHANNEL_CONNECT = "mysql2:connect";
+export declare const MYSQL2_DC_CHANNEL_POOL_CONNECT = "mysql2:pool:connect";
+/**
+ * Shape of the context object mysql2 >= 3.20.0 publishes on its query/execute
+ * tracing channels (see mysql2 `lib/base/connection.js`).
+ *
+ * Node's `traceCallback`/`tracePromise` mutate this same object with
+ * `result`/`error` once the operation settles, which `bindTracingChannelToSpan`
+ * reads in its lifecycle handlers — hence both are declared optional here.
+ *
+ * `query` is the SQL statement. On the `query` channel mysql2 has already
+ * inlined `values` into it (`Connection.format`), so it carries raw user data;
+ * on the `execute` channel it keeps `?` placeholders. Either way we sanitize it
+ * before emitting `db.query.text` and never attach `values`.
+ */
+export interface MySQL2QueryData {
+    query?: string;
+    values?: unknown;
+    database?: string;
+    serverAddress?: string;
+    /** Absent for unix-socket connections, where `serverAddress` is the socket path. */
+    serverPort?: number;
+    result?: unknown;
+    error?: Error;
+}
+/**
+ * Shape of the context object mysql2 >= 3.20.0 publishes on its
+ * `connect`/`pool:connect` channels.
+ */
+export interface MySQL2ConnectData {
+    database?: string;
+    serverAddress?: string;
+    serverPort?: number;
+    user?: string;
+    result?: unknown;
+    error?: Error;
+}
+/**
+ * Platform-provided factory that creates a native tracing channel for the given name. The
+ * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
+ * which propagates the active span through the runtime's async context.
+ *
+ * Node passes `node:diagnostics_channel`'s `tracingChannel` directly.
+ */
+export type MySQL2TracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/**
+ * Subscribe Sentry span handlers to mysql2's diagnostics-channel events
+ * (`mysql2:query`, `:execute`, `:connect`, `:pool:connect`), published by
+ * mysql2 >= 3.20.0.
+ *
+ * On older mysql2 versions the channels are never published to, so the
+ * subscribers are inert — there is no double-instrumentation against the
+ * vendored OTel patcher, which is gated to `< 3.20.0`.
+ */
+export declare function subscribeMysql2DiagnosticChannels(tracingChannel: MySQL2TracingChannelFactory): void;
+//# sourceMappingURL=mysql2-dc-subscriber.d.ts.map

package/build/types-ts3.8/node-diagnostics-channel.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Ambient shim for `node:diagnostics_channel`, injected into the TS 3.8 type output only
+ * (see `scripts/inject-ts38-shims.mjs`).
+ *
+ * `@types/node@14` — used by the SDK's TS 3.8 compatibility check — predates this module, so the
+ * published declarations that re-export `TracingChannel`/`TracingChannelSubscribers` fail to resolve
+ * it (`TS2307`). The real shapes are irrelevant here: TS 3.8 consumers only need these to type-check,
+ * never to call. This file is deliberately kept out of `src/` so it never participates in the modern
+ * build, where `@types/node` already declares the module.
+ */
+declare module 'node:diagnostics_channel' {
+  export interface TracingChannelSubscribers<ContextType = unknown> {
+    [key: string]: unknown;
+  }
+
+  export interface TracingChannel<StoreType = unknown, ContextType = unknown> {
+    [key: string]: unknown;
+  }
+}

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

@@ -0,0 +1,21 @@
+import codeTransformer from '@apm-js-collab/code-transformer-bundler-plugins/esbuild';
+import { PluginOptions } from './options';
+/**
+ * esbuild plugin that runs the orchestrion code transform on the bundled output.
+ *
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // build.mjs
+ * import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/esbuild';
+ * await esbuild.build({ plugins: [sentryOrchestrionPlugin()] });
+ * ```
+ */
+export declare function sentryOrchestrionPlugin(options?: PluginOptions): ReturnType<typeof codeTransformer>;
+//# sourceMappingURL=esbuild.d.ts.map

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

@@ -0,0 +1,29 @@
+import { InstrumentationConfig, CustomTransform } from '..';
+import { CodeTransformerPluginOptions } from '@apm-js-collab/code-transformer-bundler-plugins/core';
+export type PluginOptions = {
+    /**
+     * Additional instrumentations to include with the default instrumentation.
+     */
+    instrumentations?: InstrumentationConfig[];
+    /**
+     * Custom transforms that can be applied using the `transform` option in each `InstrumentationConfig`.
+     */
+    customTransforms?: Record<string, CustomTransform>;
+    /**
+     * Whether to inject the global diagnostics.
+     *
+     * Defaults to `true`.
+     */
+    shouldInjectDiagnostics?: boolean;
+};
+/**
+ * The `@apm-js-collab/code-transformer-bundler-plugins` options shared by every
+ * orchestrion bundler plugin.
+ *
+ * `injectDiagnostics` sets `globalThis.__SENTRY_ORCHESTRION__.bundler = ["mysql"]` at
+ * app boot so the `_experimentalSetupOrchestrion()` detector can confirm the
+ * bundler path ran (rather than relying on a build-time flag that wouldn't be
+ * visible to the runtime).
+ */
+export declare function orchestrionTransformOptions(options: PluginOptions): CodeTransformerPluginOptions;
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1,17 @@
+import codeTransformer from '@apm-js-collab/code-transformer-bundler-plugins/rollup';
+import { PluginOptions } from './options';
+/**
+ * Rollup plugin that runs the orchestrion code transform on the bundled output.
+ *
+ * Use when bundling a Node app with Rollup. For unbundled Node processes use the
+ * runtime hook instead (`node --import @sentry/node/orchestrion app.js`).
+ *
+ * @example
+ * ```ts
+ * // rollup.config.js
+ * import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/rollup';
+ * export default { plugins: [sentryOrchestrionPlugin()] };
+ * ```
+ */
+export declare function sentryOrchestrionPlugin(options?: PluginOptions): ReturnType<typeof codeTransformer>;
+//# sourceMappingURL=rollup.d.ts.map