@depup/sentry__server-utils 10.67.0-depup.0

package/build/esm/orchestrion/config/pg.js

@@ -0,0 +1,48 @@
+const pgConfig = [
+  // `pg` (node-postgres).
+  // instruments `Client.prototype.query`/`connect` (both the JS and native
+  // clients) plus `pg-pool`'s `Pool.prototype.connect`.
+  // `Auto` covers the callback, promise, and streamable-`Submittable`
+  // call shapes (like mysql).
+  // `pg/lib/client.js` is `class Client { query() {...} connect() {...} }`,
+  // so `className`+`methodName` matches directly.
+  {
+    channelName: "query",
+    module: { name: "pg", versionRange: ">=8.0.3 <9", filePath: "lib/client.js" },
+    functionQuery: { className: "Client", methodName: "query", kind: "Auto" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "pg", versionRange: ">=8.0.3 <9", filePath: "lib/client.js" },
+    functionQuery: { className: "Client", methodName: "connect", kind: "Auto" }
+  },
+  // The native client (`pg/lib/native/client.js`) is a constructor function,
+  // not a class.
+  // `Client.prototype.query = function (config, values, callback) {...}`
+  // so it needs `expressionName` (the mysql shape), publishing to the SAME
+  // `orchestrion:pg:query`/`:connect` channels as the JS client.
+  {
+    channelName: "query",
+    module: { name: "pg", versionRange: ">=8.0.3 <9", filePath: "lib/native/client.js" },
+    functionQuery: { expressionName: "query", kind: "Auto" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "pg", versionRange: ">=8.0.3 <9", filePath: "lib/native/client.js" },
+    functionQuery: { expressionName: "connect", kind: "Auto" }
+  },
+  // `pg-pool` is `class Pool extends EventEmitter { connect(cb) {...} }`.
+  {
+    channelName: "connect",
+    module: { name: "pg-pool", versionRange: ">=2.0.0 <4", filePath: "index.js" },
+    functionQuery: { className: "Pool", methodName: "connect", kind: "Auto" }
+  }
+];
+const pgChannels = {
+  PG_QUERY: "orchestrion:pg:query",
+  PG_CONNECT: "orchestrion:pg:connect",
+  PGPOOL_CONNECT: "orchestrion:pg-pool:connect"
+};
+
+export { pgChannels, pgConfig };
+//# sourceMappingURL=pg.js.map

