@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,59 @@
+import type { 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/mysql2/mysql2-dc-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2-dc-subscriber.d.ts","sourceRoot":"","sources":["../../../src/mysql2/mysql2-dc-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAoB/D,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,8BAA8B,wBAAwB,CAAC;AAQpE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEnG;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAAC,cAAc,EAAE,2BAA2B,GAAG,IAAI,CAKnG"}

package/build/types/orchestrion/bundler/esbuild.d.ts

@@ -0,0 +1,21 @@
+import codeTransformer from '@apm-js-collab/code-transformer-bundler-plugins/esbuild';
+import type { 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/orchestrion/bundler/esbuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/bundler/esbuild.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,yDAAyD,CAAC;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,aAAkB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAEvG"}

package/build/types/orchestrion/bundler/options.d.ts

@@ -0,0 +1,29 @@
+import type { InstrumentationConfig, CustomTransform } from '..';
+import type { 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/orchestrion/bundler/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/bundler/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAEjE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sDAAsD,CAAC;AAEzG,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,gBAAgB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC3C;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,aAAa,GAAG,4BAA4B,CAkBhG"}

package/build/types/orchestrion/bundler/rollup.d.ts

@@ -0,0 +1,17 @@
+import codeTransformer from '@apm-js-collab/code-transformer-bundler-plugins/rollup';
+import type { 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

package/build/types/orchestrion/bundler/rollup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/bundler/rollup.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,wDAAwD,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,aAAkB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAEvG"}

package/build/types/orchestrion/bundler/vite.d.ts

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

package/build/types/orchestrion/bundler/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/bundler/vite.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,sDAAsD,CAAC;AAEnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,aAAkB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAcvG"}

package/build/types/orchestrion/bundler/webpack.d.ts

@@ -0,0 +1,19 @@
+import type { InstrumentationConfig } from '..';
+import codeTransformerWebpack from '@apm-js-collab/code-transformer-bundler-plugins/webpack';
+import type { PluginOptions } from './options';
+/** Absolute path to the code-transform loader (a webpack loader; also usable as a Turbopack loader). */
+export declare function getOrchestrionLoaderPath(): string;
+/**
+ * Absolute path to the `@apm-js-collab/tracing-hooks` package directory, resolved from this
+ * package's own dependency graph. SDKs inject it at build time so the runtime module hook can
+ * load the package even where the bare specifier doesn't resolve (bundled SDK code under
+ * isolated installs, e.g. pnpm).
+ */
+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
+ */
+export declare function sentryOrchestrionWebpackPlugin(options?: PluginOptions): ReturnType<typeof codeTransformerWebpack>;
+//# sourceMappingURL=webpack.d.ts.map

package/build/types/orchestrion/bundler/webpack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/bundler/webpack.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAEhD,OAAO,sBAAsB,MAAM,yDAAyD,CAAC;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAgB/C,wGAAwG;AACxG,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAIjD;AAED,6FAA6F;AAC7F,wBAAgB,yBAAyB,IAAI,qBAAqB,EAAE,CAEnE;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,aAAkB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAErH"}

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

@@ -0,0 +1,130 @@
+/**
+ * Fully-qualified `diagnostics_channel` names that orchestrion publishes to.
+ *
+ * Orchestrion's transform always prefixes the configured `channelName` with
+ * `orchestrion:${module.name}:`. So a config of
+ *   `{ channelName: 'query', module: { name: 'mysql' } }`
+ * publishes to `orchestrion:mysql:query`.
+ *
+ * Subscribers (`integrations/<lib>/tracing-channel.ts`) consume the full
+ * prefixed string from this map; the config files set only the unprefixed
+ * suffix in `channelName`. Keeping both pieces in one file is what guarantees
+ * they don't drift apart and silently stop firing.
+ *
+ * Kept sorted alphabetically by module so concurrent additions insert at different
+ * points rather than all appending to the end (fewer merge conflicts).
+ */
+export declare const CHANNELS: {
+    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";
+    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";
+    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";
+    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";
+    readonly POSTGRESJS_HANDLE: "orchestrion:postgres:handle";
+    readonly POSTGRESJS_CONNECTION: "orchestrion:postgres:connection";
+    readonly POSTGRESJS_EXECUTE: "orchestrion:postgres:execute";
+    readonly POSTGRESJS_CONNECT: "orchestrion:postgres:connect";
+    readonly PG_QUERY: "orchestrion:pg:query";
+    readonly PG_CONNECT: "orchestrion:pg:connect";
+    readonly PGPOOL_CONNECT: "orchestrion:pg-pool:connect";
+    readonly OPENAI_CHAT: "orchestrion:openai:chat";
+    readonly OPENAI_EMBEDDINGS: "orchestrion:openai:embeddings";
+    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";
+    readonly MYSQL_QUERY: "orchestrion:mysql:query";
+    readonly MYSQL2_QUERY: "orchestrion:mysql2:query";
+    readonly MYSQL2_EXECUTE: "orchestrion:mysql2:execute";
+    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";
+    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";
+    readonly LRU_MEMOIZER_LOAD: "orchestrion:lru-memoizer:load";
+    readonly LANGGRAPH_STATE_GRAPH_COMPILE: "orchestrion:@langchain/langgraph:stateGraphCompile";
+    readonly LANGGRAPH_CREATE_REACT_AGENT: "orchestrion:@langchain/langgraph:createReactAgent";
+    readonly LANGCHAIN_CHAT_MODEL_INVOKE: "orchestrion:@langchain/core:chatModelInvoke";
+    readonly LANGCHAIN_CHAT_MODEL_STREAM: "orchestrion:@langchain/core:chatModelStream";
+    readonly KOA_USE: "orchestrion:koa:use";
+    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";
+    readonly KAFKAJS_SEND_BATCH: "orchestrion:kafkajs:send_batch";
+    readonly KAFKAJS_CONSUMER_RUN: "orchestrion:kafkajs:consumer_run";
+    readonly IOREDIS_COMMAND: "orchestrion:ioredis:command";
+    readonly IOREDIS_CONNECT: "orchestrion:ioredis:connect";
+    readonly HAPI_ROUTE: "orchestrion:@hapi/hapi:route";
+    readonly HAPI_EXT: "orchestrion:@hapi/hapi:ext";
+    readonly GRAPHQL_PARSE: "orchestrion:graphql:parse";
+    readonly GRAPHQL_VALIDATE: "orchestrion:graphql:validate";
+    readonly GRAPHQL_EXECUTE: "orchestrion:graphql:execute";
+    readonly GOOGLE_GENAI_GENERATE_CONTENT: "orchestrion:@google/genai:generate-content";
+    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 EXPRESS_HANDLE: "orchestrion:express:handle";
+    readonly ROUTER_HANDLE: "orchestrion:router:handle";
+    readonly EXPRESS_REGISTER: "orchestrion:express:register";
+    readonly ROUTER_REGISTER: "orchestrion:router:register";
+    readonly DATALOADER_CONSTRUCT: "orchestrion:dataloader:construct";
+    readonly DATALOADER_LOAD: "orchestrion:dataloader:load";
+    readonly DATALOADER_LOAD_MANY: "orchestrion:dataloader:loadMany";
+    readonly DATALOADER_PRIME: "orchestrion:dataloader:prime";
+    readonly DATALOADER_CLEAR: "orchestrion:dataloader:clear";
+    readonly DATALOADER_CLEAR_ALL: "orchestrion:dataloader:clearAll";
+    readonly AWS_SMITHY_CORE_SEND: "orchestrion:@smithy/core:send";
+    readonly AWS_SMITHY_CLIENT_SEND: "orchestrion:@smithy/smithy-client:send";
+    readonly AWS_SDK_SMITHY_CLIENT_SEND: "orchestrion:@aws-sdk/smithy-client:send";
+    readonly ANTHROPIC_CHAT: "orchestrion:@anthropic-ai/sdk:chat";
+    readonly ANTHROPIC_MODELS: "orchestrion:@anthropic-ai/sdk:models";
+    readonly ANTHROPIC_MESSAGES_STREAM: "orchestrion:@anthropic-ai/sdk:messages-stream";
+    readonly AMQPLIB_PUBLISH: "orchestrion:amqplib:publish";
+    readonly AMQPLIB_CONFIRM_PUBLISH: "orchestrion:amqplib:confirmPublish";
+    readonly AMQPLIB_CONSUME: "orchestrion:amqplib:consume";
+    readonly AMQPLIB_DISPATCH: "orchestrion:amqplib:dispatch";
+    readonly AMQPLIB_ACK: "orchestrion:amqplib:ack";
+    readonly AMQPLIB_NACK: "orchestrion:amqplib:nack";
+    readonly AMQPLIB_REJECT: "orchestrion:amqplib:reject";
+    readonly AMQPLIB_ACK_ALL: "orchestrion:amqplib:ackAll";
+    readonly AMQPLIB_NACK_ALL: "orchestrion:amqplib:nackAll";
+    readonly AMQPLIB_CONNECT: "orchestrion:amqplib:connect";
+};
+export type ChannelName = (typeof CHANNELS)[keyof typeof CHANNELS];
+//# sourceMappingURL=channels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/channels.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCX,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC"}

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

@@ -0,0 +1,66 @@
+export declare const amqplibConfig: ({
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "amqplib";
+        versionRange: ">=0.5.5 <2";
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Sync";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "amqplib";
+        versionRange: ">=0.5.5 <2";
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Callback";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "amqplib";
+        versionRange: ">=0.5.5 <2";
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Async";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        filePath: string;
+        name: "amqplib";
+        versionRange: ">=0.5.5 <2";
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Callback";
+        className?: undefined;
+        methodName?: undefined;
+    };
+})[];
+export declare const amqplibChannels: {
+    readonly AMQPLIB_PUBLISH: "orchestrion:amqplib:publish";
+    readonly AMQPLIB_CONFIRM_PUBLISH: "orchestrion:amqplib:confirmPublish";
+    readonly AMQPLIB_CONSUME: "orchestrion:amqplib:consume";
+    readonly AMQPLIB_DISPATCH: "orchestrion:amqplib:dispatch";
+    readonly AMQPLIB_ACK: "orchestrion:amqplib:ack";
+    readonly AMQPLIB_NACK: "orchestrion:amqplib:nack";
+    readonly AMQPLIB_REJECT: "orchestrion:amqplib:reject";
+    readonly AMQPLIB_ACK_ALL: "orchestrion:amqplib:ackAll";
+    readonly AMQPLIB_NACK_ALL: "orchestrion:amqplib:nackAll";
+    readonly AMQPLIB_CONNECT: "orchestrion:amqplib:connect";
+};
+//# sourceMappingURL=amqplib.d.ts.map

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

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

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

@@ -0,0 +1,31 @@
+export declare const anthropicAiConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Auto";
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Sync";
+    };
+})[];
+export declare const anthropicAiChannels: {
+    readonly ANTHROPIC_CHAT: "orchestrion:@anthropic-ai/sdk:chat";
+    readonly ANTHROPIC_MODELS: "orchestrion:@anthropic-ai/sdk:models";
+    readonly ANTHROPIC_MESSAGES_STREAM: "orchestrion:@anthropic-ai/sdk:messages-stream";
+};
+//# sourceMappingURL=anthropic-ai.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/anthropic-ai.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;IA+BK,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC"}

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

