@runtime-digital-twin/sdk 1.0.0

package/dist/db-wrapper.js

@@ -0,0 +1,636 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbQueryMatcher = void 0;
+exports.normalizeSql = normalizeSql;
+exports.computeParamsHash = computeParamsHash;
+exports.extractOperation = extractOperation;
+exports.compareDbQueries = compareDbQueries;
+exports.parseRecordedDbQueries = parseRecordedDbQueries;
+exports.wrapDbClient = wrapDbClient;
+exports.formatDbQueryMismatch = formatDbQueryMismatch;
+exports.formatUnexpectedDbQuery = formatUnexpectedDbQuery;
+exports.formatMissingDbQuery = formatMissingDbQuery;
+exports.formatBlockedDbAccess = formatBlockedDbAccess;
+exports.formatDbQueryFailure = formatDbQueryFailure;
+exports.createWrappedDbClient = createWrappedDbClient;
+const crypto_1 = require("crypto");
+const trace_bundle_writer_1 = require("./trace-bundle-writer");
+const http_wrapper_1 = require("./http-wrapper");
+/**
+ * Normalize SQL for matching: lowercase, trim whitespace, normalize spaces
+ */
+function normalizeSql(sql) {
+    return sql
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, " ")
+        .replace(/\(\s+/g, "(")
+        .replace(/\s+\)/g, ")");
+}
+/**
+ * Compute hash of query parameters
+ */
+function computeParamsHash(params) {
+    const paramsStr = JSON.stringify(params);
+    const hash = (0, crypto_1.createHash)("sha256").update(paramsStr).digest("hex");
+    return `sha256:${hash}`;
+}
+/**
+ * Extract operation type from SQL
+ */
+function extractOperation(sql) {
+    const normalized = sql.trim().toUpperCase();
+    if (normalized.startsWith("SELECT"))
+        return "SELECT";
+    if (normalized.startsWith("INSERT"))
+        return "INSERT";
+    if (normalized.startsWith("UPDATE"))
+        return "UPDATE";
+    if (normalized.startsWith("DELETE"))
+        return "DELETE";
+    if (normalized.startsWith("CREATE"))
+        return "CREATE";
+    if (normalized.startsWith("DROP"))
+        return "DROP";
+    if (normalized.startsWith("ALTER"))
+        return "ALTER";
+    return "UNKNOWN";
+}
+/**
+ * Compare two queries and return differences
+ */
+function compareDbQueries(expected, actual) {
+    const diffs = [];
+    // SQL (normalized)
+    const expectedSql = expected.normalizedSql;
+    const actualSql = normalizeSql(actual.sql);
+    if (expectedSql !== actualSql) {
+        diffs.push({ field: "sql", expected: expectedSql, actual: actualSql });
+    }
+    // Params hash
+    const expectedParamsHash = expected.paramsHash;
+    const actualParamsHash = computeParamsHash(actual.params);
+    if (expectedParamsHash !== actualParamsHash) {
+        diffs.push({
+            field: "params",
+            expected: JSON.stringify(expected.params),
+            actual: JSON.stringify(actual.params),
+        });
+    }
+    return { matches: diffs.length === 0, diffs };
+}
+/**
+ * Ordered DB query matcher for replay
+ */
+class DbQueryMatcher {
+    recordedQueries = [];
+    currentIndex = 0;
+    mode;
+    traceDir;
+    divergences = [];
+    logger = null;
+    constructor(recordedQueries, mode, traceDir, logger) {
+        this.recordedQueries = recordedQueries;
+        this.mode = mode;
+        this.traceDir = traceDir;
+        this.logger = logger || null;
+    }
+    /**
+     * Set the logger for structured replay logging
+     */
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Get all recorded divergences
+     */
+    getDivergences() {
+        return [...this.divergences];
+    }
+    /**
+     * Get current query index
+     */
+    getCurrentIndex() {
+        return this.currentIndex;
+    }
+    /**
+     * Get total recorded queries
+     */
+    getTotalQueries() {
+        return this.recordedQueries.length;
+    }
+    /**
+     * Check if only SELECT queries are in the recorded set
+     */
+    isReadOnly() {
+        return this.recordedQueries.every((q) => q.operation === "SELECT");
+    }
+    /**
+     * Match the next DB query against the recorded sequence
+     *
+     * In strict mode: throws DbQueryMismatch on any mismatch
+     * In explain mode: emits divergence and returns best-effort match
+     */
+    matchNext(actual) {
+        const queryIndex = this.currentIndex;
+        const operation = extractOperation(actual.sql);
+        const normalizedSql = normalizeSql(actual.sql);
+        const paramsHash = computeParamsHash(actual.params);
+        // Phase 1: Only support SELECT queries
+        if (operation !== "SELECT") {
+            const failure = {
+                type: "blocked_db_access",
+                location: `${this.traceDir}/events.jsonl:query[${queryIndex}]`,
+                expected: "SELECT query only (Phase 1)",
+                actual: `${operation} query`,
+                hint: "DB replay Phase 1 only supports SELECT queries. Write operations are blocked.",
+                query: actual,
+            };
+            // Log blocked query
+            this.logger?.dbBlocked({
+                operation,
+                sql: actual.sql.substring(0, 100),
+                reason: "Phase 1 only supports SELECT queries",
+            });
+            throw failure;
+        }
+        // Check if we've exceeded recorded queries
+        if (queryIndex >= this.recordedQueries.length) {
+            const failure = {
+                type: "unexpected_db_query",
+                location: `${this.traceDir}/events.jsonl:query[${queryIndex}]`,
+                expected: `<end of recorded queries after ${this.recordedQueries.length} query(s)>`,
+                actual: `${operation}: ${normalizedSql.substring(0, 50)}...`,
+                hint: "A DB query occurred during replay that was not recorded in the original trace.",
+                queryIndex,
+                service: this.traceDir,
+                query: actual,
+            };
+            // Log unexpected query
+            this.logger?.dbUnexpected({
+                queryIndex,
+                operation,
+                sql: normalizedSql,
+                paramsHash,
+                expectedQueryCount: this.recordedQueries.length,
+            });
+            if (this.mode === "strict") {
+                throw failure;
+            }
+            this.divergences.push({
+                type: "divergence",
+                severity: "error",
+                queryIndex,
+                message: `Unexpected DB query: ${actual.sql.substring(0, 50)}...`,
+                expected: null,
+                actual,
+                recoverable: false,
+            });
+            throw failure;
+        }
+        const expected = this.recordedQueries[queryIndex];
+        const { matches, diffs } = compareDbQueries(expected, actual);
+        if (matches) {
+            // Log successful match
+            this.logger?.dbMatch({
+                queryIndex,
+                operation,
+                sql: actual.sql,
+                normalizedSql,
+                paramsHash,
+                matchedSpanId: expected.spanId,
+                rowCount: expected.result.rowCount,
+            });
+            this.currentIndex++;
+            return expected;
+        }
+        // Explain mode: check if divergence is recoverable
+        // Only params difference is recoverable (same query structure)
+        const criticalDiffs = diffs.filter((d) => d.field === "sql");
+        const recoverable = criticalDiffs.length === 0;
+        // Log mismatch
+        this.logger?.dbMismatch({
+            queryIndex,
+            expected: {
+                operation: expected.operation,
+                sql: expected.normalizedSql,
+                paramsHash: expected.paramsHash,
+            },
+            actual: {
+                operation,
+                sql: normalizedSql,
+                paramsHash,
+            },
+            differences: diffs,
+            recoverable,
+        });
+        // Mismatch detected
+        const failure = {
+            type: "db_query_mismatch",
+            location: `${this.traceDir}/events.jsonl:query[${queryIndex}]`,
+            expected: `${expected.operation}: ${expected.normalizedSql.substring(0, 50)}...`,
+            actual: `${operation}: ${normalizedSql.substring(0, 50)}...`,
+            hint: "DB query does not match recorded trace. Check for non-determinism or code changes.",
+            queryIndex,
+            service: this.traceDir,
+            diff: diffs,
+        };
+        if (this.mode === "strict") {
+            throw failure;
+        }
+        this.divergences.push({
+            type: "divergence",
+            severity: recoverable ? "warning" : "error",
+            queryIndex,
+            message: `DB query mismatch: ${diffs
+                .map((d) => `${d.field}`)
+                .join(", ")}`,
+            expected,
+            actual,
+            recoverable,
+        });
+        console.warn(`[Replay] DB query divergence at query ${queryIndex}: ${failure.expected} vs ${failure.actual}`);
+        for (const diff of diffs) {
+            console.warn(`  ${diff.field}: expected="${diff.expected?.substring(0, 50)}" actual="${diff.actual?.substring(0, 50)}"`);
+        }
+        if (!recoverable) {
+            throw failure;
+        }
+        // Continue with the recorded response despite param differences
+        this.currentIndex++;
+        return expected;
+    }
+    /**
+     * Check if all recorded queries have been matched
+     */
+    isComplete() {
+        return this.currentIndex >= this.recordedQueries.length;
+    }
+    /**
+     * Get summary of unmatched queries
+     */
+    getUnmatchedQueries() {
+        return this.recordedQueries.slice(this.currentIndex);
+    }
+    /**
+     * Finalize replay and check for missing DB queries
+     */
+    finalize() {
+        const missingQueries = [];
+        const unmatchedQueries = this.getUnmatchedQueries();
+        for (let i = 0; i < unmatchedQueries.length; i++) {
+            const recordedQuery = unmatchedQueries[i];
+            const queryIndex = this.currentIndex + i;
+            const failure = {
+                type: "missing_db_query",
+                location: `${this.traceDir}/events.jsonl:query[${queryIndex}]`,
+                expected: `${recordedQuery.operation}: ${recordedQuery.normalizedSql.substring(0, 50)}...`,
+                actual: "<query never executed>",
+                hint: "A recorded DB query was never executed during replay.",
+                queryIndex,
+                service: this.traceDir,
+                spanId: recordedQuery.spanId,
+                recordedQuery,
+            };
+            missingQueries.push(failure);
+            // Log missing query
+            this.logger?.dbMissing({
+                queryIndex,
+                operation: recordedQuery.operation,
+                sql: recordedQuery.normalizedSql,
+                spanId: recordedQuery.spanId,
+            });
+            this.divergences.push({
+                type: "divergence",
+                severity: "error",
+                queryIndex,
+                message: `Missing DB query: ${recordedQuery.operation} ${recordedQuery.normalizedSql.substring(0, 50)}...`,
+                expected: recordedQuery,
+                actual: { sql: "", params: [] },
+                recoverable: false,
+            });
+            console.warn(`[Replay] Missing query ${queryIndex}: expected ${recordedQuery.operation} ${recordedQuery.normalizedSql.substring(0, 50)}...`);
+        }
+        if (missingQueries.length > 0 && this.mode === "strict") {
+            throw missingQueries[0];
+        }
+        return missingQueries;
+    }
+}
+exports.DbQueryMatcher = DbQueryMatcher;
+/**
+ * Parse recorded DB queries from trace events
+ */
+function parseRecordedDbQueries(events) {
+    const queries = [];
+    for (const event of events) {
+        if (event.type === "db.query") {
+            queries.push({
+                spanId: event.spanId,
+                operation: event.operation,
+                sql: event.sql,
+                normalizedSql: normalizeSql(event.sql),
+                params: event.params || [],
+                paramsHash: computeParamsHash(event.params || []),
+                result: {
+                    rows: event.rows || [],
+                    rowCount: event.rowCount || 0,
+                    resultHash: event.resultHash || null,
+                    resultBlob: event.resultBlob || null,
+                },
+                durationMs: event.durationMs || 0,
+            });
+        }
+    }
+    return queries;
+}
+/**
+ * Wrap a DB client for recording or replay
+ *
+ * During recording: captures queries and results
+ * During replay: returns recorded results, blocks live DB access
+ */
+function wrapDbClient(client, options) {
+    const { mode, matcher, readBlob } = options;
+    let queryCount = 0;
+    if (mode === "replay") {
+        if (!matcher) {
+            throw new Error("DbQueryMatcher is required for replay mode");
+        }
+        // Replay mode: return recorded results, never touch live DB
+        return {
+            async query(sql, params = []) {
+                queryCount++;
+                // Match against recorded queries
+                const recorded = matcher.matchNext({ sql, params });
+                // Return recorded result
+                let rows = recorded.result.rows;
+                // If rows are stored in blob, read from blob
+                if (recorded.result.resultBlob && readBlob && rows.length === 0) {
+                    const blobRows = await readBlob(recorded.result.resultBlob);
+                    if (blobRows) {
+                        rows = blobRows;
+                    }
+                }
+                return {
+                    rows,
+                    rowCount: recorded.result.rowCount,
+                };
+            },
+            getQueryCount() {
+                return queryCount;
+            },
+        };
+    }
+    // Record mode: capture queries and forward to real client
+    if (!client) {
+        throw new Error("DbClient is required for record mode");
+    }
+    return {
+        async query(sql, params = []) {
+            queryCount++;
+            const { bundle, spanId } = (0, http_wrapper_1.getTraceContext)();
+            const operation = extractOperation(sql);
+            const startTime = Date.now();
+            const querySpanId = (0, trace_bundle_writer_1.generateSpanId)();
+            try {
+                // Execute the real query
+                const result = await client.query(sql, params);
+                const endTime = Date.now();
+                const durationMs = endTime - startTime;
+                // Record the query if we have a trace context
+                if (bundle) {
+                    // Store result rows (potentially as blob if large)
+                    const { bodyHash: resultHash, bodyBlob: resultBlob } = await (0, trace_bundle_writer_1.processBody)(result.rows, bundle.writeBlob);
+                    await bundle.writeEvent({
+                        type: "db.query",
+                        timestamp: startTime,
+                        spanId: querySpanId,
+                        parentSpanId: spanId,
+                        operation,
+                        sql,
+                        params,
+                        rows: resultBlob ? [] : result.rows, // Inline if small, empty if in blob
+                        resultHash,
+                        resultBlob,
+                        rowCount: result.rowCount,
+                        durationMs,
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                const endTime = Date.now();
+                // Record error if we have a trace context
+                if (bundle) {
+                    const err = error;
+                    await bundle.writeEvent({
+                        type: "error",
+                        timestamp: endTime,
+                        spanId: querySpanId,
+                        parentSpanId: spanId,
+                        error: {
+                            name: err.name || "Error",
+                            message: err.message || String(error),
+                            stack: err.stack || undefined,
+                        },
+                    });
+                }
+                throw error;
+            }
+        },
+        getQueryCount() {
+            return queryCount;
+        },
+    };
+}
+/**
+ * Format DbQueryMismatch for CLI output
+ */
+function formatDbQueryMismatch(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Service: ${failure.service}`,
+        `  Query #${failure.queryIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Differences:`,
+    ];
+    for (const diff of failure.diff) {
+        lines.push(`    ${diff.field}: "${diff.expected?.substring(0, 50)}" → "${diff.actual?.substring(0, 50)}"`);
+    }
+    lines.push(`  Hint: ${failure.hint}`);
+    return lines.join("\n");
+}
+/**
+ * Format UnexpectedDbQuery for CLI output
+ */
+function formatUnexpectedDbQuery(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Service: ${failure.service}`,
+        `  Query #${failure.queryIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Query: ${failure.query.sql.substring(0, 100)}...`,
+        `  Hint: ${failure.hint}`,
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format MissingDbQuery for CLI output
+ */
+function formatMissingDbQuery(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Service: ${failure.service}`,
+        `  Span ID: ${failure.spanId}`,
+        `  Query #${failure.queryIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Hint: ${failure.hint}`,
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format BlockedDbAccess for CLI output
+ */
+function formatBlockedDbAccess(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Query: ${failure.query.sql.substring(0, 100)}...`,
+        `  Hint: ${failure.hint}`,
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format any DB query failure for CLI output
+ */
+function formatDbQueryFailure(failure) {
+    switch (failure.type) {
+        case "db_query_mismatch":
+            return formatDbQueryMismatch(failure);
+        case "unexpected_db_query":
+            return formatUnexpectedDbQuery(failure);
+        case "missing_db_query":
+            return formatMissingDbQuery(failure);
+        case "blocked_db_access":
+            return formatBlockedDbAccess(failure);
+        default:
+            return `[Replay Error] Unknown DB failure type`;
+    }
+}
+async function createWrappedDbClient(options = {}) {
+    const { realClient, traceDir, replayMode, readBlob } = options;
+    // Detect replay mode
+    const mode = process.env.RDT_MODE || process.env.RDT_REPLAY === "1" || process.env.RDT_REPLAY === "true"
+        ? "replay"
+        : "record";
+    if (mode === "replay") {
+        // Replay mode: create matcher from trace
+        const actualTraceDir = traceDir || process.env.RDT_TRACE_DIR || process.env.TRACE_DIR;
+        if (!actualTraceDir) {
+            console.warn("[DB Wrapper] Replay mode detected but RDT_TRACE_DIR not set. DB queries will be disabled.");
+            return null;
+        }
+        try {
+            // Dynamically import fs/path modules to avoid issues in browser environments
+            const { readFile } = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            const { createReadStream } = await Promise.resolve().then(() => __importStar(require("fs")));
+            const { createInterface } = await Promise.resolve().then(() => __importStar(require("readline")));
+            const { join } = await Promise.resolve().then(() => __importStar(require("path")));
+            // Load events and create matcher
+            const eventsPath = join(actualTraceDir, "events.jsonl");
+            const events = [];
+            try {
+                const fileStream = createReadStream(eventsPath);
+                const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+                for await (const line of rl) {
+                    const trimmed = line.trim();
+                    if (trimmed) {
+                        try {
+                            events.push(JSON.parse(trimmed));
+                        }
+                        catch {
+                            // Skip malformed lines
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`[DB Wrapper] Failed to load trace events from ${eventsPath}: ${error}`);
+                return null;
+            }
+            const recordedQueries = parseRecordedDbQueries(events);
+            if (recordedQueries.length === 0) {
+                // No DB queries in trace - return null (service can handle this)
+                return null;
+            }
+            const actualReplayMode = (replayMode || process.env.RDT_REPLAY_MODE || "strict");
+            const matcher = new DbQueryMatcher(recordedQueries, actualReplayMode, actualTraceDir);
+            // Default blob reader if not provided
+            const actualReadBlob = readBlob || (async (blobRef) => {
+                const hash = blobRef.startsWith("sha256:") ? blobRef.substring(7) : blobRef;
+                const blobPath = join(actualTraceDir, "blobs", `${hash}.json`);
+                try {
+                    return JSON.parse(await readFile(blobPath, "utf8"));
+                }
+                catch {
+                    return null;
+                }
+            });
+            return wrapDbClient(null, { mode: "replay", matcher, readBlob: actualReadBlob });
+        }
+        catch (error) {
+            console.warn(`[DB Wrapper] Failed to create replay DB client: ${error}`);
+            return null;
+        }
+    }
+    else {
+        // Record mode: wrap real client
+        if (!realClient) {
+            console.warn("[DB Wrapper] Record mode but no realClient provided. DB queries will be disabled.");
+            return null;
+        }
+        return wrapDbClient(realClient, { mode: "record" });
+    }
+}

package/dist/event-envelope.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Base event envelope - all trace events must include these fields
+ */
+/**
+ * Base event envelope interface
+ */
+export interface BaseEventEnvelope {
+    type: string;
+    timestamp: number;
+    traceId: string;
+    spanId: string;
+    parentSpanId: string | null;
+    serviceName: string;
+}
+/**
+ * Create a base event envelope with required fields
+ *
+ * @param type - Event type (e.g., 'http.request.inbound')
+ * @param timestamp - Event timestamp (milliseconds since epoch)
+ * @param traceId - Trace ID
+ * @param spanId - Span ID
+ * @param parentSpanId - Parent span ID (null for root spans)
+ * @param serviceName - Optional service name (will be resolved if not provided)
+ * @param additionalFields - Additional event-specific fields
+ * @returns Complete event object with base envelope + additional fields
+ */
+export declare function createBaseEvent(type: string, timestamp: number, traceId: string, spanId: string, parentSpanId: string | null, serviceName?: string, additionalFields?: Record<string, any>): BaseEventEnvelope & Record<string, any>;
+/**
+ * Validate that an event has all required base envelope fields
+ */
+export declare function validateBaseEnvelope(event: any): {
+    valid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=event-envelope.d.ts.map

package/dist/event-envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-envelope.d.ts","sourceRoot":"","sources":["../src/event-envelope.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB;AAwCD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACrC,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAiBzC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA0BrF"}