package/build/esm/orchestrion/config/pg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.js","sources":["../../../../src/orchestrion/config/pg.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const pgConfig = [\n  // `pg` (node-postgres).\n  // instruments `Client.prototype.query`/`connect` (both the JS and native\n  // clients) plus `pg-pool`'s `Pool.prototype.connect`.\n  // `Auto` covers the callback, promise, and streamable-`Submittable`\n  // call shapes (like mysql).\n  // `pg/lib/client.js` is `class Client { query() {...} connect() {...} }`,\n  // so `className`+`methodName` matches directly.\n  {\n    channelName: 'query',\n    module: { name: 'pg', versionRange: '>=8.0.3 <9', filePath: 'lib/client.js' },\n    functionQuery: { className: 'Client', methodName: 'query', kind: 'Auto' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: 'pg', versionRange: '>=8.0.3 <9', filePath: 'lib/client.js' },\n    functionQuery: { className: 'Client', methodName: 'connect', kind: 'Auto' },\n  },\n  // The native client (`pg/lib/native/client.js`) is a constructor function,\n  // not a class.\n  // `Client.prototype.query = function (config, values, callback) {...}`\n  // so it needs `expressionName` (the mysql shape), publishing to the SAME\n  // `orchestrion:pg:query`/`:connect` channels as the JS client.\n  {\n    channelName: 'query',\n    module: { name: 'pg', versionRange: '>=8.0.3 <9', filePath: 'lib/native/client.js' },\n    functionQuery: { expressionName: 'query', kind: 'Auto' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: 'pg', versionRange: '>=8.0.3 <9', filePath: 'lib/native/client.js' },\n    functionQuery: { expressionName: 'connect', kind: 'Auto' },\n  },\n  // `pg-pool` is `class Pool extends EventEmitter { connect(cb) {...} }`.\n  {\n    channelName: 'connect',\n    module: { name: 'pg-pool', versionRange: '>=2.0.0 <4', filePath: 'index.js' },\n    functionQuery: { className: 'Pool', methodName: 'connect', kind: 'Auto' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const pgChannels = {\n  PG_QUERY: 'orchestrion:pg:query',\n  PG_CONNECT: 'orchestrion:pg:connect',\n  PGPOOL_CONNECT: 'orchestrion:pg-pool:connect',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,QAAA,GAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQtB;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,MAAM,YAAA,EAAc,YAAA,EAAc,UAAU,eAAA,EAAgB;AAAA,IAC5E,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,OAAA,EAAS,MAAM,MAAA;AAAO,GAC1E;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,MAAM,YAAA,EAAc,YAAA,EAAc,UAAU,eAAA,EAAgB;AAAA,IAC5E,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,SAAA,EAAW,MAAM,MAAA;AAAO,GAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,MAAM,YAAA,EAAc,YAAA,EAAc,UAAU,sBAAA,EAAuB;AAAA,IACnF,aAAA,EAAe,EAAE,cAAA,EAAgB,OAAA,EAAS,MAAM,MAAA;AAAO,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,MAAM,YAAA,EAAc,YAAA,EAAc,UAAU,sBAAA,EAAuB;AAAA,IACnF,aAAA,EAAe,EAAE,cAAA,EAAgB,SAAA,EAAW,MAAM,MAAA;AAAO,GAC3D;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAAA,IAC5E,eAAe,EAAE,SAAA,EAAW,QAAQ,UAAA,EAAY,SAAA,EAAW,MAAM,MAAA;AAAO;AAE5E;AAEO,MAAM,UAAA,GAAa;AAAA,EACxB,QAAA,EAAU,sBAAA;AAAA,EACV,UAAA,EAAY,wBAAA;AAAA,EACZ,cAAA,EAAgB;AAClB;;;;"}

package/build/esm/orchestrion/config/postgres.js

@@ -0,0 +1,47 @@
+const postgresJsInstrumentationConfig = (dir) => [
+  // `Query.prototype.handle` (`class Query extends Promise`) is the single
+  // funnel every query passes through (`then`/`catch`/`finally`/`.execute()`/
+  // `.forEach()`/cursor all call it), guarded by `this.executed`. `Async`
+  // because `handle` is `async`.
+  {
+    channelName: "handle",
+    module: { name: "postgres", versionRange: ">=3.0.0 <4", filePath: `${dir}/query.js` },
+    functionQuery: { className: "Query", methodName: "handle", kind: "Async" }
+  },
+  // `function Connection(options, ...)` (default export of `connection.js`)
+  // returns the connection object; used to build the endpoint registry that
+  // resolves `server.address`/`server.port`/`db.namespace`.
+  {
+    channelName: "connection",
+    module: { name: "postgres", versionRange: ">=3.0.0 <4", filePath: `${dir}/connection.js` },
+    functionQuery: { functionName: "Connection", kind: "Sync" }
+  },
+  // The nested `function execute(q)` inside `Connection`; the per-connection
+  // hook that attaches connection attributes to the query's span.
+  {
+    channelName: "execute",
+    module: { name: "postgres", versionRange: ">=3.0.0 <4", filePath: `${dir}/connection.js` },
+    functionQuery: { functionName: "execute", kind: "Sync" }
+  },
+  // The connection object's `connect(query)` method. Matched by `methodName`
+  // (an object-literal method): `functionName` would hit the unrelated
+  // socket-level `async function connect()` in the same file. `self` is the
+  // connection object and `arguments[0]` the query, so the first query that
+  // opens a connection (dispatched via a bare `execute` with no `self`) still
+  // gets connection attributes in multi-endpoint apps.
+  {
+    channelName: "connect",
+    module: { name: "postgres", versionRange: ">=3.0.0 <4", filePath: `${dir}/connection.js` },
+    functionQuery: { methodName: "connect", kind: "Sync" }
+  }
+];
+const postgresJsConfig = ["src", "cjs/src"].flatMap(postgresJsInstrumentationConfig);
+const postgresJsChannels = {
+  POSTGRESJS_HANDLE: "orchestrion:postgres:handle",
+  POSTGRESJS_CONNECTION: "orchestrion:postgres:connection",
+  POSTGRESJS_EXECUTE: "orchestrion:postgres:execute",
+  POSTGRESJS_CONNECT: "orchestrion:postgres:connect"
+};
+
+export { postgresJsChannels, postgresJsConfig };
+//# sourceMappingURL=postgres.js.map

package/build/esm/orchestrion/config/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sources":["../../../../src/orchestrion/config/postgres.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// postgres.js (`postgres` npm package, v3.x). Named after the npm package;\n// `postgres` doesn't collide with `pg.ts` (that file instruments `pg`/`pg-pool`).\n//\n// The ESM build lives under `src/*`, the CJS build under `cjs/src/*` (the\n// `cf/*` workerd build has no channel subscribers, see the integration).\n// Both builds share the same class/function shapes, so a single `flatMap`\n// over the two dirs emits one entry per (dir, target).\nconst postgresJsInstrumentationConfig = (dir: string): InstrumentationConfig[] => [\n  // `Query.prototype.handle` (`class Query extends Promise`) is the single\n  // funnel every query passes through (`then`/`catch`/`finally`/`.execute()`/\n  // `.forEach()`/cursor all call it), guarded by `this.executed`. `Async`\n  // because `handle` is `async`.\n  {\n    channelName: 'handle',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/query.js` },\n    functionQuery: { className: 'Query', methodName: 'handle', kind: 'Async' },\n  },\n  // `function Connection(options, ...)` (default export of `connection.js`)\n  // returns the connection object; used to build the endpoint registry that\n  // resolves `server.address`/`server.port`/`db.namespace`.\n  {\n    channelName: 'connection',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { functionName: 'Connection', kind: 'Sync' },\n  },\n  // The nested `function execute(q)` inside `Connection`; the per-connection\n  // hook that attaches connection attributes to the query's span.\n  {\n    channelName: 'execute',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { functionName: 'execute', kind: 'Sync' },\n  },\n  // The connection object's `connect(query)` method. Matched by `methodName`\n  // (an object-literal method): `functionName` would hit the unrelated\n  // socket-level `async function connect()` in the same file. `self` is the\n  // connection object and `arguments[0]` the query, so the first query that\n  // opens a connection (dispatched via a bare `execute` with no `self`) still\n  // gets connection attributes in multi-endpoint apps.\n  {\n    channelName: 'connect',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { methodName: 'connect', kind: 'Sync' },\n  },\n];\n\nexport const postgresJsConfig = ['src', 'cjs/src'].flatMap(postgresJsInstrumentationConfig);\n\nexport const postgresJsChannels = {\n  POSTGRESJS_HANDLE: 'orchestrion:postgres:handle',\n  POSTGRESJS_CONNECTION: 'orchestrion:postgres:connection',\n  POSTGRESJS_EXECUTE: 'orchestrion:postgres:execute',\n  POSTGRESJS_CONNECT: 'orchestrion:postgres:connect',\n} as const;\n"],"names":[],"mappings":"AASA,MAAM,+BAAA,GAAkC,CAAC,GAAA,KAAyC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKhF;AAAA,IACE,WAAA,EAAa,QAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,SAAA,CAAA,EAAY;AAAA,IACpF,eAAe,EAAE,SAAA,EAAW,SAAS,UAAA,EAAY,QAAA,EAAU,MAAM,OAAA;AAAQ,GAC3E;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,IACE,WAAA,EAAa,YAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,YAAA,EAAc,YAAA,EAAc,MAAM,MAAA;AAAO,GAC5D;AAAA;AAAA;AAAA,EAGA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,YAAA,EAAc,SAAA,EAAW,MAAM,MAAA;AAAO,GACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,UAAA,EAAY,SAAA,EAAW,MAAM,MAAA;AAAO;AAEzD,CAAA;AAEO,MAAM,mBAAmB,CAAC,KAAA,EAAO,SAAS,CAAA,CAAE,QAAQ,+BAA+B;AAEnF,MAAM,kBAAA,GAAqB;AAAA,EAChC,iBAAA,EAAmB,6BAAA;AAAA,EACnB,qBAAA,EAAuB,iCAAA;AAAA,EACvB,kBAAA,EAAoB,8BAAA;AAAA,EACpB,kBAAA,EAAoB;AACtB;;;;"}

package/build/esm/orchestrion/config/prisma.js

@@ -0,0 +1,5 @@
+const prismaConfig = [];
+const prismaChannels = {};
+
+export { prismaChannels, prismaConfig };
+//# sourceMappingURL=prisma.js.map

package/build/esm/orchestrion/config/prisma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.js","sources":["../../../../src/orchestrion/config/prisma.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// TODO: Stub for the `prisma` orchestrion integration (ports `@prisma/instrumentation`).\nexport const prismaConfig: InstrumentationConfig[] = [];\n\nexport const prismaChannels = {} as const;\n"],"names":[],"mappings":"AAGO,MAAM,eAAwC;AAE9C,MAAM,iBAAiB;;;;"}

package/build/esm/orchestrion/config/react-router.js

@@ -0,0 +1,5 @@
+const reactRouterConfig = [];
+const reactRouterChannels = {};
+
+export { reactRouterChannels, reactRouterConfig };
+//# sourceMappingURL=react-router.js.map

package/build/esm/orchestrion/config/react-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-router.js","sources":["../../../../src/orchestrion/config/react-router.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// TODO: Stub for the `react-router` orchestrion integration (ports `ReactRouterInstrumentation`).\nexport const reactRouterConfig: InstrumentationConfig[] = [];\n\nexport const reactRouterChannels = {} as const;\n"],"names":[],"mappings":"AAGO,MAAM,oBAA6C;AAEnD,MAAM,sBAAsB;;;;"}

package/build/esm/orchestrion/config/redis.js

@@ -0,0 +1,73 @@
+const redisConfig = [
+  // redis `>=2.6.0 <4` (standalone `redis`). `internal_send_command` is an
+  // anonymous prototype assignment (`expressionName`); it settles via the nested
+  // `command_obj.callback`, so `kind: 'Sync'` and the subscriber wraps that callback.
+  {
+    channelName: "command",
+    module: { name: "redis", versionRange: ">=2.6.0 <4", filePath: "index.js" },
+    functionQuery: { expressionName: "internal_send_command", kind: "Sync" }
+  },
+  // node-redis v4 (`@redis/client` v1). The real chokepoint (private `#sendCommand`)
+  // isn't matchable, so wrap both public entry points: `commandsExecutor` (friendly
+  // commands) and `sendCommand` (direct calls). They never overlap, so no double span.
+  {
+    channelName: "executor",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "commandsExecutor", kind: "Async" }
+  },
+  {
+    channelName: "command",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "sendCommand", kind: "Async" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "connect", kind: "Async" }
+  },
+  // node-redis `>=5.0.0 <5.12.0` (`@redis/client` v5; >=5.12.0 has its own
+  // `node-redis:*` diagnostics_channel, see `redis-dc-subscriber.ts`). Friendly
+  // commands route through the public `sendCommand`, so it covers them all — no
+  // `executor` entry (would double-count).
+  {
+    channelName: "command",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "sendCommand", kind: "Async" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "connect", kind: "Async" }
+  },
+  // Batch (multi/pipeline) — one span per `exec`. Batched commands bypass `sendCommand`,
+  // so they go through the client's batch executors, which receive the queued commands
+  // array (→ batch size). v5 splits MULTI/PIPELINE into two methods; v4's single
+  // `multiExecutor` is MULTI when a `chainId` arg is present, PIPELINE otherwise.
+  {
+    channelName: "multi",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "_executeMulti", kind: "Async" }
+  },
+  {
+    channelName: "pipeline",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "_executePipeline", kind: "Async" }
+  },
+  {
+    channelName: "batch",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "multiExecutor", kind: "Async" }
+  }
+];
+const redisChannels = {
+  REDIS_COMMAND: "orchestrion:redis:command",
+  NODE_REDIS_COMMAND: "orchestrion:@redis/client:command",
+  NODE_REDIS_EXECUTOR: "orchestrion:@redis/client:executor",
+  NODE_REDIS_CONNECT: "orchestrion:@redis/client:connect",
+  NODE_REDIS_MULTI: "orchestrion:@redis/client:multi",
+  NODE_REDIS_PIPELINE: "orchestrion:@redis/client:pipeline",
+  NODE_REDIS_BATCH: "orchestrion:@redis/client:batch"
+};
+
+export { redisChannels, redisConfig };
+//# sourceMappingURL=redis.js.map

