@introspection-sdk/introspection-node 0.4.3 → 0.4.5

package/src/otel/integrations/index.ts

@@ -0,0 +1,151 @@
+/**
+ * Integration discovery + setup loader for `introspection.init()`.
+ *
+ * Mirrors the Python SDK's registry: built-in integrations are resolved
+ * lazily (a missing framework just skips its shim), `setupOnce` runs at most
+ * once per identifier per process, and an integration may `deactivate` others.
+ */
+
+import { logger } from "../../utils.js";
+import {
+  DidNotEnable,
+  type Integration,
+  type IntegrationHandles,
+  type IntegrationSetupContext,
+} from "./base.js";
+
+export { DidNotEnable };
+export type { Integration, IntegrationHandles, IntegrationSetupContext };
+
+/**
+ * Built-in integrations, loaded lazily. Each thunk dynamically imports an
+ * integration module; that module imports its framework at the top level, so
+ * if the framework is not installed the import rejects and the integration is
+ * skipped. Order matters only for `deactivates` resolution (handled below).
+ */
+const BUILTIN_INTEGRATIONS: ReadonlyArray<
+  () => Promise<{ default: Integration }>
+> = [
+  () => import("./anthropic.js"),
+  () => import("./gemini.js"),
+  () => import("./openai-agents.js"),
+  () => import("./vercel.js"),
+  () => import("./claude-agent.js"),
+  () => import("./langchain.js"),
+  () => import("./mastra.js"),
+  () => import("./pi.js"),
+];
+
+const installed = new Set<string>();
+// Teardown callbacks returned by integration setupOnce (e.g. uninstrument a
+// prototype patch), run by teardownIntegrations() on shutdown.
+const teardowns: Array<() => void> = [];
+
+/**
+ * Distinguish "framework package not installed" (expected — skip quietly) from
+ * a real error inside an installed integration (a bug we shouldn't hide).
+ */
+export function isModuleNotFound(e: unknown): boolean {
+  const code = (e as { code?: string } | null)?.code;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+    return true;
+  }
+  const msg = e instanceof Error ? e.message : String(e);
+  return /Cannot find (module|package)|Failed to resolve/i.test(msg);
+}
+
+/**
+ * Return the built-in integrations whose framework is importable.
+ *
+ * Each module's top-level framework import determines availability: a missing
+ * package makes the dynamic import reject, which we log at debug and skip. Any
+ * OTHER failure (a real error inside an installed integration) is surfaced at
+ * warn level rather than silently swallowed — it's a bug, not an absent peer.
+ */
+export async function discoverIntegrations(): Promise<Integration[]> {
+  const found: Integration[] = [];
+  for (const load of BUILTIN_INTEGRATIONS) {
+    try {
+      const mod = await load();
+      if (mod.default) found.push(mod.default);
+    } catch (e) {
+      if (isModuleNotFound(e)) {
+        logger.debug(
+          `Skipping integration (framework not installed): ${String(e)}`,
+        );
+      } else {
+        logger.warn(
+          `Integration failed to load with an unexpected error (skipping): ${String(e)}`,
+        );
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Run each integration's `setupOnce` once, honouring `deactivates`.
+ *
+ * @returns the set of identifiers installed so far this process.
+ */
+export function setupIntegrations(
+  integrations: Integration[],
+  ctx: IntegrationSetupContext,
+): Set<string> {
+  // First-wins de-dupe by identifier.
+  const byId = new Map<string, Integration>();
+  for (const integration of integrations) {
+    if (!byId.has(integration.identifier)) {
+      byId.set(integration.identifier, integration);
+    }
+  }
+
+  const disabled = new Set<string>();
+  for (const integration of byId.values()) {
+    for (const id of integration.deactivates ?? []) disabled.add(id);
+  }
+
+  for (const [identifier, integration] of byId) {
+    if (disabled.has(identifier)) {
+      logger.debug(
+        `Skipping ${identifier} (deactivated by another integration)`,
+      );
+      continue;
+    }
+    if (installed.has(identifier)) continue;
+    try {
+      const teardown = integration.setupOnce(ctx);
+      if (typeof teardown === "function") teardowns.push(teardown);
+      installed.add(identifier);
+    } catch (e) {
+      if (e instanceof DidNotEnable) {
+        logger.debug(`Could not enable ${identifier}: ${e.message}`);
+        continue;
+      }
+      throw e;
+    }
+  }
+
+  return new Set(installed);
+}
+
+/**
+ * Run every integration teardown and clear the run-once guard, so the next
+ * `setupIntegrations()` (e.g. after `introspection.shutdown()` + a fresh
+ * `init()`) re-installs against the rebuilt provider instead of being skipped.
+ */
+export function teardownIntegrations(): void {
+  for (const teardown of teardowns.splice(0)) {
+    try {
+      teardown();
+    } catch (e) {
+      logger.debug(`Error tearing down integration: ${String(e)}`);
+    }
+  }
+  installed.clear();
+}
+
+/** Clear the run-once guard (running teardowns). Test-only utility. */
+export function resetInstalledForTests(): void {
+  teardownIntegrations();
+}

package/src/otel/integrations/langchain.ts

@@ -0,0 +1,45 @@
+/**
+ * LangChain / LangGraph integration.
+ *
+ * The callback handler is attached per-invoke (`chain.invoke(input, { callbacks
+ * })`), so this integration builds the handler — pre-bound to the `init()`
+ * token — and publishes it via `introspection.getLangchainHandler()`.
+ *
+ * Deactivates the Anthropic integration: when LangChain drives the Anthropic
+ * model, the handler already traces the call, so the prototype-level Anthropic
+ * patch would double-trace it.
+ */
+
+// Presence gate.
+import "@langchain/core/callbacks/base";
+
+import { IntrospectionCallbackHandler } from "../langchain-handler.js";
+import type { Integration } from "./base.js";
+
+const integration: Integration = {
+  identifier: "langchain",
+  // Intentional, and matches the Python SDK: when @langchain/core is present,
+  // auto-discovery skips the always-on raw-Anthropic prototype patch so a
+  // LangChain → ChatAnthropic call isn't traced twice (once by LangChain's
+  // callback handler, once by the raw `messages.create` patch).
+  //
+  // Trade-off (by design): if an app has BOTH @langchain/core installed AND
+  // makes raw `@anthropic-ai/sdk` calls outside LangChain, those raw calls
+  // won't be auto-traced. To trace them, instrument explicitly with
+  // `new AnthropicInstrumentor().instrumentClass(...)`, or call
+  // `init({ autoDiscover: false, integrations: [anthropicIntegration] })`.
+  deactivates: ["anthropic"],
+  setupOnce({ token, serviceName, baseUrl, advanced, handles }) {
+    handles.langchainHandler = new IntrospectionCallbackHandler({
+      token,
+      serviceName,
+      baseUrl,
+      additionalHeaders: advanced?.additionalHeaders,
+      advanced: advanced?.spanExporter
+        ? { spanExporter: advanced.spanExporter }
+        : undefined,
+    });
+  },
+};
+
+export default integration;

package/src/otel/integrations/mastra.ts

@@ -0,0 +1,30 @@
+/**
+ * Mastra integration.
+ *
+ * The Mastra exporter is wired into Mastra's `observability.configs` rather
+ * than globally, so this integration builds the exporter — pre-bound to the
+ * `init()` token — and publishes it via `introspection.getMastraExporter()`.
+ *
+ * Importing `../mastra-exporter.js` (which requires `@mastra/observability`)
+ * is the presence gate: a missing Mastra makes discovery skip this shim.
+ */
+
+import { IntrospectionMastraExporter } from "../mastra-exporter.js";
+import type { Integration } from "./base.js";
+
+const integration: Integration = {
+  identifier: "mastra",
+  setupOnce({ token, baseUrl, advanced, handles }) {
+    handles.mastraExporter = new IntrospectionMastraExporter({
+      token,
+      baseUrl,
+      additionalHeaders: advanced?.additionalHeaders,
+      debug: advanced?.debug,
+      advanced: advanced?.spanExporter
+        ? { spanExporter: advanced.spanExporter }
+        : undefined,
+    });
+  },
+};
+
+export default integration;

package/src/otel/integrations/openai-agents.ts

@@ -0,0 +1,31 @@
+/**
+ * OpenAI Agents SDK integration.
+ *
+ * Registers an {@link IntrospectionTracingProcessor} with the Agents SDK's
+ * global trace pipeline. `addTraceProcessor` appends, preserving any processors
+ * other integrations (e.g. a vendor exporter) already registered.
+ */
+
+import { addTraceProcessor } from "@openai/agents";
+
+import { IntrospectionTracingProcessor } from "../tracing-processor.js";
+import type { Integration } from "./base.js";
+
+const integration: Integration = {
+  identifier: "openai_agents",
+  setupOnce({ token, serviceName, baseUrl, advanced }) {
+    addTraceProcessor(
+      new IntrospectionTracingProcessor({
+        token,
+        serviceName,
+        baseUrl,
+        additionalHeaders: advanced?.additionalHeaders,
+        advanced: advanced?.spanExporter
+          ? { spanExporter: advanced.spanExporter }
+          : undefined,
+      }),
+    );
+  },
+};
+
+export default integration;

package/src/otel/integrations/pi.ts

@@ -0,0 +1,24 @@
+/**
+ * Pi Agent SDK integration.
+ *
+ * The Pi instrumentor wraps a specific `Agent` instance, so this integration
+ * builds the instrumentor — bound to the shared provider's global tracer — and
+ * publishes it via `introspection.instrumentPi(agent, meta)`.
+ */
+
+// Presence gate.
+import "@mariozechner/pi-agent-core";
+
+import { IntrospectionPiInstrumentor } from "../pi.js";
+import type { Integration } from "./base.js";
+
+const integration: Integration = {
+  identifier: "pi",
+  setupOnce({ handles }) {
+    // The instrumentor emits onto the global tracer, which `init()` has just
+    // registered with the shared IntrospectionSpanProcessor.
+    handles.piInstrumentor = new IntrospectionPiInstrumentor();
+  },
+};
+
+export default integration;

package/src/otel/integrations/vercel.ts

@@ -0,0 +1,24 @@
+/**
+ * Vercel AI SDK integration.
+ *
+ * The AI SDK emits `ai.*` / `gen_ai.*` attributes natively via OTel when
+ * `experimental_telemetry` is enabled. The shared provider already carries an
+ * {@link IntrospectionSpanProcessor}, which converts those `ai.*` attributes to
+ * canonical `gen_ai.*` semconv at span end — so there is nothing to patch here.
+ * This integration exists so auto-discovery reports the AI SDK as detected and
+ * (via its top-level import) is skipped when `ai` is not installed.
+ */
+
+// Presence gate: a missing `ai` package makes this module's import reject.
+import "ai";
+
+import type { Integration } from "./base.js";
+
+const integration: Integration = {
+  identifier: "vercel",
+  setupOnce() {
+    // No-op: the shared IntrospectionSpanProcessor converts AI SDK spans.
+  },
+};
+
+export default integration;

package/src/otel/register.ts

@@ -0,0 +1,50 @@
+/**
+ * Zero-code preload entry point for Introspection tracing.
+ *
+ * Usage (ESM):
+ *
+ * ```bash
+ * node --import @introspection-sdk/introspection-node/otel/register app.js
+ * ```
+ *
+ * Runs `introspection.init()` from the environment **before** the app's module
+ * graph executes, so no `init()` call is needed in application source. Because
+ * the Anthropic / Gemini one-liner works by prototype-patching the SDK classes
+ * (see `AnthropicInstrumentor.instrumentClass`), every client constructed after
+ * this preload is traced with zero code changes.
+ *
+ * Configuration is read from the usual environment variables
+ * (`INTROSPECTION_TOKEN`, `INTROSPECTION_SERVICE_NAME`,
+ * `INTROSPECTION_BASE_OTEL_URL`). If no token is configured the preload logs a
+ * warning and does nothing, so it never crashes the host application.
+ *
+ * This is the counterpart to the private SDK's `register.ts`, adapted to the
+ * `src/otel` surface: it drives the existing `init()` rather than registering an
+ * import-in-the-middle loader hook (the prototype-patch path does not need one).
+ */
+import { logger } from "../utils.js";
+import { init } from "./init.js";
+
+/**
+ * Run `init()` if a token is configured. Exported (and awaited at module load)
+ * so tests can invoke it deterministically; the module-level `await` below
+ * guarantees the preload finishes — including framework auto-discovery and the
+ * prototype patch — before Node evaluates the application entry point.
+ */
+export async function registerFromEnv(): Promise<void> {
+  if (!process.env.INTROSPECTION_TOKEN) {
+    logger.warn(
+      "[introspection] register: INTROSPECTION_TOKEN not set; tracing not initialised.",
+    );
+    return;
+  }
+  try {
+    await init();
+    logger.debug("[introspection] register: tracing initialised from preload.");
+  } catch (err) {
+    // Never let a preload failure take down the host application.
+    logger.warn(`[introspection] register: init failed: ${String(err)}`);
+  }
+}
+
+await registerFromEnv();

package/src/otel/setup.ts

@@ -61,6 +61,7 @@ import {
   W3CTraceContextPropagator,
 } from "@opentelemetry/core";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
 
 import { logger } from "../utils.js";
 import {
@@ -86,6 +87,26 @@ export interface SetupTracingOptions extends IntrospectionSpanProcessorOptions {
    *     other libraries that relied on the previous registration.
    */
   onConflict?: ConflictBehavior;
+
+  /**
+   * Extra span processors attached to the same `NodeTracerProvider`, so a
+   * single set of spans fans out to other backends (Langfuse, Arize, …).
+   * This is the low-level dual-export hook:
+   *
+   * ```ts
+   * setupTracing({
+   *   serviceName: "my-app",
+   *   additionalSpanProcessors: [new BatchSpanProcessor(langfuseExporter)],
+   * });
+   * ```
+   *
+   * Note: the {@link IntrospectionSpanProcessor} forwards its *own* converted
+   * copy of each span to Introspection — it does not mutate the shared span —
+   * so these processors receive the raw span and run independently of it.
+   * Order is therefore irrelevant. `introspection.init({ spanProcessors })`
+   * is the equivalent for the one-liner surface.
+   */
+  additionalSpanProcessors?: SpanProcessor[];
 }
 
 function defaultConflictBehavior(): ConflictBehavior {
@@ -148,6 +169,20 @@ function registerPropagator(behavior: ConflictBehavior): void {
   logger.warn(msg);
 }
 
+/**
+ * Install the OTel context manager + W3C (trace-context + baggage) propagator
+ * that Introspection's baggage scopes depend on.
+ *
+ * Shared by {@link setupTracing} and `introspection.init()`. `behavior`
+ * controls what happens when a manager / propagator is already registered
+ * (see {@link ConflictBehavior}).
+ */
+export function registerOTelGlobals(behavior?: ConflictBehavior): void {
+  const resolved = behavior ?? defaultConflictBehavior();
+  registerContextManager(resolved);
+  registerPropagator(resolved);
+}
+
 /**
  * Initialise Introspection tracing for a Node.js process.
  */
@@ -161,11 +196,17 @@ export function setupTracing(
   const behavior: ConflictBehavior =
     options?.onConflict ?? defaultConflictBehavior();
 
-  registerContextManager(behavior);
-  registerPropagator(behavior);
+  registerOTelGlobals(behavior);
 
   const provider = new NodeTracerProvider({
-    spanProcessors: [new IntrospectionSpanProcessor(options)],
+    // Order is irrelevant: IntrospectionSpanProcessor exports its own converted
+    // copy and does not mutate the shared span, so co-located dual-export
+    // processors receive the raw span regardless of position. Listed first here
+    // (and in init()) purely for a consistent, readable ordering story.
+    spanProcessors: [
+      new IntrospectionSpanProcessor(options),
+      ...(options?.additionalSpanProcessors ?? []),
+    ],
   });
   provider.register();
 

package/src/utils.ts

@@ -1,12 +1,19 @@
 import { DiagLogLevel, DiagLogger } from "@opentelemetry/api";
 import { HttpsProxyAgent } from "https-proxy-agent";
+import { resolveForwardProxyUrl } from "@introspection-sdk/introspection-proxy";
 
-function getHttpsProxyUrl(): string | undefined {
-  return process.env.HTTPS_PROXY || undefined;
-}
-
+/**
+ * Attach a forward-proxy agent to OTLP exporter options when a proxy is
+ * configured in the environment.
+ *
+ * Note: the OTLP proto exporters use Node's `http`/`https` stack, so this uses
+ * `HttpsProxyAgent` (an `http.Agent`) rather than the undici dispatcher from
+ * `./proxy.js` — a dispatcher only applies to `fetch`. The proxy *URL* is
+ * resolved by the shared {@link resolveForwardProxyUrl} so fetch and OTLP
+ * traffic agree on which proxy to use.
+ */
 export function withOtlpHttpsProxy<T extends object>(options: T): T {
-  const proxyUrl = getHttpsProxyUrl();
+  const proxyUrl = resolveForwardProxyUrl();
   if (!proxyUrl) return options;
 
   return {

package/.turbo/turbo-check-types.log

@@ -1,4 +0,0 @@
-
-> @introspection-sdk/introspection-node@0.1.0 check-types /Users/julian/projects/introspection-org/introspection-js-sdk/packages/introspection-node
-> tsc --noEmit
-

package/.turbo/turbo-lint.log

@@ -1,5 +0,0 @@
-
-> @introspection-sdk/introspection-node@0.1.0 lint /Users/julian/projects/introspection-org/introspection-js-sdk/packages/introspection-node
-> eslint . --max-warnings 0
-
-Warning: React version was set to "detect" in eslint-plugin-react settings, but the "react" package is not installed. Assuming latest React version for linting.

package/dist/ai-sdk-integration.d.ts

@@ -1,123 +0,0 @@
-/**
- * AI SDK TelemetryIntegration for Introspection.
- *
- * Implements the Vercel AI SDK's TelemetryIntegration interface to capture
- * LLM interactions and export them as OpenTelemetry spans with gen_ai.*
- * semantic convention attributes to the Introspection backend.
- *
- * Similar to IntrospectionTracingProcessor for OpenAI Agents SDK and
- * IntrospectionClaudeHooks for Claude Agent SDK.
- *
- * @example
- * ```ts
- * import { IntrospectionAISDKIntegration } from "@introspection-sdk/introspection-node";
- * import { generateText } from "ai";
- * import { openai } from "@ai-sdk/openai";
- *
- * const introspection = new IntrospectionAISDKIntegration({
- *   token: "sk-intro-...",
- *   serviceName: "my-app",
- * });
- *
- * const { text } = await generateText({
- *   model: openai("gpt-4o"),
- *   prompt: "Hello!",
- *   experimental_telemetry: {
- *     isEnabled: true,
- *     integrations: [introspection],
- *   },
- * });
- *
- * await introspection.shutdown();
- * ```
- */
-import { type SpanExporter, type IdGenerator } from "@opentelemetry/sdk-trace-base";
-/** Advanced options for testing and customization. */
-export interface AISDKIntegrationAdvancedOptions {
-    /** Custom span exporter (for testing — use InMemorySpanExporter). */
-    spanExporter?: SpanExporter;
-    /** Custom ID generator (for testing). */
-    idGenerator?: IdGenerator;
-    /** Use SimpleSpanProcessor instead of BatchSpanProcessor (for testing). */
-    useSimpleSpanProcessor?: boolean;
-    /** Maximum batch size for span export. */
-    maxExportBatchSize?: number;
-    /** Delay between batch exports in milliseconds. */
-    scheduledDelayMillis?: number;
-}
-/** Configuration for {@link IntrospectionAISDKIntegration}. */
-export interface IntrospectionAISDKIntegrationOptions {
-    /** Authentication token (env: INTROSPECTION_TOKEN). */
-    token?: string;
-    /** Base URL for the API (env: INTROSPECTION_BASE_URL, default: "https://otel.introspection.dev"). */
-    baseUrl?: string;
-    /** Service name for telemetry (env: INTROSPECTION_SERVICE_NAME). */
-    serviceName?: string;
-    /** Additional headers to include in requests. */
-    additionalHeaders?: Record<string, string>;
-    /** Advanced options for testing and customization. */
-    advanced?: AISDKIntegrationAdvancedOptions;
-}
-/**
- * AI SDK {@link TelemetryIntegration} that captures LLM interactions and
- * exports them as OpenTelemetry spans with `gen_ai.*` semantic convention
- * attributes to the Introspection backend.
- *
- * Creates its own {@link BasicTracerProvider} — no external OTel setup required.
- * Each generation (generateText/streamText call) produces:
- * - A root span grouping the entire operation
- * - Step spans (one per LLM call) with full gen_ai attributes
- * - Tool call spans nested under their parent step
- */
-export declare class IntrospectionAISDKIntegration {
-    private _tracerProvider;
-    private _tracer;
-    private _generation;
-    constructor(options?: IntrospectionAISDKIntegrationOptions);
-    /**
-     * Called when a generation operation begins (before any LLM calls).
-     * Creates a root span to group all steps in this generation.
-     */
-    onStart: (event: unknown) => void;
-    /**
-     * Called when a step (individual LLM call) begins.
-     * Creates a child span under the root span and captures input messages.
-     */
-    onStepStart: (event: unknown) => void;
-    /**
-     * Called when a tool execution begins.
-     * Creates a child span under the current step span.
-     */
-    onToolCallStart: (event: unknown) => void;
-    /**
-     * Called when a tool execution completes.
-     * Sets output/error attributes and ends the tool span.
-     */
-    onToolCallFinish: (event: unknown) => void;
-    /**
-     * Called when a step (LLM call) completes.
-     * Sets gen_ai attributes (input/output messages, usage, model) and ends
-     * the step span.
-     */
-    onStepFinish: (event: unknown) => void;
-    /**
-     * Called when the entire generation completes (all steps finished).
-     * Sets total usage on the root span and ends it.
-     */
-    onFinish: (event: unknown) => void;
-    /**
-     * Shut down the tracer provider, flushing all pending spans.
-     *
-     * @returns A promise that resolves once shutdown is complete.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Force-flush any buffered spans to the Introspection backend.
-     *
-     * @returns A promise that resolves once the flush completes.
-     */
-    forceFlush(): Promise<void>;
-    /** Cleanly end any active generation, closing all open spans. */
-    private _endGeneration;
-}
-//# sourceMappingURL=ai-sdk-integration.d.ts.map

package/dist/ai-sdk-integration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-sdk-integration.d.ts","sourceRoot":"","sources":["../src/ai-sdk-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAOH,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAoBvC,sDAAsD;AACtD,MAAM,WAAW,+BAA+B;IAC9C,qEAAqE;IACrE,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,yCAAyC;IACzC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,2EAA2E;IAC3E,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,0CAA0C;IAC1C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mDAAmD;IACnD,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,+DAA+D;AAC/D,MAAM,WAAW,oCAAoC;IACnD,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qGAAqG;IACrG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,sDAAsD;IACtD,QAAQ,CAAC,EAAE,+BAA+B,CAAC;CAC5C;AAoBD;;;;;;;;;;GAUG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,WAAW,CAAgC;gBAEvC,OAAO,GAAE,oCAAyC;IA8F9D;;;OAGG;IACH,OAAO,GAAI,OAAO,OAAO,KAAG,IAAI,CA2D9B;IAEF;;;OAGG;IACH,WAAW,GAAI,OAAO,OAAO,KAAG,IAAI,CAgFlC;IAEF;;;OAGG;IACH,eAAe,GAAI,OAAO,OAAO,KAAG,IAAI,CA0CtC;IAEF;;;OAGG;IACH,gBAAgB,GAAI,OAAO,OAAO,KAAG,IAAI,CAgDvC;IAEF;;;;OAIG;IACH,YAAY,GAAI,OAAO,OAAO,KAAG,IAAI,CAuHnC;IAEF;;;OAGG;IACH,QAAQ,GAAI,OAAO,OAAO,KAAG,IAAI,CA+C/B;IAMF;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,iEAAiE;IACjE,OAAO,CAAC,cAAc;CASvB"}