@motiadev/core 0.13.0-beta.162-846200 → 0.13.1-beta.162

package/dist/src/queue-manager.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueManager = exports.MaxRetriesError = exports.HandlerTimeoutError = exports.QueueError = void 0;
+const crypto_1 = require("crypto");
+const events_1 = require("events");
+const logger_1 = require("./logger");
+class QueueError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'QueueError';
+    }
+}
+exports.QueueError = QueueError;
+class HandlerTimeoutError extends QueueError {
+    constructor(message) {
+        super(message);
+        this.name = 'HandlerTimeoutError';
+    }
+}
+exports.HandlerTimeoutError = HandlerTimeoutError;
+class MaxRetriesError extends QueueError {
+    constructor(message, attempts) {
+        super(message);
+        this.attempts = attempts;
+        this.name = 'MaxRetriesError';
+    }
+}
+exports.MaxRetriesError = MaxRetriesError;
+class QueueManager {
+    constructor(logger) {
+        this.queues = {};
+        this.subscriptions = {};
+        this.lockedGroups = new Set();
+        this.queueEmitter = new events_1.EventEmitter();
+        this.scheduledTimeouts = new Map();
+        this.metrics = new Map();
+        this.processingMessages = new Set();
+        this.logger = logger || logger_1.globalLogger;
+        this.queueEmitter.on('process', (topic) => {
+            this.processQueue(topic);
+        });
+    }
+    initMetrics(topic) {
+        if (!this.metrics.has(topic)) {
+            this.metrics.set(topic, {
+                queueDepth: 0,
+                processingCount: 0,
+                retriesCount: 0,
+                dlqCount: 0,
+            });
+        }
+    }
+    updateMetric(topic, key, delta) {
+        this.initMetrics(topic);
+        const metrics = this.metrics.get(topic);
+        metrics[key] = Math.max(0, metrics[key] + delta);
+    }
+    processQueue(topic) {
+        const queue = this.queues[topic];
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        const visibleMessages = queue.filter((msg) => msg.visibleAt <= now && !this.processingMessages.has(msg.id));
+        for (const message of visibleMessages) {
+            if (message.queueConfig.type === 'fifo' && message.messageGroupId) {
+                const lockKey = `${topic}:${message.messageGroupId}`;
+                if (this.lockedGroups.has(lockKey)) {
+                    continue;
+                }
+                this.processingMessages.add(message.id);
+                this.lockedGroups.add(lockKey);
+                void this.processMessage(topic, message, lockKey);
+            }
+            else {
+                this.processingMessages.add(message.id);
+                void this.processMessage(topic, message);
+            }
+        }
+    }
+    async processMessage(topic, message, lockKey) {
+        const handlers = this.subscriptions[topic] || [];
+        const handler = handlers.find((s) => s.internalSubscriptionId === message.internalSubscriptionId) ||
+            handlers.find((s) => s.subscriptionId === message.subscriptionId) ||
+            handlers[0];
+        if (!handler) {
+            this.processingMessages.delete(message.id);
+            this.removeMessageFromQueue(topic, message.id);
+            if (lockKey) {
+                this.lockedGroups.delete(lockKey);
+            }
+            return;
+        }
+        const handlerChanged = message.internalSubscriptionId !== handler.internalSubscriptionId;
+        if (handlerChanged && message.attempts > 0) {
+            message.attempts = 0;
+            message.internalSubscriptionId = handler.internalSubscriptionId;
+            message.subscriptionId = handler.subscriptionId;
+            message.visibleAt = Date.now();
+        }
+        this.updateMetric(topic, 'processingCount', 1);
+        try {
+            await handler.handler(message.event);
+            this.updateMetric(topic, 'processingCount', -1);
+            this.processingMessages.delete(message.id);
+            this.removeMessageFromQueue(topic, message.id);
+            if (lockKey) {
+                this.lockedGroups.delete(lockKey);
+            }
+            this.scheduleProcessing(topic, 0);
+        }
+        catch (error) {
+            this.updateMetric(topic, 'processingCount', -1);
+            this.processingMessages.delete(message.id);
+            message.attempts++;
+            if (message.attempts >= handler.queueConfig.maxRetries) {
+                const maxRetriesError = new MaxRetriesError(`Message failed after ${message.attempts} attempts`, message.attempts);
+                this.logger.error('[Queue DLQ] Message moved to dead-letter queue after max retries', {
+                    topic,
+                    messageId: message.id,
+                    attempts: message.attempts,
+                    originalError: error instanceof Error ? error.message : 'Unknown error',
+                    error: maxRetriesError.message,
+                });
+                this.updateMetric(topic, 'dlqCount', 1);
+                this.removeMessageFromQueue(topic, message.id);
+                if (lockKey) {
+                    this.lockedGroups.delete(lockKey);
+                }
+                this.scheduleProcessing(topic, 0);
+            }
+            else {
+                this.updateMetric(topic, 'retriesCount', 1);
+                message.visibleAt = Date.now() + handler.queueConfig.visibilityTimeout * 1000;
+                if (lockKey) {
+                    this.lockedGroups.delete(lockKey);
+                }
+                this.scheduleProcessing(topic, handler.queueConfig.visibilityTimeout * 1000);
+            }
+        }
+    }
+    removeMessageFromQueue(topic, messageId) {
+        const queue = this.queues[topic];
+        if (!queue) {
+            return;
+        }
+        const index = queue.findIndex((msg) => msg.id === messageId);
+        if (index !== -1) {
+            queue.splice(index, 1);
+            this.updateMetric(topic, 'queueDepth', -1);
+        }
+        if (queue.length === 0) {
+            delete this.queues[topic];
+        }
+    }
+    scheduleProcessing(topic, delayMs) {
+        const existingTimeout = this.scheduledTimeouts.get(topic);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        const timeout = setTimeout(() => {
+            this.queueEmitter.emit('process', topic);
+            this.scheduledTimeouts.delete(topic);
+        }, delayMs);
+        this.scheduledTimeouts.set(topic, timeout);
+    }
+    async enqueue(topic, event, messageGroupId) {
+        const handlers = this.subscriptions[topic] || [];
+        if (handlers.length === 0) {
+            return;
+        }
+        const effectiveMessageGroupId = messageGroupId ?? event.messageGroupId;
+        for (const subscription of handlers) {
+            const delayMs = subscription.queueConfig.delaySeconds * 1000;
+            const visibleAt = Date.now() + delayMs;
+            const queuedMessage = {
+                id: (0, crypto_1.randomUUID)(),
+                event,
+                attempts: 0,
+                visibleAt,
+                messageGroupId: effectiveMessageGroupId,
+                queueConfig: subscription.queueConfig,
+                subscriptionId: subscription.subscriptionId,
+                internalSubscriptionId: subscription.internalSubscriptionId,
+            };
+            if (!this.queues[topic]) {
+                this.queues[topic] = [];
+            }
+            this.queues[topic].push(queuedMessage);
+            this.updateMetric(topic, 'queueDepth', 1);
+            this.scheduleProcessing(topic, delayMs);
+        }
+    }
+    subscribe(topic, handler, queueConfig, subscriptionId) {
+        if (!this.subscriptions[topic]) {
+            this.subscriptions[topic] = [];
+        }
+        const internalSubscriptionId = (0, crypto_1.randomUUID)();
+        this.subscriptions[topic].push({ handler, queueConfig, subscriptionId, internalSubscriptionId });
+        if (this.queues[topic] && this.queues[topic].length > 0) {
+            const now = Date.now();
+            let madeVisible = false;
+            for (const message of this.queues[topic]) {
+                if (message.internalSubscriptionId !== internalSubscriptionId && message.attempts > 0) {
+                    message.visibleAt = now;
+                    madeVisible = true;
+                }
+            }
+            if (madeVisible) {
+                this.scheduleProcessing(topic, 0);
+            }
+        }
+    }
+    unsubscribe(topic, handler) {
+        if (!this.subscriptions[topic]) {
+            return;
+        }
+        this.subscriptions[topic] = this.subscriptions[topic].filter((sub) => sub.handler !== handler);
+        if (this.subscriptions[topic].length === 0) {
+            delete this.subscriptions[topic];
+            const hasQueuedMessages = this.queues[topic] && this.queues[topic].length > 0;
+            if (!hasQueuedMessages) {
+                const timeout = this.scheduledTimeouts.get(topic);
+                if (timeout) {
+                    clearTimeout(timeout);
+                    this.scheduledTimeouts.delete(topic);
+                }
+            }
+        }
+    }
+    getMetrics(topic) {
+        return this.metrics.get(topic);
+    }
+    getAllMetrics() {
+        const result = {};
+        this.metrics.forEach((metrics, topic) => {
+            result[topic] = { ...metrics };
+        });
+        return result;
+    }
+    reset() {
+        this.scheduledTimeouts.forEach((timeout) => clearTimeout(timeout));
+        this.scheduledTimeouts.clear();
+        this.queueEmitter.removeAllListeners();
+        this.queues = {};
+        this.subscriptions = {};
+        this.lockedGroups = new Set();
+        this.processingMessages = new Set();
+        this.metrics.clear();
+    }
+}
+exports.QueueManager = QueueManager;