package/build/esm/orchestrion/config/redis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.js","sources":["../../../../src/orchestrion/config/redis.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const redisConfig = [\n  // redis `>=2.6.0 <4` (standalone `redis`). `internal_send_command` is an\n  // anonymous prototype assignment (`expressionName`); it settles via the nested\n  // `command_obj.callback`, so `kind: 'Sync'` and the subscriber wraps that callback.\n  {\n    channelName: 'command',\n    module: { name: 'redis', versionRange: '>=2.6.0 <4', filePath: 'index.js' },\n    functionQuery: { expressionName: 'internal_send_command', kind: 'Sync' },\n  },\n  // node-redis v4 (`@redis/client` v1). The real chokepoint (private `#sendCommand`)\n  // isn't matchable, so wrap both public entry points: `commandsExecutor` (friendly\n  // commands) and `sendCommand` (direct calls). They never overlap, so no double span.\n  {\n    channelName: 'executor',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'commandsExecutor', kind: 'Async' },\n  },\n  {\n    channelName: 'command',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'sendCommand', kind: 'Async' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'connect', kind: 'Async' },\n  },\n  // node-redis `>=5.0.0 <5.12.0` (`@redis/client` v5; >=5.12.0 has its own\n  // `node-redis:*` diagnostics_channel, see `redis-dc-subscriber.ts`). Friendly\n  // commands route through the public `sendCommand`, so it covers them all — no\n  // `executor` entry (would double-count).\n  {\n    channelName: 'command',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'sendCommand', kind: 'Async' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'connect', kind: 'Async' },\n  },\n  // Batch (multi/pipeline) — one span per `exec`. Batched commands bypass `sendCommand`,\n  // so they go through the client's batch executors, which receive the queued commands\n  // array (→ batch size). v5 splits MULTI/PIPELINE into two methods; v4's single\n  // `multiExecutor` is MULTI when a `chainId` arg is present, PIPELINE otherwise.\n  {\n    channelName: 'multi',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: '_executeMulti', kind: 'Async' },\n  },\n  {\n    channelName: 'pipeline',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: '_executePipeline', kind: 'Async' },\n  },\n  {\n    channelName: 'batch',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'multiExecutor', kind: 'Async' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const redisChannels = {\n  REDIS_COMMAND: 'orchestrion:redis:command',\n  NODE_REDIS_COMMAND: 'orchestrion:@redis/client:command',\n  NODE_REDIS_EXECUTOR: 'orchestrion:@redis/client:executor',\n  NODE_REDIS_CONNECT: 'orchestrion:@redis/client:connect',\n  NODE_REDIS_MULTI: 'orchestrion:@redis/client:multi',\n  NODE_REDIS_PIPELINE: 'orchestrion:@redis/client:pipeline',\n  NODE_REDIS_BATCH: 'orchestrion:@redis/client:batch',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,WAAA,GAAc;AAAA;AAAA;AAAA;AAAA,EAIzB;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,SAAS,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAAA,IAC1E,aAAA,EAAe,EAAE,cAAA,EAAgB,uBAAA,EAAyB,MAAM,MAAA;AAAO,GACzE;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,kBAAA,EAAoB,MAAM,OAAA;AAAQ,GAC3F;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,aAAA,EAAe,MAAM,OAAA;AAAQ,GACtF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,SAAA,EAAW,MAAM,OAAA;AAAQ,GAClF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,aAAA,EAAe,MAAM,OAAA;AAAQ,GACtF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,SAAA,EAAW,MAAM,OAAA;AAAQ,GAClF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,eAAA,EAAiB,MAAM,OAAA;AAAQ,GACxF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,kBAAA,EAAoB,MAAM,OAAA;AAAQ,GAC3F;AAAA,EACA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,eAAA,EAAiB,MAAM,OAAA;AAAQ;AAE1F;AAEO,MAAM,aAAA,GAAgB;AAAA,EAC3B,aAAA,EAAe,2BAAA;AAAA,EACf,kBAAA,EAAoB,mCAAA;AAAA,EACpB,mBAAA,EAAqB,oCAAA;AAAA,EACrB,kBAAA,EAAoB,mCAAA;AAAA,EACpB,gBAAA,EAAkB,iCAAA;AAAA,EAClB,mBAAA,EAAqB,oCAAA;AAAA,EACrB,gBAAA,EAAkB;AACpB;;;;"}

package/build/esm/orchestrion/config/remix.js

@@ -0,0 +1,51 @@
+const remixInstrumentationConfig = (dir) => [
+  // `createRequestHandler` returns `async function requestHandler(request, loadContext)` — the main
+  // server span. We target the returned handler (so the span wraps each request, not the one-time
+  // handler construction). It's a *named function expression*, which name-based `functionQuery`
+  // can't match (that only sees declarations), so we select it with `astQuery`; `functionQuery`
+  // then just carries the behaviour (`kind: 'Async'`).
+  {
+    channelName: "requestHandler",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <3", filePath: `${dir}/server.js` },
+    astQuery: 'FunctionExpression[id.name="requestHandler"]',
+    functionQuery: { kind: "Async" }
+  },
+  // Sync; the subscriber reads its result to set `http.route` on the active request span.
+  {
+    channelName: "matchServerRoutes",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <3", filePath: `${dir}/routeMatching.js` },
+    functionQuery: { functionName: "matchServerRoutes", kind: "Sync" }
+  },
+  // Remix >= 2.9.0
+  {
+    channelName: "callRouteLoader",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.9.0 <3", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteLoader", kind: "Async" }
+  },
+  {
+    channelName: "callRouteAction",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.9.0 <3", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteAction", kind: "Async" }
+  },
+  // Remix 2.0.0 – 2.8.x: the same functions were suffixed `…RR`. Same channels as above.
+  {
+    channelName: "callRouteLoader",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <2.9.0", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteLoaderRR", kind: "Async" }
+  },
+  {
+    channelName: "callRouteAction",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <2.9.0", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteActionRR", kind: "Async" }
+  }
+];
+const remixConfig = ["dist", "dist/esm"].flatMap(remixInstrumentationConfig);
+const remixChannels = {
+  REMIX_REQUEST_HANDLER: "orchestrion:@remix-run/server-runtime:requestHandler",
+  REMIX_MATCH_SERVER_ROUTES: "orchestrion:@remix-run/server-runtime:matchServerRoutes",
+  REMIX_CALL_ROUTE_LOADER: "orchestrion:@remix-run/server-runtime:callRouteLoader",
+  REMIX_CALL_ROUTE_ACTION: "orchestrion:@remix-run/server-runtime:callRouteAction"
+};
+
+export { remixChannels, remixConfig };
+//# sourceMappingURL=remix.js.map

