@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,29 @@
+export declare const graphqlConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Sync";
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Auto";
+    };
+})[];
+export declare const graphqlChannels: {
+    readonly GRAPHQL_PARSE: "orchestrion:graphql:parse";
+    readonly GRAPHQL_VALIDATE: "orchestrion:graphql:validate";
+    readonly GRAPHQL_EXECUTE: "orchestrion:graphql:execute";
+};
+//# sourceMappingURL=graphql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/graphql.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;IAgBS,CAAC;AAEpC,eAAO,MAAM,eAAe;;;;CAIlB,CAAC"}

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

@@ -0,0 +1,17 @@
+export declare const hapiConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        methodName: string;
+        kind: "Sync";
+    };
+}[];
+export declare const hapiChannels: {
+    readonly HAPI_ROUTE: "orchestrion:@hapi/hapi:route";
+    readonly HAPI_EXT: "orchestrion:@hapi/hapi:ext";
+};
+//# sourceMappingURL=hapi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hapi.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/hapi.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;GAeY,CAAC;AAEpC,eAAO,MAAM,YAAY;;;CAGf,CAAC"}

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

@@ -0,0 +1,37 @@
+import type { InstrumentationConfig } from '..';
+/**
+ * The orchestrion code-transform configs. Every instrumentable library is here
+ * so the transform is all-or-nothing: whenever orchestrion is enabled, all of
+ * these are injected. The channel LISTENERS may live elsewhere (e.g. the NestJS
+ * one lives in `@sentry/nestjs`), but the config that decides what gets
+ * transformed is centralized here.
+ */
+export declare const SENTRY_INSTRUMENTATIONS: InstrumentationConfig[];
+/**
+ * The unique set of package names instrumented by `SENTRY_INSTRUMENTATIONS`
+ * merged with any caller-provided `instrumentations` (e.g. `['mysql']`).
+ *
+ * Bundler plugins MUST ensure these are actually bundled rather than
+ * externalized: an externalized dependency is resolved from `node_modules` at
+ * runtime and never passes through the code transform's `onLoad`, so its
+ * diagnostics_channel calls are silently never injected. This includes a
+ * plugin's custom `instrumentations`, otherwise those extra packages can stay
+ * externalized and their transform never runs.
+ */
+export declare function instrumentedModuleNames(instrumentations?: InstrumentationConfig[]): string[];
+/** The instrumented module names from the default Sentry config, with no custom additions. */
+export declare const INSTRUMENTED_MODULE_NAMES: string[];
+/**
+ * Returns `external` with any instrumented packages removed, so a bundler that
+ * uses an "external" denylist (esbuild, Bun, Rollup) still bundles — and thus
+ * transforms — them. Matches an exact package name (`'mysql'`) or a subpath
+ * (`'mysql/lib/...'`); wildcard/other patterns are left untouched. `undefined`
+ * is returned unchanged.
+ *
+ * Pass `moduleNames` from `instrumentedModuleNames(options.instrumentations)` so
+ * custom instrumentations are stripped too; it defaults to the Sentry config
+ * list. (Vite uses an `ssr.noExternal` allowlist instead, so it consumes
+ * `instrumentedModuleNames` directly rather than this helper.)
+ */
+export declare function withoutInstrumentedExternals(external: readonly string[] | undefined, moduleNames?: string[]): string[] | undefined;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAqChD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,qBAAqB,EAgC1D,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,gBAAgB,GAAE,qBAAqB,EAAO,GAAG,MAAM,EAAE,CAOhG;AAED,8FAA8F;AAC9F,eAAO,MAAM,yBAAyB,EAAE,MAAM,EAA8B,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACvC,WAAW,GAAE,MAAM,EAA8B,GAChD,MAAM,EAAE,GAAG,SAAS,CAKtB"}

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

@@ -0,0 +1,7 @@
+import type { InstrumentationConfig } from '..';
+export declare const ioredisConfig: InstrumentationConfig[];
+export declare const ioredisChannels: {
+    readonly IOREDIS_COMMAND: "orchestrion:ioredis:command";
+    readonly IOREDIS_CONNECT: "orchestrion:ioredis:connect";
+};
+//# sourceMappingURL=ioredis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/ioredis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAEhD,eAAO,MAAM,aAAa,yBAwBS,CAAC;AAEpC,eAAO,MAAM,eAAe;;;CAGlB,CAAC"}

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

@@ -0,0 +1,17 @@
+export declare const kafkajsConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Async";
+    };
+}[];
+export declare const kafkajsChannels: {
+    readonly KAFKAJS_SEND_BATCH: "orchestrion:kafkajs:send_batch";
+    readonly KAFKAJS_CONSUMER_RUN: "orchestrion:kafkajs:consumer_run";
+};
+//# sourceMappingURL=kafkajs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafkajs.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/kafkajs.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;GAmBS,CAAC;AAEpC,eAAO,MAAM,eAAe;;;CAGlB,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { InstrumentationConfig } from '..';
+export declare const knexConfig: InstrumentationConfig[];
+export declare const knexChannels: {
+    readonly KNEX_QUERY: "orchestrion:knex:query";
+    readonly KNEX_QUERY_BUILDER: "orchestrion:knex:queryBuilder";
+    readonly KNEX_SCHEMA_BUILDER: "orchestrion:knex:schemaBuilder";
+    readonly KNEX_RAW: "orchestrion:knex:raw";
+};
+//# sourceMappingURL=knex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"knex.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/knex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAwChD,eAAO,MAAM,UAAU,EAAE,qBAAqB,EAK7C,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;CAKf,CAAC"}

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

