@depup/sentry__server-utils 10.75.2-depup.0 → 11.0.0-depup.0

package/build/types/orchestrion/config/openai-compatible.d.ts

@@ -0,0 +1,17 @@
+import type { InstrumentationConfig } from '../apmTypes';
+/**
+ * Many providers (Groq, Together, ...) ship a Stainless-generated SDK that mirrors the classic `openai`
+ * file layout: `resources/chat/completions.{js,mjs}` (class `Completions`) and
+ * `resources/embeddings.{js,mjs}` (class `Embeddings`), each with a `create(body, options)` that returns
+ * a thenable `APIPromise` — so `kind: 'Auto'` resolves to `wrapPromise`, and a streaming call resolves to
+ * the same OpenAI-style async-iterable `Stream` the openai integration already knows how to consume. These
+ * SDKs ship dual CJS/ESM and the matcher compares `filePath` exactly, hence one entry per built file.
+ *
+ * Because the wire format is OpenAI-compatible, the span building, streaming and response parsing are all
+ * reused from `ai/openai`; only the module name, channels and `gen_ai.provider.name` differ per provider.
+ */
+export declare function openAiCompatibleConfig(module: {
+    name: string;
+    versionRange: string;
+}): InstrumentationConfig[];
+//# sourceMappingURL=openai-compatible.d.ts.map

package/build/types/orchestrion/config/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/openai-compatible.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,qBAAqB,EAAE,CAa9G"}

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