package/build/esm/orchestrion/config/remix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remix.js","sources":["../../../../src/orchestrion/config/remix.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// Four concepts, one channel each:\n//   - `requestHandler`    → the async handler returned by `createRequestHandler` (the server span)\n//   - `matchServerRoutes` → sync route match; enriches the active span (creates no span of its own)\n//   - `callRouteLoader`   → LOADER span. Remix 2.0–2.8 named it `callRouteLoaderRR`\n//   - `callRouteAction`   → ACTION span. Remix 2.0–2.8 named it `callRouteActionRR`\n//\n// Emitted for both the CJS (`dist/*`) and ESM (`dist/esm/*`) builds, which share function shapes.\nconst remixInstrumentationConfig = (dir: string): InstrumentationConfig[] => [\n  // `createRequestHandler` returns `async function requestHandler(request, loadContext)` — the main\n  // server span. We target the returned handler (so the span wraps each request, not the one-time\n  // handler construction). It's a *named function expression*, which name-based `functionQuery`\n  // can't match (that only sees declarations), so we select it with `astQuery`; `functionQuery`\n  // then just carries the behaviour (`kind: 'Async'`).\n  {\n    channelName: 'requestHandler',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <3', filePath: `${dir}/server.js` },\n    astQuery: 'FunctionExpression[id.name=\"requestHandler\"]',\n    functionQuery: { kind: 'Async' },\n  },\n  // Sync; the subscriber reads its result to set `http.route` on the active request span.\n  {\n    channelName: 'matchServerRoutes',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <3', filePath: `${dir}/routeMatching.js` },\n    functionQuery: { functionName: 'matchServerRoutes', kind: 'Sync' },\n  },\n  // Remix >= 2.9.0\n  {\n    channelName: 'callRouteLoader',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.9.0 <3', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteLoader', kind: 'Async' },\n  },\n  {\n    channelName: 'callRouteAction',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.9.0 <3', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteAction', kind: 'Async' },\n  },\n  // Remix 2.0.0 – 2.8.x: the same functions were suffixed `…RR`. Same channels as above.\n  {\n    channelName: 'callRouteLoader',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <2.9.0', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteLoaderRR', kind: 'Async' },\n  },\n  {\n    channelName: 'callRouteAction',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <2.9.0', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteActionRR', kind: 'Async' },\n  },\n];\n\nexport const remixConfig = ['dist', 'dist/esm'].flatMap(remixInstrumentationConfig);\n\nexport const remixChannels = {\n  REMIX_REQUEST_HANDLER: 'orchestrion:@remix-run/server-runtime:requestHandler',\n  REMIX_MATCH_SERVER_ROUTES: 'orchestrion:@remix-run/server-runtime:matchServerRoutes',\n  REMIX_CALL_ROUTE_LOADER: 'orchestrion:@remix-run/server-runtime:callRouteLoader',\n  REMIX_CALL_ROUTE_ACTION: 'orchestrion:@remix-run/server-runtime:callRouteAction',\n} as const;\n"],"names":[],"mappings":"AASA,MAAM,0BAAA,GAA6B,CAAC,GAAA,KAAyC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3E;AAAA,IACE,WAAA,EAAa,gBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,UAAA,CAAA,EAAa;AAAA,IACtG,QAAA,EAAU,8CAAA;AAAA,IACV,aAAA,EAAe,EAAE,IAAA,EAAM,OAAA;AAAQ,GACjC;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,mBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,iBAAA,CAAA,EAAoB;AAAA,IAC7G,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,MAAA;AAAO,GACnE;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACpG,aAAA,EAAe,EAAE,YAAA,EAAc,iBAAA,EAAmB,MAAM,OAAA;AAAQ,GAClE;AAAA,EACA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACpG,aAAA,EAAe,EAAE,YAAA,EAAc,iBAAA,EAAmB,MAAM,OAAA;AAAQ,GAClE;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,gBAAA,EAAkB,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACxG,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,OAAA;AAAQ,GACpE;AAAA,EACA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,gBAAA,EAAkB,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACxG,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,OAAA;AAAQ;AAEtE,CAAA;AAEO,MAAM,cAAc,CAAC,MAAA,EAAQ,UAAU,CAAA,CAAE,QAAQ,0BAA0B;AAE3E,MAAM,aAAA,GAAgB;AAAA,EAC3B,qBAAA,EAAuB,sDAAA;AAAA,EACvB,yBAAA,EAA2B,yDAAA;AAAA,EAC3B,uBAAA,EAAyB,uDAAA;AAAA,EACzB,uBAAA,EAAyB;AAC3B;;;;"}

package/build/esm/orchestrion/config/tedious.js

@@ -0,0 +1,21 @@
+const MODULE_NAME = "tedious";
+const FILE_PATH = "lib/connection.js";
+const VERSION_RANGE = ">=1.11.0 <20";
+const METHODS = ["connect", "execSql", "execSqlBatch", "callProcedure", "execBulkLoad", "prepare", "execute"];
+const tediousConfig = METHODS.map((methodName) => ({
+  channelName: methodName,
+  module: { name: MODULE_NAME, versionRange: VERSION_RANGE, filePath: FILE_PATH },
+  functionQuery: { className: "Connection", methodName, kind: "Sync" }
+}));
+const tediousChannels = {
+  TEDIOUS_CONNECT: "orchestrion:tedious:connect",
+  TEDIOUS_EXEC_SQL: "orchestrion:tedious:execSql",
+  TEDIOUS_EXEC_SQL_BATCH: "orchestrion:tedious:execSqlBatch",
+  TEDIOUS_CALL_PROCEDURE: "orchestrion:tedious:callProcedure",
+  TEDIOUS_EXEC_BULK_LOAD: "orchestrion:tedious:execBulkLoad",
+  TEDIOUS_PREPARE: "orchestrion:tedious:prepare",
+  TEDIOUS_EXECUTE: "orchestrion:tedious:execute"
+};
+
+export { tediousChannels, tediousConfig };
+//# sourceMappingURL=tedious.js.map

package/build/esm/orchestrion/config/tedious.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tedious.js","sources":["../../../../src/orchestrion/config/tedious.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nconst MODULE_NAME = 'tedious';\n\n// `Connection` has lived in `lib/connection.js` across the whole supported range (matches the vendored\n// OTel `supportedVersions`). Orchestrion never matches a file that doesn't exist, so a single entry is\n// safe even for versions that shipped extra layouts.\nconst FILE_PATH = 'lib/connection.js';\nconst VERSION_RANGE = '>=1.11.0 <20';\n\n// `Connection` methods that dispatch a request (each traced as one db span) plus `connect`, which the\n// subscriber wraps for bookkeeping only (tracking the connection's active database, read into `db.name`).\n// All return synchronously; the request completes later via its callback/events, so the subscriber owns\n// span-ending rather than the channel lifecycle.\nconst METHODS = ['connect', 'execSql', 'execSqlBatch', 'callProcedure', 'execBulkLoad', 'prepare', 'execute'] as const;\n\nexport const tediousConfig: InstrumentationConfig[] = METHODS.map(methodName => ({\n  channelName: methodName,\n  module: { name: MODULE_NAME, versionRange: VERSION_RANGE, filePath: FILE_PATH },\n  functionQuery: { className: 'Connection', methodName, kind: 'Sync' },\n}));\n\nexport const tediousChannels = {\n  TEDIOUS_CONNECT: 'orchestrion:tedious:connect',\n  TEDIOUS_EXEC_SQL: 'orchestrion:tedious:execSql',\n  TEDIOUS_EXEC_SQL_BATCH: 'orchestrion:tedious:execSqlBatch',\n  TEDIOUS_CALL_PROCEDURE: 'orchestrion:tedious:callProcedure',\n  TEDIOUS_EXEC_BULK_LOAD: 'orchestrion:tedious:execBulkLoad',\n  TEDIOUS_PREPARE: 'orchestrion:tedious:prepare',\n  TEDIOUS_EXECUTE: 'orchestrion:tedious:execute',\n} as const;\n"],"names":[],"mappings":"AAEA,MAAM,WAAA,GAAc,SAAA;AAKpB,MAAM,SAAA,GAAY,mBAAA;AAClB,MAAM,aAAA,GAAgB,cAAA;AAMtB,MAAM,OAAA,GAAU,CAAC,SAAA,EAAW,SAAA,EAAW,gBAAgB,eAAA,EAAiB,cAAA,EAAgB,WAAW,SAAS,CAAA;AAErG,MAAM,aAAA,GAAyC,OAAA,CAAQ,GAAA,CAAI,CAAA,UAAA,MAAe;AAAA,EAC/E,WAAA,EAAa,UAAA;AAAA,EACb,QAAQ,EAAE,IAAA,EAAM,aAAa,YAAA,EAAc,aAAA,EAAe,UAAU,SAAA,EAAU;AAAA,EAC9E,eAAe,EAAE,SAAA,EAAW,YAAA,EAAc,UAAA,EAAY,MAAM,MAAA;AAC9D,CAAA,CAAE;AAEK,MAAM,eAAA,GAAkB;AAAA,EAC7B,eAAA,EAAiB,6BAAA;AAAA,EACjB,gBAAA,EAAkB,6BAAA;AAAA,EAClB,sBAAA,EAAwB,kCAAA;AAAA,EACxB,sBAAA,EAAwB,mCAAA;AAAA,EACxB,sBAAA,EAAwB,kCAAA;AAAA,EACxB,eAAA,EAAiB,6BAAA;AAAA,EACjB,eAAA,EAAiB;AACnB;;;;"}

