@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-ai.js","sources":["../../../../src/orchestrion/config/anthropic-ai.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const anthropicAiConfig = [\n  // One entry each for CJS/ESM\n  ...['resources/messages/messages.js', 'resources/messages/messages.mjs'].flatMap(filePath =>\n    (['create', 'countTokens'] as const).map(methodName => ({\n      channelName: 'chat',\n      module: { name: '@anthropic-ai/sdk', versionRange: '>=0.19.2 <1', filePath },\n      functionQuery: { className: 'Messages', methodName, kind: 'Auto' as const },\n    })),\n  ),\n  ...['resources/completions.js', 'resources/completions.mjs'].map(filePath => ({\n    channelName: 'chat',\n    module: { name: '@anthropic-ai/sdk', versionRange: '>=0.19.2 <1', filePath },\n    functionQuery: { className: 'Completions', methodName: 'create', kind: 'Auto' as const },\n  })),\n  ...['resources/beta/messages/messages.js', 'resources/beta/messages/messages.mjs'].map(filePath => ({\n    channelName: 'chat',\n    module: { name: '@anthropic-ai/sdk', versionRange: '>=0.19.2 <1', filePath },\n    functionQuery: { className: 'Messages', methodName: 'create', kind: 'Auto' as const },\n  })),\n  ...['resources/models.js', 'resources/models.mjs'].map(filePath => ({\n    channelName: 'models',\n    module: { name: '@anthropic-ai/sdk', versionRange: '>=0.19.2 <1', filePath },\n    functionQuery: { className: 'Models', methodName: 'retrieve', kind: 'Auto' as const },\n  })),\n  // `messages.stream()` returns a synchronous emitter, not a promise, so `kind: 'Sync'` is required:\n  // `Auto`'s promise wrapper never publishes `end` for a non-thenable return, so the span would never end.\n  ...['resources/messages/messages.js', 'resources/messages/messages.mjs'].map(filePath => ({\n    channelName: 'messages-stream',\n    module: { name: '@anthropic-ai/sdk', versionRange: '>=0.19.2 <1', filePath },\n    functionQuery: { className: 'Messages', methodName: 'stream', kind: 'Sync' as const },\n  })),\n] satisfies InstrumentationConfig[];\n\nexport const anthropicAiChannels = {\n  ANTHROPIC_CHAT: 'orchestrion:@anthropic-ai/sdk:chat',\n  ANTHROPIC_MODELS: 'orchestrion:@anthropic-ai/sdk:models',\n  ANTHROPIC_MESSAGES_STREAM: 'orchestrion:@anthropic-ai/sdk:messages-stream',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,iBAAA,GAAoB;AAAA;AAAA,EAE/B,GAAG,CAAC,gCAAA,EAAkC,iCAAiC,CAAA,CAAE,OAAA;AAAA,IAAQ,cAC9E,CAAC,QAAA,EAAU,aAAa,CAAA,CAAY,IAAI,CAAA,UAAA,MAAe;AAAA,MACtD,WAAA,EAAa,MAAA;AAAA,MACb,QAAQ,EAAE,IAAA,EAAM,mBAAA,EAAqB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,MAC3E,eAAe,EAAE,SAAA,EAAW,UAAA,EAAY,UAAA,EAAY,MAAM,MAAA;AAAgB,KAC5E,CAAE;AAAA,GACJ;AAAA,EACA,GAAG,CAAC,0BAAA,EAA4B,2BAA2B,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IAC5E,WAAA,EAAa,MAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,mBAAA,EAAqB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,IAC3E,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,QAAA,EAAU,MAAM,MAAA;AAAgB,GACzF,CAAE,CAAA;AAAA,EACF,GAAG,CAAC,qCAAA,EAAuC,sCAAsC,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IAClG,WAAA,EAAa,MAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,mBAAA,EAAqB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,IAC3E,eAAe,EAAE,SAAA,EAAW,YAAY,UAAA,EAAY,QAAA,EAAU,MAAM,MAAA;AAAgB,GACtF,CAAE,CAAA;AAAA,EACF,GAAG,CAAC,qBAAA,EAAuB,sBAAsB,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IAClE,WAAA,EAAa,QAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,mBAAA,EAAqB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,IAC3E,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,UAAA,EAAY,MAAM,MAAA;AAAgB,GACtF,CAAE,CAAA;AAAA;AAAA;AAAA,EAGF,GAAG,CAAC,gCAAA,EAAkC,iCAAiC,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IACxF,WAAA,EAAa,iBAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,mBAAA,EAAqB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,IAC3E,eAAe,EAAE,SAAA,EAAW,YAAY,UAAA,EAAY,QAAA,EAAU,MAAM,MAAA;AAAgB,GACtF,CAAE;AACJ;AAEO,MAAM,mBAAA,GAAsB;AAAA,EACjC,cAAA,EAAgB,oCAAA;AAAA,EAChB,gBAAA,EAAkB,sCAAA;AAAA,EAClB,yBAAA,EAA2B;AAC7B;;;;"}

package/build/esm/orchestrion/config/aws-sdk.js

@@ -0,0 +1,25 @@
+const awsSdkConfig = [
+  {
+    channelName: "send",
+    module: { name: "@smithy/core", versionRange: ">=3.24.0 <4", filePath: "dist-cjs/submodules/client/index.js" },
+    functionQuery: { className: "Client", methodName: "send", kind: "Async" }
+  },
+  {
+    channelName: "send",
+    module: { name: "@smithy/smithy-client", versionRange: ">=1.0.3 <5", filePath: "dist-cjs/index.js" },
+    functionQuery: { className: "Client", methodName: "send", kind: "Async" }
+  },
+  {
+    channelName: "send",
+    module: { name: "@aws-sdk/smithy-client", versionRange: "^3.1.0", filePath: "dist-cjs/index.js" },
+    functionQuery: { className: "Client", methodName: "send", kind: "Async" }
+  }
+];
+const awsSdkChannels = {
+  AWS_SMITHY_CORE_SEND: "orchestrion:@smithy/core:send",
+  AWS_SMITHY_CLIENT_SEND: "orchestrion:@smithy/smithy-client:send",
+  AWS_SDK_SMITHY_CLIENT_SEND: "orchestrion:@aws-sdk/smithy-client:send"
+};
+
+export { awsSdkChannels, awsSdkConfig };
+//# sourceMappingURL=aws-sdk.js.map

package/build/esm/orchestrion/config/aws-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-sdk.js","sources":["../../../../src/orchestrion/config/aws-sdk.ts"],"sourcesContent":["import type { InstrumentationConfig } from '@apm-js-collab/code-transformer';\n\n// The AWS SDK (v3) routes every command through the smithy `Client.prototype.send` method. Which\n// package hosts that `Client` class changed across versions, so we target all of them; only the one\n// the app's client actually extends is ever invoked.\n//\n// - `@smithy/core` >= 3.24.0: the `Client` class moved into the `client` submodule bundle.\n// - `@smithy/smithy-client`: the `Client` class for aws-sdk v3.363.0+ (pre-`@smithy/core` stack).\n// - `@aws-sdk/smithy-client`: the `Client` class for older aws-sdk v3 releases.\n//\n// `send` is `async send(command, options)` (returns a promise), so `kind: 'Async'`.\nexport const awsSdkConfig = [\n  {\n    channelName: 'send',\n    module: { name: '@smithy/core', versionRange: '>=3.24.0 <4', filePath: 'dist-cjs/submodules/client/index.js' },\n    functionQuery: { className: 'Client', methodName: 'send', kind: 'Async' },\n  },\n  {\n    channelName: 'send',\n    module: { name: '@smithy/smithy-client', versionRange: '>=1.0.3 <5', filePath: 'dist-cjs/index.js' },\n    functionQuery: { className: 'Client', methodName: 'send', kind: 'Async' },\n  },\n  {\n    channelName: 'send',\n    module: { name: '@aws-sdk/smithy-client', versionRange: '^3.1.0', filePath: 'dist-cjs/index.js' },\n    functionQuery: { className: 'Client', methodName: 'send', kind: 'Async' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const awsSdkChannels = {\n  AWS_SMITHY_CORE_SEND: 'orchestrion:@smithy/core:send',\n  AWS_SMITHY_CLIENT_SEND: 'orchestrion:@smithy/smithy-client:send',\n  AWS_SDK_SMITHY_CLIENT_SEND: 'orchestrion:@aws-sdk/smithy-client:send',\n} as const;\n"],"names":[],"mappings":"AAWO,MAAM,YAAA,GAAe;AAAA,EAC1B;AAAA,IACE,WAAA,EAAa,MAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,gBAAgB,YAAA,EAAc,aAAA,EAAe,UAAU,qCAAA,EAAsC;AAAA,IAC7G,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,MAAA,EAAQ,MAAM,OAAA;AAAQ,GAC1E;AAAA,EACA;AAAA,IACE,WAAA,EAAa,MAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,yBAAyB,YAAA,EAAc,YAAA,EAAc,UAAU,mBAAA,EAAoB;AAAA,IACnG,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,MAAA,EAAQ,MAAM,OAAA;AAAQ,GAC1E;AAAA,EACA;AAAA,IACE,WAAA,EAAa,MAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,0BAA0B,YAAA,EAAc,QAAA,EAAU,UAAU,mBAAA,EAAoB;AAAA,IAChG,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,MAAA,EAAQ,MAAM,OAAA;AAAQ;AAE5E;AAEO,MAAM,cAAA,GAAiB;AAAA,EAC5B,oBAAA,EAAsB,+BAAA;AAAA,EACtB,sBAAA,EAAwB,wCAAA;AAAA,EACxB,0BAAA,EAA4B;AAC9B;;;;"}

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

@@ -0,0 +1,50 @@
+const module$1 = { name: "dataloader", versionRange: ">=2.0.0 <3", filePath: "index.js" };
+const dataloaderConfig = [
+  // Wrap the constructor so the subscriber can wrap the user's `batchLoadFn` (arg 0). The batch span
+  // is opened when that wrapped function actually runs (on the deferred dispatch tick), mirroring the
+  // vendored OTel instrumentation which also wraps `batchLoadFn` at construction time.
+  {
+    channelName: "construct",
+    module: module$1,
+    functionQuery: { functionName: "DataLoader", kind: "Sync" }
+  },
+  // `load`/`loadMany` return Promises, so they're `Async`: the span ends on `asyncEnd` (when the
+  // load resolves), capturing the real latency and enclosing the deferred `batch` span — matching the
+  // vendored OTel `startSpan`. `prime`/`clear`/`clearAll` return `this` synchronously, so they stay `Sync`.
+  {
+    channelName: "load",
+    module: module$1,
+    functionQuery: { expressionName: "load", kind: "Async" }
+  },
+  {
+    channelName: "loadMany",
+    module: module$1,
+    functionQuery: { expressionName: "loadMany", kind: "Async" }
+  },
+  {
+    channelName: "prime",
+    module: module$1,
+    functionQuery: { expressionName: "prime", kind: "Sync" }
+  },
+  {
+    channelName: "clear",
+    module: module$1,
+    functionQuery: { expressionName: "clear", kind: "Sync" }
+  },
+  {
+    channelName: "clearAll",
+    module: module$1,
+    functionQuery: { expressionName: "clearAll", kind: "Sync" }
+  }
+];
+const dataloaderChannels = {
+  DATALOADER_CONSTRUCT: "orchestrion:dataloader:construct",
+  DATALOADER_LOAD: "orchestrion:dataloader:load",
+  DATALOADER_LOAD_MANY: "orchestrion:dataloader:loadMany",
+  DATALOADER_PRIME: "orchestrion:dataloader:prime",
+  DATALOADER_CLEAR: "orchestrion:dataloader:clear",
+  DATALOADER_CLEAR_ALL: "orchestrion:dataloader:clearAll"
+};
+
+export { dataloaderChannels, dataloaderConfig };
+//# sourceMappingURL=dataloader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataloader.js","sources":["../../../../src/orchestrion/config/dataloader.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// `dataloader` ships a single transpiled CommonJS `index.js`. Its class methods are emitted as\n// `_proto.<name> = function <name>() {}` (named function *expressions*), so they match on\n// `expressionName` rather than `methodName`. The constructor is a named function declaration.\n// The version range mirrors `supportedVersions` in the vendored OTel instrumentation.\nconst module = { name: 'dataloader', versionRange: '>=2.0.0 <3', filePath: 'index.js' } as const;\n\nexport const dataloaderConfig = [\n  // Wrap the constructor so the subscriber can wrap the user's `batchLoadFn` (arg 0). The batch span\n  // is opened when that wrapped function actually runs (on the deferred dispatch tick), mirroring the\n  // vendored OTel instrumentation which also wraps `batchLoadFn` at construction time.\n  {\n    channelName: 'construct',\n    module,\n    functionQuery: { functionName: 'DataLoader', kind: 'Sync' },\n  },\n  // `load`/`loadMany` return Promises, so they're `Async`: the span ends on `asyncEnd` (when the\n  // load resolves), capturing the real latency and enclosing the deferred `batch` span — matching the\n  // vendored OTel `startSpan`. `prime`/`clear`/`clearAll` return `this` synchronously, so they stay `Sync`.\n  {\n    channelName: 'load',\n    module,\n    functionQuery: { expressionName: 'load', kind: 'Async' },\n  },\n  {\n    channelName: 'loadMany',\n    module,\n    functionQuery: { expressionName: 'loadMany', kind: 'Async' },\n  },\n  {\n    channelName: 'prime',\n    module,\n    functionQuery: { expressionName: 'prime', kind: 'Sync' },\n  },\n  {\n    channelName: 'clear',\n    module,\n    functionQuery: { expressionName: 'clear', kind: 'Sync' },\n  },\n  {\n    channelName: 'clearAll',\n    module,\n    functionQuery: { expressionName: 'clearAll', kind: 'Sync' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const dataloaderChannels = {\n  DATALOADER_CONSTRUCT: 'orchestrion:dataloader:construct',\n  DATALOADER_LOAD: 'orchestrion:dataloader:load',\n  DATALOADER_LOAD_MANY: 'orchestrion:dataloader:loadMany',\n  DATALOADER_PRIME: 'orchestrion:dataloader:prime',\n  DATALOADER_CLEAR: 'orchestrion:dataloader:clear',\n  DATALOADER_CLEAR_ALL: 'orchestrion:dataloader:clearAll',\n} as const;\n"],"names":["module"],"mappings":"AAMA,MAAMA,WAAS,EAAE,IAAA,EAAM,cAAc,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAE/E,MAAM,gBAAA,GAAmB;AAAA;AAAA;AAAA;AAAA,EAI9B;AAAA,IACE,WAAA,EAAa,WAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,YAAA,EAAc,YAAA,EAAc,MAAM,MAAA;AAAO,GAC5D;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,IACE,WAAA,EAAa,MAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,cAAA,EAAgB,MAAA,EAAQ,MAAM,OAAA;AAAQ,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,cAAA,EAAgB,UAAA,EAAY,MAAM,OAAA;AAAQ,GAC7D;AAAA,EACA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,cAAA,EAAgB,OAAA,EAAS,MAAM,MAAA;AAAO,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,cAAA,EAAgB,OAAA,EAAS,MAAM,MAAA;AAAO,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,YACbA,QAAA;AAAA,IACA,aAAA,EAAe,EAAE,cAAA,EAAgB,UAAA,EAAY,MAAM,MAAA;AAAO;AAE9D;AAEO,MAAM,kBAAA,GAAqB;AAAA,EAChC,oBAAA,EAAsB,kCAAA;AAAA,EACtB,eAAA,EAAiB,6BAAA;AAAA,EACjB,oBAAA,EAAsB,iCAAA;AAAA,EACtB,gBAAA,EAAkB,8BAAA;AAAA,EAClB,gBAAA,EAAkB,8BAAA;AAAA,EAClB,oBAAA,EAAsB;AACxB;;;;"}

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

@@ -0,0 +1,74 @@
+const expressConfig = [
+  // Express funnels every middleware/route handler through a single method on
+  // its routing `Layer`, so instrumenting that one method covers the whole
+  // request pipeline. The `expressChannelIntegration` opens one span per layer
+  // invocation. Both are `Layer.prototype.<method> = function <fn>(req, res, next)`
+  // prototype assignments (not `class` methods), so `expressionName` (matching
+  // the assignment's `left.property.name`) is used. `Callback`: the handler's
+  // last argument is `next`, so the transform ends the traced operation when
+  // `next` is invoked (and publishes `error` when it's called with an error).
+  //
+  // Express v4 ships its own router in `express/lib/router/layer.js`.
+  {
+    channelName: "handle",
+    module: { name: "express", versionRange: ">=4.0.0 <5", filePath: "lib/router/layer.js" },
+    // v4's method is `Layer.prototype.handle_request = function handle(...)` —
+    // match the assigned property name, not the function name.
+    functionQuery: { expressionName: "handle_request", kind: "Callback" }
+  },
+  // Express v5 delegates routing to the standalone `router` package.
+  {
+    channelName: "handle",
+    module: { name: "router", versionRange: ">=2.0.0 <3", filePath: "lib/layer.js" },
+    functionQuery: { expressionName: "handleRequest", kind: "Callback" }
+  },
+  // Layer *registration* methods. `Router.prototype.route`/`.use` are called
+  // once per registered route/middleware (including internally by `app.get`/
+  // `app.use`), so subscribing here lets us record each layer's registered path
+  // *pattern* — which the handler path (`req.baseUrl`) can't recover for
+  // parameterized mounts. `Sync`: these return synchronously and, unlike a
+  // handler, `use`'s trailing function argument is a registration payload, not a
+  // callback — so `Callback` would misclassify it and never fire `end`.
+  //
+  // `route` and `use` share one `register` channel because the subscriber handles
+  // them identically, saving a channel per module.
+  //
+  // Express v4 ships its own router in `express/lib/router/index.js`.
+  {
+    channelName: "register",
+    module: { name: "express", versionRange: ">=4.0.0 <5", filePath: "lib/router/index.js" },
+    functionQuery: { expressionName: "route", kind: "Sync" }
+  },
+  {
+    channelName: "register",
+    module: { name: "express", versionRange: ">=4.0.0 <5", filePath: "lib/router/index.js" },
+    functionQuery: { expressionName: "use", kind: "Sync" }
+  },
+  // Express v5 delegates routing to the standalone `router` package.
+  {
+    channelName: "register",
+    module: { name: "router", versionRange: ">=2.0.0 <3", filePath: "index.js" },
+    functionQuery: { expressionName: "route", kind: "Sync" }
+  },
+  {
+    channelName: "register",
+    module: { name: "router", versionRange: ">=2.0.0 <3", filePath: "index.js" },
+    functionQuery: { expressionName: "use", kind: "Sync" }
+  }
+];
+const expressChannels = {
+  // Express v4 runs each layer's handler through `Layer.prototype.handle_request`
+  // in the `express` module.
+  EXPRESS_HANDLE: "orchestrion:express:handle",
+  // Express v5 delegates routing to the standalone `router` package, where the
+  // equivalent method is `Layer.prototype.handleRequest`.
+  ROUTER_HANDLE: "orchestrion:router:handle",
+  // Layer *registration* (`Router.prototype.route`/`.use`), used to capture each
+  // layer's registered path pattern so the matched route can be reconstructed
+  // with its parameters intact (`req.baseUrl` only exposes the resolved prefix).
+  EXPRESS_REGISTER: "orchestrion:express:register",
+  ROUTER_REGISTER: "orchestrion:router:register"
+};
+
+export { expressChannels, expressConfig };
+//# sourceMappingURL=express.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sources":["../../../../src/orchestrion/config/express.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const expressConfig = [\n  // Express funnels every middleware/route handler through a single method on\n  // its routing `Layer`, so instrumenting that one method covers the whole\n  // request pipeline. The `expressChannelIntegration` opens one span per layer\n  // invocation. Both are `Layer.prototype.<method> = function <fn>(req, res, next)`\n  // prototype assignments (not `class` methods), so `expressionName` (matching\n  // the assignment's `left.property.name`) is used. `Callback`: the handler's\n  // last argument is `next`, so the transform ends the traced operation when\n  // `next` is invoked (and publishes `error` when it's called with an error).\n  //\n  // Express v4 ships its own router in `express/lib/router/layer.js`.\n  {\n    channelName: 'handle',\n    module: { name: 'express', versionRange: '>=4.0.0 <5', filePath: 'lib/router/layer.js' },\n    // v4's method is `Layer.prototype.handle_request = function handle(...)` —\n    // match the assigned property name, not the function name.\n    functionQuery: { expressionName: 'handle_request', kind: 'Callback' },\n  },\n  // Express v5 delegates routing to the standalone `router` package.\n  {\n    channelName: 'handle',\n    module: { name: 'router', versionRange: '>=2.0.0 <3', filePath: 'lib/layer.js' },\n    functionQuery: { expressionName: 'handleRequest', kind: 'Callback' },\n  },\n  // Layer *registration* methods. `Router.prototype.route`/`.use` are called\n  // once per registered route/middleware (including internally by `app.get`/\n  // `app.use`), so subscribing here lets us record each layer's registered path\n  // *pattern* — which the handler path (`req.baseUrl`) can't recover for\n  // parameterized mounts. `Sync`: these return synchronously and, unlike a\n  // handler, `use`'s trailing function argument is a registration payload, not a\n  // callback — so `Callback` would misclassify it and never fire `end`.\n  //\n  // `route` and `use` share one `register` channel because the subscriber handles\n  // them identically, saving a channel per module.\n  //\n  // Express v4 ships its own router in `express/lib/router/index.js`.\n  {\n    channelName: 'register',\n    module: { name: 'express', versionRange: '>=4.0.0 <5', filePath: 'lib/router/index.js' },\n    functionQuery: { expressionName: 'route', kind: 'Sync' },\n  },\n  {\n    channelName: 'register',\n    module: { name: 'express', versionRange: '>=4.0.0 <5', filePath: 'lib/router/index.js' },\n    functionQuery: { expressionName: 'use', kind: 'Sync' },\n  },\n  // Express v5 delegates routing to the standalone `router` package.\n  {\n    channelName: 'register',\n    module: { name: 'router', versionRange: '>=2.0.0 <3', filePath: 'index.js' },\n    functionQuery: { expressionName: 'route', kind: 'Sync' },\n  },\n  {\n    channelName: 'register',\n    module: { name: 'router', versionRange: '>=2.0.0 <3', filePath: 'index.js' },\n    functionQuery: { expressionName: 'use', kind: 'Sync' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const expressChannels = {\n  // Express v4 runs each layer's handler through `Layer.prototype.handle_request`\n  // in the `express` module.\n  EXPRESS_HANDLE: 'orchestrion:express:handle',\n  // Express v5 delegates routing to the standalone `router` package, where the\n  // equivalent method is `Layer.prototype.handleRequest`.\n  ROUTER_HANDLE: 'orchestrion:router:handle',\n  // Layer *registration* (`Router.prototype.route`/`.use`), used to capture each\n  // layer's registered path pattern so the matched route can be reconstructed\n  // with its parameters intact (`req.baseUrl` only exposes the resolved prefix).\n  EXPRESS_REGISTER: 'orchestrion:express:register',\n  ROUTER_REGISTER: 'orchestrion:router:register',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,aAAA,GAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW3B;AAAA,IACE,WAAA,EAAa,QAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,qBAAA,EAAsB;AAAA;AAAA;AAAA,IAGvF,aAAA,EAAe,EAAE,cAAA,EAAgB,gBAAA,EAAkB,MAAM,UAAA;AAAW,GACtE;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,QAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,UAAU,YAAA,EAAc,YAAA,EAAc,UAAU,cAAA,EAAe;AAAA,IAC/E,aAAA,EAAe,EAAE,cAAA,EAAgB,eAAA,EAAiB,MAAM,UAAA;AAAW,GACrE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,qBAAA,EAAsB;AAAA,IACvF,aAAA,EAAe,EAAE,cAAA,EAAgB,OAAA,EAAS,MAAM,MAAA;AAAO,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,qBAAA,EAAsB;AAAA,IACvF,aAAA,EAAe,EAAE,cAAA,EAAgB,KAAA,EAAO,MAAM,MAAA;AAAO,GACvD;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,UAAU,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAAA,IAC3E,aAAA,EAAe,EAAE,cAAA,EAAgB,OAAA,EAAS,MAAM,MAAA;AAAO,GACzD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,UAAU,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAAA,IAC3E,aAAA,EAAe,EAAE,cAAA,EAAgB,KAAA,EAAO,MAAM,MAAA;AAAO;AAEzD;AAEO,MAAM,eAAA,GAAkB;AAAA;AAAA;AAAA,EAG7B,cAAA,EAAgB,4BAAA;AAAA;AAAA;AAAA,EAGhB,aAAA,EAAe,2BAAA;AAAA;AAAA;AAAA;AAAA,EAIf,gBAAA,EAAkB,8BAAA;AAAA,EAClB,eAAA,EAAiB;AACnB;;;;"}

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

@@ -0,0 +1,5 @@
+const firebaseConfig = [];
+const firebaseChannels = {};
+
+export { firebaseChannels, firebaseConfig };
+//# sourceMappingURL=firebase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firebase.js","sources":["../../../../src/orchestrion/config/firebase.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// TODO: Stub for the `firebase` orchestrion integration (ports `FirebaseInstrumentation`).\nexport const firebaseConfig: InstrumentationConfig[] = [];\n\nexport const firebaseChannels = {} as const;\n"],"names":[],"mappings":"AAGO,MAAM,iBAA0C;AAEhD,MAAM,mBAAmB;;;;"}

package/build/esm/orchestrion/config/generic-pool.js

@@ -0,0 +1,18 @@
+const genericPoolConfig = [
+  {
+    channelName: "acquire",
+    module: { name: "generic-pool", versionRange: ">=3.0.0 <4", filePath: "lib/Pool.js" },
+    functionQuery: { className: "Pool", methodName: "acquire", kind: "Auto" }
+  },
+  {
+    channelName: "acquire",
+    module: { name: "generic-pool", versionRange: ">=2.4.0 <3", filePath: "lib/generic-pool.js" },
+    functionQuery: { expressionName: "acquire", kind: "Callback" }
+  }
+];
+const genericPoolChannels = {
+  GENERIC_POOL_ACQUIRE: "orchestrion:generic-pool:acquire"
+};
+
+export { genericPoolChannels, genericPoolConfig };
+//# sourceMappingURL=generic-pool.js.map

package/build/esm/orchestrion/config/generic-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-pool.js","sources":["../../../../src/orchestrion/config/generic-pool.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// Two shapes of `acquire`, both publishing to the same `orchestrion:generic-pool:acquire` channel:\n// - v3+: `class Pool { acquire(priority) }` returns a promise, so `kind: 'Auto'` resolves to `wrapPromise`.\n// - v2.4–v3: `Pool.prototype.acquire = function acquire(callback, priority)` is callback-based.\n// Versions before 2.4 assigned an anonymous `acquire` per pool instance (a factory), which a static\n// transform can't target, so they're out of scope (matching how the OTel instrumentation split them).\nexport const genericPoolConfig = [\n  {\n    channelName: 'acquire',\n    module: { name: 'generic-pool', versionRange: '>=3.0.0 <4', filePath: 'lib/Pool.js' },\n    functionQuery: { className: 'Pool', methodName: 'acquire', kind: 'Auto' },\n  },\n  {\n    channelName: 'acquire',\n    module: { name: 'generic-pool', versionRange: '>=2.4.0 <3', filePath: 'lib/generic-pool.js' },\n    functionQuery: { expressionName: 'acquire', kind: 'Callback' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const genericPoolChannels = {\n  GENERIC_POOL_ACQUIRE: 'orchestrion:generic-pool:acquire',\n} as const;\n"],"names":[],"mappings":"AAOO,MAAM,iBAAA,GAAoB;AAAA,EAC/B;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,gBAAgB,YAAA,EAAc,YAAA,EAAc,UAAU,aAAA,EAAc;AAAA,IACpF,eAAe,EAAE,SAAA,EAAW,QAAQ,UAAA,EAAY,SAAA,EAAW,MAAM,MAAA;AAAO,GAC1E;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,gBAAgB,YAAA,EAAc,YAAA,EAAc,UAAU,qBAAA,EAAsB;AAAA,IAC5F,aAAA,EAAe,EAAE,cAAA,EAAgB,SAAA,EAAW,MAAM,UAAA;AAAW;AAEjE;AAEO,MAAM,mBAAA,GAAsB;AAAA,EACjC,oBAAA,EAAsB;AACxB;;;;"}

package/build/esm/orchestrion/config/google-genai.js

@@ -0,0 +1,35 @@
+const NODE_DIST_FILES = ["dist/node/index.js", "dist/node/index.mjs", "dist/node/index.cjs"];
+const googleGenAiConfig = [
+  // `generateContent`/`generateContentStream` are arrow properties assigned in the constructor, not class
+  // methods, so they need `expressionName` rather than `className`/`methodName`.
+  ...NODE_DIST_FILES.flatMap(
+    (filePath) => ["generateContent", "generateContentStream"].map((expressionName) => ({
+      channelName: "generate-content",
+      module: { name: "@google/genai", versionRange: ">=0.10.0 <2", filePath },
+      functionQuery: { expressionName, kind: "Auto" }
+    }))
+  ),
+  // `embedContent` and the `Chat` methods are real class methods.
+  ...NODE_DIST_FILES.map((filePath) => ({
+    channelName: "embed-content",
+    module: { name: "@google/genai", versionRange: ">=0.10.0 <2", filePath },
+    functionQuery: { className: "Models", methodName: "embedContent", kind: "Auto" }
+  })),
+  // `sendMessage`/`sendMessageStream` internally delegate to `Models.generateContent(Stream)`; the
+  // subscriber suppresses that nested `generate-content` event so a chat call yields a single span.
+  ...NODE_DIST_FILES.flatMap(
+    (filePath) => ["sendMessage", "sendMessageStream"].map((methodName) => ({
+      channelName: "chat",
+      module: { name: "@google/genai", versionRange: ">=0.10.0 <2", filePath },
+      functionQuery: { className: "Chat", methodName, kind: "Auto" }
+    }))
+  )
+];
+const googleGenAiChannels = {
+  GOOGLE_GENAI_GENERATE_CONTENT: "orchestrion:@google/genai:generate-content",
+  GOOGLE_GENAI_EMBED_CONTENT: "orchestrion:@google/genai:embed-content",
+  GOOGLE_GENAI_CHAT: "orchestrion:@google/genai:chat"
+};
+
+export { googleGenAiChannels, googleGenAiConfig };
+//# sourceMappingURL=google-genai.js.map

package/build/esm/orchestrion/config/google-genai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-genai.js","sources":["../../../../src/orchestrion/config/google-genai.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// `@google/genai` ships one bundled file per module format and the matcher compares `filePath` exactly,\n// so we list every file the `node` export condition resolves to across the supported range: `index.js`\n// (ESM+CJS for <0.15.0, CJS for <1.1.0), `index.mjs` (ESM for >=0.15.0), and `index.cjs` (CJS for >=1.1.0).\n// A file that doesn't exist in a given version simply never matches, so listing all three is safe.\nconst NODE_DIST_FILES = ['dist/node/index.js', 'dist/node/index.mjs', 'dist/node/index.cjs'];\n\nexport const googleGenAiConfig = [\n  // `generateContent`/`generateContentStream` are arrow properties assigned in the constructor, not class\n  // methods, so they need `expressionName` rather than `className`/`methodName`.\n  ...NODE_DIST_FILES.flatMap(filePath =>\n    (['generateContent', 'generateContentStream'] as const).map(expressionName => ({\n      channelName: 'generate-content',\n      module: { name: '@google/genai', versionRange: '>=0.10.0 <2', filePath },\n      functionQuery: { expressionName, kind: 'Auto' as const },\n    })),\n  ),\n  // `embedContent` and the `Chat` methods are real class methods.\n  ...NODE_DIST_FILES.map(filePath => ({\n    channelName: 'embed-content',\n    module: { name: '@google/genai', versionRange: '>=0.10.0 <2', filePath },\n    functionQuery: { className: 'Models', methodName: 'embedContent', kind: 'Auto' as const },\n  })),\n  // `sendMessage`/`sendMessageStream` internally delegate to `Models.generateContent(Stream)`; the\n  // subscriber suppresses that nested `generate-content` event so a chat call yields a single span.\n  ...NODE_DIST_FILES.flatMap(filePath =>\n    (['sendMessage', 'sendMessageStream'] as const).map(methodName => ({\n      channelName: 'chat',\n      module: { name: '@google/genai', versionRange: '>=0.10.0 <2', filePath },\n      functionQuery: { className: 'Chat', methodName, kind: 'Auto' as const },\n    })),\n  ),\n] satisfies InstrumentationConfig[];\n\nexport const googleGenAiChannels = {\n  GOOGLE_GENAI_GENERATE_CONTENT: 'orchestrion:@google/genai:generate-content',\n  GOOGLE_GENAI_EMBED_CONTENT: 'orchestrion:@google/genai:embed-content',\n  GOOGLE_GENAI_CHAT: 'orchestrion:@google/genai:chat',\n} as const;\n"],"names":[],"mappings":"AAMA,MAAM,eAAA,GAAkB,CAAC,oBAAA,EAAsB,qBAAA,EAAuB,qBAAqB,CAAA;AAEpF,MAAM,iBAAA,GAAoB;AAAA;AAAA;AAAA,EAG/B,GAAG,eAAA,CAAgB,OAAA;AAAA,IAAQ,cACxB,CAAC,iBAAA,EAAmB,uBAAuB,CAAA,CAAY,IAAI,CAAA,cAAA,MAAmB;AAAA,MAC7E,WAAA,EAAa,kBAAA;AAAA,MACb,QAAQ,EAAE,IAAA,EAAM,eAAA,EAAiB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,MACvE,aAAA,EAAe,EAAE,cAAA,EAAgB,IAAA,EAAM,MAAA;AAAgB,KACzD,CAAE;AAAA,GACJ;AAAA;AAAA,EAEA,GAAG,eAAA,CAAgB,GAAA,CAAI,CAAA,QAAA,MAAa;AAAA,IAClC,WAAA,EAAa,eAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,eAAA,EAAiB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,IACvE,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,cAAA,EAAgB,MAAM,MAAA;AAAgB,GAC1F,CAAE,CAAA;AAAA;AAAA;AAAA,EAGF,GAAG,eAAA,CAAgB,OAAA;AAAA,IAAQ,cACxB,CAAC,aAAA,EAAe,mBAAmB,CAAA,CAAY,IAAI,CAAA,UAAA,MAAe;AAAA,MACjE,WAAA,EAAa,MAAA;AAAA,MACb,QAAQ,EAAE,IAAA,EAAM,eAAA,EAAiB,YAAA,EAAc,eAAe,QAAA,EAAS;AAAA,MACvE,eAAe,EAAE,SAAA,EAAW,MAAA,EAAQ,UAAA,EAAY,MAAM,MAAA;AAAgB,KACxE,CAAE;AAAA;AAEN;AAEO,MAAM,mBAAA,GAAsB;AAAA,EACjC,6BAAA,EAA+B,4CAAA;AAAA,EAC/B,0BAAA,EAA4B,yCAAA;AAAA,EAC5B,iBAAA,EAAmB;AACrB;;;;"}

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

@@ -0,0 +1,25 @@
+const graphqlConfig = [
+  {
+    channelName: "parse",
+    module: { name: "graphql", versionRange: ">=14.0.0 <17", filePath: "language/parser.js" },
+    functionQuery: { functionName: "parse", kind: "Sync" }
+  },
+  {
+    channelName: "validate",
+    module: { name: "graphql", versionRange: ">=14.0.0 <17", filePath: "validation/validate.js" },
+    functionQuery: { functionName: "validate", kind: "Sync" }
+  },
+  {
+    channelName: "execute",
+    module: { name: "graphql", versionRange: ">=14.0.0 <17", filePath: "execution/execute.js" },
+    functionQuery: { functionName: "execute", kind: "Auto" }
+  }
+];
+const graphqlChannels = {
+  GRAPHQL_PARSE: "orchestrion:graphql:parse",
+  GRAPHQL_VALIDATE: "orchestrion:graphql:validate",
+  GRAPHQL_EXECUTE: "orchestrion:graphql:execute"
+};
+
+export { graphqlChannels, graphqlConfig };
+//# sourceMappingURL=graphql.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.js","sources":["../../../../src/orchestrion/config/graphql.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// `parse`/`validate`/`execute` are top-level named `function` declarations in graphql's compiled\n// files, stable across the supported majors, so `functionName` matches. `execute` returns\n// `PromiseOrValue`, so `Auto` covers both async (settles on `asyncEnd`) and sync (`end`) schemas.\nexport const graphqlConfig = [\n  {\n    channelName: 'parse',\n    module: { name: 'graphql', versionRange: '>=14.0.0 <17', filePath: 'language/parser.js' },\n    functionQuery: { functionName: 'parse', kind: 'Sync' },\n  },\n  {\n    channelName: 'validate',\n    module: { name: 'graphql', versionRange: '>=14.0.0 <17', filePath: 'validation/validate.js' },\n    functionQuery: { functionName: 'validate', kind: 'Sync' },\n  },\n  {\n    channelName: 'execute',\n    module: { name: 'graphql', versionRange: '>=14.0.0 <17', filePath: 'execution/execute.js' },\n    functionQuery: { functionName: 'execute', kind: 'Auto' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const graphqlChannels = {\n  GRAPHQL_PARSE: 'orchestrion:graphql:parse',\n  GRAPHQL_VALIDATE: 'orchestrion:graphql:validate',\n  GRAPHQL_EXECUTE: 'orchestrion:graphql:execute',\n} as const;\n"],"names":[],"mappings":"AAKO,MAAM,aAAA,GAAgB;AAAA,EAC3B;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,cAAA,EAAgB,UAAU,oBAAA,EAAqB;AAAA,IACxF,aAAA,EAAe,EAAE,YAAA,EAAc,OAAA,EAAS,MAAM,MAAA;AAAO,GACvD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,cAAA,EAAgB,UAAU,wBAAA,EAAyB;AAAA,IAC5F,aAAA,EAAe,EAAE,YAAA,EAAc,UAAA,EAAY,MAAM,MAAA;AAAO,GAC1D;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,cAAA,EAAgB,UAAU,sBAAA,EAAuB;AAAA,IAC1F,aAAA,EAAe,EAAE,YAAA,EAAc,SAAA,EAAW,MAAM,MAAA;AAAO;AAE3D;AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,aAAA,EAAe,2BAAA;AAAA,EACf,gBAAA,EAAkB,8BAAA;AAAA,EAClB,eAAA,EAAiB;AACnB;;;;"}

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

@@ -0,0 +1,23 @@
+const hapiConfig = [
+  // hapi's `route`/`ext` live on an anonymous class (`internals.Server = class {}`),
+  // so `{className}` can't match — `{methodName}` targets them in lib/server.js. Both
+  // are synchronous void methods, so `Sync` suffices: we only use `start` to swap
+  // handlers in `ctx.arguments`. Shape verified across the whole range.
+  {
+    channelName: "route",
+    module: { name: "@hapi/hapi", versionRange: ">=17.0.0 <22.0.0", filePath: "lib/server.js" },
+    functionQuery: { methodName: "route", kind: "Sync" }
+  },
+  {
+    channelName: "ext",
+    module: { name: "@hapi/hapi", versionRange: ">=17.0.0 <22.0.0", filePath: "lib/server.js" },
+    functionQuery: { methodName: "ext", kind: "Sync" }
+  }
+];
+const hapiChannels = {
+  HAPI_ROUTE: "orchestrion:@hapi/hapi:route",
+  HAPI_EXT: "orchestrion:@hapi/hapi:ext"
+};
+
+export { hapiChannels, hapiConfig };
+//# sourceMappingURL=hapi.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hapi.js","sources":["../../../../src/orchestrion/config/hapi.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const hapiConfig = [\n  // hapi's `route`/`ext` live on an anonymous class (`internals.Server = class {}`),\n  // so `{className}` can't match — `{methodName}` targets them in lib/server.js. Both\n  // are synchronous void methods, so `Sync` suffices: we only use `start` to swap\n  // handlers in `ctx.arguments`. Shape verified across the whole range.\n  {\n    channelName: 'route',\n    module: { name: '@hapi/hapi', versionRange: '>=17.0.0 <22.0.0', filePath: 'lib/server.js' },\n    functionQuery: { methodName: 'route', kind: 'Sync' },\n  },\n  {\n    channelName: 'ext',\n    module: { name: '@hapi/hapi', versionRange: '>=17.0.0 <22.0.0', filePath: 'lib/server.js' },\n    functionQuery: { methodName: 'ext', kind: 'Sync' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const hapiChannels = {\n  HAPI_ROUTE: 'orchestrion:@hapi/hapi:route',\n  HAPI_EXT: 'orchestrion:@hapi/hapi:ext',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,UAAA,GAAa;AAAA;AAAA;AAAA;AAAA;AAAA,EAKxB;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,cAAc,YAAA,EAAc,kBAAA,EAAoB,UAAU,eAAA,EAAgB;AAAA,IAC1F,aAAA,EAAe,EAAE,UAAA,EAAY,OAAA,EAAS,MAAM,MAAA;AAAO,GACrD;AAAA,EACA;AAAA,IACE,WAAA,EAAa,KAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,cAAc,YAAA,EAAc,kBAAA,EAAoB,UAAU,eAAA,EAAgB;AAAA,IAC1F,aAAA,EAAe,EAAE,UAAA,EAAY,KAAA,EAAO,MAAM,MAAA;AAAO;AAErD;AAEO,MAAM,YAAA,GAAe;AAAA,EAC1B,UAAA,EAAY,8BAAA;AAAA,EACZ,QAAA,EAAU;AACZ;;;;"}

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

@@ -0,0 +1,84 @@
+import { uniq } from '@sentry/core';
+import { amqplibConfig } from './amqplib.js';
+import { anthropicAiConfig } from './anthropic-ai.js';
+import { awsSdkConfig } from './aws-sdk.js';
+import { dataloaderConfig } from './dataloader.js';
+import { expressConfig } from './express.js';
+import { firebaseConfig } from './firebase.js';
+import { genericPoolConfig } from './generic-pool.js';
+import { googleGenAiConfig } from './google-genai.js';
+import { graphqlConfig } from './graphql.js';
+import { hapiConfig } from './hapi.js';
+import { ioredisConfig } from './ioredis.js';
+import { kafkajsConfig } from './kafkajs.js';
+import { knexConfig } from './knex.js';
+import { koaConfig } from './koa.js';
+import { langchainConfig } from './langchain.js';
+import { langgraphConfig } from './langgraph.js';
+import { lruMemoizerConfig } from './lru-memoizer.js';
+import { mongodbConfig } from './mongodb.js';
+import { mongooseConfig } from './mongoose.js';
+import { mysql2Config } from './mysql2.js';
+import { mysqlConfig } from './mysql.js';
+import { nestjsConfig } from './nestjs.js';
+import { openaiConfig } from './openai.js';
+import { pgConfig } from './pg.js';
+import { postgresJsConfig } from './postgres.js';
+import { prismaConfig } from './prisma.js';
+import { reactRouterConfig } from './react-router.js';
+import { redisConfig } from './redis.js';
+import { remixConfig } from './remix.js';
+import { tediousConfig } from './tedious.js';
+import { vercelAiConfig } from './vercel-ai.js';
+
+const SENTRY_INSTRUMENTATIONS = [
+  ...amqplibConfig,
+  ...anthropicAiConfig,
+  ...awsSdkConfig,
+  ...dataloaderConfig,
+  ...expressConfig,
+  ...firebaseConfig,
+  ...genericPoolConfig,
+  ...googleGenAiConfig,
+  ...graphqlConfig,
+  ...hapiConfig,
+  ...ioredisConfig,
+  ...kafkajsConfig,
+  ...knexConfig,
+  ...koaConfig,
+  ...langchainConfig,
+  ...langgraphConfig,
+  ...lruMemoizerConfig,
+  ...mongodbConfig,
+  ...mongooseConfig,
+  ...mysql2Config,
+  ...mysqlConfig,
+  ...nestjsConfig,
+  ...openaiConfig,
+  ...pgConfig,
+  ...postgresJsConfig,
+  ...prismaConfig,
+  ...reactRouterConfig,
+  ...redisConfig,
+  ...remixConfig,
+  ...tediousConfig,
+  ...vercelAiConfig
+];
+function instrumentedModuleNames(instrumentations = []) {
+  return [
+    ...uniq([...SENTRY_INSTRUMENTATIONS, ...instrumentations].map((i) => i.module.name)),
+    // Additional things that need to be bundled but are not covered by the above
+    // Remix needs to bundle this so @remix-run/server-runtime is _also_ bundled
+    "@remix-run/node"
+  ];
+}
+const INSTRUMENTED_MODULE_NAMES = instrumentedModuleNames();
+function withoutInstrumentedExternals(external, moduleNames = INSTRUMENTED_MODULE_NAMES) {
+  if (!external) {
+    return void 0;
+  }
+  return external.filter((entry) => !moduleNames.some((name) => entry === name || entry.startsWith(`${name}/`)));
+}
+
+export { INSTRUMENTED_MODULE_NAMES, SENTRY_INSTRUMENTATIONS, instrumentedModuleNames, withoutInstrumentedExternals };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/orchestrion/config/index.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\nimport { uniq } from '@sentry/core';\n\nimport { amqplibConfig } from './amqplib';\nimport { anthropicAiConfig } from './anthropic-ai';\nimport { awsSdkConfig } from './aws-sdk';\nimport { dataloaderConfig } from './dataloader';\nimport { expressConfig } from './express';\nimport { firebaseConfig } from './firebase';\nimport { genericPoolConfig } from './generic-pool';\nimport { googleGenAiConfig } from './google-genai';\nimport { graphqlConfig } from './graphql';\nimport { hapiConfig } from './hapi';\nimport { ioredisConfig } from './ioredis';\nimport { kafkajsConfig } from './kafkajs';\nimport { knexConfig } from './knex';\nimport { koaConfig } from './koa';\nimport { langchainConfig } from './langchain';\nimport { langgraphConfig } from './langgraph';\nimport { lruMemoizerConfig } from './lru-memoizer';\nimport { mongodbConfig } from './mongodb';\nimport { mongooseConfig } from './mongoose';\nimport { mysql2Config } from './mysql2';\nimport { mysqlConfig } from './mysql';\nimport { nestjsConfig } from './nestjs';\nimport { openaiConfig } from './openai';\nimport { pgConfig } from './pg';\nimport { postgresJsConfig } from './postgres';\nimport { prismaConfig } from './prisma';\nimport { reactRouterConfig } from './react-router';\nimport { redisConfig } from './redis';\nimport { remixConfig } from './remix';\nimport { tediousConfig } from './tedious';\nimport { vercelAiConfig } from './vercel-ai';\n// Kept sorted alphabetically by module so concurrent additions insert at different\n// points rather than all appending to the end (fewer merge conflicts).\n\n/**\n * The orchestrion code-transform configs. Every instrumentable library is here\n * so the transform is all-or-nothing: whenever orchestrion is enabled, all of\n * these are injected. The channel LISTENERS may live elsewhere (e.g. the NestJS\n * one lives in `@sentry/nestjs`), but the config that decides what gets\n * transformed is centralized here.\n */\nexport const SENTRY_INSTRUMENTATIONS: InstrumentationConfig[] = [\n  ...amqplibConfig,\n  ...anthropicAiConfig,\n  ...awsSdkConfig,\n  ...dataloaderConfig,\n  ...expressConfig,\n  ...firebaseConfig,\n  ...genericPoolConfig,\n  ...googleGenAiConfig,\n  ...graphqlConfig,\n  ...hapiConfig,\n  ...ioredisConfig,\n  ...kafkajsConfig,\n  ...knexConfig,\n  ...koaConfig,\n  ...langchainConfig,\n  ...langgraphConfig,\n  ...lruMemoizerConfig,\n  ...mongodbConfig,\n  ...mongooseConfig,\n  ...mysql2Config,\n  ...mysqlConfig,\n  ...nestjsConfig,\n  ...openaiConfig,\n  ...pgConfig,\n  ...postgresJsConfig,\n  ...prismaConfig,\n  ...reactRouterConfig,\n  ...redisConfig,\n  ...remixConfig,\n  ...tediousConfig,\n  ...vercelAiConfig,\n];\n\n/**\n * The unique set of package names instrumented by `SENTRY_INSTRUMENTATIONS`\n * merged with any caller-provided `instrumentations` (e.g. `['mysql']`).\n *\n * Bundler plugins MUST ensure these are actually bundled rather than\n * externalized: an externalized dependency is resolved from `node_modules` at\n * runtime and never passes through the code transform's `onLoad`, so its\n * diagnostics_channel calls are silently never injected. This includes a\n * plugin's custom `instrumentations`, otherwise those extra packages can stay\n * externalized and their transform never runs.\n */\nexport function instrumentedModuleNames(instrumentations: InstrumentationConfig[] = []): string[] {\n  return [\n    ...uniq([...SENTRY_INSTRUMENTATIONS, ...instrumentations].map(i => i.module.name)),\n    // Additional things that need to be bundled but are not covered by the above\n    // Remix needs to bundle this so @remix-run/server-runtime is _also_ bundled\n    '@remix-run/node',\n  ];\n}\n\n/** The instrumented module names from the default Sentry config, with no custom additions. */\nexport const INSTRUMENTED_MODULE_NAMES: string[] = instrumentedModuleNames();\n\n/**\n * Returns `external` with any instrumented packages removed, so a bundler that\n * uses an \"external\" denylist (esbuild, Bun, Rollup) still bundles — and thus\n * transforms — them. Matches an exact package name (`'mysql'`) or a subpath\n * (`'mysql/lib/...'`); wildcard/other patterns are left untouched. `undefined`\n * is returned unchanged.\n *\n * Pass `moduleNames` from `instrumentedModuleNames(options.instrumentations)` so\n * custom instrumentations are stripped too; it defaults to the Sentry config\n * list. (Vite uses an `ssr.noExternal` allowlist instead, so it consumes\n * `instrumentedModuleNames` directly rather than this helper.)\n */\nexport function withoutInstrumentedExternals(\n  external: readonly string[] | undefined,\n  moduleNames: string[] = INSTRUMENTED_MODULE_NAMES,\n): string[] | undefined {\n  if (!external) {\n    return undefined;\n  }\n  return external.filter(entry => !moduleNames.some(name => entry === name || entry.startsWith(`${name}/`)));\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CO,MAAM,uBAAA,GAAmD;AAAA,EAC9D,GAAG,aAAA;AAAA,EACH,GAAG,iBAAA;AAAA,EACH,GAAG,YAAA;AAAA,EACH,GAAG,gBAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG,cAAA;AAAA,EACH,GAAG,iBAAA;AAAA,EACH,GAAG,iBAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG,UAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG,UAAA;AAAA,EACH,GAAG,SAAA;AAAA,EACH,GAAG,eAAA;AAAA,EACH,GAAG,eAAA;AAAA,EACH,GAAG,iBAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG,cAAA;AAAA,EACH,GAAG,YAAA;AAAA,EACH,GAAG,WAAA;AAAA,EACH,GAAG,YAAA;AAAA,EACH,GAAG,YAAA;AAAA,EACH,GAAG,QAAA;AAAA,EACH,GAAG,gBAAA;AAAA,EACH,GAAG,YAAA;AAAA,EACH,GAAG,iBAAA;AAAA,EACH,GAAG,WAAA;AAAA,EACH,GAAG,WAAA;AAAA,EACH,GAAG,aAAA;AAAA,EACH,GAAG;AACL;AAaO,SAAS,uBAAA,CAAwB,gBAAA,GAA4C,EAAC,EAAa;AAChG,EAAA,OAAO;AAAA,IACL,GAAG,IAAA,CAAK,CAAC,GAAG,uBAAA,EAAyB,GAAG,gBAAgB,CAAA,CAAE,GAAA,CAAI,CAAA,CAAA,KAAK,CAAA,CAAE,MAAA,CAAO,IAAI,CAAC,CAAA;AAAA;AAAA;AAAA,IAGjF;AAAA,GACF;AACF;AAGO,MAAM,4BAAsC,uBAAA;AAc5C,SAAS,4BAAA,CACd,QAAA,EACA,WAAA,GAAwB,yBAAA,EACF;AACtB,EAAA,IAAI,CAAC,QAAA,EAAU;AACb,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAO,QAAA,CAAS,MAAA,CAAO,CAAA,KAAA,KAAS,CAAC,YAAY,IAAA,CAAK,CAAA,IAAA,KAAQ,KAAA,KAAU,IAAA,IAAQ,MAAM,UAAA,CAAW,CAAA,EAAG,IAAI,CAAA,CAAA,CAAG,CAAC,CAAC,CAAA;AAC3G;;;;"}

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

@@ -0,0 +1,32 @@
+const ioredisConfig = [
+  // ioredis `<5.11.0` (>=5.11.0 publishes its own `ioredis:*` diagnostics_channel)
+  ...["lib/redis.js", "built/redis.js", "built/redis/index.js"].flatMap((filePath) => [
+    {
+      channelName: "command",
+      module: { name: "ioredis", versionRange: ">=2.0.0 <5.0.0", filePath },
+      functionQuery: { expressionName: "sendCommand", kind: "Async" }
+    },
+    {
+      channelName: "connect",
+      module: { name: "ioredis", versionRange: ">=2.0.0 <5.0.0", filePath },
+      functionQuery: { expressionName: "connect", kind: "Async" }
+    }
+  ]),
+  {
+    channelName: "command",
+    module: { name: "ioredis", versionRange: ">=5.0.0 <5.11.0", filePath: "built/Redis.js" },
+    functionQuery: { className: "Redis", methodName: "sendCommand", kind: "Async" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "ioredis", versionRange: ">=5.0.0 <5.11.0", filePath: "built/Redis.js" },
+    functionQuery: { className: "Redis", methodName: "connect", kind: "Async" }
+  }
+];
+const ioredisChannels = {
+  IOREDIS_COMMAND: "orchestrion:ioredis:command",
+  IOREDIS_CONNECT: "orchestrion:ioredis:connect"
+};
+
+export { ioredisChannels, ioredisConfig };
+//# sourceMappingURL=ioredis.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis.js","sources":["../../../../src/orchestrion/config/ioredis.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const ioredisConfig = [\n  // ioredis `<5.11.0` (>=5.11.0 publishes its own `ioredis:*` diagnostics_channel)\n  ...['lib/redis.js', 'built/redis.js', 'built/redis/index.js'].flatMap((filePath): InstrumentationConfig[] => [\n    {\n      channelName: 'command',\n      module: { name: 'ioredis', versionRange: '>=2.0.0 <5.0.0', filePath },\n      functionQuery: { expressionName: 'sendCommand', kind: 'Async' },\n    },\n    {\n      channelName: 'connect',\n      module: { name: 'ioredis', versionRange: '>=2.0.0 <5.0.0', filePath },\n      functionQuery: { expressionName: 'connect', kind: 'Async' },\n    },\n  ]),\n  {\n    channelName: 'command',\n    module: { name: 'ioredis', versionRange: '>=5.0.0 <5.11.0', filePath: 'built/Redis.js' },\n    functionQuery: { className: 'Redis', methodName: 'sendCommand', kind: 'Async' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: 'ioredis', versionRange: '>=5.0.0 <5.11.0', filePath: 'built/Redis.js' },\n    functionQuery: { className: 'Redis', methodName: 'connect', kind: 'Async' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const ioredisChannels = {\n  IOREDIS_COMMAND: 'orchestrion:ioredis:command',\n  IOREDIS_CONNECT: 'orchestrion:ioredis:connect',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,aAAA,GAAgB;AAAA;AAAA,EAE3B,GAAG,CAAC,cAAA,EAAgB,gBAAA,EAAkB,sBAAsB,CAAA,CAAE,OAAA,CAAQ,CAAC,QAAA,KAAsC;AAAA,IAC3G;AAAA,MACE,WAAA,EAAa,SAAA;AAAA,MACb,QAAQ,EAAE,IAAA,EAAM,SAAA,EAAW,YAAA,EAAc,kBAAkB,QAAA,EAAS;AAAA,MACpE,aAAA,EAAe,EAAE,cAAA,EAAgB,aAAA,EAAe,MAAM,OAAA;AAAQ,KAChE;AAAA,IACA;AAAA,MACE,WAAA,EAAa,SAAA;AAAA,MACb,QAAQ,EAAE,IAAA,EAAM,SAAA,EAAW,YAAA,EAAc,kBAAkB,QAAA,EAAS;AAAA,MACpE,aAAA,EAAe,EAAE,cAAA,EAAgB,SAAA,EAAW,MAAM,OAAA;AAAQ;AAC5D,GACD,CAAA;AAAA,EACD;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,iBAAA,EAAmB,UAAU,gBAAA,EAAiB;AAAA,IACvF,eAAe,EAAE,SAAA,EAAW,SAAS,UAAA,EAAY,aAAA,EAAe,MAAM,OAAA;AAAQ,GAChF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,iBAAA,EAAmB,UAAU,gBAAA,EAAiB;AAAA,IACvF,eAAe,EAAE,SAAA,EAAW,SAAS,UAAA,EAAY,SAAA,EAAW,MAAM,OAAA;AAAQ;AAE9E;AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,eAAA,EAAiB,6BAAA;AAAA,EACjB,eAAA,EAAiB;AACnB;;;;"}

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

@@ -0,0 +1,27 @@
+const kafkajsConfig = [
+  {
+    channelName: "send_batch",
+    module: { name: "kafkajs", versionRange: ">=2.0.0 <3", filePath: "src/producer/messageProducer.js" },
+    // `const sendBatch = async (...) => {...}` — `expressionName` matches the `const` assignment.
+    // We instrument ONLY `sendBatch`: `send` funnels into it internally, so `producer.send`,
+    // `producer.sendBatch` and their transactional variants all flow through this one channel.
+    // Instrumenting `send` too would double-count spans.
+    functionQuery: { expressionName: "sendBatch", kind: "Async" }
+  },
+  {
+    channelName: "consumer_run",
+    module: { name: "kafkajs", versionRange: ">=2.0.0 <3", filePath: "src/consumer/index.js" },
+    // `const run = async (config) => {...}` — matched by `expressionName`. We don't span `run` itself:
+    // the `start` subscriber swaps `config.eachMessage`/`eachBatch` (on `ctx.arguments[0]`) for
+    // span-creating wrappers before the original runs. This works because the transform re-reads
+    // `ctx.arguments` when invoking the original.
+    functionQuery: { expressionName: "run", kind: "Async" }
+  }
+];
+const kafkajsChannels = {
+  KAFKAJS_SEND_BATCH: "orchestrion:kafkajs:send_batch",
+  KAFKAJS_CONSUMER_RUN: "orchestrion:kafkajs:consumer_run"
+};
+
+export { kafkajsChannels, kafkajsConfig };
+//# sourceMappingURL=kafkajs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafkajs.js","sources":["../../../../src/orchestrion/config/kafkajs.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const kafkajsConfig = [\n  {\n    channelName: 'send_batch',\n    module: { name: 'kafkajs', versionRange: '>=2.0.0 <3', filePath: 'src/producer/messageProducer.js' },\n    // `const sendBatch = async (...) => {...}` — `expressionName` matches the `const` assignment.\n    // We instrument ONLY `sendBatch`: `send` funnels into it internally, so `producer.send`,\n    // `producer.sendBatch` and their transactional variants all flow through this one channel.\n    // Instrumenting `send` too would double-count spans.\n    functionQuery: { expressionName: 'sendBatch', kind: 'Async' },\n  },\n  {\n    channelName: 'consumer_run',\n    module: { name: 'kafkajs', versionRange: '>=2.0.0 <3', filePath: 'src/consumer/index.js' },\n    // `const run = async (config) => {...}` — matched by `expressionName`. We don't span `run` itself:\n    // the `start` subscriber swaps `config.eachMessage`/`eachBatch` (on `ctx.arguments[0]`) for\n    // span-creating wrappers before the original runs. This works because the transform re-reads\n    // `ctx.arguments` when invoking the original.\n    functionQuery: { expressionName: 'run', kind: 'Async' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const kafkajsChannels = {\n  KAFKAJS_SEND_BATCH: 'orchestrion:kafkajs:send_batch',\n  KAFKAJS_CONSUMER_RUN: 'orchestrion:kafkajs:consumer_run',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,aAAA,GAAgB;AAAA,EAC3B;AAAA,IACE,WAAA,EAAa,YAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,iCAAA,EAAkC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKnG,aAAA,EAAe,EAAE,cAAA,EAAgB,WAAA,EAAa,MAAM,OAAA;AAAQ,GAC9D;AAAA,EACA;AAAA,IACE,WAAA,EAAa,cAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,WAAW,YAAA,EAAc,YAAA,EAAc,UAAU,uBAAA,EAAwB;AAAA;AAAA;AAAA;AAAA;AAAA,IAKzF,aAAA,EAAe,EAAE,cAAA,EAAgB,KAAA,EAAO,MAAM,OAAA;AAAQ;AAE1D;AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,kBAAA,EAAoB,gCAAA;AAAA,EACpB,oBAAA,EAAsB;AACxB;;;;"}

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

@@ -0,0 +1,40 @@
+const MODULE_NAME = "knex";
+const RUNNER_FILES = [
+  { filePath: "lib/execution/runner.js", versionRange: ">=0.22.0 <4" },
+  { filePath: "lib/runner.js", versionRange: ">=0.10.0 <0.22.0" },
+  { filePath: "src/runner.js", versionRange: ">=0.18.0 <0.19.0" }
+];
+const CLIENT_FILES = [
+  { filePath: "lib/client.js", versionRange: ">=0.10.0 <4" },
+  { filePath: "src/client.js", versionRange: ">=0.18.0 <0.19.0" }
+];
+const CLIENT_METHODS = ["queryBuilder", "schemaBuilder", "raw"];
+function runnerQuery(filePath, versionRange) {
+  return {
+    channelName: "query",
+    module: { name: MODULE_NAME, versionRange, filePath },
+    functionQuery: { className: "Runner", methodName: "query", kind: "Async" }
+  };
+}
+function clientMethod(methodName, filePath, versionRange) {
+  return {
+    channelName: methodName,
+    module: { name: MODULE_NAME, versionRange, filePath },
+    functionQuery: { className: "Client", methodName, kind: "Sync" }
+  };
+}
+const knexConfig = [
+  ...RUNNER_FILES.map(({ filePath, versionRange }) => runnerQuery(filePath, versionRange)),
+  ...CLIENT_FILES.flatMap(
+    ({ filePath, versionRange }) => CLIENT_METHODS.map((methodName) => clientMethod(methodName, filePath, versionRange))
+  )
+];
+const knexChannels = {
+  KNEX_QUERY: "orchestrion:knex:query",
+  KNEX_QUERY_BUILDER: "orchestrion:knex:queryBuilder",
+  KNEX_SCHEMA_BUILDER: "orchestrion:knex:schemaBuilder",
+  KNEX_RAW: "orchestrion:knex:raw"
+};
+
+export { knexChannels, knexConfig };
+//# sourceMappingURL=knex.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"knex.js","sources":["../../../../src/orchestrion/config/knex.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nconst MODULE_NAME = 'knex';\n\n// knex ships different file layouts across versions (see `SUPPORTED_VERSIONS` in the vendored OTel\n// instrumentation). Modern builds keep the runner under `lib/execution`, older ones under `lib`, and\n// the source-tree build under `src`. A file that doesn't exist for a given version simply never\n// matches, so overlapping ranges are safe.\nconst RUNNER_FILES = [\n  { filePath: 'lib/execution/runner.js', versionRange: '>=0.22.0 <4' },\n  { filePath: 'lib/runner.js', versionRange: '>=0.10.0 <0.22.0' },\n  { filePath: 'src/runner.js', versionRange: '>=0.18.0 <0.19.0' },\n];\n\nconst CLIENT_FILES = [\n  { filePath: 'lib/client.js', versionRange: '>=0.10.0 <4' },\n  { filePath: 'src/client.js', versionRange: '>=0.18.0 <0.19.0' },\n];\n\n// The three `Client` methods that create a builder. Wrapping them lets the subscriber capture the\n// span active at builder-creation time, which is reused as the parent when the query runs later\n// (often in a different async context).\nconst CLIENT_METHODS = ['queryBuilder', 'schemaBuilder', 'raw'] as const;\n\nfunction runnerQuery(filePath: string, versionRange: string): InstrumentationConfig {\n  return {\n    channelName: 'query',\n    module: { name: MODULE_NAME, versionRange, filePath },\n    functionQuery: { className: 'Runner', methodName: 'query', kind: 'Async' },\n  };\n}\n\nfunction clientMethod(methodName: string, filePath: string, versionRange: string): InstrumentationConfig {\n  return {\n    channelName: methodName,\n    module: { name: MODULE_NAME, versionRange, filePath },\n    functionQuery: { className: 'Client', methodName, kind: 'Sync' },\n  };\n}\n\nexport const knexConfig: InstrumentationConfig[] = [\n  ...RUNNER_FILES.map(({ filePath, versionRange }) => runnerQuery(filePath, versionRange)),\n  ...CLIENT_FILES.flatMap(({ filePath, versionRange }) =>\n    CLIENT_METHODS.map(methodName => clientMethod(methodName, filePath, versionRange)),\n  ),\n];\n\nexport const knexChannels = {\n  KNEX_QUERY: 'orchestrion:knex:query',\n  KNEX_QUERY_BUILDER: 'orchestrion:knex:queryBuilder',\n  KNEX_SCHEMA_BUILDER: 'orchestrion:knex:schemaBuilder',\n  KNEX_RAW: 'orchestrion:knex:raw',\n} as const;\n"],"names":[],"mappings":"AAEA,MAAM,WAAA,GAAc,MAAA;AAMpB,MAAM,YAAA,GAAe;AAAA,EACnB,EAAE,QAAA,EAAU,yBAAA,EAA2B,YAAA,EAAc,aAAA,EAAc;AAAA,EACnE,EAAE,QAAA,EAAU,eAAA,EAAiB,YAAA,EAAc,kBAAA,EAAmB;AAAA,EAC9D,EAAE,QAAA,EAAU,eAAA,EAAiB,YAAA,EAAc,kBAAA;AAC7C,CAAA;AAEA,MAAM,YAAA,GAAe;AAAA,EACnB,EAAE,QAAA,EAAU,eAAA,EAAiB,YAAA,EAAc,aAAA,EAAc;AAAA,EACzD,EAAE,QAAA,EAAU,eAAA,EAAiB,YAAA,EAAc,kBAAA;AAC7C,CAAA;AAKA,MAAM,cAAA,GAAiB,CAAC,cAAA,EAAgB,eAAA,EAAiB,KAAK,CAAA;AAE9D,SAAS,WAAA,CAAY,UAAkB,YAAA,EAA6C;AAClF,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,OAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,WAAA,EAAa,cAAc,QAAA,EAAS;AAAA,IACpD,eAAe,EAAE,SAAA,EAAW,UAAU,UAAA,EAAY,OAAA,EAAS,MAAM,OAAA;AAAQ,GAC3E;AACF;AAEA,SAAS,YAAA,CAAa,UAAA,EAAoB,QAAA,EAAkB,YAAA,EAA6C;AACvG,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,UAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,WAAA,EAAa,cAAc,QAAA,EAAS;AAAA,IACpD,eAAe,EAAE,SAAA,EAAW,QAAA,EAAU,UAAA,EAAY,MAAM,MAAA;AAAO,GACjE;AACF;AAEO,MAAM,UAAA,GAAsC;AAAA,EACjD,GAAG,YAAA,CAAa,GAAA,CAAI,CAAC,EAAE,QAAA,EAAU,YAAA,EAAa,KAAM,WAAA,CAAY,QAAA,EAAU,YAAY,CAAC,CAAA;AAAA,EACvF,GAAG,YAAA,CAAa,OAAA;AAAA,IAAQ,CAAC,EAAE,QAAA,EAAU,YAAA,EAAa,KAChD,cAAA,CAAe,GAAA,CAAI,CAAA,UAAA,KAAc,YAAA,CAAa,UAAA,EAAY,QAAA,EAAU,YAAY,CAAC;AAAA;AAErF;AAEO,MAAM,YAAA,GAAe;AAAA,EAC1B,UAAA,EAAY,wBAAA;AAAA,EACZ,kBAAA,EAAoB,+BAAA;AAAA,EACpB,mBAAA,EAAqB,gCAAA;AAAA,EACrB,QAAA,EAAU;AACZ;;;;"}

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

@@ -0,0 +1,13 @@
+const koaConfig = [
+  {
+    channelName: "use",
+    module: { name: "koa", versionRange: ">=2.0.0 <4", filePath: "lib/application.js" },
+    functionQuery: { className: "Application", methodName: "use", kind: "Sync" }
+  }
+];
+const koaChannels = {
+  KOA_USE: "orchestrion:koa:use"
+};
+
+export { koaChannels, koaConfig };
+//# sourceMappingURL=koa.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"koa.js","sources":["../../../../src/orchestrion/config/koa.ts"],"sourcesContent":["import type { InstrumentationConfig } from '@apm-js-collab/code-transformer';\n\nexport const koaConfig = [\n  {\n    channelName: 'use',\n    module: { name: 'koa', versionRange: '>=2.0.0 <4', filePath: 'lib/application.js' },\n    functionQuery: { className: 'Application', methodName: 'use', kind: 'Sync' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const koaChannels = {\n  KOA_USE: 'orchestrion:koa:use',\n} as const;\n"],"names":[],"mappings":"AAEO,MAAM,SAAA,GAAY;AAAA,EACvB;AAAA,IACE,WAAA,EAAa,KAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,OAAO,YAAA,EAAc,YAAA,EAAc,UAAU,oBAAA,EAAqB;AAAA,IAClF,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,KAAA,EAAO,MAAM,MAAA;AAAO;AAE/E;AAEO,MAAM,WAAA,GAAc;AAAA,EACzB,OAAA,EAAS;AACX;;;;"}