@@ -0,0 +1,19 @@
+export declare const awsSdkConfig: {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Async";
+    };
+}[];
+export declare const awsSdkChannels: {
+    readonly AWS_SMITHY_CORE_SEND: "orchestrion:@smithy/core:send";
+    readonly AWS_SMITHY_CLIENT_SEND: "orchestrion:@smithy/smithy-client:send";
+    readonly AWS_SDK_SMITHY_CLIENT_SEND: "orchestrion:@aws-sdk/smithy-client:send";
+};
+//# sourceMappingURL=aws-sdk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aws-sdk.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/aws-sdk.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;GAgBU,CAAC;AAEpC,eAAO,MAAM,cAAc;;;;CAIjB,CAAC"}

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

@@ -0,0 +1,46 @@
+export declare const dataloaderConfig: ({
+    channelName: string;
+    module: {
+        readonly name: "dataloader";
+        readonly versionRange: ">=2.0.0 <3";
+        readonly filePath: "index.js";
+    };
+    functionQuery: {
+        functionName: string;
+        kind: "Sync";
+        expressionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        readonly name: "dataloader";
+        readonly versionRange: ">=2.0.0 <3";
+        readonly filePath: "index.js";
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Async";
+        functionName?: undefined;
+    };
+} | {
+    channelName: string;
+    module: {
+        readonly name: "dataloader";
+        readonly versionRange: ">=2.0.0 <3";
+        readonly filePath: "index.js";
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Sync";
+        functionName?: undefined;
+    };
+})[];
+export declare const dataloaderChannels: {
+    readonly DATALOADER_CONSTRUCT: "orchestrion:dataloader:construct";
+    readonly DATALOADER_LOAD: "orchestrion:dataloader:load";
+    readonly DATALOADER_LOAD_MANY: "orchestrion:dataloader:loadMany";
+    readonly DATALOADER_PRIME: "orchestrion:dataloader:prime";
+    readonly DATALOADER_CLEAR: "orchestrion:dataloader:clear";
+    readonly DATALOADER_CLEAR_ALL: "orchestrion:dataloader:clearAll";
+};
+//# sourceMappingURL=dataloader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataloader.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/dataloader.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqCM,CAAC;AAEpC,eAAO,MAAM,kBAAkB;;;;;;;CAOrB,CAAC"}

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