package/dist/src/ruby/get-ruby-config.d.ts

@@ -0,0 +1,3 @@
+import type { StepConfig } from '../types';
+export declare const getRubyConfig: (file: string) => Promise<StepConfig>;
+//# sourceMappingURL=get-ruby-config.d.ts.map

package/dist/src/ruby/get-ruby-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-ruby-config.d.ts","sourceRoot":"","sources":["../../../src/ruby/get-ruby-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,OAAO,CAAC,UAAU,CAyB9D,CAAA"}

package/dist/src/ruby/get-ruby-config.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRubyConfig = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const getRubyConfig = (file) => {
+    const getConfig = path_1.default.join(__dirname, 'get_config.rb');
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const child = (0, child_process_1.spawn)('ruby', [getConfig, file], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        });
+        child.on('message', (message) => {
+            logger_1.globalLogger.debug('[Ruby Config] Read config', { config: message });
+            config = message;
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+            else if (!config) {
+                reject(new Error(`No config found for file ${file}`));
+            }
+            else {
+                resolve(config);
+            }
+        });
+    });
+};
+exports.getRubyConfig = getRubyConfig;

package/dist/src/run-stream-can-access.d.ts

@@ -0,0 +1,10 @@
+import type { StreamSubscription } from './types-stream';
+type RunStreamCanAccessOptions = {
+    file: string;
+    subscription: StreamSubscription;
+    authContext?: unknown;
+    projectRoot?: string;
+};
+export declare const runStreamCanAccess: ({ file, subscription, authContext, projectRoot, }: RunStreamCanAccessOptions) => Promise<boolean>;
+export {};
+//# sourceMappingURL=run-stream-can-access.d.ts.map

