@mongodb-js/agent-engine-runner-shared 0.11.3

package/dist/tracing/exporters.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Span exporters for the Runner SDK tracing pipeline.
+ *
+ * Ported from `agent_engine_runner_shared/tracing/exporters.py`. Two exporters:
+ *   - `JSONLSpanExporter` — optional explicit local debugging exporter.
+ *   - `MongoDBSpanExporter` — inserts spans as documents into a Mongo collection.
+ *
+ * Both implement the `@opentelemetry/sdk-trace-base` `SpanExporter` interface.
+ */
+import type { ExportResult } from "@opentelemetry/core";
+import type { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
+import type { Collection } from "mongodb";
+/** Resolve the on-disk trace file path from env vars (mirrors Python). */
+export declare function getTracePath(): string;
+export declare class JSONLSpanExporter implements SpanExporter {
+    private readonly path;
+    constructor(path?: string);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+export declare class MongoDBSpanExporter implements SpanExporter {
+    private readonly collection;
+    constructor(collection: Collection);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+/**
+ * Read the content-capture policy from `AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE`.
+ * Defaults to `"metadata-only"`; any value other than `"full"` is treated as
+ * `"metadata-only"` so a typo'd env var fails closed, not open.
+ */
+export declare function getContentCaptureMode(): string;
+/**
+ * Wraps an OTLP `SpanExporter`, enforcing `AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE`.
+ * Redaction failures fail closed: a batch that can't be safely redacted is
+ * dropped rather than forwarded unredacted, matching the metadata-only
+ * default's privacy-first intent. Transport failures on the wrapped exporter
+ * never throw — they're surfaced only through `resultCallback`.
+ */
+export declare class ContentPolicyOTLPSpanExporter implements SpanExporter {
+    private readonly inner;
+    private readonly contentCaptureMode;
+    constructor(inner: SpanExporter, contentCaptureMode?: string);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    private exportInner;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+//# sourceMappingURL=exporters.d.ts.map

package/dist/tracing/exporters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporters.d.ts","sourceRoot":"","sources":["../../src/tracing/exporters.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAEhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAsB1C,0EAA0E;AAC1E,wBAAgB,YAAY,IAAI,MAAM,CAWrC;AAqDD,qBAAa,iBAAkB,YAAW,YAAY;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;gBAEzB,IAAI,CAAC,EAAE,MAAM;IAIzB,MAAM,CACJ,KAAK,EAAE,YAAY,EAAE,EACrB,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC7C,IAAI;IAqBP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B;AAED,qBAAa,mBAAoB,YAAW,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD,MAAM,CACJ,KAAK,EAAE,YAAY,EAAE,EACrB,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC7C,IAAI;IAeP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B;AAyED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAS9C;AA6CD;;;;;;GAMG;AACH,qBAAa,6BAA8B,YAAW,YAAY;IAI9D,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHxB,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAGzB,KAAK,EAAE,YAAY,EACpC,kBAAkB,CAAC,EAAE,MAAM;IAa7B,MAAM,CACJ,KAAK,EAAE,YAAY,EAAE,EACrB,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC7C,IAAI;IAyBP,OAAO,CAAC,WAAW;IAYnB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAMzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}

package/dist/tracing/exporters.js

@@ -0,0 +1,327 @@
+/**
+ * Span exporters for the Runner SDK tracing pipeline.
+ *
+ * Ported from `agent_engine_runner_shared/tracing/exporters.py`. Two exporters:
+ *   - `JSONLSpanExporter` — optional explicit local debugging exporter.
+ *   - `MongoDBSpanExporter` — inserts spans as documents into a Mongo collection.
+ *
+ * Both implement the `@opentelemetry/sdk-trace-base` `SpanExporter` interface.
+ */
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getLogger } from "../logger.js";
+const logger = getLogger("agent_engine_runner_shared.tracing");
+const EXPORT_SUCCESS = 0; // ExportResultCode.SUCCESS
+const EXPORT_FAILED = 1; // ExportResultCode.FAILED
+const MAX_TRACE_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+function rotateIfNeeded(path) {
+    try {
+        const stat = statSync(path, { throwIfNoEntry: false });
+        if (stat && stat.size >= MAX_TRACE_FILE_BYTES) {
+            renameSync(path, path + ".1");
+        }
+    }
+    catch {
+        // best-effort — a failed rotation is better than crashing the exporter
+    }
+}
+/** Resolve the on-disk trace file path from env vars (mirrors Python). */
+export function getTracePath() {
+    let path;
+    if (process.env["AGENTIC_TRACES_FILE"]) {
+        path = process.env["AGENTIC_TRACES_FILE"];
+    }
+    else if (process.env["AGENTIC_OBSERVABILITY_DIR"]) {
+        path = join(process.env["AGENTIC_OBSERVABILITY_DIR"], "traces.jsonl");
+    }
+    else {
+        path = join("observability", "traces.jsonl");
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    return path;
+}
+function spanToDoc(span) {
+    const ctx = span.spanContext();
+    const attributes = { ...span.attributes };
+    const sessionId = attributes["session.id"] ?? attributes["session_id"];
+    const executionId = attributes["execution.id"] ?? attributes["execution_id"];
+    const doc = {
+        trace_id: ctx.traceId,
+        span_id: ctx.spanId,
+        name: span.name,
+        kind: String(span.kind),
+        start_time_ns: hrtimeToNs(span.startTime),
+        end_time_ns: hrtimeToNs(span.endTime),
+        duration_ns: hrtimeDurationNs(span.startTime, span.endTime),
+        status: {
+            code: String(span.status.code),
+            description: span.status.message ?? null,
+        },
+        attributes,
+        resource: { ...(span.resource.attributes ?? {}) },
+    };
+    if (sessionId !== undefined)
+        doc["session_id"] = sessionId;
+    if (executionId !== undefined)
+        doc["execution_id"] = executionId;
+    if (span.parentSpanContext?.spanId) {
+        doc["parent_span_id"] = span.parentSpanContext.spanId;
+    }
+    if (span.events && span.events.length > 0) {
+        doc["events"] = span.events.map((e) => ({
+            name: e.name,
+            timestamp_ns: hrtimeToNs(e.time),
+            attributes: { ...(e.attributes ?? {}) },
+        }));
+    }
+    return doc;
+}
+function hrtimeToNs(t) {
+    return t[0] * 1e9 + t[1];
+}
+function hrtimeDurationNs(start, end) {
+    return hrtimeToNs(end) - hrtimeToNs(start);
+}
+export class JSONLSpanExporter {
+    path;
+    constructor(path) {
+        this.path = path ?? null;
+    }
+    export(spans, resultCallback) {
+        if (spans.length === 0) {
+            resultCallback({ code: EXPORT_SUCCESS });
+            return;
+        }
+        const target = this.path ?? getTracePath();
+        try {
+            rotateIfNeeded(target);
+            const lines = spans.map((s) => JSON.stringify(spanToDoc(s))).join("\n") + "\n";
+            appendFileSync(target, lines, { encoding: "utf-8" });
+            resultCallback({ code: EXPORT_SUCCESS });
+        }
+        catch (err) {
+            logger.error({ path: target, err: err.message }, "Failed to write traces");
+            resultCallback({ code: EXPORT_FAILED, error: err });
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+export class MongoDBSpanExporter {
+    collection;
+    constructor(collection) {
+        this.collection = collection;
+    }
+    export(spans, resultCallback) {
+        if (spans.length === 0) {
+            resultCallback({ code: EXPORT_SUCCESS });
+            return;
+        }
+        const docs = spans.map((s) => spanToDoc(s));
+        this.collection
+            .insertMany(docs)
+            .then(() => resultCallback({ code: EXPORT_SUCCESS }))
+            .catch((err) => {
+            logger.error({ err: err.message }, "Failed to write traces to MongoDB");
+            resultCallback({ code: EXPORT_FAILED, error: err });
+        });
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+// =============================================================================
+// Content-capture policy
+//
+// Mongo stays unredacted (customer's own BYOC DB, canonical for the
+// playground). This policy applies only to the OTLP path, which leaves the
+// process bound for a third-party tool. Ported from
+// `agent_engine_runner_shared/tracing/exporters.py` — keep `REDACTED_KEY_FRAGMENTS` in
+// sync with that module's `_REDACTED_KEY_FRAGMENTS`; a drifted copy either
+// leaks content this list was meant to block, or over-redacts metadata.
+// =============================================================================
+const CONTENT_CAPTURE_ENV = "AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE";
+const CONTENT_CAPTURE_FULL = "full";
+const CONTENT_CAPTURE_METADATA_ONLY = "metadata-only";
+// Substrings matched case-insensitively against attribute keys. OpenInference
+// flattens nested/indexed fields (e.g. "llm.input_messages.0.message.content"),
+// so this is fragment matching, not an exact-key set. See exporters.py for the
+// full rationale (allowlist deliberately deferred, etc.) — this list must stay
+// identical to Python's.
+const REDACTED_KEY_FRAGMENTS = [
+    // Prompts / completions
+    "input.value",
+    "output.value",
+    "llm.input_messages",
+    "llm.output_messages",
+    "llm.prompts",
+    "llm.prompt_template.variables",
+    "llm.prompt_template.template",
+    "llm.invocation_parameters",
+    "message.content",
+    "message.function_call_arguments_json",
+    "tool_call.function.arguments",
+    "llm.function_call",
+    // Tool args/results
+    "tool.parameters",
+    "llm.tools",
+    // Retrieved docs
+    "retrieval.documents",
+    "document.content",
+    "reranker.query",
+    // Embeddings
+    "embedding.embeddings",
+    "embedding.text",
+    "embedding.vector",
+    "embedding.invocation_parameters",
+    // Memory contents
+    "memory.content",
+    "memory.value",
+    // Real end-user identifier
+    "user.id",
+    // Free-form metadata / exceptions
+    "metadata",
+    "exception.message",
+    "exception.stacktrace",
+    // Network / infra
+    "http.url",
+    "url.full",
+    "net.peer",
+    "server.address",
+    "net.sock.peer",
+    "db.connection_string",
+    // Secrets
+    "secret",
+    "password",
+    "credential",
+    "api_key",
+    "access_token",
+    "bearer",
+];
+/**
+ * Read the content-capture policy from `AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE`.
+ * Defaults to `"metadata-only"`; any value other than `"full"` is treated as
+ * `"metadata-only"` so a typo'd env var fails closed, not open.
+ */
+export function getContentCaptureMode() {
+    const mode = (process.env[CONTENT_CAPTURE_ENV] ?? CONTENT_CAPTURE_METADATA_ONLY)
+        .trim()
+        .toLowerCase();
+    return mode === CONTENT_CAPTURE_FULL
+        ? CONTENT_CAPTURE_FULL
+        : CONTENT_CAPTURE_METADATA_ONLY;
+}
+function isRedactedAttributeKey(key) {
+    const lowered = key.toLowerCase();
+    return REDACTED_KEY_FRAGMENTS.some((fragment) => lowered.includes(fragment));
+}
+function redactAttributes(attributes) {
+    if (!attributes)
+        return {};
+    const redacted = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (!isRedactedAttributeKey(key))
+            redacted[key] = value;
+    }
+    return redacted;
+}
+/**
+ * Return a copy of `span` with content-bearing attributes (and event
+ * attributes) stripped.
+ *
+ * A real SDK `Span` exposes `spanContext()` (and other members) as methods
+ * on its prototype, not as own enumerable properties — a plain `{ ...span }`
+ * spread silently drops them, so anything downstream that calls
+ * `span.spanContext()` (e.g. the OTLP transformer) throws
+ * "span.spanContext is not a function". `Object.create(span)` instead makes
+ * `span` itself the new object's prototype: every unlisted member (methods
+ * and data alike) falls through the prototype chain to the original span
+ * unchanged, and only `attributes`/`events` are shadowed as own properties.
+ */
+function redactSpan(span) {
+    const redacted = Object.create(span);
+    Object.defineProperty(redacted, "attributes", {
+        value: redactAttributes(span.attributes),
+        enumerable: true,
+    });
+    Object.defineProperty(redacted, "events", {
+        value: (span.events ?? []).map((e) => ({
+            ...e,
+            attributes: redactAttributes(e.attributes),
+        })),
+        enumerable: true,
+    });
+    return redacted;
+}
+/**
+ * Wraps an OTLP `SpanExporter`, enforcing `AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE`.
+ * Redaction failures fail closed: a batch that can't be safely redacted is
+ * dropped rather than forwarded unredacted, matching the metadata-only
+ * default's privacy-first intent. Transport failures on the wrapped exporter
+ * never throw — they're surfaced only through `resultCallback`.
+ */
+export class ContentPolicyOTLPSpanExporter {
+    inner;
+    contentCaptureMode;
+    constructor(inner, contentCaptureMode) {
+        this.inner = inner;
+        if (contentCaptureMode !== undefined) {
+            const normalized = contentCaptureMode.trim().toLowerCase();
+            this.contentCaptureMode =
+                normalized === CONTENT_CAPTURE_FULL
+                    ? CONTENT_CAPTURE_FULL
+                    : CONTENT_CAPTURE_METADATA_ONLY;
+        }
+        else {
+            this.contentCaptureMode = getContentCaptureMode();
+        }
+    }
+    export(spans, resultCallback) {
+        if (spans.length === 0) {
+            resultCallback({ code: EXPORT_SUCCESS });
+            return;
+        }
+        if (this.contentCaptureMode === CONTENT_CAPTURE_FULL) {
+            this.exportInner(spans, resultCallback);
+            return;
+        }
+        let redacted;
+        try {
+            redacted = spans.map((span) => redactSpan(span));
+        }
+        catch (err) {
+            logger.error({ err: err.message }, "Content-capture redaction failed; dropping batch rather than risk exporting unredacted content");
+            resultCallback({ code: EXPORT_FAILED, error: err });
+            return;
+        }
+        this.exportInner(redacted, resultCallback);
+    }
+    exportInner(spans, resultCallback) {
+        try {
+            this.inner.export(spans, resultCallback);
+        }
+        catch (err) {
+            logger.error({ err: err.message }, "OTLP export failed");
+            resultCallback({ code: EXPORT_FAILED, error: err });
+        }
+    }
+    shutdown() {
+        return Promise.resolve(this.inner.shutdown()).catch((err) => {
+            logger.error({ err: err.message }, "OTLP exporter shutdown failed");
+        });
+    }
+    forceFlush() {
+        if (this.inner.forceFlush === undefined)
+            return Promise.resolve();
+        return Promise.resolve(this.inner.forceFlush()).catch((err) => {
+            logger.error({ err: err.message }, "OTLP exporter force_flush failed");
+        });
+    }
+}

package/dist/tracing/index.d.ts

@@ -0,0 +1,3 @@
+export { ContentPolicyOTLPSpanExporter, JSONLSpanExporter, MongoDBSpanExporter, getContentCaptureMode, getTracePath, } from "./exporters.js";
+export { setupTracing, shutdownTracing, attachMongoTracing, tracingStatus, getCurrentTraceContext, getTracer, runInstrumentor, scrubCredentials, type SetupTracingArgs, } from "./setup.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tracing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC"}

package/dist/tracing/index.js

@@ -0,0 +1,2 @@
+export { ContentPolicyOTLPSpanExporter, JSONLSpanExporter, MongoDBSpanExporter, getContentCaptureMode, getTracePath, } from "./exporters.js";
+export { setupTracing, shutdownTracing, attachMongoTracing, tracingStatus, getCurrentTraceContext, getTracer, runInstrumentor, scrubCredentials, } from "./setup.js";

package/dist/tracing/setup.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Tracing setup for Runner SDK.
+ *
+ * Ported from `agent_engine_runner_shared/tracing/setup.py`. Initializes OpenTelemetry
+ * with `BasicTracerProvider` and optionally a Mongo exporter. Calls the
+ * framework instrumentor hook
+ * registered via `agent_engine_runner_shared/hooks.ts:registerInstrumentor`.
+ */
+import type { Tracer } from "@opentelemetry/api";
+import type { Collection } from "mongodb";
+export interface SetupTracingArgs {
+    serviceName?: string;
+    /**
+     * URI for the trace store. When provided, `setupTracing` builds the
+     * MongoClient, pings `admin`, and resolves the `(database, collection)`
+     * itself.
+     *
+     * Python's `TenantRuntime._setup_tracing` does this synchronously and
+     * passes the collection in; Node's driver is fundamentally async so the
+     * connect + ping live here instead. After a connection failure, a background
+     * retry attaches the MongoDB exporter once the store recovers —
+     * same recovery shape as Python.
+     */
+    mongodbUri?: string | null;
+    /** Explicit database override. Omit to use the platform store default. */
+    mongodbDatabaseName?: string | null;
+    /** Collection name within `mongodbDatabaseName`. Defaults to `"traces"`. */
+    mongodbCollectionName?: string;
+}
+/**
+ * Mask the userinfo of any `mongodb://` / `mongodb+srv://` URI embedded in a
+ * credential-bearing error message (driver parse/connect errors echo the raw
+ * connection string).
+ *
+ * The userinfo run is GREEDY up to the LAST '@' that a host-shaped token
+ * follows, so passwords containing an unescaped '@', space, or '/' are still
+ * fully masked — the old `:\/\/[^@\s]+@` pattern stopped at the first '@' and
+ * could not cross whitespace, leaking the password tail (or the whole
+ * userinfo) to the centralized log sink. The run is tempered so it never
+ * crosses into a second URI's scheme; when message text after the URI
+ * contains its own '@' the mask may extend to it — over-redaction is the
+ * fail-closed direction, a leak is not recoverable. Keep in sync with
+ * `scrub_credentials` in Python's `agent_engine_runner_shared/tracing/setup.py`.
+ *
+ * Accepts `unknown` and coerces: error paths hand this whatever a rejection
+ * carried (string throws, objects without a string `message`, undefined) —
+ * it must never throw itself, or a degraded trace store turns into a
+ * startup failure.
+ */
+export declare function scrubCredentials(message: unknown): string;
+export declare function setupTracing(args?: SetupTracingArgs): Promise<void>;
+export declare function runInstrumentor(): void;
+export declare function shutdownTracing(): Promise<void>;
+/**
+ * Snapshot of the database trace-store exporter for /health. Mirrors Python's
+ * `tracing_status`: `"attached"` (MongoDB span processor live), `"degraded"`
+ * (store URI configured but unreachable at startup, retrying), or `"disabled"`
+ * (no store URI configured, not a degradation).
+ */
+export declare function tracingStatus(): {
+    database_exporter: string;
+};
+/**
+ * Wire the recovered trace-store collection into the lazy Mongo exporter
+ * registered at setup time. Called from the background retry loop
+ * once a failed connection recovers. Idempotent — a no-op if already attached.
+ * New spans created after this call route to the store; spans emitted while the
+ * store was unreachable are not retroactively recovered.
+ */
+export declare function attachMongoTracing(collection: Collection): void;
+export declare function getCurrentTraceContext(): {
+    traceId: string | null;
+    spanId: string | null;
+};
+export declare function getTracer(name?: string): Tracer;
+//# sourceMappingURL=setup.d.ts.map

package/dist/tracing/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/tracing/setup.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAW,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAe1D,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,SAAS,CAAC;AA4GvD,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,4EAA4E;IAC5E,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAqDD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CASzD;AAsED,wBAAsB,YAAY,CAAC,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY7E;AA8DD,wBAAgB,eAAe,IAAI,IAAI,CAiBtC;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAgCrD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAI7D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAmB/D;AAwDD,wBAAgB,sBAAsB,IAAI;IACxC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAMA;AAED,wBAAgB,SAAS,CAAC,IAAI,SAAe,GAAG,MAAM,CAErD"}