package/build/esm/orchestrion/config/vercel-ai.js

@@ -0,0 +1,45 @@
+const vercelAiConfig = [
+  // Vercel AI v6: mirror the v7 native `ai:telemetry` channel by injecting
+  // channels into the top-level entry points. `resolveLanguageModel` is wrapped
+  // not to span it, but so the subscriber can monkey-patch `doGenerate`/
+  // `doStream` on the returned model (the only way to span the model call,
+  // which is an inline call with no injectable definition in `ai`).
+  // `streamText` returns its result synchronously (streaming is lazy), so it's
+  // `Sync`; the subscriber binds the span via `bindTracingChannelToSpan`, which
+  // ends it when the (synchronous) call returns.
+  // The majority of entrypoints are present in all versions we support
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "generateText", "generateText", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "streamText", "streamText", "Sync"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "generateObject", "generateObject", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "embed", "embed", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "embedMany", "embedMany", "Async"),
+  // The following entry is only present in v5 and later
+  ...vercelAiEntries(">=5.0.0 <7.0.0", "resolveLanguageModel", "resolveLanguageModel", "Sync"),
+  // The following entry is only present in v6 and later
+  ...vercelAiEntries(">=6.0.0 <7.0.0", "executeToolCall", "executeToolCall", "Async")
+];
+const vercelAiChannels = {
+  // Vercel AI (`ai`): orchestrion injects these so the same channel-based
+  // integration that consumes `ai`'s native `ai:telemetry` channel (v7) can
+  // also instrument v4/v5/v6. Each maps to a top-level function in `ai`'s bundle.
+  // All three versions share the same channel names (the subscriber is version-agnostic);
+  // `VERCEL_AI_EXECUTE_TOOL_CALL` is v6-only (v4/v5 have no `executeToolCall` export) and
+  // `VERCEL_AI_RESOLVE_LANGUAGE_MODEL` is v5/v6-only (v4 has no such chokepoint).
+  VERCEL_AI_GENERATE_TEXT: "orchestrion:ai:generateText",
+  VERCEL_AI_STREAM_TEXT: "orchestrion:ai:streamText",
+  VERCEL_AI_GENERATE_OBJECT: "orchestrion:ai:generateObject",
+  VERCEL_AI_EMBED: "orchestrion:ai:embed",
+  VERCEL_AI_EMBED_MANY: "orchestrion:ai:embedMany",
+  VERCEL_AI_EXECUTE_TOOL_CALL: "orchestrion:ai:executeToolCall",
+  VERCEL_AI_RESOLVE_LANGUAGE_MODEL: "orchestrion:ai:resolveLanguageModel"
+};
+function vercelAiEntries(versionRange, channelName, functionName, kind) {
+  return ["dist/index.js", "dist/index.mjs"].map((filePath) => ({
+    channelName,
+    module: { name: "ai", versionRange, filePath },
+    functionQuery: { functionName, kind }
+  }));
+}
+
+export { vercelAiChannels, vercelAiConfig };
+//# sourceMappingURL=vercel-ai.js.map

