@veryfront/ext-observability-opentelemetry 0.1.1032 → 0.1.1035

package/esm/src/utils/logger/logger.js

@@ -0,0 +1,490 @@
+import { getEnv, isStdoutTTY } from "../../platform/compat/process.js";
+import { RUNTIME_VERSION } from "../version.js";
+import { ANSI, colorize, formatContextText, formatTimestamp, LEVEL_COLORS, LEVEL_GLYPHS, padTag, serializeError, } from "./core.js";
+import { redactSensitive, sanitizeSerializedError, sanitizeUrlCredentials } from "./redact.js";
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+// ---- Config helpers (must be declared before the eager init below) ----
+const LOG_LEVEL_MAP = {
+    DEBUG: LogLevel.DEBUG,
+    INFO: LogLevel.INFO,
+    WARN: LogLevel.WARN,
+    ERROR: LogLevel.ERROR,
+};
+function parseLogLevel(levelString) {
+    if (!levelString)
+        return undefined;
+    return LOG_LEVEL_MAP[levelString.toUpperCase()];
+}
+/**
+ * Determine the log level based on environment variables.
+ * Exported for testing purposes.
+ * @internal
+ */
+export function getDefaultLevel(envLevel = getEnv("LOG_LEVEL"), debugFlag = getEnv("VERYFRONT_DEBUG")) {
+    const parsedLevel = parseLogLevel(envLevel);
+    if (parsedLevel !== undefined)
+        return parsedLevel;
+    if (debugFlag === "1" || debugFlag === "true")
+        return LogLevel.DEBUG;
+    return LogLevel.INFO;
+}
+/**
+ * Determine log format from environment.
+ * Defaults to JSON in production for Grafana compatibility.
+ */
+function getDefaultFormat(envFormat = getEnv("LOG_FORMAT"), envMode = getEnv("NODE_ENV")) {
+    if (envFormat === "json" || envFormat === "text")
+        return envFormat;
+    return envMode === "production" ? "json" : "text";
+}
+// ---- Eager config resolution ----
+/**
+ * Eagerly resolved at module load time so the config is captured from
+ * host process env vars BEFORE any per-request project env overlay is
+ * active. The project overlay blocks access to host env (for security),
+ * which would cause the logger to fall back to "text" format during SSR.
+ */
+let loggerConfig = {
+    level: getDefaultLevel(),
+    format: getDefaultFormat(),
+};
+let logRecordEmitter = null;
+/**
+ * Re-read logger configuration from environment variables.
+ * Call after loading .env files so the logger picks up any overrides.
+ */
+export function refreshLoggerConfig() {
+    loggerConfig = {
+        level: getDefaultLevel(),
+        format: getDefaultFormat(),
+    };
+}
+/** @internal Alias kept for tests. */
+export const __resetLoggerConfigForTests = refreshLoggerConfig;
+/** Register a process-level structured log emitter, for example an OTel bridge. */
+export function __registerLogRecordEmitter(emitter) {
+    logRecordEmitter = emitter;
+}
+/** Reset the process-level structured log emitter. Only intended for tests. */
+export function __resetLogRecordEmitterForTests() {
+    logRecordEmitter = null;
+}
+function resolveLoggerConfig() {
+    return loggerConfig;
+}
+/**
+ * Extract context from variadic args.
+ * First object argument becomes context, errors are handled specially.
+ */
+function extractContext(args) {
+    let context;
+    let error;
+    for (const arg of args) {
+        if (arg instanceof Error) {
+            error = serializeError(arg);
+            continue;
+        }
+        if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+            const contextArg = arg;
+            if (contextArg.error instanceof Error) {
+                const { error: contextError, ...rest } = contextArg;
+                error = serializeError(contextError);
+                if (Object.keys(rest).length > 0) {
+                    context = { ...context, ...rest };
+                }
+                continue;
+            }
+            context = { ...context, ...contextArg };
+        }
+    }
+    return { context, error };
+}
+const TAG_COLORS = {
+    CLI: ANSI.green,
+    SERVER: ANSI.blue,
+    RENDERER: ANSI.magenta,
+    BUNDLER: ANSI.yellow,
+    AGENT: ANSI.cyan,
+    PROXY: ANSI.cyan,
+    VERYFRONT: ANSI.cyan,
+};
+function isTty() {
+    try {
+        return isStdoutTTY();
+    }
+    catch (_) {
+        /* expected: TTY detection may fail in restricted environments */
+        return false;
+    }
+}
+function shouldUseColor() {
+    const noColor = getEnv("NO_COLOR");
+    const forceColor = getEnv("FORCE_COLOR");
+    const logColor = getEnv("LOG_COLOR");
+    if (forceColor === "0" || logColor === "0")
+        return false;
+    if (noColor !== undefined)
+        return false;
+    if (getEnv("CI") !== undefined)
+        return false;
+    if (forceColor || logColor === "1" || logColor === "true")
+        return true;
+    return isTty();
+}
+function extractToEntryField(entry, context, key, coerce) {
+    if (!(key in context))
+        return;
+    entry[key] = coerce(context[key]);
+    delete context[key];
+}
+function extractAliasToEntryField(entry, context, sourceKey, targetKey, coerce) {
+    if (entry[targetKey] !== undefined || !(sourceKey in context))
+        return;
+    entry[targetKey] = coerce(context[sourceKey]);
+    delete context[sourceKey];
+}
+class ConsoleLogger {
+    prefix;
+    options;
+    boundContext;
+    componentName;
+    constructor(prefix, boundContext, componentName, options = {}) {
+        this.prefix = prefix;
+        this.options = options;
+        this.boundContext = boundContext ?? {};
+        this.componentName = componentName;
+    }
+    child(context) {
+        return new ConsoleLogger(this.prefix, { ...this.boundContext, ...context }, this.componentName, this.options);
+    }
+    component(name) {
+        return new ConsoleLogger(this.prefix, { ...this.boundContext }, name, this.options);
+    }
+    createEntry(level, message, args) {
+        const { context, error } = extractContext(args);
+        const mergedContext = { ...this.boundContext, ...context };
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            service: this.prefix.toLowerCase(),
+            veryfrontVersion: RUNTIME_VERSION,
+            message,
+        };
+        if (this.componentName)
+            entry.component = this.componentName;
+        // Extract known fields to top level for easier Grafana filtering
+        extractToEntryField(entry, mergedContext, "requestId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "traceId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "spanId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "projectSlug", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "durationMs", (v) => Number(v));
+        // Auto-inject trace context from OTel when not already set
+        if ((this.options.injectTraceContext ?? true) && traceContextGetter && !entry.traceId) {
+            const traceCtx = traceContextGetter();
+            if (traceCtx.traceId) {
+                entry.traceId = traceCtx.traceId;
+                entry.spanId = traceCtx.spanId;
+            }
+        }
+        // Extract standard snake_case fields for Loki filtering
+        extractToEntryField(entry, mergedContext, "request_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "trace_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "span_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "project_slug", (v) => String(v));
+        // request_url / domain are URL-shaped and lifted out of mergedContext
+        // *before* redactSensitive runs, so they bypass the key-based redactor.
+        // Scrub embedded credentials (userinfo, ?access_token=, …) here (#1989).
+        extractToEntryField(entry, mergedContext, "request_url", (v) => sanitizeUrlCredentials(String(v)));
+        extractToEntryField(entry, mergedContext, "domain", (v) => sanitizeUrlCredentials(String(v)));
+        extractToEntryField(entry, mergedContext, "project_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "release_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "branch_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "branch_name", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "run_execution_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "run_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "agent_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "thread_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "schedule_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "schedule_name", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "tool_name", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "tool_call_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "batch_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "run_target", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "task", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "event_kind", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "user_visible", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "duration_ms", (v) => Number(v));
+        extractToEntryField(entry, mergedContext, "user_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "conversation_id", (v) => String(v));
+        // Also extract camelCase variants so callers can use either convention
+        extractToEntryField(entry, mergedContext, "userId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "conversationId", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "runId", "run_id", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "agentId", "agent_id", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "threadId", "thread_id", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "scheduleId", "schedule_id", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "scheduleName", "schedule_name", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "toolName", "tool_name", (v) => String(v));
+        extractAliasToEntryField(entry, mergedContext, "toolCallId", "tool_call_id", (v) => String(v));
+        // Emit snake_case aliases for camelCase fields (transition period)
+        if (entry.requestId && !entry.request_id)
+            entry.request_id = entry.requestId;
+        if (entry.traceId && !entry.trace_id)
+            entry.trace_id = entry.traceId;
+        if (entry.spanId && !entry.span_id)
+            entry.span_id = entry.spanId;
+        if (entry.projectSlug && !entry.project_slug)
+            entry.project_slug = entry.projectSlug;
+        if (entry.durationMs != null && entry.duration_ms == null)
+            entry.duration_ms = entry.durationMs;
+        if (entry.userId && !entry.user_id)
+            entry.user_id = entry.userId;
+        if (entry.conversationId && !entry.conversation_id) {
+            entry.conversation_id = entry.conversationId;
+        }
+        // Redact credential-like keys from the free-form context bag before
+        // serialization (the deliberate top-level fields above are already
+        // extracted out of mergedContext, so they are unaffected).
+        if (Object.keys(mergedContext).length > 0)
+            entry.context = redactSensitive(mergedContext);
+        // The serialized error (name/message/stack) bypasses the key-based
+        // redactor; scrub credentials embedded in its message/stack (DSNs, Mongo
+        // URIs, ?access_token= URLs, userinfo) before emission (#1989).
+        if (error)
+            entry.error = sanitizeSerializedError(error);
+        return entry;
+    }
+    formatJson(level, message, args) {
+        const entry = this.createEntry(level, message, args);
+        return JSON.stringify(entry);
+    }
+    formatTextLine(level, message, args) {
+        const { context, error } = extractContext(args);
+        const mergedContext = { ...this.boundContext, ...context };
+        const enableColor = shouldUseColor();
+        const timestamp = colorize(formatTimestamp(), ANSI.dim, enableColor);
+        const tag = colorize(padTag(this.prefix), TAG_COLORS[this.prefix] ?? ANSI.cyan, enableColor);
+        const glyph = colorize(LEVEL_GLYPHS[level], LEVEL_COLORS[level], enableColor);
+        const componentTag = this.componentName
+            ? ` ${colorize(`[${this.componentName}]`, ANSI.dim, enableColor)}`
+            : "";
+        const contextText = formatContextText(redactSensitive(mergedContext), sanitizeSerializedError(error), enableColor);
+        return `${timestamp}  ${tag} ${glyph}${componentTag} ${message}${contextText}`;
+    }
+    log(level, logLevel, consoleFn, message, args) {
+        const { level: resolvedLevel, format: resolvedFormat } = resolveLoggerConfig();
+        if (resolvedLevel > logLevel)
+            return;
+        let entry;
+        const line = resolvedFormat === "json"
+            ? (() => {
+                entry = this.createEntry(level, message, args);
+                return JSON.stringify(entry);
+            })()
+            : this.formatTextLine(level, message, args);
+        if (logRecordEmitter) {
+            try {
+                logRecordEmitter(entry ?? this.createEntry(level, message, args));
+            }
+            catch (_) {
+                /* do not let telemetry export failures affect application logging */
+            }
+        }
+        consoleFn(line);
+    }
+    debug(message, ...args) {
+        this.log("debug", LogLevel.DEBUG, console.debug, message, args);
+    }
+    info(message, ...args) {
+        this.log("info", LogLevel.INFO, console.log, message, args);
+    }
+    warn(message, ...args) {
+        this.log("warn", LogLevel.WARN, console.warn, message, args);
+    }
+    error(message, ...args) {
+        this.log("error", LogLevel.ERROR, console.error, message, args);
+    }
+    async time(label, fn) {
+        const start = performance.now();
+        try {
+            const result = await fn();
+            const durationMs = performance.now() - start;
+            this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
+            return result;
+        }
+        catch (error) {
+            const durationMs = performance.now() - start;
+            this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
+            throw error;
+        }
+    }
+}
+function createLogger(prefix, options) {
+    return new ConsoleLogger(prefix, undefined, undefined, options);
+}
+// Base loggers without request context
+const baseCliLogger = createLogger("CLI");
+const baseServerLogger = createLogger("SERVER");
+const baseRendererLogger = createLogger("RENDERER");
+const baseBundlerLogger = createLogger("BUNDLER");
+const baseAgentLogger = createLogger("AGENT");
+const baseProxyLogger = createLogger("PROXY");
+const baseLogger = createLogger("VERYFRONT");
+const BASE_LOGGER_MAP = {
+    CLI: baseCliLogger,
+    SERVER: baseServerLogger,
+    RENDERER: baseRendererLogger,
+    BUNDLER: baseBundlerLogger,
+    AGENT: baseAgentLogger,
+    PROXY: baseProxyLogger,
+};
+/**
+ * Request context getter - set by request-context.ts to avoid circular imports.
+ * This pattern allows the logger module to be imported first without
+ * depending on request-context.ts.
+ */
+let requestContextGetter = null;
+/**
+ * Register the request context getter.
+ * Called by request-context.ts during module initialization.
+ * @internal
+ */
+export function __registerRequestContextGetter(getter) {
+    requestContextGetter = getter;
+}
+/**
+ * Trace context getter - set by trace-bridge.ts to avoid importing OTel
+ * directly in the logger module. Returns the active span's traceId/spanId
+ * when OTel is initialized.
+ */
+let traceContextGetter = null;
+/**
+ * Register the trace context getter.
+ * Called by trace-bridge.ts after OTLP initialization.
+ * @internal
+ */
+export function __registerTraceContextGetter(getter) {
+    traceContextGetter = getter;
+}
+/**
+ * Reset the trace context getter.
+ * Only intended for testing purposes.
+ * @internal
+ */
+export function __resetTraceContextGetterForTests() {
+    traceContextGetter = null;
+}
+function withRequestLogger(base) {
+    const ctx = requestContextGetter?.();
+    return ctx?.logger ?? base;
+}
+/**
+ * Create a context-aware logger proxy that automatically uses
+ * request-scoped context from AsyncLocalStorage when available.
+ */
+function createContextAwareLogger(base) {
+    return {
+        debug(message, ...args) {
+            withRequestLogger(base).debug(message, ...args);
+        },
+        info(message, ...args) {
+            withRequestLogger(base).info(message, ...args);
+        },
+        warn(message, ...args) {
+            withRequestLogger(base).warn(message, ...args);
+        },
+        error(message, ...args) {
+            withRequestLogger(base).error(message, ...args);
+        },
+        time(label, fn) {
+            return withRequestLogger(base).time(label, fn);
+        },
+        child(context) {
+            return withRequestLogger(base).child(context);
+        },
+        component(name) {
+            return createComponentAwareLogger(base, name);
+        },
+    };
+}
+/**
+ * Create a component-scoped logger that still defers request-context
+ * resolution to call time. This avoids eagerly binding to whatever
+ * context exists at module load — critical because component loggers
+ * are typically created as top-level constants.
+ */
+function createComponentAwareLogger(base, componentName) {
+    return {
+        debug(message, ...args) {
+            withRequestLogger(base).component(componentName).debug(message, ...args);
+        },
+        info(message, ...args) {
+            withRequestLogger(base).component(componentName).info(message, ...args);
+        },
+        warn(message, ...args) {
+            withRequestLogger(base).component(componentName).warn(message, ...args);
+        },
+        error(message, ...args) {
+            withRequestLogger(base).component(componentName).error(message, ...args);
+        },
+        time(label, fn) {
+            return withRequestLogger(base).component(componentName).time(label, fn);
+        },
+        child(context) {
+            return withRequestLogger(base).component(componentName).child(context);
+        },
+        component(name) {
+            return createComponentAwareLogger(base, name);
+        },
+    };
+}
+// Context-aware loggers that automatically include request context
+export const cliLogger = createContextAwareLogger(baseCliLogger);
+/** Shared server logger value. */
+export const serverLogger = createContextAwareLogger(baseServerLogger);
+/** Shared renderer logger value. */
+export const rendererLogger = createContextAwareLogger(baseRendererLogger);
+/** Shared bundler logger value. */
+export const bundlerLogger = createContextAwareLogger(baseBundlerLogger);
+/** Shared agent logger value. */
+export const agentLogger = createContextAwareLogger(baseAgentLogger);
+export const proxyLogger = createContextAwareLogger(baseProxyLogger);
+/** Shared logger value. */
+export const logger = createContextAwareLogger(baseLogger);
+/**
+ * Get the base logger without request context awareness.
+ * Use this when you need to create a request-scoped logger in middleware.
+ */
+export function getBaseLogger(prefix, options) {
+    const resolvedPrefix = prefix.toUpperCase();
+    const validPrefix = resolvedPrefix in BASE_LOGGER_MAP ? resolvedPrefix : "VERYFRONT";
+    if (options?.injectTraceContext === false) {
+        return createLogger(validPrefix, options);
+    }
+    return BASE_LOGGER_MAP[resolvedPrefix] ?? baseLogger;
+}
+/**
+ * Create a logger for a specific request context.
+ * Useful for binding request-specific metadata to all logs.
+ */
+export function createRequestLogger(baseLogger, requestContext) {
+    return baseLogger.child(requestContext);
+}
+/** Create run user logger. */
+export function createRunUserLogger(baseLogger, runContext) {
+    return baseLogger.child({
+        project_id: runContext.projectId,
+        run_execution_id: runContext.runExecutionId,
+        ...(runContext.batchId ? { batch_id: runContext.batchId } : {}),
+        ...(runContext.runTarget ? { run_target: runContext.runTarget } : {}),
+        task: runContext.task,
+        event_kind: runContext.eventKind ?? "run_user_log",
+        user_visible: "true",
+    });
+}

package/esm/src/utils/logger/redact.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Secret / credential redaction for structured log context.
+ *
+ * Defense-in-depth (#1989): the logger, the error-logging path, and the
+ * observability log buffer all accept arbitrary `context`/`data` objects from
+ * callers and serialize them to log sinks. There is no guarantee a caller
+ * never hands us a tokens object, an `Authorization` header bag, or a request
+ * body with a password field. This pass masks values whose *key* looks like a
+ * credential before serialization, so an accidental
+ * `logger.info("...", { authorization: token })` cannot leak the secret.
+ *
+ * Scope is intentionally key-based: we do not attempt to find secrets embedded
+ * in free-form message strings (too lossy). The deny-list errs toward
+ * over-redaction — masking a benign `tokenCount` is acceptable; leaking a real
+ * token is not. The traversal fails *closed*: on a cycle, depth overflow, or a
+ * throwing getter it returns {@link REDACTED} rather than risk emitting an
+ * unredacted object.
+ */
+/** Replacement value substituted for any sensitive field. */
+export declare const REDACTED = "[REDACTED]";
+/**
+ * Whether a context key names a credential and should have its value masked.
+ *
+ * Uses substring matching on a normalized key, so `clientSecret`,
+ * `x-api-key`, and `refresh_token` all match while benign words that merely
+ * *contain* a pattern as a separate token (e.g. `author`) do not — `author`
+ * normalizes to `author`, which contains none of the patterns.
+ */
+export declare function isSensitiveKey(key: string): boolean;
+/**
+ * Returns a redacted deep copy of `context`. Any property whose key is
+ * {@link isSensitiveKey} has its value replaced with {@link REDACTED}; nested
+ * plain objects, class instances, and arrays are traversed. The input is never
+ * mutated, and the pass fails closed (returns {@link REDACTED}) on cycles,
+ * depth overflow, or a throwing getter.
+ */
+export declare function redactSensitive<T>(context: T): T;
+/**
+ * Strip credentials from URL-shaped strings so they can be safely emitted in
+ * free-form text (error messages, stacks, lifted `request_url` fields). Unlike
+ * {@link redactSensitive}, which is key-based, this scrubs secrets embedded in
+ * the *value* itself:
+ *
+ * - URL userinfo: `http://user:pass@host` → `http://user:[REDACTED]@host`
+ * - sensitive query params: `?access_token=abc` → `?access_token=[REDACTED]`
+ *
+ * It is intentionally tolerant: it operates on any string (a DSN, a Mongo URI,
+ * an axios error message containing a URL) via regex rather than requiring a
+ * parseable URL, so malformed or partial URLs in error text are still scrubbed.
+ * Non-URL strings pass through unchanged.
+ */
+export declare function sanitizeUrlCredentials(input: string): string;
+/**
+ * Return the URL form safe to attach to observability span attributes.
+ *
+ * Span attributes bypass the logger's structured redaction pass, so `http.url`
+ * must not include query strings, fragments, or URL userinfo. This intentionally
+ * strips every query parameter instead of selectively redacting credential-like
+ * names because cache keys and callback state can be sensitive even when the
+ * parameter name is not obviously a credential.
+ */
+export declare function sanitizeUrlForSpan(input: string): string;
+/**
+ * Apply {@link sanitizeUrlCredentials} to the `message` and `stack` of a
+ * serialized-error-shaped object, returning a new object. Used by the logger's
+ * JSON and text paths so errors carrying DSNs, Mongo URIs, or
+ * `?access_token=`-bearing URLs do not leak credentials (the serialized error
+ * bypasses the key-based redactor). Returns the input unchanged when falsy.
+ */
+export declare function sanitizeSerializedError<T extends {
+    message?: unknown;
+    stack?: unknown;
+} | undefined>(error: T): T;
+//# sourceMappingURL=redact.d.ts.map

package/esm/src/utils/logger/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,eAAe,CAAC;AA8CrC;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAcnD;AA6ED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAEhD;AA2BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA4B5D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgBxD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EAC5D,KAAK,EAAE,CAAC,GAAG,CAAC,CAMb"}