@runtime-digital-twin/sdk 1.0.0

package/dist/shape-digest-utils.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Shape Digest Utilities
+ *
+ * Utilities for computing shape digests with sampling and feature flags.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShapeDigestMode = getShapeDigestMode;
+exports.getShapeDigestSampleRate = getShapeDigestSampleRate;
+exports.shouldComputeShapeDigest = shouldComputeShapeDigest;
+exports.isJsonContentType = isJsonContentType;
+exports.tryParseJson = tryParseJson;
+exports.computeBodyShapeDigest = computeBodyShapeDigest;
+exports.getContentType = getContentType;
+exports.getBodySizeBytes = getBodySizeBytes;
+const core_1 = require("@runtime-digital-twin/core");
+/**
+ * Get shape digest mode from environment
+ */
+function getShapeDigestMode() {
+    const mode = process.env.WRAITH_SHAPE_DIGEST_MODE?.toLowerCase();
+    if (mode === "off" || mode === "sampled" || mode === "on") {
+        return mode;
+    }
+    return "sampled"; // default
+}
+/**
+ * Get sample rate from environment
+ */
+function getShapeDigestSampleRate() {
+    const rate = parseFloat(process.env.WRAITH_SHAPE_DIGEST_SAMPLE_RATE || "0.1");
+    if (isNaN(rate) || rate < 0 || rate > 1) {
+        return 0.1; // default 10%
+    }
+    return rate;
+}
+/**
+ * Determine if shape digest should be computed
+ */
+function shouldComputeShapeDigest(mode, sampleRate, statusCode, hasError) {
+    if (mode === "off") {
+        return false;
+    }
+    if (mode === "on") {
+        return true;
+    }
+    // mode === "sampled"
+    // Always compute for errors or status >= 400
+    if (hasError || (statusCode !== null && statusCode !== undefined && statusCode >= 400)) {
+        return true;
+    }
+    // Sample based on rate
+    return Math.random() < sampleRate;
+}
+/**
+ * Check if content type indicates JSON
+ */
+function isJsonContentType(contentType) {
+    if (!contentType)
+        return false;
+    const lower = contentType.toLowerCase();
+    return (lower.includes("application/json") ||
+        lower.includes("application/vnd.api+json") ||
+        lower.includes("application/hal+json") ||
+        lower.includes("application/problem+json"));
+}
+/**
+ * Attempt to parse body as JSON
+ */
+function tryParseJson(body) {
+    if (!body)
+        return null;
+    if (typeof body === "object" && !Buffer.isBuffer(body)) {
+        return body; // Already parsed
+    }
+    if (Buffer.isBuffer(body)) {
+        try {
+            return JSON.parse(body.toString("utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    if (typeof body === "string") {
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Compute shape digest for a body if conditions are met
+ */
+async function computeBodyShapeDigest(body, contentType, options) {
+    // Check if we should compute
+    if (!shouldComputeShapeDigest(options.mode, options.sampleRate, options.statusCode, options.hasError)) {
+        return null;
+    }
+    // Try to parse as JSON first
+    const parsed = tryParseJson(body);
+    const isJson = isJsonContentType(contentType);
+    // Only compute for JSON content type OR if we can parse as JSON
+    // This allows us to compute digests for JSON responses even if content-type is missing/wrong
+    if (!isJson && parsed === null) {
+        return null;
+    }
+    // Compute digest on parsed JSON (or original if already object)
+    const input = parsed !== null ? parsed : body;
+    return (0, core_1.computeShapeDigest)(input);
+}
+/**
+ * Get content type from headers
+ */
+function getContentType(headers) {
+    if (!headers)
+        return null;
+    // Check if it's a Headers object (handle both real Headers and mock Headers)
+    if (headers instanceof Headers || (typeof headers.get === 'function')) {
+        return headers.get("content-type");
+    }
+    const contentType = headers["content-type"] || headers["Content-Type"];
+    if (typeof contentType === "string") {
+        return contentType;
+    }
+    if (Array.isArray(contentType) && contentType.length > 0) {
+        return contentType[0];
+    }
+    return null;
+}
+/**
+ * Get size in bytes for a body
+ */
+function getBodySizeBytes(body) {
+    if (!body)
+        return 0;
+    if (Buffer.isBuffer(body)) {
+        return body.length;
+    }
+    if (typeof body === "string") {
+        return Buffer.byteLength(body, "utf8");
+    }
+    if (typeof body === "object") {
+        try {
+            return Buffer.byteLength(JSON.stringify(body), "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}

package/dist/trace-bundle-writer.d.ts

@@ -0,0 +1,52 @@
+export interface CreateTraceOptions {
+    serviceName: string;
+    mode?: "record" | "replay";
+    serviceVersion?: string;
+    environment?: string;
+    traceDir?: string;
+    traceId?: string;
+}
+export interface TraceBundle {
+    traceId: string;
+    serviceName: string;
+    writeEvent: (event: Record<string, any>) => Promise<void>;
+    writeBlob: (content: string | object) => Promise<string>;
+    complete: (inboundRequest?: {
+        method: string;
+        path: string;
+        headers: Record<string, string>;
+        bodyHash?: string;
+    }) => Promise<void>;
+}
+import { CURRENT_TRACE_FORMAT_VERSION } from "./constants";
+export { CURRENT_TRACE_FORMAT_VERSION };
+/**
+ * Generate a span ID
+ */
+declare function generateSpanId(): string;
+/**
+ * Create a new trace bundle
+ */
+export declare function createTrace(options: CreateTraceOptions): Promise<TraceBundle>;
+/**
+ * Helper to process body content and store as blob
+ * Applies redaction to sensitive fields before storing
+ * NOTE: Always stores bodies as blobs so they can be retrieved during replay
+ */
+export declare function processBody(body: string | Buffer | object | null | undefined, writeBlobFn: (content: string | object) => Promise<string>, options?: {
+    skipRedaction?: boolean;
+}): Promise<{
+    bodyHash: string | null;
+    bodyBlob: string | null;
+}>;
+/**
+ * Filter headers based on allowlist and apply redaction
+ */
+export declare function filterHeaders(headers: Record<string, string | string[] | undefined>, allowlist?: string[], options?: {
+    skipRedaction?: boolean;
+}): Record<string, string>;
+/**
+ * Generate span ID (exported for use in middleware)
+ */
+export { generateSpanId };
+//# sourceMappingURL=trace-bundle-writer.d.ts.map

package/dist/trace-bundle-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-bundle-writer.d.ts","sourceRoot":"","sources":["../src/trace-bundle-writer.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD,QAAQ,EAAE,CAAC,cAAc,CAAC,EAAE;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAM3D,OAAO,EAAE,4BAA4B,EAAE,CAAC;AAWxC;;GAEG;AACH,iBAAS,cAAc,IAAI,MAAM,CAEhC;AAgBD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAkLtB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAC1D,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GACpC,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAiC7D;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,EACtD,SAAS,CAAC,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GACpC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAyCxB;AAED;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/trace-bundle-writer.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_TRACE_FORMAT_VERSION = void 0;
+exports.createTrace = createTrace;
+exports.processBody = processBody;
+exports.filterHeaders = filterHeaders;
+exports.generateSpanId = generateSpanId;
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const redaction_1 = require("./redaction");
+const event_envelope_1 = require("./event-envelope");
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "CURRENT_TRACE_FORMAT_VERSION", { enumerable: true, get: function () { return constants_1.CURRENT_TRACE_FORMAT_VERSION; } });
+const BLOB_THRESHOLD = 1024; // 1KB
+const DEFAULT_TRACE_DIR = "./traces";
+/**
+ * Generate a trace ID in format: trace-<timestamp>-<random>
+ */
+function generateTraceId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `trace-${timestamp}-${random}`;
+}
+/**
+ * Generate a span ID
+ */
+function generateSpanId() {
+    return `span-${Math.random().toString(36).substring(2, 15)}`;
+}
+/**
+ * Compute SHA256 hash of content
+ */
+function computeHash(content) {
+    return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+/**
+ * Format hash as sha256:<hex>
+ */
+function formatHash(hex) {
+    return `sha256:${hex}`;
+}
+/**
+ * Create a new trace bundle
+ */
+async function createTrace(options) {
+    const { serviceName, mode = "record", serviceVersion = "1.0.0", environment = "production", traceDir = DEFAULT_TRACE_DIR, traceId: providedTraceId, } = options;
+    // Use provided traceId (from cross-service propagation) or generate new one
+    const traceId = providedTraceId || generateTraceId();
+    const tracePath = (0, path_1.join)(traceDir, traceId);
+    const blobsPath = (0, path_1.join)(tracePath, "blobs");
+    const eventsPath = (0, path_1.join)(tracePath, "events.jsonl");
+    const metaPath = (0, path_1.join)(tracePath, "meta.json");
+    // Create directory structure
+    try {
+        await (0, promises_1.mkdir)(blobsPath, { recursive: true });
+    }
+    catch (error) {
+        // Fail-open: log error but don't throw
+        console.error(`[SDK] Failed to create trace directory: ${error}`);
+        throw error; // Re-throw for critical errors
+    }
+    // Write initial meta.json
+    const startedAt = new Date().toISOString();
+    const meta = {
+        trace_format_version: constants_1.CURRENT_TRACE_FORMAT_VERSION,
+        traceId,
+        startedAt,
+        completedAt: null,
+        serviceName,
+        serviceVersion,
+        environment,
+        mode,
+        inboundRequest: null,
+    };
+    try {
+        await (0, promises_1.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+        // Create empty events.jsonl file eagerly
+        await (0, promises_1.writeFile)(eventsPath, "", "utf8");
+    }
+    catch (error) {
+        console.error(`[SDK] Failed to write meta.json: ${error}`);
+        throw error;
+    }
+    let completed = false;
+    const writeEvent = async (event) => {
+        if (completed) {
+            console.warn(`[SDK] Attempted to write event to completed trace: ${traceId}`);
+            return;
+        }
+        try {
+            // Extract required fields from event
+            const eventType = event.type;
+            const eventTimestamp = event.timestamp ?? Date.now();
+            const eventSpanId = event.spanId;
+            const eventParentSpanId = event.parentSpanId ?? null;
+            // Remove base envelope fields from event to avoid duplication
+            // (they will be added by createBaseEvent)
+            const { type: _, timestamp: __, traceId: ___, spanId: ____, parentSpanId: _____, serviceName: ______, ...eventFields } = event;
+            // Create base envelope and merge with event-specific fields
+            // Base envelope fields take precedence to ensure consistency
+            const envelopeEvent = (0, event_envelope_1.createBaseEvent)(eventType, eventTimestamp, traceId, // From bundle
+            eventSpanId, eventParentSpanId, serviceName, // From bundle
+            eventFields // Event-specific fields only
+            );
+            const line = JSON.stringify(envelopeEvent) + "\n";
+            // Ensure directory exists before writing (in case it was deleted)
+            try {
+                await (0, promises_1.mkdir)((0, path_1.dirname)(eventsPath), { recursive: true });
+            }
+            catch (dirError) {
+                // Directory might already exist, ignore
+            }
+            // Ensure file exists (create if it doesn't)
+            if (!(0, fs_1.existsSync)(eventsPath)) {
+                await (0, promises_1.writeFile)(eventsPath, "", "utf8");
+            }
+            await (0, promises_1.appendFile)(eventsPath, line, "utf8");
+            if (process.env.DEBUG_TRACE_WRITER) {
+                console.log(`[TRACE_WRITER] Wrote event: ${eventType} to ${eventsPath}`);
+            }
+        }
+        catch (error) {
+            // Fail-open: log error but don't throw
+            console.error(`[SDK] Failed to write event: ${error}`);
+            if (process.env.DEBUG_TRACE_WRITER) {
+                console.error(`[TRACE_WRITER] Error details:`, error);
+                console.error(`[TRACE_WRITER] Event path: ${eventsPath}`);
+                console.error(`[TRACE_WRITER] Event type: ${event.type}`);
+            }
+        }
+    };
+    const writeBlob = async (content) => {
+        // Allow blob writes even after trace completion (for async operations)
+        // This is safe because blobs are deduplicated by hash
+        if (completed && process.env.DEBUG_TRACE_WRITER) {
+            console.warn(`[SDK] Writing blob to completed trace: ${traceId}`);
+        }
+        try {
+            // Ensure blobs directory exists (even if trace is completed)
+            try {
+                await (0, promises_1.mkdir)(blobsPath, { recursive: true });
+            }
+            catch (error) {
+                // Directory might already exist, ignore
+            }
+            const contentStr = typeof content === "string" ? content : JSON.stringify(content);
+            const hash = computeHash(contentStr);
+            const hashFormatted = formatHash(hash);
+            const blobPath = (0, path_1.join)(blobsPath, `${hash}.json`);
+            // Only write if blob doesn't exist (deduplication)
+            if (!(0, fs_1.existsSync)(blobPath)) {
+                await (0, promises_1.writeFile)(blobPath, contentStr, "utf8");
+            }
+            return hashFormatted;
+        }
+        catch (error) {
+            console.error(`[SDK] Failed to write blob: ${error}`);
+            throw error;
+        }
+    };
+    const complete = async (inboundRequest) => {
+        if (completed) {
+            return;
+        }
+        completed = true;
+        try {
+            const completedAt = new Date().toISOString();
+            const finalMeta = {
+                ...meta,
+                completedAt,
+                inboundRequest: inboundRequest || null,
+            };
+            await (0, promises_1.writeFile)(metaPath, JSON.stringify(finalMeta, null, 2));
+        }
+        catch (error) {
+            console.error(`[SDK] Failed to complete trace: ${error}`);
+        }
+    };
+    return {
+        traceId,
+        serviceName,
+        writeEvent,
+        writeBlob,
+        complete,
+    };
+}
+/**
+ * Helper to process body content and store as blob
+ * Applies redaction to sensitive fields before storing
+ * NOTE: Always stores bodies as blobs so they can be retrieved during replay
+ */
+function processBody(body, writeBlobFn, options) {
+    if (!body) {
+        return Promise.resolve({ bodyHash: null, bodyBlob: null });
+    }
+    let bodyStr;
+    if (Buffer.isBuffer(body)) {
+        bodyStr = body.toString("utf8");
+    }
+    else if (typeof body === "object") {
+        bodyStr = JSON.stringify(body);
+    }
+    else {
+        bodyStr = String(body);
+    }
+    // Apply redaction unless explicitly skipped
+    if (!options?.skipRedaction) {
+        const redacted = (0, redaction_1.redactBody)(bodyStr);
+        if (typeof redacted === "string") {
+            bodyStr = redacted;
+        }
+        else if (redacted !== null && redacted !== undefined) {
+            bodyStr = JSON.stringify(redacted);
+        }
+    }
+    const hash = computeHash(bodyStr);
+    const hashFormatted = formatHash(hash);
+    // Always store body as blob so it can be retrieved during replay
+    // (Even small bodies need to be retrievable)
+    return writeBlobFn(bodyStr).then((blobRef) => ({
+        bodyHash: hashFormatted,
+        bodyBlob: blobRef,
+    }));
+}
+/**
+ * Filter headers based on allowlist and apply redaction
+ */
+function filterHeaders(headers, allowlist, options) {
+    if (!allowlist || allowlist.length === 0) {
+        // Default allowlist: common headers that are safe to capture
+        const defaultAllowlist = [
+            "content-type",
+            "content-length",
+            "user-agent",
+            "accept",
+            "accept-encoding",
+            "authorization",
+            "x-api-key",
+            "x-request-id",
+            "x-correlation-id",
+        ];
+        return filterHeaders(headers, defaultAllowlist, options);
+    }
+    const filtered = {};
+    const lowerAllowlist = allowlist.map((h) => h.toLowerCase());
+    for (const [key, value] of Object.entries(headers)) {
+        const lowerKey = key.toLowerCase();
+        if (lowerAllowlist.includes(lowerKey) && value !== undefined) {
+            // Convert array to string if needed
+            filtered[key] = Array.isArray(value) ? value.join(", ") : String(value);
+        }
+    }
+    // Apply redaction unless explicitly skipped
+    if (!options?.skipRedaction) {
+        const redacted = (0, redaction_1.redactHeaders)(filtered);
+        const result = {};
+        for (const [key, value] of Object.entries(redacted)) {
+            if (value !== undefined) {
+                result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+            }
+        }
+        return result;
+    }
+    return filtered;
+}

package/dist/trace-loader.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Structured failure object for trace loading errors
+ */
+export interface TraceLoadFailure {
+    type: 'schema_drift' | 'missing_file' | 'parse_error' | 'validation_error';
+    location: string;
+    expected: string;
+    actual: string;
+    hint: string;
+}
+/**
+ * Result of loading trace metadata
+ */
+export interface TraceMetadata {
+    trace_format_version: number;
+    traceId: string;
+    startedAt: string;
+    completedAt: string | null;
+    serviceName: string;
+    serviceVersion: string;
+    environment: string;
+    mode: 'record' | 'replay';
+    inboundRequest: {
+        method: string;
+        path: string;
+        headers: Record<string, string>;
+        bodyHash?: string;
+    } | null;
+}
+/**
+ * Warning event emitted when trace_format_version is missing
+ */
+export interface TraceVersionWarning {
+    type: 'warning';
+    code: 'missing_trace_format_version';
+    message: string;
+    traceDir: string;
+    assumedVersion: number;
+}
+/**
+ * Result of loading trace metadata with potential warnings
+ */
+export interface TraceLoadResult {
+    meta: TraceMetadata;
+    warnings: TraceVersionWarning[];
+}
+/**
+ * Load trace metadata with version guard.
+ *
+ * - If trace_format_version is missing: assumes version 1 and emits a warning
+ * - If trace_format_version > CURRENT_TRACE_FORMAT_VERSION: throws TraceLoadFailure
+ *
+ * @param traceDir - Path to the trace directory
+ * @returns TraceLoadResult with metadata and any warnings
+ * @throws TraceLoadFailure if trace cannot be loaded or version is unsupported
+ */
+export declare function loadTraceMeta(traceDir: string): Promise<TraceLoadResult>;
+/**
+ * Validate that a trace directory contains required files.
+ *
+ * @param traceDir - Path to the trace directory
+ * @throws TraceLoadFailure if required files are missing
+ */
+export declare function validateTraceStructure(traceDir: string): Promise<void>;
+/**
+ * Helper to format TraceLoadFailure for CLI output
+ */
+export declare function formatTraceLoadFailure(failure: TraceLoadFailure): string;
+//# sourceMappingURL=trace-loader.d.ts.map

package/dist/trace-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-loader.d.ts","sourceRoot":"","sources":["../src/trace-loader.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,aAAa,GAAG,kBAAkB,CAAC;IAC3E,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,cAAc,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,IAAI,CAAC;CACV;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,8BAA8B,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAcD;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAwF9E;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa5E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAQxE"}