package/build/esm/orchestrion/config/vercel-ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-ai.js","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const vercelAiConfig = [\n  // Vercel AI v6: mirror the v7 native `ai:telemetry` channel by injecting\n  // channels into the top-level entry points. `resolveLanguageModel` is wrapped\n  // not to span it, but so the subscriber can monkey-patch `doGenerate`/\n  // `doStream` on the returned model (the only way to span the model call,\n  // which is an inline call with no injectable definition in `ai`).\n  // `streamText` returns its result synchronously (streaming is lazy), so it's\n  // `Sync`; the subscriber binds the span via `bindTracingChannelToSpan`, which\n  // ends it when the (synchronous) call returns.\n\n  // The majority of entrypoints are present in all versions we support\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'generateText', 'generateText', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'streamText', 'streamText', 'Sync'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'generateObject', 'generateObject', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'embed', 'embed', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'embedMany', 'embedMany', 'Async'),\n\n  // The following entry is only present in v5 and later\n  ...vercelAiEntries('>=5.0.0 <7.0.0', 'resolveLanguageModel', 'resolveLanguageModel', 'Sync'),\n\n  // The following entry is only present in v6 and later\n  ...vercelAiEntries('>=6.0.0 <7.0.0', 'executeToolCall', 'executeToolCall', 'Async'),\n] satisfies InstrumentationConfig[];\n\nexport const vercelAiChannels = {\n  // Vercel AI (`ai`): orchestrion injects these so the same channel-based\n  // integration that consumes `ai`'s native `ai:telemetry` channel (v7) can\n  // also instrument v4/v5/v6. Each maps to a top-level function in `ai`'s bundle.\n  // All three versions share the same channel names (the subscriber is version-agnostic);\n  // `VERCEL_AI_EXECUTE_TOOL_CALL` is v6-only (v4/v5 have no `executeToolCall` export) and\n  // `VERCEL_AI_RESOLVE_LANGUAGE_MODEL` is v5/v6-only (v4 has no such chokepoint).\n  VERCEL_AI_GENERATE_TEXT: 'orchestrion:ai:generateText',\n  VERCEL_AI_STREAM_TEXT: 'orchestrion:ai:streamText',\n  VERCEL_AI_GENERATE_OBJECT: 'orchestrion:ai:generateObject',\n  VERCEL_AI_EMBED: 'orchestrion:ai:embed',\n  VERCEL_AI_EMBED_MANY: 'orchestrion:ai:embedMany',\n  VERCEL_AI_EXECUTE_TOOL_CALL: 'orchestrion:ai:executeToolCall',\n  VERCEL_AI_RESOLVE_LANGUAGE_MODEL: 'orchestrion:ai:resolveLanguageModel',\n} as const;\n\n/**\n * The central list of channel injections orchestrion should perform.\n *\n * This module has NO side effects — it's the only thing both the runtime hook\n * (`runtime/import-hook.mjs`) and the bundler plugins (`bundler/vite.ts`, …)\n * import from. Adding a new instrumented method is one entry here plus one\n * subscriber in `integrations/<lib>/tracing-channel.ts`.\n *\n * `channelName` here is the unprefixed suffix; the actual diagnostics_channel\n * name is `orchestrion:${module.name}:${channelName}` (see `channels.ts`).\n */\n/**\n * `ai` ships a single bundled entry per module system, so each instrumented\n * function needs one config entry per file (the app loads whichever matches its\n * module system). This expands a single target into both.\n */\nfunction vercelAiEntries(\n  versionRange: string,\n  channelName: string,\n  functionName: string,\n  kind: 'Async' | 'Sync',\n): InstrumentationConfig[] {\n  return ['dist/index.js', 'dist/index.mjs'].map(filePath => ({\n    channelName,\n    module: { name: 'ai', versionRange, filePath },\n    functionQuery: { functionName, kind },\n  }));\n}\n"],"names":[],"mappings":"AAEO,MAAM,cAAA,GAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5B,GAAG,eAAA,CAAgB,gBAAA,EAAkB,cAAA,EAAgB,gBAAgB,OAAO,CAAA;AAAA,EAC5E,GAAG,eAAA,CAAgB,gBAAA,EAAkB,YAAA,EAAc,cAAc,MAAM,CAAA;AAAA,EACvE,GAAG,eAAA,CAAgB,gBAAA,EAAkB,gBAAA,EAAkB,kBAAkB,OAAO,CAAA;AAAA,EAChF,GAAG,eAAA,CAAgB,gBAAA,EAAkB,OAAA,EAAS,SAAS,OAAO,CAAA;AAAA,EAC9D,GAAG,eAAA,CAAgB,gBAAA,EAAkB,WAAA,EAAa,aAAa,OAAO,CAAA;AAAA;AAAA,EAGtE,GAAG,eAAA,CAAgB,gBAAA,EAAkB,sBAAA,EAAwB,wBAAwB,MAAM,CAAA;AAAA;AAAA,EAG3F,GAAG,eAAA,CAAgB,gBAAA,EAAkB,iBAAA,EAAmB,mBAAmB,OAAO;AACpF;AAEO,MAAM,gBAAA,GAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,uBAAA,EAAyB,6BAAA;AAAA,EACzB,qBAAA,EAAuB,2BAAA;AAAA,EACvB,yBAAA,EAA2B,+BAAA;AAAA,EAC3B,eAAA,EAAiB,sBAAA;AAAA,EACjB,oBAAA,EAAsB,0BAAA;AAAA,EACtB,2BAAA,EAA6B,gCAAA;AAAA,EAC7B,gCAAA,EAAkC;AACpC;AAkBA,SAAS,eAAA,CACP,YAAA,EACA,WAAA,EACA,YAAA,EACA,IAAA,EACyB;AACzB,EAAA,OAAO,CAAC,eAAA,EAAiB,gBAAgB,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IAC1D,WAAA;AAAA,IACA,MAAA,EAAQ,EAAE,IAAA,EAAM,IAAA,EAAM,cAAc,QAAA,EAAS;AAAA,IAC7C,aAAA,EAAe,EAAE,YAAA,EAAc,IAAA;AAAK,GACtC,CAAE,CAAA;AACJ;;;;"}

package/build/esm/orchestrion/detect.js

@@ -0,0 +1,23 @@
+import { GLOBAL_OBJ, debug } from '@sentry/core';
+
+function isOrchestrionInjected() {
+  return !!GLOBAL_OBJ.__SENTRY_ORCHESTRION__;
+}
+function detectOrchestrionSetup() {
+  const { runtime, bundler } = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ ?? {};
+  if (!runtime && !bundler) {
+    debug.warn(
+      "[Sentry] No diagnostics-channel injection detected. Channel-based integrations will not record spans. Make sure the diagnostics channels are injected via the runtime `--import` hook or a bundler plugin before the instrumented modules load."
+    );
+    return;
+  }
+  debug.log(
+    runtime ? `[Sentry] Runtime hook registered, injected libraries=${JSON.stringify(runtime)}` : "[Sentry] Runtime hook not registered"
+  );
+  debug.log(
+    bundler ? `[Sentry] Bundler plugin ran, injected libraries=${JSON.stringify(bundler)}` : "[Sentry] Bundler plugin did not run"
+  );
+}
+
+export { detectOrchestrionSetup, isOrchestrionInjected };
+//# sourceMappingURL=detect.js.map

package/build/esm/orchestrion/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","sources":["../../../src/orchestrion/detect.ts"],"sourcesContent":["import { debug, GLOBAL_OBJ } from '@sentry/core';\n\n/**\n * Whether orchestrion has injected the diagnostics channels into this process,\n * either by the runtime `--import` hook / init-time registration (`runtime`)\n * or a bundler plugin (`bundler`). Both injectors set a flag on the\n * `globalThis.__SENTRY_ORCHESTRION__` marker.\n *\n * Use this to avoid wiring up channel-subscriber integrations when nothing\n * will ever publish to those channels.\n */\nexport function isOrchestrionInjected(): boolean {\n  return !!GLOBAL_OBJ.__SENTRY_ORCHESTRION__;\n}\n\n/**\n * Verifies that the diagnostics channels have been injected either by the\n * runtime `--import` hook (or init-time registration), a bundler plugin, or\n * both, and warns if not. When at least one injector is active, logs for each\n * mechanism whether it hooked (a defined array, even empty, means it did) and\n * which libraries it injected.\n *\n * Both injectors being active at once is fine: they operate on disjoint module\n * sets (a module is either loaded through Node's loader and transformed by the\n * runtime hook, or inlined by the bundler and transformed by the plugin), so\n * a single module can't be double-wrapped. A hybrid setup, with some deps\n * external and runtime-instrumented, others bundled and plugin-instrumented,\n * is fine.\n */\nexport function detectOrchestrionSetup(): void {\n  const { runtime, bundler } = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ ?? {};\n\n  if (!runtime && !bundler) {\n    debug.warn(\n      '[Sentry] No diagnostics-channel injection detected. Channel-based integrations ' +\n        'will not record spans. Make sure the diagnostics channels are injected ' +\n        'via the runtime `--import` hook or a bundler plugin before the instrumented modules load.',\n    );\n    return;\n  }\n\n  debug.log(\n    runtime\n      ? `[Sentry] Runtime hook registered, injected libraries=${JSON.stringify(runtime)}`\n      : '[Sentry] Runtime hook not registered',\n  );\n  debug.log(\n    bundler\n      ? `[Sentry] Bundler plugin ran, injected libraries=${JSON.stringify(bundler)}`\n      : '[Sentry] Bundler plugin did not run',\n  );\n}\n"],"names":[],"mappings":";;AAWO,SAAS,qBAAA,GAAiC;AAC/C,EAAA,OAAO,CAAC,CAAC,UAAA,CAAW,sBAAA;AACtB;AAgBO,SAAS,sBAAA,GAA+B;AAC7C,EAAA,MAAM,EAAE,OAAA,EAAS,OAAA,EAAQ,GAAI,UAAA,CAAW,0BAA0B,EAAC;AAEnE,EAAA,IAAI,CAAC,OAAA,IAAW,CAAC,OAAA,EAAS;AACxB,IAAA,KAAA,CAAM,IAAA;AAAA,MACJ;AAAA,KAGF;AACA,IAAA;AAAA,EACF;AAEA,EAAA,KAAA,CAAM,GAAA;AAAA,IACJ,UACI,CAAA,qDAAA,EAAwD,IAAA,CAAK,SAAA,CAAU,OAAO,CAAC,CAAA,CAAA,GAC/E;AAAA,GACN;AACA,EAAA,KAAA,CAAM,GAAA;AAAA,IACJ,UACI,CAAA,gDAAA,EAAmD,IAAA,CAAK,SAAA,CAAU,OAAO,CAAC,CAAA,CAAA,GAC1E;AAAA,GACN;AACF;;;;"}

package/build/esm/orchestrion/index.js

@@ -0,0 +1,58 @@
+import { amqplibChannelIntegration } from '../integrations/tracing-channel/amqplib.js';
+import { anthropicChannelIntegration } from '../integrations/tracing-channel/anthropic.js';
+import { awsChannelIntegration } from '../integrations/tracing-channel/aws-sdk/index.js';
+export { dataloaderChannelIntegration } from '../integrations/tracing-channel/dataloader.js';
+import { genericPoolChannelIntegration } from '../integrations/tracing-channel/generic-pool.js';
+import { googleGenAIChannelIntegration } from '../integrations/tracing-channel/google-genai.js';
+import { graphqlDiagnosticsChannelIntegration } from '../integrations/tracing-channel/graphql/index.js';
+export { graphqlChannelIntegration } from '../integrations/tracing-channel/graphql/index.js';
+import { hapiChannelIntegration } from '../integrations/tracing-channel/hapi.js';
+import { koaChannelIntegration } from '../integrations/tracing-channel/koa.js';
+export { ioredisChannelIntegration } from '../integrations/tracing-channel/ioredis.js';
+import { kafkajsChannelIntegration } from '../integrations/tracing-channel/kafkajs/index.js';
+export { knexChannelIntegration } from '../integrations/tracing-channel/knex.js';
+import { langChainChannelIntegration } from '../integrations/tracing-channel/langchain.js';
+import { langGraphChannelIntegration } from '../integrations/tracing-channel/langgraph.js';
+import { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer.js';
+import { mongodbChannelIntegration } from '../integrations/tracing-channel/mongodb.js';
+import { mongooseChannelIntegration } from '../integrations/tracing-channel/mongoose.js';
+import { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql.js';
+import { mysql2ChannelIntegration } from '../integrations/tracing-channel/mysql2.js';
+import { openaiChannelIntegration } from '../integrations/tracing-channel/openai.js';
+import { postgresChannelIntegration } from '../integrations/tracing-channel/postgres.js';
+import { postgresJsChannelIntegration } from '../integrations/tracing-channel/postgres-js.js';
+import { tediousChannelIntegration } from '../integrations/tracing-channel/tedious.js';
+import { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai.js';
+import { expressChannelIntegration } from '../integrations/tracing-channel/express/index.js';
+export { detectOrchestrionSetup, isOrchestrionInjected } from './detect.js';
+export { nestjsChannels } from './config/nestjs.js';
+export { remixChannels } from './config/remix.js';
+export { redisChannelIntegration } from '../integrations/tracing-channel/redis.js';
+
+const channelIntegrations = {
+  postgresIntegration: postgresChannelIntegration,
+  postgresJsIntegration: postgresJsChannelIntegration,
+  mongoIntegration: mongodbChannelIntegration,
+  mysqlIntegration: mysqlChannelIntegration,
+  mysql2Integration: mysql2ChannelIntegration,
+  genericPoolIntegration: genericPoolChannelIntegration,
+  mongooseIntegration: mongooseChannelIntegration,
+  lruMemoizerIntegration: lruMemoizerChannelIntegration,
+  openaiIntegration: openaiChannelIntegration,
+  anthropicIntegration: anthropicChannelIntegration,
+  googleGenAIIntegration: googleGenAIChannelIntegration,
+  langChainIntegration: langChainChannelIntegration,
+  langGraphIntegration: langGraphChannelIntegration,
+  vercelAiIntegration: vercelAiChannelIntegration,
+  amqplibIntegration: amqplibChannelIntegration,
+  hapiIntegration: hapiChannelIntegration,
+  koaIntegration: koaChannelIntegration,
+  expressIntegration: expressChannelIntegration,
+  graphqlIntegration: graphqlDiagnosticsChannelIntegration,
+  kafkajsIntegration: kafkajsChannelIntegration,
+  tediousIntegration: tediousChannelIntegration,
+  awsIntegration: awsChannelIntegration
+};
+
+export { amqplibChannelIntegration, anthropicChannelIntegration, awsChannelIntegration, channelIntegrations, expressChannelIntegration, genericPoolChannelIntegration, googleGenAIChannelIntegration, hapiChannelIntegration, kafkajsChannelIntegration, koaChannelIntegration, langChainChannelIntegration, langGraphChannelIntegration, lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysql2ChannelIntegration, mysqlChannelIntegration, openaiChannelIntegration, postgresChannelIntegration, postgresJsChannelIntegration, tediousChannelIntegration, vercelAiChannelIntegration };
+//# sourceMappingURL=index.js.map

package/build/esm/orchestrion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/orchestrion/index.ts"],"sourcesContent":["import { amqplibChannelIntegration } from '../integrations/tracing-channel/amqplib';\nimport { anthropicChannelIntegration } from '../integrations/tracing-channel/anthropic';\nimport { awsChannelIntegration } from '../integrations/tracing-channel/aws-sdk';\nimport { dataloaderChannelIntegration } from '../integrations/tracing-channel/dataloader';\nimport { genericPoolChannelIntegration } from '../integrations/tracing-channel/generic-pool';\nimport { googleGenAIChannelIntegration } from '../integrations/tracing-channel/google-genai';\nimport {\n  graphqlChannelIntegration,\n  graphqlDiagnosticsChannelIntegration,\n} from '../integrations/tracing-channel/graphql';\nimport { hapiChannelIntegration } from '../integrations/tracing-channel/hapi';\nimport { koaChannelIntegration } from '../integrations/tracing-channel/koa';\nimport { ioredisChannelIntegration } from '../integrations/tracing-channel/ioredis';\nimport { kafkajsChannelIntegration } from '../integrations/tracing-channel/kafkajs';\nimport { knexChannelIntegration } from '../integrations/tracing-channel/knex';\nimport { langChainChannelIntegration } from '../integrations/tracing-channel/langchain';\nimport { langGraphChannelIntegration } from '../integrations/tracing-channel/langgraph';\nimport { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';\nimport { mongodbChannelIntegration } from '../integrations/tracing-channel/mongodb';\nimport { mongooseChannelIntegration } from '../integrations/tracing-channel/mongoose';\nimport { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';\nimport { mysql2ChannelIntegration } from '../integrations/tracing-channel/mysql2';\nimport { openaiChannelIntegration } from '../integrations/tracing-channel/openai';\nimport { postgresChannelIntegration } from '../integrations/tracing-channel/postgres';\nimport { postgresJsChannelIntegration } from '../integrations/tracing-channel/postgres-js';\nimport { tediousChannelIntegration } from '../integrations/tracing-channel/tedious';\nimport { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai';\nimport { expressChannelIntegration } from '../integrations/tracing-channel/express';\n\nexport { detectOrchestrionSetup, isOrchestrionInjected } from './detect';\n// The `@nestjs/*` channel names live here alongside their transform config; the\n// listener that subscribes to them lives in `@sentry/nestjs`, which imports this.\nexport { nestjsChannels } from './config/nestjs';\n// The remix channel names live here alongside their transform config; the\n// listener that subscribes to them lives in `@sentry/remix`, which imports this.\nexport { remixChannels } from './config/remix';\nexport {\n  amqplibChannelIntegration,\n  anthropicChannelIntegration,\n  awsChannelIntegration,\n  dataloaderChannelIntegration,\n  genericPoolChannelIntegration,\n  googleGenAIChannelIntegration,\n  graphqlChannelIntegration,\n  hapiChannelIntegration,\n  koaChannelIntegration,\n  ioredisChannelIntegration,\n  kafkajsChannelIntegration,\n  knexChannelIntegration,\n  langChainChannelIntegration,\n  langGraphChannelIntegration,\n  lruMemoizerChannelIntegration,\n  mongodbChannelIntegration,\n  mongooseChannelIntegration,\n  mysqlChannelIntegration,\n  mysql2ChannelIntegration,\n  openaiChannelIntegration,\n  postgresChannelIntegration,\n  postgresJsChannelIntegration,\n  tediousChannelIntegration,\n  vercelAiChannelIntegration,\n  expressChannelIntegration,\n};\nexport type { KoaChannelIntegrationOptions } from '../integrations/tracing-channel/koa';\nexport type { IORedisChannelIntegrationOptions, IORedisResponseHook } from '../integrations/tracing-channel/ioredis';\nexport type { PostgresJsChannelIntegrationOptions } from '../integrations/tracing-channel/postgres-js';\nexport { redisChannelIntegration } from '../integrations/tracing-channel/redis';\nexport type { RedisChannelIntegrationOptions, RedisResponseHook } from '../integrations/tracing-channel/redis';\nexport type { InstrumentationConfig, CustomTransform } from '@apm-js-collab/code-transformer-bundler-plugins/core';\n\n// The structural `graphql` package types are the single source of truth shared with `@sentry/node`'s\n// vendored OTel graphql instrumentation (re-exported from here so the two can't drift).\nexport type * from '../integrations/tracing-channel/graphql/graphql-types';\n\n/**\n * The canonical set of orchestrion diagnostics-channel integrations, keyed by their public\n * (OTel-parity) factory name.\n *\n * Single source of truth: add a new channel integration here and every consumer — the `@sentry/node`\n * opt-in helper (`experimentalUseDiagnosticsChannelInjection`) and its public\n * `diagnosticsChannelInjectionIntegrations()` map — picks it up automatically, so there's no separate\n * list to keep in sync.\n *\n * NOTE: `ioredisChannelIntegration` and `redisChannelIntegration` are intentionally NOT here. They\n * only partially replace the composite OTel `Redis` integration and need the node SDK's redis cache\n * `responseHook` (which can't live in `server-utils`), so `@sentry/node` wires them up separately.\n *\n * Framework SDKs that own their own channel listener (e.g. `@sentry/nestjs`'s `Nest`) are NOT here\n * either: their transform config is still in `SENTRY_INSTRUMENTATIONS`, but the listener lives in\n * their package and picks the channel-vs-OTel path itself at `setupOnce`, so it needs no central swap.\n *\n * NOTE: `dataloaderChannelIntegration` is also NOT here. Everything in this map is auto-appended to\n * the default integrations, but the OTel `Dataloader` integration is opt-in (never a default). Like\n * `@sentry/nestjs`'s `Nest`, its `@sentry/node` factory picks the channel-vs-OTel path itself at\n * `setupOnce` (via `isOrchestrionInjected()`), so there's nothing for the central swap to do.\n */\nexport const channelIntegrations = {\n  postgresIntegration: postgresChannelIntegration,\n  postgresJsIntegration: postgresJsChannelIntegration,\n  mongoIntegration: mongodbChannelIntegration,\n  mysqlIntegration: mysqlChannelIntegration,\n  mysql2Integration: mysql2ChannelIntegration,\n  genericPoolIntegration: genericPoolChannelIntegration,\n  mongooseIntegration: mongooseChannelIntegration,\n  lruMemoizerIntegration: lruMemoizerChannelIntegration,\n  openaiIntegration: openaiChannelIntegration,\n  anthropicIntegration: anthropicChannelIntegration,\n  googleGenAIIntegration: googleGenAIChannelIntegration,\n  langChainIntegration: langChainChannelIntegration,\n  langGraphIntegration: langGraphChannelIntegration,\n  vercelAiIntegration: vercelAiChannelIntegration,\n  amqplibIntegration: amqplibChannelIntegration,\n  hapiIntegration: hapiChannelIntegration,\n  koaIntegration: koaChannelIntegration,\n  expressIntegration: expressChannelIntegration,\n  graphqlIntegration: graphqlDiagnosticsChannelIntegration,\n  kafkajsIntegration: kafkajsChannelIntegration,\n  tediousIntegration: tediousChannelIntegration,\n  awsIntegration: awsChannelIntegration,\n} as const;\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGO,MAAM,mBAAA,GAAsB;AAAA,EACjC,mBAAA,EAAqB,0BAAA;AAAA,EACrB,qBAAA,EAAuB,4BAAA;AAAA,EACvB,gBAAA,EAAkB,yBAAA;AAAA,EAClB,gBAAA,EAAkB,uBAAA;AAAA,EAClB,iBAAA,EAAmB,wBAAA;AAAA,EACnB,sBAAA,EAAwB,6BAAA;AAAA,EACxB,mBAAA,EAAqB,0BAAA;AAAA,EACrB,sBAAA,EAAwB,6BAAA;AAAA,EACxB,iBAAA,EAAmB,wBAAA;AAAA,EACnB,oBAAA,EAAsB,2BAAA;AAAA,EACtB,sBAAA,EAAwB,6BAAA;AAAA,EACxB,oBAAA,EAAsB,2BAAA;AAAA,EACtB,oBAAA,EAAsB,2BAAA;AAAA,EACtB,mBAAA,EAAqB,0BAAA;AAAA,EACrB,kBAAA,EAAoB,yBAAA;AAAA,EACpB,eAAA,EAAiB,sBAAA;AAAA,EACjB,cAAA,EAAgB,qBAAA;AAAA,EAChB,kBAAA,EAAoB,yBAAA;AAAA,EACpB,kBAAA,EAAoB,oCAAA;AAAA,EACpB,kBAAA,EAAoB,yBAAA;AAAA,EACpB,kBAAA,EAAoB,yBAAA;AAAA,EACpB,cAAA,EAAgB;AAClB;;;;"}

package/build/esm/orchestrion/runtime/register.js

@@ -0,0 +1,76 @@
+import { GLOBAL_OBJ, debug } from '@sentry/core';
+import * as Module from 'node:module';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { isMainThread, parentPort, MessageChannel } from 'node:worker_threads';
+import { SENTRY_INSTRUMENTATIONS } from '../config/index.js';
+
+function hasStableSyncModuleHooks(denoVersionString) {
+  const parseVersion = (v) => v.split(".").map((n) => parseInt(n, 10));
+  const nodeVersion = parseVersion(process.versions.node ?? "0.0.0");
+  const denoVersion = parseVersion(denoVersionString ?? "0.0.0");
+  return (nodeVersion[0] ?? 0) > 25 || nodeVersion[0] === 25 && (nodeVersion[1] ?? 0) >= 1 || nodeVersion[0] === 24 && (nodeVersion[1] ?? 0) >= 13 || (denoVersion[0] ?? 0) > 2 || denoVersion[0] === 2 && (denoVersion[1] ?? 0) >= 8;
+}
+function registerDiagnosticsChannelInjection(options) {
+  if (!isMainThread && !parentPort) {
+    return;
+  }
+  if (GLOBAL_OBJ?.__SENTRY_ORCHESTRION__?.runtime) {
+    return;
+  }
+  const globalAny = globalThis;
+  const stableSyncHooks = hasStableSyncModuleHooks(globalAny.Deno?.version?.deno);
+  let thisModuleUrl;
+  thisModuleUrl = import.meta.url;
+  let nodeRequire;
+  nodeRequire = createRequire(import.meta.url);
+  const tracingHooksDir = options?.tracingHooksDir;
+  const requireFromHooksDir = tracingHooksDir ? createRequire(thisModuleUrl) : void 0;
+  const mod = Module;
+  try {
+    const { setDiagnosticsHook } = requireFromHooksDir ? requireFromHooksDir(`${tracingHooksDir}/lib/diagnostics.js`) : nodeRequire("@apm-js-collab/tracing-hooks/lib/diagnostics.js");
+    const onDiagnostics = ({ moduleName, error }) => {
+      if (error) {
+        debug.warn(`[orchestrion] failed to inject diagnostics-channel into ${moduleName}:`, error);
+      } else {
+        GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};
+        GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];
+        GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime.push(moduleName);
+      }
+    };
+    setDiagnosticsHook(onDiagnostics);
+    if (typeof mod.registerHooks === "function" && stableSyncHooks) {
+      const { initialize, resolve, load } = requireFromHooksDir ? requireFromHooksDir(`${tracingHooksDir}/hook-sync.mjs`) : nodeRequire("@apm-js-collab/tracing-hooks/hook-sync.mjs");
+      initialize({ instrumentations: SENTRY_INSTRUMENTATIONS });
+      mod.registerHooks({ resolve, load });
+      debug.log("Registered diagnostics-channel injection via Module.registerHooks()");
+    } else if (typeof mod.register === "function" && !globalAny.Bun && !globalAny.Deno) {
+      const hookSpecifier = tracingHooksDir ? pathToFileURL(`${tracingHooksDir}/hook.mjs`).href : "@apm-js-collab/tracing-hooks/hook.mjs";
+      const { port1, port2 } = new MessageChannel();
+      port1.on("message", onDiagnostics);
+      port1.unref();
+      mod.register(hookSpecifier, {
+        parentURL: thisModuleUrl,
+        data: { instrumentations: SENTRY_INSTRUMENTATIONS, diagnosticsPort: port2 },
+        transferList: [port2]
+      });
+      const ModulePatch = requireFromHooksDir && tracingHooksDir ? requireFromHooksDir(tracingHooksDir) : nodeRequire("@apm-js-collab/tracing-hooks");
+      new ModulePatch({ instrumentations: SENTRY_INSTRUMENTATIONS }).patch();
+      debug.log("Registered diagnostics-channel injection via Module.register()");
+    } else {
+      debug.warn("No available Node API to register diagnostics-channel injection hooks; skipping.");
+      return;
+    }
+  } catch (error) {
+    debug.warn(
+      "Failed to register diagnostics-channel injection hooks; channel-based integrations will not record spans.",
+      error
+    );
+    return;
+  }
+  GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};
+  GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];
+}
+
+export { registerDiagnosticsChannelInjection };
+//# sourceMappingURL=register.js.map