@dexto/core 1.2.6 → 1.4.0

package/dist/session/chat-session.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { createDatabaseHistoryProvider } from "./history/factory.js";
 import { createLLMService } from "../llm/services/factory.js";
 import {
@@ -8,6 +8,7 @@ import {
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { DextoRuntimeError, ErrorScope, ErrorType } from "../errors/index.js";
 import { PluginErrorCode } from "../plugins/error-codes.js";
+import { getModelPricing, calculateCost } from "../llm/registry.js";
 class ChatSession {
   /**
    * Creates a new ChatSession instance.
@@ -58,6 +59,10 @@ class ChatSession {
    * Stores the bound functions so they can be removed from the event bus.
    */
   forwarders = /* @__PURE__ */ new Map();
+  /**
+   * Token accumulator listener for cleanup.
+   */
+  tokenAccumulatorListener = null;
   /**
    * AbortController for the currently running turn, if any.
    * Calling cancel() aborts the in-flight LLM request and tool execution checks.
@@ -88,10 +93,33 @@ class ChatSession {
       this.forwarders.set(eventName, forwarder);
       this.eventBus.on(eventName, forwarder);
     });
+    this.setupTokenAccumulation();
     this.logger.debug(
       `[setupEventForwarding] Event forwarding setup complete for session=${this.id}`
     );
   }
+  /**
+   * Sets up token usage accumulation by listening to llm:response events.
+   * Accumulates token usage and cost to session metadata for /stats tracking.
+   */
+  setupTokenAccumulation() {
+    this.tokenAccumulatorListener = (payload) => {
+      if (payload.tokenUsage) {
+        let cost;
+        const llmConfig = this.services.stateManager.getLLMConfig(this.id);
+        const pricing = getModelPricing(llmConfig.provider, llmConfig.model);
+        if (pricing) {
+          cost = calculateCost(payload.tokenUsage, pricing);
+        }
+        this.services.sessionManager.accumulateTokenUsage(this.id, payload.tokenUsage, cost).catch((err) => {
+          this.logger.warn(
+            `Failed to accumulate token usage: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      }
+    };
+    this.eventBus.on("llm:response", this.tokenAccumulatorListener);
+  }
   /**
    * Initializes session-specific services.
    */
@@ -104,7 +132,6 @@ class ChatSession {
     );
     this.llmService = createLLMService(
       llmConfig,
-      llmConfig.router,
       this.services.toolManager,
       this.services.systemPromptManager,
       this.historyProvider,
@@ -133,12 +160,12 @@ class ChatSession {
   async saveBlockedInteraction(userInput, errorMessage, _imageData, _fileData) {
     const userMessage = {
       role: "user",
-      content: "[Blocked by content policy: input redacted]"
+      content: [{ type: "text", text: "[Blocked by content policy: input redacted]" }]
     };
     const errorContent = `Error: ${errorMessage}`;
     const assistantMessage = {
       role: "assistant",
-      content: errorContent
+      content: [{ type: "text", text: errorContent }]
     };
     await this.historyProvider.saveMessage(userMessage);
     await this.historyProvider.saveMessage(assistantMessage);
@@ -146,44 +173,61 @@ class ChatSession {
     this.eventBus.emit("llm:response", {
       content: errorContent,
       provider: llmConfig.provider,
-      model: llmConfig.model,
-      router: llmConfig.router
+      model: llmConfig.model
     });
   }
   /**
-   * Processes user input through the session's LLM service and returns the response.
+   * Stream a response for the given content.
+   * Primary method for running conversations with multi-image support.
    *
-   * This method:
-   * 1. Takes user input (text, optionally with image or file data)
-   * 2. Passes it to the LLM service for processing
-   * 3. Returns the AI's response text
-   *
-   * The method handles both text-only and multimodal input (text + images/files).
-   * Tool calls and conversation management are handled internally by the LLM service.
-   *
-   * @param input - The user's text input
-   * @param imageDataInput - Optional image data for multimodal input
-   * @param fileDataInput - Optional file data for file input
-   * @param stream - Optional flag to enable streaming responses
+   * @param content - String or ContentPart[] (text, images, files)
+   * @param options - { signal?: AbortSignal }
    * @returns Promise that resolves to the AI's response text
    *
    * @example
    * ```typescript
-   * const response = await session.run('What is the weather like today?');
-   * console.log(response); // "I'll check the weather for you..."
+   * // Text only
+   * const response = await session.stream('What is the weather?');
+   *
+   * // Multiple images
+   * const response = await session.stream([
+   *     { type: 'text', text: 'Compare these images' },
+   *     { type: 'image', image: base64Data1, mimeType: 'image/png' },
+   *     { type: 'image', image: base64Data2, mimeType: 'image/png' }
+   * ]);
    * ```
    */
-  async run(input, imageDataInput, fileDataInput, stream) {
+  async stream(content, options) {
+    const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
+    const textParts = parts.filter(
+      (p) => p.type === "text"
+    );
+    const imageParts = parts.filter((p) => p.type === "image");
+    const fileParts = parts.filter((p) => p.type === "file");
     this.logger.debug(
-      `Running session ${this.id} | input.len=${input?.length ?? 0} | image=${imageDataInput ? imageDataInput.mimeType : "none"} | file=${fileDataInput ? `${fileDataInput.mimeType}:${fileDataInput.filename ?? "unknown"}` : "none"}`
+      `Streaming session ${this.id} | textParts=${textParts.length} | images=${imageParts.length} | files=${fileParts.length}`
     );
     this.currentRunController = new AbortController();
-    const signal = this.currentRunController.signal;
+    const signal = options?.signal ? this.combineSignals(options.signal, this.currentRunController.signal) : this.currentRunController.signal;
     try {
+      const textContent = textParts.map((p) => p.text).join("\n");
+      const firstImage = imageParts[0];
+      const firstFile = fileParts[0];
       const beforeLLMPayload = {
-        text: input,
-        ...imageDataInput !== void 0 && { imageData: imageDataInput },
-        ...fileDataInput !== void 0 && { fileData: fileDataInput },
+        text: textContent,
+        ...firstImage && {
+          imageData: {
+            image: typeof firstImage.image === "string" ? firstImage.image : "[binary]",
+            mimeType: firstImage.mimeType || "image/jpeg"
+          }
+        },
+        ...firstFile && {
+          fileData: {
+            data: typeof firstFile.data === "string" ? firstFile.data : "[binary]",
+            mimeType: firstFile.mimeType,
+            ...firstFile.filename && { filename: firstFile.filename }
+          }
+        },
         sessionId: this.id
       };
       const modifiedBeforePayload = await this.services.pluginManager.executePlugins(
@@ -198,22 +242,17 @@ class ChatSession {
           abortSignal: signal
         }
       );
-      const finalInput = modifiedBeforePayload.text;
-      const finalImageData = modifiedBeforePayload.imageData;
-      const finalFileData = modifiedBeforePayload.fileData;
-      const response = await this.llmService.completeTask(
-        finalInput,
-        { signal },
-        finalImageData,
-        finalFileData,
-        stream
-      );
+      let modifiedParts = [...parts];
+      if (modifiedBeforePayload.text !== textContent && textParts.length > 0) {
+        modifiedParts = modifiedParts.filter((p) => p.type !== "text");
+        modifiedParts.unshift({ type: "text", text: modifiedBeforePayload.text });
+      }
+      const response = await this.llmService.stream(modifiedParts, { signal });
       const llmConfig = this.services.stateManager.getLLMConfig(this.id);
       const beforeResponsePayload = {
         content: response,
         provider: llmConfig.provider,
         model: llmConfig.model,
-        router: llmConfig.router,
         sessionId: this.id
       };
       const modifiedResponsePayload = await this.services.pluginManager.executePlugins(
@@ -237,16 +276,21 @@ class ChatSession {
           context: "user_cancelled",
           recoverable: true
         });
+        try {
+          const history = await this.getHistory();
+          const lastAssistant = history.filter((m) => m.role === "assistant").pop();
+          if (lastAssistant && typeof lastAssistant.content === "string") {
+            return lastAssistant.content;
+          }
+        } catch {
+          this.logger.debug("Failed to retrieve partial response from history on cancel");
+        }
         return "";
       }
       if (error instanceof DextoRuntimeError && error.code === PluginErrorCode.PLUGIN_BLOCKED_EXECUTION && error.scope === ErrorScope.PLUGIN && error.type === ErrorType.FORBIDDEN) {
+        const textContent = parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
         try {
-          await this.saveBlockedInteraction(
-            input,
-            error.message,
-            imageDataInput,
-            fileDataInput
-          );
+          await this.saveBlockedInteraction(textContent, error.message);
           this.logger.debug(
             `ChatSession ${this.id}: Saved blocked interaction to history`
           );
@@ -257,15 +301,27 @@ class ChatSession {
         }
         return error.message;
       }
-      const errortype = error instanceof Error ? "object" : "string";
       this.logger.error(
-        `Error in ChatSession.run: errortype=${errortype}: ${error instanceof Error ? error.message : String(error)}`
+        `Error in ChatSession.stream: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
     } finally {
       this.currentRunController = null;
     }
   }
+  /**
+   * Combine multiple abort signals into one.
+   */
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    signal1.addEventListener("abort", onAbort);
+    signal2.addEventListener("abort", onAbort);
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
   /**
    * Retrieves the complete conversation history for this session.
    *
@@ -336,11 +392,11 @@ class ChatSession {
   /**
    * Switches the LLM service for this session while preserving conversation history.
    *
-   * This method creates a new LLM service with the specified configuration and router,
+   * This method creates a new LLM service with the specified configuration,
    * while maintaining the existing ContextManager and conversation history. This allows
    * users to change AI models mid-conversation without losing context.
    *
-   * @param newLLMConfig The new LLM configuration to use (includes router)
+   * @param newLLMConfig The new LLM configuration to use
    *
    * @example
    * ```typescript
@@ -349,16 +405,13 @@ class ChatSession {
    *   provider: 'openai',
    *   model: 'gpt-5',
    *   apiKey: process.env.OPENAI_API_KEY,
-   *   router: 'in-built'
    * });
    * ```
    */
   async switchLLM(newLLMConfig) {
     try {
-      const router = newLLMConfig.router;
       const newLLMService = createLLMService(
         newLLMConfig,
-        router,
         this.services.toolManager,
         this.services.systemPromptManager,
         this.historyProvider,
@@ -375,7 +428,6 @@ class ChatSession {
       );
       this.eventBus.emit("llm:switched", {
         newConfig: newLLMConfig,
-        router,
         historyRetained: true
       });
     } catch (error) {
@@ -416,8 +468,54 @@ class ChatSession {
       this.eventBus.off(eventName, forwarder);
     });
     this.forwarders.clear();
+    if (this.tokenAccumulatorListener) {
+      this.eventBus.off("llm:response", this.tokenAccumulatorListener);
+      this.tokenAccumulatorListener = null;
+    }
     this.logger.debug(`Session ${this.id} disposed successfully`);
   }
+  /**
+   * Check if this session is currently processing a message.
+   * Returns true if a run is in progress and has not been aborted.
+   */
+  isBusy() {
+    return this.currentRunController !== null && !this.currentRunController.signal.aborted;
+  }
+  /**
+   * Queue a message for processing when the session is busy.
+   * The message will be injected into the conversation when the current turn completes.
+   *
+   * @param message The user message to queue
+   * @returns Queue position and message ID
+   */
+  queueMessage(message) {
+    return this.llmService.getMessageQueue().enqueue(message);
+  }
+  /**
+   * Get all messages currently in the queue.
+   * @returns Array of queued messages
+   */
+  getQueuedMessages() {
+    return this.llmService.getMessageQueue().getAll();
+  }
+  /**
+   * Remove a queued message.
+   * @param id Message ID to remove
+   * @returns true if message was found and removed; false otherwise
+   */
+  removeQueuedMessage(id) {
+    return this.llmService.getMessageQueue().remove(id);
+  }
+  /**
+   * Clear all queued messages.
+   * @returns Number of messages that were cleared
+   */
+  clearMessageQueue() {
+    const queue = this.llmService.getMessageQueue();
+    const count = queue.pendingCount();
+    queue.clear();
+    return count;
+  }
   /**
    * Cancel the currently running turn for this session, if any.
    * Returns true if a run was in progress and was signaled to abort.

package/dist/session/error-codes.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 var SessionErrorCode = /* @__PURE__ */ ((SessionErrorCode2) => {
   SessionErrorCode2["SESSION_NOT_FOUND"] = "session_not_found";
   SessionErrorCode2["SESSION_INITIALIZATION_FAILED"] = "session_initialization_failed";

package/dist/session/errors.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { SessionErrorCode } from "./error-codes.js";

package/dist/session/history/database.cjs

@@ -24,47 +24,58 @@ module.exports = __toCommonJS(database_exports);
 var import_types = require("../../logger/v2/types.cjs");
 var import_errors = require("../errors.js");
 class DatabaseHistoryProvider {
+  // Debounce window for batching updates
   constructor(sessionId, database, logger) {
     this.sessionId = sessionId;
     this.database = database;
     this.logger = logger.createChild(import_types.DextoLogComponent.SESSION);
   }
   logger;
+  // Cache state
+  cache = null;
+  dirty = false;
+  flushTimer = null;
+  flushPromise = null;
+  // Flush configuration
+  static FLUSH_DELAY_MS = 100;
   async getHistory() {
-    const key = this.getMessagesKey();
-    try {
-      const messages = await this.database.getRange(key, 0, 1e3);
-      this.logger.debug(
-        `DatabaseHistoryProvider: Retrieved ${messages.length} messages for session ${this.sessionId}`
-      );
-      return messages;
-    } catch (error) {
-      this.logger.error(
-        `DatabaseHistoryProvider: Error retrieving messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return [];
+    if (this.cache === null) {
+      const key = this.getMessagesKey();
+      try {
+        this.cache = await this.database.getRange(key, 0, 1e4);
+        this.logger.debug(
+          `DatabaseHistoryProvider: Loaded ${this.cache.length} messages from DB for session ${this.sessionId}`
+        );
+      } catch (error) {
+        this.logger.error(
+          `DatabaseHistoryProvider: Error loading messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw import_errors.SessionError.storageFailed(
+          this.sessionId,
+          "load history",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
     }
+    return [...this.cache];
   }
   async saveMessage(message) {
     const key = this.getMessagesKey();
+    if (this.cache === null) {
+      await this.getHistory();
+    }
+    this.cache.push(message);
     try {
       await this.database.append(key, message);
-      let contentPreview = "[no content]";
-      if (message.content) {
-        if (typeof message.content === "string") {
-          contentPreview = message.content.length > 100 ? `${message.content.substring(0, 100)}...` : message.content;
-        } else if (Array.isArray(message.content)) {
-          contentPreview = `[${message.content.length} parts]`;
-        }
-      }
       this.logger.debug(
         `DatabaseHistoryProvider: Saved message for session ${this.sessionId}`,
         {
           role: message.role,
-          content: contentPreview
+          id: message.id
         }
       );
     } catch (error) {
+      this.cache.pop();
       this.logger.error(
         `DatabaseHistoryProvider: Error saving message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -75,7 +86,34 @@ class DatabaseHistoryProvider {
       );
     }
   }
+  async updateMessage(message) {
+    if (!message.id) {
+      this.logger.warn(
+        `DatabaseHistoryProvider: Ignoring update for message without id in session ${this.sessionId}`
+      );
+      return;
+    }
+    if (this.cache === null) {
+      await this.getHistory();
+    }
+    const index = this.cache.findIndex((m) => m.id === message.id);
+    if (index !== -1) {
+      this.cache[index] = message;
+      this.dirty = true;
+      this.scheduleFlush();
+      this.logger.debug(
+        `DatabaseHistoryProvider: Updated message ${message.id} in cache for session ${this.sessionId}`
+      );
+    } else {
+      this.logger.warn(
+        `DatabaseHistoryProvider: Message ${message.id} not found for update in session ${this.sessionId}`
+      );
+    }
+  }
   async clearHistory() {
+    this.cancelPendingFlush();
+    this.cache = [];
+    this.dirty = false;
     const key = this.getMessagesKey();
     try {
       await this.database.delete(key);
@@ -92,6 +130,81 @@ class DatabaseHistoryProvider {
       );
     }
   }
+  /**
+   * Flush any pending updates to the database.
+   * Should be called at turn boundaries to ensure durability.
+   */
+  async flush() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
+    this.cancelPendingFlush();
+    if (!this.dirty || !this.cache) {
+      return;
+    }
+    this.flushPromise = this.doFlush();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  /**
+   * Internal flush implementation.
+   * Writes entire cache to DB (delete + re-append all).
+   */
+  async doFlush() {
+    if (!this.dirty || !this.cache) {
+      return;
+    }
+    const key = this.getMessagesKey();
+    const messageCount = this.cache.length;
+    try {
+      await this.database.delete(key);
+      for (const msg of this.cache) {
+        await this.database.append(key, msg);
+      }
+      if (!this.flushTimer) {
+        this.dirty = false;
+      }
+      this.logger.debug(
+        `DatabaseHistoryProvider: Flushed ${messageCount} messages to DB for session ${this.sessionId}`
+      );
+    } catch (error) {
+      this.logger.error(
+        `DatabaseHistoryProvider: Error flushing messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw import_errors.SessionError.storageFailed(
+        this.sessionId,
+        "flush messages",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Schedule a debounced flush.
+   * Batches rapid updateMessage() calls into a single DB write.
+   */
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.doFlush().catch(() => {
+      });
+    }, DatabaseHistoryProvider.FLUSH_DELAY_MS);
+  }
+  /**
+   * Cancel any pending scheduled flush.
+   */
+  cancelPendingFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
   getMessagesKey() {
     return `messages:${this.sessionId}`;
   }

package/dist/session/history/database.d.ts

@@ -4,24 +4,53 @@ import type { InternalMessage } from '../../context/types.js';
 import type { IConversationHistoryProvider } from './types.js';
 /**
  * History provider that works directly with DatabaseBackend.
- * Handles message-specific operations and key formatting internally.
+ * Uses write-through caching for read performance while maintaining durability.
  *
- * TODO: Add in-memory caching to reduce database queries.
- * Cache should be invalidated on writes and persist across LLM switches.
- * Consider caching strategy:
- * - Load cache on first getHistory() call
- * - Update cache optimistically on saveMessage()
- * - Clear cache on clearHistory()
- * This will significantly improve performance for sessions with many messages.
+ * Caching strategy:
+ * - getHistory(): Returns cached messages after first load (eliminates repeated DB reads)
+ * - saveMessage(): Updates cache AND writes to DB immediately (new messages are critical)
+ * - updateMessage(): Updates cache immediately, debounces DB writes (batches rapid updates)
+ * - flush(): Forces all pending updates to DB (called at turn boundaries)
+ * - clearHistory(): Clears cache and DB immediately
+ *
+ * Durability guarantees:
+ * - New messages (saveMessage) are always immediately durable
+ * - Updates (updateMessage) are durable within flush interval or on explicit flush()
+ * - Worst case on crash: lose updates from last flush interval (typically <100ms)
  */
 export declare class DatabaseHistoryProvider implements IConversationHistoryProvider {
     private sessionId;
     private database;
     private logger;
+    private cache;
+    private dirty;
+    private flushTimer;
+    private flushPromise;
+    private static readonly FLUSH_DELAY_MS;
     constructor(sessionId: string, database: Database, logger: IDextoLogger);
     getHistory(): Promise<InternalMessage[]>;
     saveMessage(message: InternalMessage): Promise<void>;
+    updateMessage(message: InternalMessage): Promise<void>;
     clearHistory(): Promise<void>;
+    /**
+     * Flush any pending updates to the database.
+     * Should be called at turn boundaries to ensure durability.
+     */
+    flush(): Promise<void>;
+    /**
+     * Internal flush implementation.
+     * Writes entire cache to DB (delete + re-append all).
+     */
+    private doFlush;
+    /**
+     * Schedule a debounced flush.
+     * Batches rapid updateMessage() calls into a single DB write.
+     */
+    private scheduleFlush;
+    /**
+     * Cancel any pending scheduled flush.
+     */
+    private cancelPendingFlush;
     private getMessagesKey;
 }
 //# sourceMappingURL=database.d.ts.map

package/dist/session/history/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/session/history/database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAwB,YAAW,4BAA4B;IAIpE,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAJpB,OAAO,CAAC,MAAM,CAAe;gBAGjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,YAAY;IAKlB,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAmBxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqCpD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBnC,OAAO,CAAC,cAAc;CAGzB"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/session/history/database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,uBAAwB,YAAW,4BAA4B;IAapE,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAbpB,OAAO,CAAC,MAAM,CAAe;IAG7B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,YAAY,CAA8B;IAGlD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAO;gBAGjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,YAAY;IAKlB,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAyBxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCpD,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCtD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BnC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwB5B;;;OAGG;YACW,OAAO;IAoCrB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAerB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,cAAc;CAGzB"}