package/dist/src/run-stream-can-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-stream-can-access.d.ts","sourceRoot":"","sources":["../../src/run-stream-can-access.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,kBAAkB,CAAA;IAChC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAU,mDAKtC,yBAAyB,KAAG,OAAO,CAAC,OAAO,CAyD7C,CAAA"}

package/dist/src/run-stream-can-access.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStreamCanAccess = void 0;
+const language_runner_1 = require("./language-runner");
+const logger_1 = require("./logger");
+const process_manager_1 = require("./process-communication/process-manager");
+const runStreamCanAccess = async ({ file, subscription, authContext, projectRoot, }) => {
+    const { runner, command, args } = (0, language_runner_1.getLanguageBasedRunner)(file, {
+        python: 'can-access.py',
+        ruby: 'can-access.rb',
+        node: { js: 'can-access.js', ts: 'can-access.ts' },
+    });
+    const payload = JSON.stringify({ subscription, authContext });
+    return new Promise((resolve, reject) => {
+        let result = null;
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, file, payload],
+            logger: logger_1.globalLogger,
+            context: 'StreamCanAccess',
+            projectRoot,
+        });
+        processManager
+            .spawn()
+            .then(() => {
+            processManager.onMessage((message) => {
+                result = Boolean(message);
+                resolve(result);
+                processManager.kill();
+            });
+            processManager.onProcessClose((code) => {
+                processManager.close();
+                if (result !== null) {
+                    return;
+                }
+                if (code !== 0) {
+                    reject(`Process exited with code ${code}`);
+                }
+                else {
+                    reject('Stream canAccess evaluation returned no result');
+                }
+            });
+            processManager.onProcessError((error) => {
+                processManager.close();
+                if (error.code === 'ENOENT') {
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        })
+            .catch((error) => {
+            processManager.close();
+            reject(`Failed to spawn process: ${error}`);
+        });
+    });
+};
+exports.runStreamCanAccess = runStreamCanAccess;

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { StandardSchemaV1 } from 'zod/v4/core/standard-schema.cjs';
+import type { JsonSchema } from './types/schema.types';
+export type SchemaInput = StandardSchemaV1 | z.ZodType | JsonSchema | null | undefined;
+export declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+export declare function isZodSchema(value: unknown): value is z.ZodType;
+export declare function isJsonSchema(value: unknown): value is JsonSchema;
+export declare function schemaToJsonSchema(schema: SchemaInput): JsonSchema | null;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utils.d.ts","sourceRoot":"","sources":["../../src/schema-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAStD,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,CAAC,CAAC,OAAO,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,CAAA;AAEtF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAQ1E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,OAAO,CAS9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAMhE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,IAAI,CAqBzE"}

