@runtime-digital-twin/sdk 1.0.0

package/dist/outbound-matcher.js

@@ -0,0 +1,457 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundMatcher = void 0;
+exports.normalizeUrl = normalizeUrl;
+exports.normalizeHeaders = normalizeHeaders;
+exports.computeBodyHash = computeBodyHash;
+exports.computeMatchSignature = computeMatchSignature;
+exports.compareOutboundCalls = compareOutboundCalls;
+exports.parseRecordedOutboundCalls = parseRecordedOutboundCalls;
+exports.formatOutboundMismatch = formatOutboundMismatch;
+exports.formatUnexpectedOutboundCall = formatUnexpectedOutboundCall;
+exports.formatMissingOutboundCall = formatMissingOutboundCall;
+exports.formatOutboundCallFailure = formatOutboundCallFailure;
+const crypto_1 = require("crypto");
+/**
+ * Headers to include in matching (case-insensitive)
+ */
+const MATCHING_HEADERS = ["content-type", "accept", "authorization"];
+/**
+ * Normalize URL for matching: pathname + sorted query params
+ */
+function normalizeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const searchParams = new URLSearchParams(urlObj.search);
+        const sortedParams = Array.from(searchParams.entries()).sort(([a], [b]) => a.localeCompare(b));
+        const normalizedSearch = new URLSearchParams(sortedParams).toString();
+        return `${urlObj.pathname}${normalizedSearch ? "?" + normalizedSearch : ""}`;
+    }
+    catch {
+        // If URL parsing fails, try to extract path+query manually
+        const match = url.match(/^[^:]+:\/\/[^/]+(\/.*)$/);
+        if (match) {
+            return match[1];
+        }
+        return url;
+    }
+}
+/**
+ * Normalize headers for matching: lowercase keys, filter to matching headers
+ */
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        const lowerKey = key.toLowerCase();
+        if (MATCHING_HEADERS.includes(lowerKey)) {
+            normalized[lowerKey] = value;
+        }
+    }
+    return normalized;
+}
+/**
+ * Compute body hash from content
+ */
+function computeBodyHash(body) {
+    if (!body)
+        return null;
+    let bodyStr;
+    if (Buffer.isBuffer(body)) {
+        bodyStr = body.toString("utf8");
+    }
+    else if (typeof body === "object") {
+        bodyStr = JSON.stringify(body);
+    }
+    else {
+        bodyStr = String(body);
+    }
+    const hash = (0, crypto_1.createHash)("sha256").update(bodyStr).digest("hex");
+    return `sha256:${hash}`;
+}
+/**
+ * Compute match signature for comparison
+ */
+function computeMatchSignature(call) {
+    const normalizedUrl = normalizeUrl(call.url);
+    const normalizedHeaders = normalizeHeaders(call.headers);
+    const headerStr = Object.entries(normalizedHeaders)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([k, v]) => `${k}=${v}`)
+        .join("&");
+    return `${call.method}:${normalizedUrl}:${call.bodyHash || "null"}:${headerStr}`;
+}
+/**
+ * Compare two calls and return differences
+ */
+function compareOutboundCalls(expected, actual) {
+    const diffs = [];
+    // Method
+    if (expected.method !== actual.method) {
+        diffs.push({
+            field: "method",
+            expected: expected.method,
+            actual: actual.method,
+        });
+    }
+    // URL (normalized)
+    const expectedUrl = expected.normalizedUrl;
+    const actualUrl = normalizeUrl(actual.url);
+    if (expectedUrl !== actualUrl) {
+        diffs.push({ field: "url", expected: expectedUrl, actual: actualUrl });
+    }
+    // Body hash
+    if (expected.bodyHash !== actual.bodyHash) {
+        diffs.push({
+            field: "bodyHash",
+            expected: expected.bodyHash,
+            actual: actual.bodyHash,
+        });
+    }
+    // Headers (only check headers that were RECORDED - if recorded headers are empty, skip comparison)
+    const expectedHeaders = normalizeHeaders(expected.headers);
+    const actualHeaders = normalizeHeaders(actual.headers);
+    // Only compare headers that exist in the recorded trace
+    // Headers in actual but not in expected are ignored (caller may add headers we don't care about)
+    for (const key of Object.keys(expectedHeaders)) {
+        const expectedVal = expectedHeaders[key];
+        const actualVal = actualHeaders[key] || null;
+        if (expectedVal !== actualVal) {
+            diffs.push({
+                field: `header:${key}`,
+                expected: expectedVal,
+                actual: actualVal,
+            });
+        }
+    }
+    return { matches: diffs.length === 0, diffs };
+}
+/**
+ * Ordered outbound call matcher for replay
+ */
+class OutboundMatcher {
+    recordedCalls = [];
+    currentIndex = 0;
+    mode;
+    traceDir;
+    divergences = [];
+    logger = null;
+    constructor(recordedCalls, mode, traceDir, logger) {
+        this.recordedCalls = recordedCalls;
+        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 (for explain mode)
+     */
+    getDivergences() {
+        return [...this.divergences];
+    }
+    /**
+     * Get current call index
+     */
+    getCurrentIndex() {
+        return this.currentIndex;
+    }
+    /**
+     * Get total recorded calls
+     */
+    getTotalCalls() {
+        return this.recordedCalls.length;
+    }
+    /**
+     * Match the next outbound call against the recorded sequence
+     *
+     * In strict mode: throws OutboundRequestMismatch on any mismatch
+     * In explain mode: emits divergence and returns best-effort match
+     */
+    matchNext(actual) {
+        const callIndex = this.currentIndex;
+        const actualNormalizedUrl = normalizeUrl(actual.url);
+        // Check if we've exceeded recorded calls - this is an unexpected call
+        if (callIndex >= this.recordedCalls.length) {
+            const failure = {
+                type: "unexpected_outbound_call",
+                location: `${this.traceDir}/events.jsonl:call[${callIndex}]`,
+                expected: `<end of recorded calls after ${this.recordedCalls.length} call(s)>`,
+                actual: `${actual.method} ${actualNormalizedUrl}`,
+                hint: "An outbound HTTP call occurred during replay that was not recorded in the original trace. This may indicate non-deterministic behavior or code changes.",
+                callIndex,
+                service: this.traceDir,
+                spanId: null,
+                call: actual,
+            };
+            // Log unexpected call
+            this.logger?.httpUnexpected({
+                callIndex,
+                method: actual.method,
+                url: actual.url,
+                bodyHash: actual.bodyHash,
+                expectedCallCount: this.recordedCalls.length,
+            });
+            if (this.mode === "strict") {
+                throw failure;
+            }
+            // Explain mode: emit divergence and fail (no recorded response to return)
+            this.divergences.push({
+                type: "divergence",
+                severity: "error",
+                callIndex,
+                message: `Unexpected outbound call: ${actual.method} ${actual.url}`,
+                expected: null,
+                actual,
+                recoverable: false,
+            });
+            throw failure; // Can't continue without a response
+        }
+        const expected = this.recordedCalls[callIndex];
+        const { matches, diffs } = compareOutboundCalls(expected, actual);
+        if (matches) {
+            // Log successful match
+            this.logger?.httpMatch({
+                callIndex,
+                method: actual.method,
+                url: actual.url,
+                normalizedUrl: actualNormalizedUrl,
+                bodyHash: actual.bodyHash,
+                matchedSpanId: expected.spanId,
+            });
+            this.currentIndex++;
+            return expected;
+        }
+        // Mismatch detected
+        const failure = {
+            type: "outbound_request_mismatch",
+            location: `${this.traceDir}/events.jsonl:call[${callIndex}]`,
+            expected: `${expected.method} ${expected.normalizedUrl}`,
+            actual: `${actual.method} ${actualNormalizedUrl}`,
+            hint: "Outbound call does not match recorded trace. Check for non-determinism or code changes.",
+            callIndex,
+            diff: diffs,
+        };
+        // Explain mode: check if divergence is recoverable
+        // Recoverable if only headers differ (method, URL, body match)
+        const criticalDiffs = diffs.filter((d) => d.field === "method" || d.field === "url" || d.field === "bodyHash");
+        const recoverable = criticalDiffs.length === 0;
+        // Log mismatch
+        this.logger?.httpMismatch({
+            callIndex,
+            expected: {
+                method: expected.method,
+                url: expected.normalizedUrl,
+                bodyHash: expected.bodyHash,
+            },
+            actual: {
+                method: actual.method,
+                url: actualNormalizedUrl,
+                bodyHash: actual.bodyHash,
+            },
+            differences: diffs,
+            recoverable,
+        });
+        if (this.mode === "strict") {
+            throw failure;
+        }
+        this.divergences.push({
+            type: "divergence",
+            severity: recoverable ? "warning" : "error",
+            callIndex,
+            message: `Outbound call mismatch: ${diffs
+                .map((d) => `${d.field}: ${d.expected} → ${d.actual}`)
+                .join(", ")}`,
+            expected,
+            actual,
+            recoverable,
+        });
+        // Emit to stderr for CLI visibility
+        console.warn(`[Replay] Divergence at call ${callIndex}: ${failure.expected} vs ${failure.actual}`);
+        for (const diff of diffs) {
+            console.warn(`  ${diff.field}: expected="${diff.expected}" actual="${diff.actual}"`);
+        }
+        if (!recoverable) {
+            throw failure;
+        }
+        // Continue with the recorded response despite header differences
+        this.currentIndex++;
+        return expected;
+    }
+    /**
+     * Check if all recorded calls have been matched
+     */
+    isComplete() {
+        return this.currentIndex >= this.recordedCalls.length;
+    }
+    /**
+     * Get summary of unmatched calls (calls that were recorded but not replayed)
+     */
+    getUnmatchedCalls() {
+        return this.recordedCalls.slice(this.currentIndex);
+    }
+    /**
+     * Finalize replay and check for missing outbound calls.
+     * Should be called at the end of replay to detect any recorded calls that never happened.
+     *
+     * In strict mode: throws MissingOutboundCall[] if any calls are missing
+     * In explain mode: emits divergences and returns the missing calls
+     *
+     * @returns Array of MissingOutboundCall failures (empty if all calls matched)
+     */
+    finalize() {
+        const missingCalls = [];
+        const unmatchedCalls = this.getUnmatchedCalls();
+        for (let i = 0; i < unmatchedCalls.length; i++) {
+            const recordedCall = unmatchedCalls[i];
+            const callIndex = this.currentIndex + i;
+            const failure = {
+                type: "missing_outbound_call",
+                location: `${this.traceDir}/events.jsonl:call[${callIndex}]`,
+                expected: `${recordedCall.method} ${recordedCall.normalizedUrl}`,
+                actual: "<call never made>",
+                hint: "A recorded outbound HTTP call was never made during replay. This may indicate code path divergence, conditional logic changes, or early termination.",
+                callIndex,
+                service: this.traceDir,
+                spanId: recordedCall.spanId,
+                recordedCall,
+            };
+            missingCalls.push(failure);
+            // Log missing call
+            this.logger?.httpMissing({
+                callIndex,
+                method: recordedCall.method,
+                url: recordedCall.normalizedUrl,
+                spanId: recordedCall.spanId,
+                bodyHash: recordedCall.bodyHash,
+            });
+            // Emit divergence
+            this.divergences.push({
+                type: "divergence",
+                severity: "error",
+                callIndex,
+                message: `Missing outbound call: ${recordedCall.method} ${recordedCall.normalizedUrl}`,
+                expected: recordedCall,
+                actual: { method: "", url: "", headers: {}, bodyHash: null },
+                recoverable: false,
+            });
+            // Emit to stderr for CLI visibility
+            console.warn(`[Replay] Missing call ${callIndex}: expected ${recordedCall.method} ${recordedCall.normalizedUrl}`);
+        }
+        if (missingCalls.length > 0 && this.mode === "strict") {
+            // In strict mode, throw the first missing call
+            // (caller can access all via the returned array if caught)
+            throw missingCalls[0];
+        }
+        return missingCalls;
+    }
+}
+exports.OutboundMatcher = OutboundMatcher;
+/**
+ * Parse recorded outbound calls from trace events
+ */
+function parseRecordedOutboundCalls(events) {
+    const requestsBySpan = new Map();
+    for (const event of events) {
+        if (event.type === "http.request.outbound") {
+            requestsBySpan.set(event.spanId, {
+                spanId: event.spanId,
+                method: event.method,
+                url: event.url,
+                normalizedUrl: normalizeUrl(event.url),
+                headers: event.headers || {},
+                bodyHash: event.bodyHash || null,
+                response: null,
+            });
+        }
+        else if (event.type === "http.response.outbound") {
+            const request = requestsBySpan.get(event.spanId);
+            if (request) {
+                request.response = {
+                    statusCode: event.statusCode,
+                    headers: event.headers || {},
+                    bodyHash: event.bodyHash || null,
+                    bodyBlob: event.bodyBlob || null,
+                };
+            }
+        }
+    }
+    // Return calls in order (by their appearance in events)
+    // Filter out requests without responses
+    return Array.from(requestsBySpan.values()).filter((call) => call.response !== null);
+}
+/**
+ * Format OutboundRequestMismatch for CLI output
+ */
+function formatOutboundMismatch(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Call #${failure.callIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Differences:`,
+    ];
+    for (const diff of failure.diff) {
+        lines.push(`    ${diff.field}: "${diff.expected}" → "${diff.actual}"`);
+    }
+    lines.push(`  Hint: ${failure.hint}`);
+    return lines.join("\n");
+}
+/**
+ * Format UnexpectedOutboundCall for CLI output
+ */
+function formatUnexpectedOutboundCall(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Service: ${failure.service}`,
+        `  Call #${failure.callIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Call Details:`,
+        `    Method: ${failure.call.method}`,
+        `    URL: ${failure.call.url}`,
+        `    Body Hash: ${failure.call.bodyHash || "<none>"}`,
+        `  Hint: ${failure.hint}`,
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format MissingOutboundCall for CLI output
+ */
+function formatMissingOutboundCall(failure) {
+    const lines = [
+        `[Replay Error] ${failure.type}`,
+        `  Location: ${failure.location}`,
+        `  Service: ${failure.service}`,
+        `  Span ID: ${failure.spanId}`,
+        `  Call #${failure.callIndex}`,
+        `  Expected: ${failure.expected}`,
+        `  Actual: ${failure.actual}`,
+        `  Recorded Call:`,
+        `    Method: ${failure.recordedCall.method}`,
+        `    URL: ${failure.recordedCall.url}`,
+        `    Body Hash: ${failure.recordedCall.bodyHash || "<none>"}`,
+        `  Hint: ${failure.hint}`,
+    ];
+    return lines.join("\n");
+}
+/**
+ * Format any outbound call failure for CLI output
+ */
+function formatOutboundCallFailure(failure) {
+    switch (failure.type) {
+        case "outbound_request_mismatch":
+            return formatOutboundMismatch(failure);
+        case "unexpected_outbound_call":
+            return formatUnexpectedOutboundCall(failure);
+        case "missing_outbound_call":
+            return formatMissingOutboundCall(failure);
+        default:
+            return `[Replay Error] Unknown failure type`;
+    }
+}

package/dist/peer-service-resolver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Peer service resolution for outbound HTTP calls
+ * Maps hostnames to service names for multi-service graph building
+ */
+/**
+ * Resolve peer service name from hostname using mapping
+ *
+ * @param hostname - The hostname from the URL (e.g., "pricing.internal", "api.example.com")
+ * @returns Object with peerService (string | null) and peerHost (string | null)
+ */
+export declare function resolvePeerService(hostname: string): {
+    peerService: string | null;
+    peerHost: string | null;
+};
+/**
+ * Extract URL template from URL (path without query params)
+ *
+ * @param url - Full URL string
+ * @returns URL template (path only, no query params) or null if parsing fails
+ */
+export declare function extractUrlTemplate(url: string): string | null;
+//# sourceMappingURL=peer-service-resolver.d.ts.map

package/dist/peer-service-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-service-resolver.d.ts","sourceRoot":"","sources":["../src/peer-service-resolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACpD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAiDA;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgB7D"}

package/dist/peer-service-resolver.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Peer service resolution for outbound HTTP calls
+ * Maps hostnames to service names for multi-service graph building
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePeerService = resolvePeerService;
+exports.extractUrlTemplate = extractUrlTemplate;
+/**
+ * Resolve peer service name from hostname using mapping
+ *
+ * @param hostname - The hostname from the URL (e.g., "pricing.internal", "api.example.com")
+ * @returns Object with peerService (string | null) and peerHost (string | null)
+ */
+function resolvePeerService(hostname) {
+    // Parse peer mapping from environment variable
+    const peerMapJson = process.env.WRAITH_PEER_MAP_JSON;
+    if (!peerMapJson) {
+        // No mapping configured - return hostname as peerHost
+        return {
+            peerService: null,
+            peerHost: hostname,
+        };
+    }
+    let peerMap;
+    try {
+        peerMap = JSON.parse(peerMapJson);
+    }
+    catch (error) {
+        console.warn(`[SDK] Failed to parse WRAITH_PEER_MAP_JSON: ${error}`);
+        return {
+            peerService: null,
+            peerHost: hostname,
+        };
+    }
+    // Check for exact hostname match
+    if (peerMap[hostname]) {
+        return {
+            peerService: peerMap[hostname],
+            peerHost: hostname,
+        };
+    }
+    // Check for domain match (e.g., "*.internal" matches "pricing.internal")
+    for (const [pattern, serviceName] of Object.entries(peerMap)) {
+        if (pattern.startsWith('*.')) {
+            const domain = pattern.substring(2); // Remove "*."
+            if (hostname.endsWith('.' + domain) || hostname === domain) {
+                return {
+                    peerService: serviceName,
+                    peerHost: hostname,
+                };
+            }
+        }
+    }
+    // No match found - return hostname as peerHost
+    return {
+        peerService: null,
+        peerHost: hostname,
+    };
+}
+/**
+ * Extract URL template from URL (path without query params)
+ *
+ * @param url - Full URL string
+ * @returns URL template (path only, no query params) or null if parsing fails
+ */
+function extractUrlTemplate(url) {
+    try {
+        const urlObj = new URL(url);
+        return urlObj.pathname;
+    }
+    catch (error) {
+        // If URL parsing fails, try to extract path manually
+        try {
+            const pathMatch = url.match(/^https?:\/\/[^\/]+(\/[^?]*)/);
+            if (pathMatch) {
+                return pathMatch[1];
+            }
+        }
+        catch {
+            // Ignore
+        }
+        return null;
+    }
+}

package/dist/redaction.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Redaction Module
+ *
+ * Provides privacy guardrails for trace capture by:
+ * - Masking sensitive headers (auth, tokens, cookies)
+ * - Redacting passwords and secrets from request/response bodies
+ * - Supporting custom redaction rules via config file
+ * - Using deterministic hashing for redacted values (stable across runs)
+ */
+/**
+ * Redaction rule types
+ */
+export type RedactionRuleType = "header" | "body_field" | "body_pattern" | "query_param";
+/**
+ * A single redaction rule
+ */
+export interface RedactionRule {
+    type: RedactionRuleType;
+    /** For header/query_param: exact name or pattern */
+    name?: string;
+    /** For body_pattern: regex pattern */
+    pattern?: string;
+    /** Whether to use regex matching for name */
+    regex?: boolean;
+    /** Custom replacement (default: [REDACTED:hash]) */
+    replacement?: string;
+    /** Whether to include a deterministic hash suffix */
+    hash?: boolean;
+}
+/**
+ * Redaction configuration
+ */
+export interface RedactionConfig {
+    /** Enable/disable redaction (default: true) */
+    enabled: boolean;
+    /** Custom rules to add to defaults */
+    rules: RedactionRule[];
+    /** Override default rules entirely */
+    overrideDefaults?: boolean;
+    /** Salt for deterministic hashing (for privacy, use a secret) */
+    hashSalt?: string;
+}
+/**
+ * Compute a deterministic hash for a redacted value
+ * The hash is stable across runs given the same input and salt
+ */
+export declare function computeRedactionHash(value: string, salt?: string): string;
+/**
+ * Create a redacted placeholder
+ */
+export declare function createRedactedValue(originalValue: string, includeHash?: boolean, salt?: string): string;
+/**
+ * Load redaction config from file
+ */
+export declare function loadRedactionConfig(configPath?: string): RedactionConfig;
+/**
+ * Set global redaction config
+ */
+export declare function setRedactionConfig(config: Partial<RedactionConfig>): void;
+/**
+ * Get current redaction config
+ */
+export declare function getRedactionConfig(): RedactionConfig;
+/**
+ * Reset redaction config to defaults
+ */
+export declare function resetRedactionConfig(): void;
+/**
+ * Check if a header name should be redacted
+ */
+export declare function shouldRedactHeader(headerName: string): boolean;
+/**
+ * Check if a query param should be redacted
+ */
+export declare function shouldRedactQueryParam(paramName: string): boolean;
+/**
+ * Redact headers in a headers object
+ */
+export declare function redactHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string | string[] | undefined>;
+/**
+ * Redact query parameters
+ */
+export declare function redactQueryParams(query: Record<string, any>): Record<string, any>;
+/**
+ * Redact sensitive fields from a body object (recursive)
+ */
+export declare function redactBodyObject(body: any): any;
+/**
+ * Redact patterns from a body string
+ */
+export declare function redactBodyPatterns(body: string): string;
+/**
+ * Redact a body (handles both string and object)
+ */
+export declare function redactBody(body: string | object | null | undefined): string | object | null | undefined;
+/**
+ * Redact a URL (query params)
+ */
+export declare function redactUrl(url: string): string;
+/**
+ * Check if a value looks like it contains sensitive data
+ * (heuristic-based, for additional protection)
+ */
+export declare function containsSensitivePatterns(value: string): boolean;
+/**
+ * Export default sensitive lists for testing
+ */
+export declare const SENSITIVE_HEADERS: string[];
+export declare const SENSITIVE_QUERY_PARAMS: string[];
+export declare const SENSITIVE_BODY_FIELDS: string[];
+//# sourceMappingURL=redaction.d.ts.map

package/dist/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../src/redaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,YAAY,GACZ,cAAc,GACd,aAAa,CAAC;AAElB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,iBAAiB,CAAC;IACxB,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,sCAAsC;IACtC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAkJD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,MAAoC,GACzC,MAAM,CAMR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,OAAc,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAMR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,eAAe,CAwCxE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAQzE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAEpD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAiB9D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAiBjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GACrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAwB/C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAsBrB;AAsBD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAkC/C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAwBvD;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CA6BpC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6B7C;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAYhE;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAA4B,CAAC;AAC3D,eAAO,MAAM,sBAAsB,UAAiC,CAAC;AACrE,eAAO,MAAM,qBAAqB,UAAgC,CAAC"}