@@ -1,4 +1,3 @@
-import type { InstrumentationConfig } from '..';
 export declare const openaiConfig: {
     channelName: string;
     module: {
@@ -9,12 +8,12 @@ export declare const openaiConfig: {
     functionQuery: {
         className: string;
         methodName: string;
-        kind: "Auto";
+        kind: 'Auto';
     };
 }[];
+export declare const openaiModuleNames: string[];
 export declare const openaiChannels: {
-    readonly OPENAI_CHAT: "orchestrion:openai:chat";
-    readonly OPENAI_EMBEDDINGS: "orchestrion:openai:embeddings";
+    readonly OPENAI_CHAT: 'orchestrion:openai:chat';
+    readonly OPENAI_EMBEDDINGS: 'orchestrion:openai:embeddings';
 };
-export declare const openaiSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=openai.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/openai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,YAAY;;;;;;;;;;;;GA2BU,CAAC;AAEpC,eAAO,MAAM,cAAc;;;CAKjB,CAAC;AAEX,eAAO,MAAM,wBAAwB,yBAAsC,CAAC"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/openai.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;QAOJ,SAAS;QAAiB,UAAU;QAAY,IAAI,EAAE,MAAM;;GAoB9C,CAAC;AAEpC,eAAO,MAAM,iBAAiB,UAA+B,CAAC;AAE9D,eAAO,MAAM,cAAc;aAGzB,WAAW,EAAE,yBAAyB;aACtC,iBAAiB,EAAE,+BAA+B;CAC1C,CAAC"}

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

@@ -1,4 +1,3 @@
-import type { InstrumentationConfig } from '..';
 export declare const pgConfig: ({
     channelName: string;
     module: {
@@ -20,16 +19,16 @@ export declare const pgConfig: ({
         filePath: string;
     };
     functionQuery: {
-        expressionName: string;
-        kind: "Auto";
         className?: undefined;
         methodName?: undefined;
+        expressionName: string;
+        kind: "Auto";
     };
 })[];
+export declare const pgModuleNames: string[];
 export declare const pgChannels: {
-    readonly PG_QUERY: "orchestrion:pg:query";
-    readonly PG_CONNECT: "orchestrion:pg:connect";
-    readonly PGPOOL_CONNECT: "orchestrion:pg-pool:connect";
+    readonly PG_QUERY: 'orchestrion:pg:query';
+    readonly PG_CONNECT: 'orchestrion:pg:connect';
+    readonly PGPOOL_CONNECT: 'orchestrion:pg-pool:connect';
 };
-export declare const pgSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=pg.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/pg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;IAuCc,CAAC;AAEpC,eAAO,MAAM,UAAU;;;;CAIb,CAAC;AAEX,eAAO,MAAM,oBAAoB,yBAAkC,CAAC"}
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/pg.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ;;;QAUP,IAAI;QAAQ,YAAY;QAAgB,QAAQ;;;;;;;;;;;QAehD,IAAI;QAAQ,YAAY;QAAgB,QAAQ;;;;;;;;IAc3B,CAAC;AAEpC,eAAO,MAAM,aAAa,UAA2B,CAAC;AAEtD,eAAO,MAAM,UAAU;aACrB,QAAQ,EAAE,sBAAsB;aAChC,UAAU,EAAE,wBAAwB;aACpC,cAAc,EAAE,6BAA6B;CACrC,CAAC"}

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

@@ -1,10 +1,10 @@
-import type { InstrumentationConfig } from '..';
+import type { InstrumentationConfig } from '../apmTypes';
 export declare const postgresJsConfig: InstrumentationConfig[];
+export declare const postgresJsModuleNames: string[];
 export declare const postgresJsChannels: {
-    readonly POSTGRESJS_HANDLE: "orchestrion:postgres:handle";
-    readonly POSTGRESJS_CONNECTION: "orchestrion:postgres:connection";
-    readonly POSTGRESJS_EXECUTE: "orchestrion:postgres:execute";
-    readonly POSTGRESJS_CONNECT: "orchestrion:postgres:connect";
+    readonly POSTGRESJS_HANDLE: 'orchestrion:postgres:handle';
+    readonly POSTGRESJS_CONNECTION: 'orchestrion:postgres:connection';
+    readonly POSTGRESJS_EXECUTE: 'orchestrion:postgres:execute';
+    readonly POSTGRESJS_CONNECT: 'orchestrion:postgres:connect';
 };
-export declare const postgresJsSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=postgres.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAgDhD,eAAO,MAAM,gBAAgB,yBAA8D,CAAC;AAE5F,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AAEX,eAAO,MAAM,4BAA4B,yBAA0C,CAAC"}
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAiDzD,eAAO,MAAM,gBAAgB,yBAA8D,CAAC;AAE5F,eAAO,MAAM,qBAAqB,UAAmC,CAAC;AAEtE,eAAO,MAAM,kBAAkB;aAC7B,iBAAiB,EAAE,6BAA6B;aAChD,qBAAqB,EAAE,iCAAiC;aACxD,kBAAkB,EAAE,8BAA8B;aAClD,kBAAkB,EAAE,8BAA8B;CAC1C,CAAC"}

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

@@ -1,39 +1,13 @@
-import type { InstrumentationConfig } from '..';
-export declare const redisConfig: ({
-    channelName: string;
-    module: {
-        name: string;
-        versionRange: string;
-        filePath: string;
-    };
-    functionQuery: {
-        expressionName: string;
-        kind: "Sync";
-        className?: undefined;
-        methodName?: undefined;
-    };
-} | {
-    channelName: string;
-    module: {
-        name: string;
-        versionRange: string;
-        filePath: string;
-    };
-    functionQuery: {
-        className: string;
-        methodName: string;
-        kind: "Async";
-        expressionName?: undefined;
-    };
-})[];
+import type { InstrumentationConfig } from '../apmTypes';
+export declare const redisConfig: InstrumentationConfig[];
+export declare const redisModuleNames: string[];
 export declare const redisChannels: {
-    readonly REDIS_COMMAND: "orchestrion:redis:command";
-    readonly NODE_REDIS_COMMAND: "orchestrion:@redis/client:command";
-    readonly NODE_REDIS_EXECUTOR: "orchestrion:@redis/client:executor";
-    readonly NODE_REDIS_CONNECT: "orchestrion:@redis/client:connect";
-    readonly NODE_REDIS_MULTI: "orchestrion:@redis/client:multi";
-    readonly NODE_REDIS_PIPELINE: "orchestrion:@redis/client:pipeline";
-    readonly NODE_REDIS_BATCH: "orchestrion:@redis/client:batch";
+    readonly REDIS_COMMAND: 'orchestrion:redis:command';
+    readonly NODE_REDIS_COMMAND: 'orchestrion:@redis/client:command';
+    readonly NODE_REDIS_EXECUTOR: 'orchestrion:@redis/client:executor';
+    readonly NODE_REDIS_CONNECT: 'orchestrion:@redis/client:connect';
+    readonly NODE_REDIS_MULTI: 'orchestrion:@redis/client:multi';
+    readonly NODE_REDIS_PIPELINE: 'orchestrion:@redis/client:pipeline';
+    readonly NODE_REDIS_BATCH: 'orchestrion:@redis/client:batch';
 };
-export declare const redisSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=redis.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DW,CAAC;AAEpC,eAAO,MAAM,aAAa;;;;;;;;CAQhB,CAAC;AAEX,eAAO,MAAM,uBAAuB,yBAAqC,CAAC"}
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAKzD,eAAO,MAAM,WAAW,yBA6DW,CAAC;AAEpC,eAAO,MAAM,gBAAgB,UAA8B,CAAC;AAE5D,eAAO,MAAM,aAAa;aACxB,aAAa,EAAE,2BAA2B;aAC1C,kBAAkB,EAAE,mCAAmC;aACvD,mBAAmB,EAAE,oCAAoC;aACzD,kBAAkB,EAAE,mCAAmC;aACvD,gBAAgB,EAAE,iCAAiC;aACnD,mBAAmB,EAAE,oCAAoC;aACzD,gBAAgB,EAAE,iCAAiC;CAC3C,CAAC"}

package/build/types/orchestrion/config/registration-only.d.ts

@@ -0,0 +1,22 @@
+import type { InstrumentationConfig } from '../apmTypes';
+/**
+ * Name of the custom transform (see `bundler/moduleInjectedTransform.ts`) that
+ * splices only the module-injected registration snippet — no channel machinery.
+ * Prefixed so it can never shadow a built-in operator (`traceSync`,
+ * `tracingChannelImport`, ...), which the custom-transforms map overrides by
+ * name.
+ */
+export declare const MODULE_REGISTRATION_TRANSFORM = "sentryModuleRegistration";
+/**
+ * Build a registration-only config for one file of a library whose tracing
+ * channels are native (published by the library itself): no channels are
+ * injected, but transforming the file registers the module's channel-subscriber
+ * integration at evaluation time. `astQuery: 'Program'` matches the file root
+ * unconditionally, so no anchor function inside the library needs to exist.
+ */
+export declare function registrationOnly(module: {
+    name: string;
+    versionRange: string;
+    filePath: string;
+}): InstrumentationConfig;
+//# sourceMappingURL=registration-only.d.ts.map

package/build/types/orchestrion/config/registration-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration-only.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/registration-only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB,CAOxB"}

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

@@ -1,10 +1,9 @@
-import type { InstrumentationConfig } from '..';
+import type { InstrumentationConfig } from '../apmTypes';
 export declare const remixConfig: InstrumentationConfig[];
 export declare const remixChannels: {
-    readonly REMIX_REQUEST_HANDLER: "orchestrion:@remix-run/server-runtime:requestHandler";
-    readonly REMIX_MATCH_SERVER_ROUTES: "orchestrion:@remix-run/server-runtime:matchServerRoutes";
-    readonly REMIX_CALL_ROUTE_LOADER: "orchestrion:@remix-run/server-runtime:callRouteLoader";
-    readonly REMIX_CALL_ROUTE_ACTION: "orchestrion:@remix-run/server-runtime:callRouteAction";
+    readonly REMIX_REQUEST_HANDLER: 'orchestrion:@remix-run/server-runtime:requestHandler';
+    readonly REMIX_MATCH_SERVER_ROUTES: 'orchestrion:@remix-run/server-runtime:matchServerRoutes';
+    readonly REMIX_CALL_ROUTE_LOADER: 'orchestrion:@remix-run/server-runtime:callRouteLoader';
+    readonly REMIX_CALL_ROUTE_ACTION: 'orchestrion:@remix-run/server-runtime:callRouteAction';
 };
-export declare const remixSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=remix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"remix.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/remix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAoDhD,eAAO,MAAM,WAAW,yBAA2D,CAAC;AAEpF,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC;AAEX,eAAO,MAAM,uBAAuB,yBAAqC,CAAC"}
+{"version":3,"file":"remix.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/remix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAmDzD,eAAO,MAAM,WAAW,yBAA2D,CAAC;AAEpF,eAAO,MAAM,aAAa;aACxB,qBAAqB,EAAE,sDAAsD;aAC7E,yBAAyB,EAAE,yDAAyD;aACpF,uBAAuB,EAAE,uDAAuD;aAChF,uBAAuB,EAAE,uDAAuD;CACxE,CAAC"}

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

@@ -1,13 +1,13 @@
-import type { InstrumentationConfig } from '..';
+import type { InstrumentationConfig } from '../apmTypes';
 export declare const tediousConfig: InstrumentationConfig[];
+export declare const tediousModuleNames: string[];
 export declare const tediousChannels: {
-    readonly TEDIOUS_CONNECT: "orchestrion:tedious:connect";
-    readonly TEDIOUS_EXEC_SQL: "orchestrion:tedious:execSql";
-    readonly TEDIOUS_EXEC_SQL_BATCH: "orchestrion:tedious:execSqlBatch";
-    readonly TEDIOUS_CALL_PROCEDURE: "orchestrion:tedious:callProcedure";
-    readonly TEDIOUS_EXEC_BULK_LOAD: "orchestrion:tedious:execBulkLoad";
-    readonly TEDIOUS_PREPARE: "orchestrion:tedious:prepare";
-    readonly TEDIOUS_EXECUTE: "orchestrion:tedious:execute";
+    readonly TEDIOUS_CONNECT: 'orchestrion:tedious:connect';
+    readonly TEDIOUS_EXEC_SQL: 'orchestrion:tedious:execSql';
+    readonly TEDIOUS_EXEC_SQL_BATCH: 'orchestrion:tedious:execSqlBatch';
+    readonly TEDIOUS_CALL_PROCEDURE: 'orchestrion:tedious:callProcedure';
+    readonly TEDIOUS_EXEC_BULK_LOAD: 'orchestrion:tedious:execBulkLoad';
+    readonly TEDIOUS_PREPARE: 'orchestrion:tedious:prepare';
+    readonly TEDIOUS_EXECUTE: 'orchestrion:tedious:execute';
 };
-export declare const tediousSubscribeInjection: InstrumentationConfig[];
 //# sourceMappingURL=tedious.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/tedious.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAiBhD,eAAO,MAAM,aAAa,EAAE,qBAAqB,EAI9C,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;CAQlB,CAAC;AAEX,eAAO,MAAM,yBAAyB,yBAAuC,CAAC"}
+{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/tedious.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAkBzD,eAAO,MAAM,aAAa,EAAE,qBAAqB,EAI9C,CAAC;AAEJ,eAAO,MAAM,kBAAkB,UAAgC,CAAC;AAEhE,eAAO,MAAM,eAAe;aAC1B,eAAe,EAAE,6BAA6B;aAC9C,gBAAgB,EAAE,6BAA6B;aAC/C,sBAAsB,EAAE,kCAAkC;aAC1D,sBAAsB,EAAE,mCAAmC;aAC3D,sBAAsB,EAAE,kCAAkC;aAC1D,eAAe,EAAE,6BAA6B;aAC9C,eAAe,EAAE,6BAA6B;CACtC,CAAC"}

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

@@ -0,0 +1,8 @@
+import type { InstrumentationConfig } from '../apmTypes';
+export declare const togetherAiConfig: InstrumentationConfig[];
+export declare const togetherAiModuleNames: string[];
+export declare const togetherAiChannels: {
+    readonly TOGETHER_CHAT: 'orchestrion:together-ai:chat';
+    readonly TOGETHER_EMBEDDINGS: 'orchestrion:together-ai:embeddings';
+};
+//# sourceMappingURL=together-ai.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"together-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/together-ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAMzD,eAAO,MAAM,gBAAgB,yBAGO,CAAC;AAErC,eAAO,MAAM,qBAAqB,UAAmC,CAAC;AAEtE,eAAO,MAAM,kBAAkB;aAC7B,aAAa,EAAE,8BAA8B;aAC7C,mBAAmB,EAAE,oCAAoC;CACjD,CAAC"}

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

@@ -1,13 +1,13 @@
-import type { InstrumentationConfig } from '..';
+import type { InstrumentationConfig } from '../apmTypes';
 export declare const vercelAiConfig: InstrumentationConfig[];
 export declare const vercelAiChannels: {
-    readonly VERCEL_AI_GENERATE_TEXT: "orchestrion:ai:generateText";
-    readonly VERCEL_AI_STREAM_TEXT: "orchestrion:ai:streamText";
-    readonly VERCEL_AI_GENERATE_OBJECT: "orchestrion:ai:generateObject";
-    readonly VERCEL_AI_EMBED: "orchestrion:ai:embed";
-    readonly VERCEL_AI_EMBED_MANY: "orchestrion:ai:embedMany";
-    readonly VERCEL_AI_EXECUTE_TOOL_CALL: "orchestrion:ai:executeToolCall";
-    readonly VERCEL_AI_RESOLVE_LANGUAGE_MODEL: "orchestrion:ai:resolveLanguageModel";
+    readonly VERCEL_AI_GENERATE_TEXT: 'orchestrion:ai:generateText';
+    readonly VERCEL_AI_STREAM_TEXT: 'orchestrion:ai:streamText';
+    readonly VERCEL_AI_GENERATE_OBJECT: 'orchestrion:ai:generateObject';
+    readonly VERCEL_AI_EMBED: 'orchestrion:ai:embed';
+    readonly VERCEL_AI_EMBED_MANY: 'orchestrion:ai:embedMany';
+    readonly VERCEL_AI_EXECUTE_TOOL_CALL: 'orchestrion:ai:executeToolCall';
+    readonly VERCEL_AI_RESOLVE_LANGUAGE_MODEL: 'orchestrion:ai:resolveLanguageModel';
 };
-export declare const vercelAiSubscribeInjection: InstrumentationConfig[];
+export declare const vercelAiModuleNames: string[];
 //# sourceMappingURL=vercel-ai.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,IAAI,CAAC;AAGhD,eAAO,MAAM,cAAc,yBAsBQ,CAAC;AAEpC,eAAO,MAAM,gBAAgB;;;;;;;;CAcnB,CAAC;AA+BX,eAAO,MAAM,0BAA0B,yBAAwC,CAAC"}
+{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAKzD,eAAO,MAAM,cAAc,yBAyBQ,CAAC;AAEpC,eAAO,MAAM,gBAAgB;aAO3B,uBAAuB,EAAE,6BAA6B;aACtD,qBAAqB,EAAE,2BAA2B;aAClD,yBAAyB,EAAE,+BAA+B;aAC1D,eAAe,EAAE,sBAAsB;aACvC,oBAAoB,EAAE,0BAA0B;aAChD,2BAA2B,EAAE,gCAAgC;aAC7D,gCAAgC,EAAE,qCAAqC;CAC/D,CAAC;AA+BX,eAAO,MAAM,mBAAmB,UAAiC,CAAC"}

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

@@ -1,19 +1,22 @@
 /**
- * Whether orchestrion has injected the diagnostics channels into this process,
- * either by the runtime `--import` hook / init-time registration (`runtime`)
- * or a bundler plugin (`bundler`). Both injectors set a flag on the
- * `globalThis.__SENTRY_ORCHESTRION__` marker.
+ * The module names (e.g. `mysql`, `@hapi/hapi`) orchestrion has already injected
+ * into this process — from the runtime `--import` hook (`runtime`) and/or the
+ * snippets a bundler transform spliced into each transformed module (`bundler`).
+ * Channel-based integrations use it to decide whether to subscribe now (their
+ * module is already loaded) or wait for the module-injected event.
  *
- * Use this to avoid wiring up channel-subscriber integrations when nothing
- * will ever publish to those channels.
+ * The `instanceof Set` guard is runtime safety, not typing: a banner from
+ * another SDK copy or version may have written a non-Set flag here.
  */
-export declare function isOrchestrionInjected(): boolean;
+export declare function getOrchestrionInjectedModules(): string[];
 /**
  * Verifies that the diagnostics channels have been injected either by the
  * runtime `--import` hook (or init-time registration), a bundler plugin, or
  * both, and warns if not. When at least one injector is active, logs for each
- * mechanism whether it hooked (a defined array, even empty, means it did) and
- * which libraries it injected.
+ * mechanism whether it hooked (a defined list, even empty, means it did) and
+ * which libraries it injected. For the bundler path, the entry banner ensures
+ * an empty `Set` at boot; module names arrive as each transformed module is
+ * evaluated, so an empty set can also just mean none has loaded yet.
  *
  * Both injectors being active at once is fine: they operate on disjoint module
  * sets (a module is either loaded through Node's loader and transformed by the

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

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/detect.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAsB7C"}
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/detect.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,EAAE,CAGxD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAwB7C"}

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

@@ -0,0 +1,37 @@
+import type { Client } from '@sentry/core';
+declare const INSTRUMENTED: unique symbol;
+type InstrumentationFn = ((...args: any[]) => void) & {
+    [INSTRUMENTED]?: boolean;
+};
+/**
+ * Run an integration's channel-subscription callback once one of its modules is
+ * orchestrion-injected, and never more than once.
+ *
+ * Channel integrations must NOT subscribe eagerly at `Sentry.init()`: Node caps
+ * the number of `diagnostics_channel` channels in use at 1024, and every default
+ * channel integration binding several channels up front would burn that budget
+ * for modules the app never loads. So we defer:
+ *
+ * - If a module is already injected, then a bundler transformed and loaded it
+ *   (which records it via `orchestrionModuleInjected`), or the runtime hook
+ *   injected it before `init()`, so subscribe right away.
+ * - Otherwise wait for the `orchestrion.module-injected` event, which fires
+ *   when the module is loaded and transformed, before it can publish to its
+ *   channels.
+ *
+ * Bun and Deno have no such channel limit and no reliable per-module injection
+ * tracking, so there we just subscribe immediately.
+ *
+ * `waitForTracingChannelBinding` still wraps the callback: the async-context
+ * binding the subscription needs for span parenting may not exist yet.
+ *
+ * Note: it is possible to register extra event listeners, if the same callback
+ * is registered multiple times. However, this is (a) not something that happens
+ * normally, and (b) ultimately fine, because it'll only call the callback one
+ * time. There'll just be a few no-op client event listeners.
+ */
+export declare function invokeOrchestrionInstrumentation<Callback extends InstrumentationFn>(client: Client, moduleNames: readonly string[], callback: Callback, args: Parameters<Callback>, { requiresTracingChannelBinding }?: {
+    requiresTracingChannelBinding?: boolean;
+}): void;
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/instrumentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAQ3C,QAAA,MAAM,YAAY,eAA8C,CAAC;AAIjE,KAAK,iBAAiB,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC,GAAG;IAAE,CAAC,YAAY,CAAC,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAMnF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,SAAS,iBAAiB,EACjF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,EAK1B,EAAE,6BAAoC,EAAE,GAAE;IAAE,6BAA6B,CAAC,EAAE,OAAO,CAAA;CAAO,GACzF,IAAI,CAuEN"}

package/build/types/tracing-channel.d.ts

@@ -62,6 +62,8 @@ export interface TracingChannelBindingHandle<TData extends object = object> {
      */
     unbind: () => void;
 }
+/** Runs a span-building callback so a throw inside it can never break the user's traced call. */
+export declare function safeChannelCallback<T>(fn: () => T): T | undefined;
 /**
  * Bind a span and its lifecycle to a tracing channel so the span becomes the active async context
  * for the traced operation and is ended when the operation completes.
@@ -72,4 +74,12 @@ export interface TracingChannelBindingHandle<TData extends object = object> {
  * loop's per-step events, where ending a freshly opened span would close the parent prematurely.
  */
 export declare function bindTracingChannelToSpan<TData extends object>(channel: TracingChannel<TData, TData>, getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined, opts?: TracingChannelLifeCycleOptions<TData>): TracingChannelBindingHandle<TData>;
+/**
+ * Bind a span into the channel's async context so it becomes active for the traced operation,
+ * without managing its lifecycle. The primitive behind {@link bindTracingChannelToSpan}, which
+ * layers span-ending and error handling on top.
+ *
+ * `getSpan` may return `undefined` to leave the active context untouched for that payload.
+ */
+export declare function bindSpanToChannelStore<TData extends object>(channel: TracingChannel<TData, TData>, getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined, opts?: Pick<TracingChannelLifeCycleOptions, 'requiresParentSpan'>): TracingChannelBindingHandle<TData>;
 //# sourceMappingURL=tracing-channel.d.ts.map

package/build/types/tracing-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracing-channel.d.ts","sourceRoot":"","sources":["../../src/tracing-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAE1F,OAAO,KAAK,EAAE,kCAAkC,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAa7E,MAAM,MAAM,6BAA6B,CAAC,KAAK,SAAS,MAAM,IAAI,KAAK,GAAG;IACxE;;OAEG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC;IAEnB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAKF,MAAM,WAAW,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,IAAI,CAC/E,cAAc,CAAC,KAAK,EAAE,6BAA6B,CAAC,KAAK,CAAC,CAAC,EAC3D,WAAW,GAAG,aAAa,CAC5B;IACC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,yBAAyB,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACvG,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,yBAAyB,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC1G;AAED,MAAM,WAAW,8BAA8B,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IAC3E;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAEjF;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,kCAAkC,CAAC,CAAC;IAE9E;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QACpB,IAAI,EAAE,IAAI,CAAC;QACX,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,CAAC;QAC3C,8GAA8G;QAC9G,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;KAChC,KAAK,OAAO,CAAC;IAEd;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,8FAA8F;AAC9F,MAAM,WAAW,2BAA2B,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACxE;;OAEG;IACH,OAAO,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAErC;;;OAGG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAID;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,MAAM,EAC3D,OAAO,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACrC,OAAO,EAAE,CAAC,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,SAAS,EACzE,IAAI,CAAC,EAAE,8BAA8B,CAAC,KAAK,CAAC,GAC3C,2BAA2B,CAAC,KAAK,CAAC,CA6FpC"}
+{"version":3,"file":"tracing-channel.d.ts","sourceRoot":"","sources":["../../src/tracing-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAE1F,OAAO,KAAK,EAAE,kCAAkC,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAgB7E,MAAM,MAAM,6BAA6B,CAAC,KAAK,SAAS,MAAM,IAAI,KAAK,GAAG;IACxE;;OAEG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC;IAEnB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAKF,MAAM,WAAW,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,IAAI,CAC/E,cAAc,CAAC,KAAK,EAAE,6BAA6B,CAAC,KAAK,CAAC,CAAC,EAC3D,WAAW,GAAG,aAAa,CAC5B;IACC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,yBAAyB,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACvG,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,yBAAyB,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC1G;AAED,MAAM,WAAW,8BAA8B,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IAC3E;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAEjF;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,kCAAkC,CAAC,CAAC;IAE9E;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QACpB,IAAI,EAAE,IAAI,CAAC;QACX,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,CAAC;QAC3C,8GAA8G;QAC9G,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;KAChC,KAAK,OAAO,CAAC;IAEd;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,8FAA8F;AAC9F,MAAM,WAAW,2BAA2B,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACxE;;OAEG;IACH,OAAO,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAErC;;;OAGG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAID,iGAAiG;AACjG,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAOjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,MAAM,EAC3D,OAAO,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACrC,OAAO,EAAE,CAAC,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,SAAS,EACzE,IAAI,CAAC,EAAE,8BAA8B,CAAC,KAAK,CAAC,GAC3C,2BAA2B,CAAC,KAAK,CAAC,CA6FpC;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,SAAS,MAAM,EACzD,OAAO,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACrC,OAAO,EAAE,CAAC,IAAI,EAAE,6BAA6B,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,SAAS,EACzE,IAAI,CAAC,EAAE,IAAI,CAAC,8BAA8B,EAAE,oBAAoB,CAAC,GAChE,2BAA2B,CAAC,KAAK,CAAC,CAsDpC"}

package/build/types/utils/moduleInjected.d.ts

@@ -0,0 +1,30 @@
+import type { Integration } from '@sentry/core';
+/**
+ * Record a bundler-injected module and notify channel integrations. This is the
+ * runtime target of the snippet the `tracingChannelImport` override splices
+ * into every instrumented module (see
+ * `orchestrion/bundler/moduleInjectedTransform.ts`), so it runs when that module
+ * is first evaluated — the moment its diagnostics channels can start publishing.
+ *
+ * Lives on the main `@sentry/server-utils` entry, not the orchestrion one: it is
+ * a plain runtime helper (reads the global marker, emits a client event) with no
+ * dependency on the orchestrion bundler/config code, and the injected snippet
+ * imports it from the same entry as the subscriber factories.
+ *
+ * It records the module name on the global orchestrion marker, stores the
+ * module's channel-subscriber integration factory (when the module has one)
+ * keyed by module name, and emits the `orchestrion.module-injected` client
+ * event. Recording happens BEFORE the emit so listeners triggered by the event
+ * can read the marker.
+ *
+ * Deliberately record-and-emit only — no `addIntegration` here. Whether an
+ * integration is *installed* is each SDK's policy: `@sentry/node` registers its
+ * channel integrations statically and only needs the event to trigger their
+ * lazy subscription (so a user who removed one from `integrations` stays opted
+ * out), while a bundler-only SDK like `@sentry/cloudflare` instantiates the
+ * stored factories at `init()` and listens for this event to pick up modules
+ * that evaluate later (e.g. a lazily-required driver after a per-request
+ * `init()` already snapshotted the marker).
+ */
+export declare function orchestrionModuleInjected(moduleName: string, integrationFn?: () => Integration): void;
+//# sourceMappingURL=moduleInjected.d.ts.map

package/build/types/utils/moduleInjected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleInjected.d.ts","sourceRoot":"","sources":["../../../src/utils/moduleInjected.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAcrG"}

package/build/types/utils/setHttpServerSpanRouteAttribute.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Set the `http.route` attribute on the root HTTP server span for the current trace.
+ *
+ * No-op when there is no active span, no root span, or the root span is not an
+ * `http.server` span — so framework instrumentations can call this unconditionally
+ * without risking attribute pollution on non-HTTP root spans.
+ */
+export declare function setHttpServerSpanRouteAttribute(route: string): void;
+//# sourceMappingURL=setHttpServerSpanRouteAttribute.d.ts.map

package/build/types/utils/setHttpServerSpanRouteAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setHttpServerSpanRouteAttribute.d.ts","sourceRoot":"","sources":["../../../src/utils/setHttpServerSpanRouteAttribute.ts"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAoBnE"}

package/build/types/utils/sql.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Derives a low-cardinality summary from a SQL query for use as `db.query.summary`.
+ *
+ * Conforms to the OTEL semantic convention for generating query summaries:
+ * - Preserves original case of operations and identifiers (no normalization)
+ * - Uses format: `{operation} {target1} {target2} ...`
+ * - Strips filler words (INTO, FROM) from the operation
+ * - Captures multiple table targets (JOINs)
+ * - Handles INSERT...SELECT with both targets
+ * - Truncates to 255 characters without splitting mid-value
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/database/database-spans/#generating-a-summary-of-the-query
+ */
+export declare function getSqlQuerySummary(query: string | undefined): string | undefined;
+/**
+ * SQL dialect variants that matter for finding the end of a string literal:
+ * - `standard` (PostgreSQL, SQLite): `"` quotes identifiers, `''` is the only in-string escape,
+ *   and PostgreSQL's `$$…$$` dollar quoting opens a literal.
+ * - `mysql`: `"` quotes a string literal unless `ANSI_QUOTES` is set, and `\` escapes the next
+ *   character unless `NO_BACKSLASH_ESCAPES` is set. Both default to off, and mysql/mysql2 escape
+ *   inlined values with backslashes, so this is the mode their statements arrive in.
+ * - `mssql`: `[...]` quotes an identifier, so a `'` inside one is part of the name. `"` quotes
+ *   one too, unless the connection sets `QUOTED_IDENTIFIER OFF`, which tedious leaves on.
+ */
+export type SqlDialect = 'standard' | 'mysql' | 'mssql';
+/**
+ * Maps a driver or `db.system.name` value to the dialect its statements are written in. Callers
+ * report different spellings for one engine: knex uses the driver name, Prisma the provider name,
+ * and OTel the semantic-convention name. An engine we do not know about is lexed as `standard`.
+ */
+export declare function toSqlDialect(system: unknown): SqlDialect;
+/**
+ * Sanitize SQL query as per the OTEL semantic conventions
+ * https://opentelemetry.io/docs/specs/semconv/database/database-spans/#sanitization-of-dbquerytext
+ *
+ * Parameter placeholders survive: PostgreSQL `$n`, SQLite `?n`, and named forms like `:name` and
+ * `@name`. Per the OTEL spec they mark a parameterized query, so only values (strings, numbers,
+ * booleans) are sanitized.
+ *
+ * Pass `dialect` when the statement comes from a driver whose literals are not standard-quoted;
+ * see {@link SqlDialect}.
+ */
+export declare function sanitizeSqlQuery(sqlQuery: string | undefined, dialect?: SqlDialect): string;
+/**
+ * Sanitizes a collected SQL statement and derives the matching `db.query.summary`, the pair the SQL
+ * integrations attach to their spans. Both come back `undefined` when there is no statement, so an
+ * empty query omits the attributes instead of reporting the sanitizer's fallback text.
+ */
+export declare function sanitizeSqlQueryWithSummary(sqlQuery: string | undefined, dialect?: SqlDialect): {
+    queryText: string | undefined;
+    querySummary: string | undefined;
+};
+//# sourceMappingURL=sql.d.ts.map

package/build/types/utils/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../../src/utils/sql.ts"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAmDhF;AAsED;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAQxD;AAkJD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,UAAuB,GAAG,MAAM,CA0BvG;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,CAAC,EAAE,UAAU,GACnB;IAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAGrE"}

package/changes.json

@@ -1,10 +1,10 @@
 {
   "bumped": {
     "@sentry/conventions": {
-      "from": "^0.16.0",
-      "to": "^0.23.0"
+      "from": "^0.23.0",
+      "to": "^0.24.0"
     }
   },
-  "timestamp": "2026-09-22T16:11:39.007Z",
+  "timestamp": "2026-09-23T16:11:07.737Z",
   "totalUpdated": 1
 }