@@ -0,0 +1,17 @@
+export declare const koaConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Sync";
+    };
+}[];
+export declare const koaChannels: {
+    readonly KOA_USE: "orchestrion:koa:use";
+};
+//# sourceMappingURL=koa.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"koa.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/koa.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;GAMa,CAAC;AAEpC,eAAO,MAAM,WAAW;;CAEd,CAAC"}

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

@@ -0,0 +1,18 @@
+export declare const langchainConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        methodName: string;
+        kind: "Async";
+    };
+}[];
+export declare const langchainEmbeddingsChannels: string[];
+export declare const langchainChannels: {
+    readonly LANGCHAIN_CHAT_MODEL_INVOKE: "orchestrion:@langchain/core:chatModelInvoke";
+    readonly LANGCHAIN_CHAT_MODEL_STREAM: "orchestrion:@langchain/core:chatModelStream";
+};
+//# sourceMappingURL=langchain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/langchain.ts"],"names":[],"mappings":"AA6DA,eAAO,MAAM,eAAe;;;;;;;;;;;GAA8E,CAAC;AAI3G,eAAO,MAAM,2BAA2B,UAEvC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;CAGpB,CAAC"}

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

@@ -0,0 +1,21 @@
+export declare const langgraphConfig: ({
+    channelName: string;
+    module: import("@apm-js-collab/code-transformer").ModuleMatcher;
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Sync";
+    };
+} | {
+    channelName: string;
+    module: import("@apm-js-collab/code-transformer").ModuleMatcher;
+    functionQuery: {
+        functionName: string;
+        kind: "Sync";
+    };
+})[];
+export declare const langgraphChannels: {
+    readonly LANGGRAPH_STATE_GRAPH_COMPILE: "orchestrion:@langchain/langgraph:stateGraphCompile";
+    readonly LANGGRAPH_CREATE_REACT_AGENT: "orchestrion:@langchain/langgraph:createReactAgent";
+};
+//# sourceMappingURL=langgraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/langgraph.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;IAAkF,CAAC;AAE/G,eAAO,MAAM,iBAAiB;;;CAGpB,CAAC"}

package/build/types/orchestrion/config/lru-memoizer.d.ts

@@ -0,0 +1,16 @@
+export declare const lruMemoizerConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Callback";
+    };
+}[];
+export declare const lruMemoizerChannels: {
+    readonly LRU_MEMOIZER_LOAD: "orchestrion:lru-memoizer:load";
+};
+//# sourceMappingURL=lru-memoizer.d.ts.map

package/build/types/orchestrion/config/lru-memoizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-memoizer.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/lru-memoizer.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;GAOK,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;CAEtB,CAAC"}

package/build/types/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/orchestrion/config/mongodb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/mongodb.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiDS,CAAC;AAEpC,eAAO,MAAM,eAAe;;;;;;;;;CASlB,CAAC"}

package/build/types/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/orchestrion/config/mongoose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/mongoose.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;IAoEQ,CAAC;AAEpC,eAAO,MAAM,gBAAgB;;;;;;;;CAQnB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,EAAE,MAAM,EAErD,CAAC"}

package/build/types/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/orchestrion/config/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/mysql.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;GAMW,CAAC;AAEpC,eAAO,MAAM,aAAa;;CAEhB,CAAC"}

package/build/types/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/orchestrion/config/mysql2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/mysql2.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,YAAY;;;;;;;;;;;;GAqBU,CAAC;AAEpC,eAAO,MAAM,cAAc;;;CAGjB,CAAC"}

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

@@ -0,0 +1,24 @@
+import type { 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/orchestrion/config/nestjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/nestjs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAmBhD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,yBAqGU,CAAC;AAEpC,eAAO,MAAM,cAAc;;;;;;;;;;CAUjB,CAAC"}

package/build/types/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/orchestrion/config/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/openai.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;GA2BU,CAAC;AAEpC,eAAO,MAAM,cAAc;;;CAKjB,CAAC"}

package/build/types/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/orchestrion/config/pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/pg.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;IAuCc,CAAC;AAEpC,eAAO,MAAM,UAAU;;;;CAIb,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { 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/orchestrion/config/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AA+ChD,eAAO,MAAM,gBAAgB,yBAA8D,CAAC;AAE5F,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,YAAY,EAAE,qBAAqB,EAAO,CAAC;AAExD,eAAO,MAAM,cAAc,IAAc,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"react-router.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/react-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,iBAAiB,EAAE,qBAAqB,EAAO,CAAC;AAE7D,eAAO,MAAM,mBAAmB,IAAc,CAAC"}

package/build/types/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/orchestrion/config/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/redis.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DW,CAAC;AAEpC,eAAO,MAAM,aAAa;;;;;;;;CAQhB,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { 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/orchestrion/config/remix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remix.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/remix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAmDhD,eAAO,MAAM,WAAW,yBAA2D,CAAC;AAEpF,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { 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/orchestrion/config/tedious.d.ts.map

@@ -0,0 +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"}

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

@@ -0,0 +1,12 @@
+import type { 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/orchestrion/config/vercel-ai.d.ts.map

@@ -0,0 +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"}

package/build/types/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