@@ -0,0 +1,30 @@
+export declare const expressConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Callback";
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: string;
+        kind: "Sync";
+    };
+})[];
+export declare const expressChannels: {
+    readonly EXPRESS_HANDLE: "orchestrion:express:handle";
+    readonly ROUTER_HANDLE: "orchestrion:router:handle";
+    readonly EXPRESS_REGISTER: "orchestrion:express:register";
+    readonly ROUTER_REGISTER: "orchestrion:router:register";
+};
+//# sourceMappingURL=express.d.ts.map

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

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

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

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

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

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

package/build/types/orchestrion/config/generic-pool.d.ts

@@ -0,0 +1,31 @@
+export declare const genericPoolConfig: ({
+    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: "Callback";
+        className?: undefined;
+        methodName?: undefined;
+    };
+})[];
+export declare const genericPoolChannels: {
+    readonly GENERIC_POOL_ACQUIRE: "orchestrion:generic-pool:acquire";
+};
+//# sourceMappingURL=generic-pool.d.ts.map

package/build/types/orchestrion/config/generic-pool.d.ts.map

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

package/build/types/orchestrion/config/google-genai.d.ts

@@ -0,0 +1,30 @@
+export declare const googleGenAiConfig: ({
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        expressionName: "generateContent" | "generateContentStream";
+        kind: "Auto";
+    };
+} | {
+    channelName: string;
+    module: {
+        name: string;
+        versionRange: string;
+        filePath: string;
+    };
+    functionQuery: {
+        className: string;
+        methodName: string;
+        kind: "Auto";
+    };
+})[];
+export declare const googleGenAiChannels: {
+    readonly GOOGLE_GENAI_GENERATE_CONTENT: "orchestrion:@google/genai:generate-content";
+    readonly GOOGLE_GENAI_EMBED_CONTENT: "orchestrion:@google/genai:embed-content";
+    readonly GOOGLE_GENAI_CHAT: "orchestrion:@google/genai:chat";
+};
+//# sourceMappingURL=google-genai.d.ts.map

package/build/types/orchestrion/config/google-genai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-genai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/google-genai.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;IAyBK,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC"}