@depup/sentry__server-utils 10.67.0-depup.0

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

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

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

@@ -0,0 +1,136 @@
+import { amqplibChannelIntegration } from '../integrations/tracing-channel/amqplib';
+import { anthropicChannelIntegration } from '../integrations/tracing-channel/anthropic';
+import { awsChannelIntegration } from '../integrations/tracing-channel/aws-sdk';
+import { dataloaderChannelIntegration } from '../integrations/tracing-channel/dataloader';
+import { genericPoolChannelIntegration } from '../integrations/tracing-channel/generic-pool';
+import { googleGenAIChannelIntegration } from '../integrations/tracing-channel/google-genai';
+import { graphqlChannelIntegration } from '../integrations/tracing-channel/graphql';
+import { hapiChannelIntegration } from '../integrations/tracing-channel/hapi';
+import { koaChannelIntegration } from '../integrations/tracing-channel/koa';
+import { ioredisChannelIntegration } from '../integrations/tracing-channel/ioredis';
+import { kafkajsChannelIntegration } from '../integrations/tracing-channel/kafkajs';
+import { knexChannelIntegration } from '../integrations/tracing-channel/knex';
+import { langChainChannelIntegration } from '../integrations/tracing-channel/langchain';
+import { langGraphChannelIntegration } from '../integrations/tracing-channel/langgraph';
+import { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';
+import { mongodbChannelIntegration } from '../integrations/tracing-channel/mongodb';
+import { mongooseChannelIntegration } from '../integrations/tracing-channel/mongoose';
+import { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';
+import { mysql2ChannelIntegration } from '../integrations/tracing-channel/mysql2';
+import { openaiChannelIntegration } from '../integrations/tracing-channel/openai';
+import { postgresChannelIntegration } from '../integrations/tracing-channel/postgres';
+import { postgresJsChannelIntegration } from '../integrations/tracing-channel/postgres-js';
+import { tediousChannelIntegration } from '../integrations/tracing-channel/tedious';
+import { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai';
+import { expressChannelIntegration } from '../integrations/tracing-channel/express';
+export { detectOrchestrionSetup, isOrchestrionInjected } from './detect';
+export { nestjsChannels } from './config/nestjs';
+export { remixChannels } from './config/remix';
+export { amqplibChannelIntegration, anthropicChannelIntegration, awsChannelIntegration, dataloaderChannelIntegration, genericPoolChannelIntegration, googleGenAIChannelIntegration, graphqlChannelIntegration, hapiChannelIntegration, koaChannelIntegration, ioredisChannelIntegration, kafkajsChannelIntegration, knexChannelIntegration, langChainChannelIntegration, langGraphChannelIntegration, lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysqlChannelIntegration, mysql2ChannelIntegration, openaiChannelIntegration, postgresChannelIntegration, postgresJsChannelIntegration, tediousChannelIntegration, vercelAiChannelIntegration, expressChannelIntegration, };
+export type { KoaChannelIntegrationOptions } from '../integrations/tracing-channel/koa';
+export type { IORedisChannelIntegrationOptions, IORedisResponseHook } from '../integrations/tracing-channel/ioredis';
+export type { PostgresJsChannelIntegrationOptions } from '../integrations/tracing-channel/postgres-js';
+export { redisChannelIntegration } from '../integrations/tracing-channel/redis';
+export type { RedisChannelIntegrationOptions, RedisResponseHook } from '../integrations/tracing-channel/redis';
+export type { InstrumentationConfig, CustomTransform } from '@apm-js-collab/code-transformer-bundler-plugins/core';
+export type * from '../integrations/tracing-channel/graphql/graphql-types';
+/**
+ * The canonical set of orchestrion diagnostics-channel integrations, keyed by their public
+ * (OTel-parity) factory name.
+ *
+ * Single source of truth: add a new channel integration here and every consumer — the `@sentry/node`
+ * opt-in helper (`experimentalUseDiagnosticsChannelInjection`) and its public
+ * `diagnosticsChannelInjectionIntegrations()` map — picks it up automatically, so there's no separate
+ * list to keep in sync.
+ *
+ * NOTE: `ioredisChannelIntegration` and `redisChannelIntegration` are intentionally NOT here. They
+ * only partially replace the composite OTel `Redis` integration and need the node SDK's redis cache
+ * `responseHook` (which can't live in `server-utils`), so `@sentry/node` wires them up separately.
+ *
+ * Framework SDKs that own their own channel listener (e.g. `@sentry/nestjs`'s `Nest`) are NOT here
+ * either: their transform config is still in `SENTRY_INSTRUMENTATIONS`, but the listener lives in
+ * their package and picks the channel-vs-OTel path itself at `setupOnce`, so it needs no central swap.
+ *
+ * NOTE: `dataloaderChannelIntegration` is also NOT here. Everything in this map is auto-appended to
+ * the default integrations, but the OTel `Dataloader` integration is opt-in (never a default). Like
+ * `@sentry/nestjs`'s `Nest`, its `@sentry/node` factory picks the channel-vs-OTel path itself at
+ * `setupOnce` (via `isOrchestrionInjected()`), so there's nothing for the central swap to do.
+ */
+export declare const channelIntegrations: {
+    readonly postgresIntegration: (options?: {
+        ignoreConnectSpans?: boolean;
+    } | undefined) => import("@sentry/core").Integration & {
+        name: "Postgres";
+    };
+    readonly postgresJsIntegration: (options?: import(".").PostgresJsChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "PostgresJs";
+    };
+    readonly mongoIntegration: () => import("@sentry/core").Integration & {
+        name: "Mongo";
+    };
+    readonly mysqlIntegration: () => import("@sentry/core").Integration & {
+        name: "Mysql";
+    };
+    readonly mysql2Integration: () => import("@sentry/core").Integration & {
+        name: "Mysql2";
+    };
+    readonly genericPoolIntegration: () => import("@sentry/core").Integration & {
+        name: "GenericPool";
+    };
+    readonly mongooseIntegration: () => import("@sentry/core").Integration & {
+        name: "Mongoose";
+    };
+    readonly lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+        name: "LruMemoizer";
+    };
+    readonly openaiIntegration: (options?: import("@sentry/core").OpenAiOptions | undefined) => import("@sentry/core").Integration & {
+        name: "OpenAI";
+    };
+    readonly anthropicIntegration: (options?: import("@sentry/core").AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Anthropic_AI";
+    };
+    readonly googleGenAIIntegration: (options?: import("@sentry/core").GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Google_GenAI";
+    };
+    readonly langChainIntegration: (options?: import("@sentry/core").LangChainOptions | undefined) => import("@sentry/core").Integration & {
+        name: "LangChain";
+    };
+    readonly langGraphIntegration: (options?: import("@sentry/core").LangGraphOptions | undefined) => import("@sentry/core").Integration & {
+        name: "LangGraph";
+    };
+    readonly vercelAiIntegration: (options?: {
+        recordInputs?: boolean;
+        recordOutputs?: boolean;
+        enableTruncation?: boolean;
+    } | undefined) => import("@sentry/core").Integration & {
+        name: "VercelAI";
+    };
+    readonly amqplibIntegration: () => import("@sentry/core").Integration & {
+        name: "Amqplib";
+    };
+    readonly hapiIntegration: () => import("@sentry/core").Integration & {
+        name: "Hapi";
+    };
+    readonly koaIntegration: (options?: import(".").KoaChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Koa";
+    };
+    readonly expressIntegration: (options?: import("../integrations/tracing-channel/express/types").ExpressIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+        name: "Express";
+    };
+    readonly graphqlIntegration: (options?: import("../graphql/graphql-dc-subscriber").GraphqlDiagnosticChannelsOptions) => Omit<import("@sentry/core").Integration & {
+        name: "Graphql";
+    }, "name" | "setupOnce"> & {
+        name: "Graphql";
+        setupOnce: () => void | undefined;
+    };
+    readonly kafkajsIntegration: () => import("@sentry/core").Integration & {
+        name: "Kafka";
+    };
+    readonly tediousIntegration: () => import("@sentry/core").Integration & {
+        name: "Tedious";
+    };
+    readonly awsIntegration: () => import("@sentry/core").Integration & {
+        name: "Aws";
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrion/index.ts"],"names":[],"mappings":"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"}

package/build/types/orchestrion/runtime/register.d.ts

@@ -0,0 +1,25 @@
+export interface RegisterDiagnosticsChannelInjectionOptions {
+    /**
+     * Absolute directory of the `@apm-js-collab/tracing-hooks` package (forward slashes).
+     *
+     * Needed when SDK code is bundled into an app's server build: the default bare-specifier
+     * require then resolves from the emitted chunk, which fails under isolated installs (pnpm).
+     * Framework SDKs (e.g. `@sentry/nextjs`) resolve the package at build time and pass its
+     * location here; it is loaded through an opaque `createRequire` that bundlers can't trace.
+     */
+    tracingHooksDir?: string;
+}
+/**
+ * Synchronously register the diagnostics-channel injection module hooks.
+ *
+ * This is the single source of truth for the registration logic. It is used by:
+ * - `Sentry.init()` (the Node SDK calls it directly — that's why this module
+ *   must be CJS-compatible / dual-built, so it can be `require()`d synchronously
+ *   before the app's `import`s resolve), and
+ * - `import-hook.mjs`, the side-effecting `--import` entry, which just calls it.
+ *
+ * Libraries imported *after* this call publish the `tracingChannel` events that
+ * the channel-based integrations subscribe to.
+ */
+export declare function registerDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void;
+//# sourceMappingURL=register.d.ts.map

package/build/types/orchestrion/runtime/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/orchestrion/runtime/register.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,0CAA0C;IACzD;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE,0CAA0C,GAAG,IAAI,CAiJ9G"}

package/build/types/prisma/global.d.ts

@@ -0,0 +1,5 @@
+import type { TracingHelper } from './types';
+export declare function getGlobalTracingHelper(): TracingHelper | undefined;
+export declare function setGlobalTracingHelper(helper: TracingHelper): void;
+export declare function clearGlobalTracingHelper(): void;
+//# sourceMappingURL=global.d.ts.map

package/build/types/prisma/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../../../src/prisma/global.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAoC,aAAa,EAAE,MAAM,SAAS,CAAC;AAe/E,wBAAgB,sBAAsB,IAAI,aAAa,GAAG,SAAS,CAUlE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAKlE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C"}

package/build/types/prisma/index.d.ts

@@ -0,0 +1,45 @@
+export interface PrismaInstrumentationConfig {
+    /**
+     * Span types that should not be traced. Matched against the full span name (e.g. `prisma:client:operation`),
+     * either exactly (string) or by pattern (RegExp).
+     */
+    ignoreSpanTypes?: (string | RegExp)[];
+}
+export interface PrismaOptions {
+    /**
+     * @deprecated This is no longer used, v5 works out of the box.
+     */
+    prismaInstrumentation?: unknown;
+    /**
+     * Configuration for the Prisma tracing helper.
+     */
+    instrumentationConfig?: PrismaInstrumentationConfig;
+}
+/**
+ * Sets up the global Prisma tracing helper that Prisma looks up on `globalThis` to emit tracing data.
+ *
+ * Prisma reads `globalThis.PRISMA_INSTRUMENTATION` (and its versioned variant) to find a "TracingHelper"
+ * which it uses internally to create spans, so it can produce tracing data without depending on
+ * OpenTelemetry. The helper we install here mints spans through Sentry's span APIs. A single helper
+ * serves both Prisma v5 (which calls `createEngineSpan`) and v6/v7 (which call `dispatchEngineSpans`),
+ * so it doesn't blow up on version mismatches.
+ */
+export declare function instrumentPrisma(options?: PrismaOptions): void;
+/**
+ * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
+ * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
+ *
+ * NOTE: This integration works out of the box with Prisma v6, and v7.
+ * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
+ *
+ *    ```
+ *    generator client {
+ *      provider = "prisma-client-js"
+ *      previewFeatures = ["tracing"]
+ *    }
+ *    ```
+ */
+export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Prisma";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/prisma/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/prisma/index.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;OAEG;IACH,qBAAqB,CAAC,EAAE,2BAA2B,CAAC;CACrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAM9D;AAWD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;CAAwC,CAAC"}

package/build/types/prisma/tracing-helper.d.ts

@@ -0,0 +1,46 @@
+import type { Span } from '@sentry/core';
+import type { EngineSpan, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
+type Options = {
+    ignoreSpanTypes: (string | RegExp)[];
+};
+type V5EngineSpanEvent = {
+    span: boolean;
+    spans: V5EngineSpan[];
+};
+type V5EngineSpanKind = 'client' | 'internal';
+type V5EngineSpan = {
+    span: boolean;
+    name: string;
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string;
+    start_time: [number, number];
+    end_time: [number, number];
+    attributes?: Record<string, string>;
+    links?: {
+        trace_id: string;
+        span_id: string;
+    }[];
+    kind: V5EngineSpanKind;
+};
+/**
+ * This satisifes the TracingHelper interface for Prisma v5 and v6/v7.
+ */
+export declare class ActiveTracingHelper implements TracingHelper {
+    private ignoreSpanTypes;
+    constructor({ ignoreSpanTypes }: Options);
+    isEnabled(): boolean;
+    getTraceParent(span?: Span): string;
+    dispatchEngineSpans(spans: EngineSpan[]): void;
+    /**
+     * Prisma v5 broke the tracing helper interface with the v6 major, replacing `createEngineSpan` with
+     * `dispatchEngineSpans`. We implement the v6/v7 interface (`dispatchEngineSpans`) but also keep this
+     * v5-only method so the same helper doesn't blow up in Prisma 5 users' faces, minting v5 engine spans
+     * through Sentry's span APIs instead of crashing.
+     */
+    createEngineSpan(engineSpanEvent: V5EngineSpanEvent): void;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+export {};
+//# sourceMappingURL=tracing-helper.d.ts.map

package/build/types/prisma/tracing-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing-helper.d.ts","sourceRoot":"","sources":["../../../src/prisma/tracing-helper.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,cAAc,CAAC;AAWzD,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAiB5F,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACtC,CAAC;AAGF,KAAK,iBAAiB,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,gBAAgB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9C,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChD,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AAkGF;;GAEG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,eAAe,CAAsB;gBAE1B,EAAE,eAAe,EAAE,EAAE,OAAO;IAIxC,SAAS,IAAI,OAAO;IAIpB,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;IAQnC,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI;IASrD;;;;;OAKG;IACI,gBAAgB,CAAC,eAAe,EAAE,iBAAiB,GAAG,IAAI;IAiB1D,gBAAgB,IAAI,IAAI,GAAG,SAAS;IAIpC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC;CAsCpG"}

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

@@ -0,0 +1,37 @@
+import type { Span, SpanAttributes, SpanKindValue, SpanLink, SpanTimeInput } from '@sentry/core';
+export type SpanCallback<R> = (span?: Span, parentSpan?: Span) => R;
+export interface ExtendedSpanOptions {
+    /** The name of the span */
+    name: string;
+    internal?: boolean;
+    /** Whether it propagates context (?=true) */
+    active?: boolean;
+    attributes?: SpanAttributes;
+    kind?: SpanKindValue;
+    links?: SpanLink[];
+    startTime?: SpanTimeInput;
+}
+export type EngineSpanId = string;
+export type HrTime = [number, number];
+export type EngineSpanKind = 'client' | 'internal';
+export type EngineSpan = {
+    id: EngineSpanId;
+    parentId: string | null;
+    name: string;
+    startTime: HrTime;
+    endTime: HrTime;
+    kind: EngineSpanKind;
+    attributes?: Record<string, unknown>;
+    links?: EngineSpanId[];
+};
+export interface TracingHelper {
+    isEnabled(): boolean;
+    getTraceParent(span?: Span): string;
+    dispatchEngineSpans(spans: EngineSpan[]): void;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+export interface PrismaInstrumentationGlobalValue {
+    helper?: TracingHelper;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/prisma/types.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAEjG,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC;AAEpE,MAAM,WAAW,mBAAmB;IAClC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACpC,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAC/C,gBAAgB,IAAI,IAAI,GAAG,SAAS,CAAC;IACrC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAC9F;AAED,MAAM,WAAW,gCAAgC;IAC/C,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}

package/build/types/redis/index.d.ts

@@ -0,0 +1,18 @@
+import { type RedisDiagnosticChannelResponseHook } from './redis-dc-subscriber';
+/** Options controlling the redis diagnostics-channel subscription. */
+export interface RedisDiagnosticChannelsOptions {
+    /**
+     * Optional hook invoked once the redis command response arrives. Useful for attaching
+     * response-derived attributes (e.g. cache hit/miss, payload size).
+     */
+    responseHook?: RedisDiagnosticChannelResponseHook;
+}
+/**
+ * Auto-instrument the [redis](https://www.npmjs.com/package/redis) and
+ * [ioredis](https://www.npmjs.com/package/ioredis) libraries via their native
+ * `node:diagnostics_channel` tracing channels (node-redis >= 5.12.0, ioredis >= 5.11.0).
+ */
+export declare const redisIntegration: (options?: RedisDiagnosticChannelsOptions | undefined) => import("@sentry/core").Integration & {
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/redis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/redis/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kCAAkC,EAAoC,MAAM,uBAAuB,CAAC;AAElH,sEAAsE;AACtE,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,YAAY,CAAC,EAAE,kCAAkC,CAAC;CACnD;AAkBD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;CAAuC,CAAC"}

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

@@ -0,0 +1,89 @@
+import type { TracingChannel } from 'node:diagnostics_channel';
+import type { Span } from '@sentry/core';
+export declare const REDIS_DC_CHANNEL_COMMAND = "node-redis:command";
+export declare const REDIS_DC_CHANNEL_BATCH = "node-redis:batch";
+export declare const REDIS_DC_CHANNEL_CONNECT = "node-redis:connect";
+export declare const IOREDIS_DC_CHANNEL_COMMAND = "ioredis:command";
+export declare const IOREDIS_DC_CHANNEL_CONNECT = "ioredis:connect";
+/**
+ * Shape of the `node-redis:command` channel payload published by node-redis.
+ *
+ * Both `command` and `args` are already redacted by node-redis itself (see
+ * `sanitizeArgs` in @redis/client) using the OTel `redis-common` rules. The
+ * arg array is `[<command>, <safe arg>, ..., '?', ...]` — `?` replaces any
+ * value the library considers sensitive. Subscribers can emit `args` directly
+ * as `db.query.text` without further serialization.
+ */
+export interface RedisCommandData {
+    command: string;
+    /** First arg is the command name itself; consumers should slice it off. */
+    args: string[];
+    database?: number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown;
+    error?: Error;
+}
+/**
+ * Shape of the `ioredis:command` channel payload published by ioredis >= 5.11.0.
+ *
+ * As with node-redis, args are already sanitized by ioredis (`sanitizeArgs` in
+ * `lib/tracing.ts`) before publishing. Unlike node-redis, the command name is
+ * NOT prepended to `args`.
+ */
+export interface IORedisCommandData {
+    command: string;
+    args: string[];
+    batchMode?: 'MULTI';
+    batchSize?: number;
+    database?: number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown;
+    error?: Error;
+}
+/** Shape of the `node-redis:batch` channel payload published by node-redis. */
+export interface RedisBatchData {
+    batchMode?: 'MULTI' | 'PIPELINE';
+    batchSize?: number;
+    database?: number;
+    clientId?: string | number;
+    serverAddress?: string;
+    serverPort?: number;
+    result?: unknown[];
+    error?: Error;
+}
+/** Shape of the `*:connect` channel payload published by node-redis and ioredis. */
+export interface RedisConnectData {
+    serverAddress?: string;
+    serverPort?: number;
+    url?: string;
+    error?: Error;
+}
+/**
+ * Optional callback invoked once the redis command response arrives. Useful
+ * for attaching response-derived attributes (e.g. cache hit/miss, payload size).
+ *
+ * Mirrors `@opentelemetry/instrumentation-ioredis`' response hook so existing
+ * Sentry node code (`cacheResponseHook`) can be reused unchanged.
+ */
+export type RedisDiagnosticChannelResponseHook = (span: Span, cmdName: string, cmdArgs: string[], result: unknown) => void;
+/**
+ * Platform-provided factory that creates a native tracing channel for the given name. The
+ * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
+ * which propagates the active span through the runtime's async context.
+ *
+ * Both Node and Deno pass `node:diagnostics_channel`'s `tracingChannel` directly.
+ */
+export type RedisTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/**
+ * Subscribe Sentry span handlers to node-redis and ioredis diagnostics-channel
+ * events: `node-redis:command`/`:batch`/`:connect` (published by node-redis
+ * >= 5.12.0) and `ioredis:command`/`:connect` (published by ioredis >= 5.11.0).
+ *
+ * On older client versions the channels are never published to, so subscribers
+ * are inert — there is no double-instrumentation against any IITM-based
+ * patcher gated to those older versions.
+ */
+export declare function subscribeRedisDiagnosticChannels(tracingChannel: RedisTracingChannelFactory, responseHook?: RedisDiagnosticChannelResponseHook): void;
+//# sourceMappingURL=redis-dc-subscriber.d.ts.map

package/build/types/redis/redis-dc-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-dc-subscriber.d.ts","sourceRoot":"","sources":["../../../src/redis/redis-dc-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAQ/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAQzC,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAC7D,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AACzD,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAC7D,eAAO,MAAM,0BAA0B,oBAAoB,CAAC;AAC5D,eAAO,MAAM,0BAA0B,oBAAoB,CAAC;AAK5D;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,oFAAoF;AACpF,MAAM,WAAW,gBAAgB;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kCAAkC,GAAG,CAC/C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,OAAO,KACZ,IAAI,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAElG;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAC9C,cAAc,EAAE,0BAA0B,EAC1C,YAAY,CAAC,EAAE,kCAAkC,GAChD,IAAI,CAkBN"}

package/build/types/redis/redis-statement-serializer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given the redis command name and arguments, return a combination of the
+ * command name + the allowed arguments according to `serializationSubsets`.
+ */
+export declare const defaultDbStatementSerializer: (cmdName: string, cmdArgs: Array<string | Buffer | number | unknown[]>) => string;
+//# sourceMappingURL=redis-statement-serializer.d.ts.map

package/build/types/redis/redis-statement-serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-statement-serializer.d.ts","sourceRoot":"","sources":["../../../src/redis/redis-statement-serializer.ts"],"names":[],"mappings":"AA0CA;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACvC,SAAS,MAAM,EACf,SAAS,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC,KACnD,MAWF,CAAC"}

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

@@ -0,0 +1,73 @@
+import type { TracingChannel, TracingChannelSubscribers } from 'node:diagnostics_channel';
+import type { ExclusiveEventHintOrCaptureContext, Span } from '@sentry/core';
+export type TracingChannelPayloadWithSpan<TData extends object> = TData & {
+    /**
+     * The current active span for the traced call.
+     */
+    _sentrySpan?: Span;
+    /**
+     * The context's active store value, used to restore the context for asyncStart continuations for callback-based tracing.
+     */
+    _sentryCallerStore?: unknown;
+};
+export interface SentryTracingChannel<TData extends object = object> extends Omit<TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>, 'subscribe' | 'unsubscribe'> {
+    subscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
+    unsubscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
+}
+export interface TracingChannelLifeCycleOptions<TData extends object = object> {
+    /**
+     * Invoked with the span and the channel context object once the traced operation completes
+     * Use it to enrich the span from the result/error (branch on `'error' in data` / `'result' in data`) or to run cleanup.
+     */
+    beforeSpanEnd?: (span: Span, data: TracingChannelPayloadWithSpan<TData>) => void;
+    /**
+     * Whether a thrown error is captured as a Sentry event. The span is always marked with error status regardless. Defaults to `false`.
+     * You can alternatively pass a function that sets the ExclusiveEventHintOrCaptureContext on the captured error.
+     * Set `true` for instrumentations that own the error boundary, (e.g: route handlers)
+     * For database drivers, it is not recommended to set this at all.
+     */
+    captureError?: boolean | ((e: unknown) => ExclusiveEventHintOrCaptureContext);
+    /**
+     * Take ownership of *when* the span ends: return `true` and the helper won't end it on
+     * `end`/`asyncEnd`. For results that settle out-of-band — e.g. a streamed `EventEmitter` that
+     * completes via its own `'end'`/`'error'` events.
+     *
+     * Call `end` when it settles — `end()` on success, `end(error)` on failure. `end` owns *how* the span
+     * ends (error status/attributes, `captureError`, `beforeSpanEnd`) and is idempotent. Default `false`
+     * lets the helper end the span as usual.
+     */
+    deferSpanEnd?: (args: {
+        span: Span;
+        data: TracingChannelPayloadWithSpan<TData>;
+        /** Ends the span: `end()` on success, `end(error)` on failure. Idempotent. */
+        end: (error?: unknown) => void;
+    }) => boolean;
+    /**
+     * Apply span/scope binding only if there is a parent span, similar to returning `undefined` in the `getSpan` callback.
+     * If you need to perform some conditional checking on the parent span before deciding, do it in the `getSpan` callback.
+     */
+    requiresParentSpan?: boolean;
+}
+/** Returned by {@link bindTracingChannelToSpan}: the bound channel plus a teardown handle. */
+export interface TracingChannelBindingHandle<TData extends object = object> {
+    /**
+     * The tracing channel with the span bound into async context.
+     */
+    channel: SentryTracingChannel<TData>;
+    /**
+     * Tears down the binding: unsubscribes lifecycle handlers, when present, and unbinds the start store.
+     * Idempotent, and a no-op when no async context binding was available.
+     */
+    unbind: () => void;
+}
+/**
+ * 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.
+ *
+ * `getSpan` may return `undefined` to opt a payload out entirely: nothing is bound, no span is
+ * tracked, and the active context is left untouched. Use it for events that ride the same channel
+ * but should reuse the enclosing span instead of opening (and ending) their own — e.g. an agent
+ * 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>;
+//# sourceMappingURL=tracing-channel.d.ts.map

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

@@ -0,0 +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;CAC9B,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,8EAA8E;QAC9E,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,CA0FpC"}

package/build/types/vercel-ai/index.d.ts

@@ -0,0 +1,27 @@
+type VercelAiOptions = {
+    /**
+     * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
+};
+/**
+ * Auto-instrument the `ai` SDK's native telemetry tracing channel (ai >= 7).
+ */
+export declare const vercelAiIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "VercelAI";
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types/vercel-ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/index.ts"],"names":[],"mappings":"AAIA,KAAK,eAAe,GAAG;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAoBF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

package/build/types/vercel-ai/util.d.ts

@@ -0,0 +1,30 @@
+/** Shared, state-free helpers for the Vercel AI (`ai`) channel subscribers, plus the streamed model-call tap. */
+/** Narrow to a string, or `undefined` for anything else. */
+export declare function asString(value: unknown): string | undefined;
+/** Narrow to a finite number, or `undefined` for anything else (including `NaN`). */
+export declare function asNumber(value: unknown): number | undefined;
+/** Add two optional numbers, treating a missing operand as `0` but returning `undefined` when both are absent. */
+export declare function sum(a: number | undefined, b: number | undefined): number | undefined;
+/** The aggregate handed back once a streamed model call finishes, in the shape `enrichSpanOnEnd` expects. */
+export interface StreamedModelCallResult {
+    text?: string;
+    toolCalls: Array<Record<string, unknown>>;
+    usage?: unknown;
+    finishReason?: unknown;
+    responseId?: string;
+    responseModel?: string;
+    providerMetadata?: unknown;
+}
+/** A minimal structural check — the streamed model call exposes a web `ReadableStream` on `result.stream`. */
+export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
+/**
+ * Wrap a streamed model call's `ReadableStream` so its chunks are observed as the SDK consumes them,
+ * without altering what the SDK sees. Returns a replacement stream to swap onto `result.stream`.
+ *
+ * `onFinal` runs exactly once when the stream drains cleanly; `onError` runs exactly once if it errors
+ * or is cancelled. Reading one source chunk per `pull` preserves the SDK's backpressure. The
+ * `try/catch` around every read guarantees the owning span is always ended — a leaked open span on a
+ * mid-stream failure would be worse than a slightly-less-enriched one.
+ */
+export declare function tapModelCallStream(stream: ReadableStream<unknown>, onFinal: (result: StreamedModelCallResult) => void, onError: (error: unknown) => void): ReadableStream<unknown>;
+//# sourceMappingURL=util.d.ts.map

package/build/types/vercel-ai/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/util.ts"],"names":[],"mappings":"AAAA,iHAAiH;AAIjH,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE3D;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE3D;AAED,kHAAkH;AAClH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEpF;AAoCD,6GAA6G;AAC7G,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,8GAA8G;AAC9G,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAAC,OAAO,CAAC,CAMjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC,EAC/B,OAAO,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,EAClD,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAChC,cAAc,CAAC,OAAO,CAAC,CAkDzB"}