package/dist/src/schema-utils.js

@@ -0,0 +1,80 @@
+"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.isStandardSchema = isStandardSchema;
+exports.isZodSchema = isZodSchema;
+exports.isJsonSchema = isJsonSchema;
+exports.schemaToJsonSchema = schemaToJsonSchema;
+const z = __importStar(require("zod"));
+function isStandardSchema(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const schema = value;
+    return '~standard' in schema && schema['~standard'] !== null && typeof schema['~standard'] === 'object';
+}
+function isZodSchema(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        typeof value.safeParse === 'function' &&
+        '_zod' in value &&
+        typeof value._zod === 'object' &&
+        'def' in value._zod);
+}
+function isJsonSchema(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const schema = value;
+    return typeof schema.type === 'string' || Array.isArray(schema.type) || 'properties' in schema;
+}
+function schemaToJsonSchema(schema) {
+    if (!schema) {
+        return null;
+    }
+    if (isZodSchema(schema)) {
+        return z.toJSONSchema(schema, { target: 'draft-7' });
+    }
+    if (isStandardSchema(schema)) {
+        if ('toJSON' in schema && typeof schema.toJSON === 'function') {
+            return schema.toJSON();
+        }
+        return null;
+    }
+    if (isJsonSchema(schema)) {
+        return schema;
+    }
+    return null;
+}

package/dist/src/server.d.ts

@@ -0,0 +1,37 @@
+import { type Express } from 'express';
+import http from 'http';
+import type { Server as WsServer } from 'ws';
+import type { CronAdapter } from './adapters/interfaces/cron-adapter.interface';
+import type { EventAdapter } from './adapters/interfaces/event-adapter.interface';
+import type { StateAdapter } from './adapters/interfaces/state-adapter.interface';
+import type { StreamAdapterManager } from './adapters/interfaces/stream-adapter-manager.interface';
+import { type CronManager } from './cron-handler';
+import type { LockedData } from './locked-data';
+import type { Motia } from './motia';
+import { Printer } from './printer';
+import { type MotiaEventManager } from './step-handlers';
+import type { ApiRouteConfig, Step } from './types';
+export type MotiaServer = {
+    printer: Printer;
+    app: Express;
+    server: http.Server;
+    socketServer: WsServer;
+    close: () => Promise<void>;
+    removeRoute: (step: Step<ApiRouteConfig>) => void;
+    addRoute: (step: Step<ApiRouteConfig>) => void;
+    cronManager: CronManager;
+    motiaEventManager: MotiaEventManager;
+    motia: Motia;
+};
+type MotiaServerConfig = {
+    isVerbose: boolean;
+    printer?: Printer;
+};
+type AdapterOptions = {
+    eventAdapter: EventAdapter;
+    cronAdapter: CronAdapter;
+    streamAdapter?: StreamAdapterManager;
+};
+export declare const createServer: (lockedData: LockedData, state: StateAdapter, config: MotiaServerConfig, adapters: AdapterOptions, configureApp?: (app: Express) => void) => MotiaServer;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/src/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AACA,OAAgB,EAAE,KAAK,OAAO,EAA+B,MAAM,SAAS,CAAA;AAC5E,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,KAAK,EAAE,MAAM,IAAI,QAAQ,EAAE,MAAM,IAAI,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8CAA8C,CAAA;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wDAAwD,CAAA;AAGlG,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,gBAAgB,CAAA;AAOpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAG/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAG5E,OAAO,KAAK,EAA2B,cAAc,EAA4B,IAAI,EAAE,MAAM,SAAS,CAAA;AAStG,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,IAAI,CAAC,MAAM,CAAA;IACnB,YAAY,EAAE,QAAQ,CAAA;IACtB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,IAAI,CAAA;IACjD,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,IAAI,CAAA;IAC9C,WAAW,EAAE,WAAW,CAAA;IACxB,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,YAAY,CAAA;IAC1B,WAAW,EAAE,WAAW,CAAA;IACxB,aAAa,CAAC,EAAE,oBAAoB,CAAA;CACrC,CAAA;AAED,eAAO,MAAM,YAAY,GACvB,YAAY,UAAU,EACtB,OAAO,YAAY,EACnB,QAAQ,iBAAiB,EACzB,UAAU,cAAc,EACxB,eAAe,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,KACpC,WAqVF,CAAA"}