@dexto/core 1.1.9 → 1.1.11

package/dist/storage/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/storage/schemas.js

@@ -1,89 +1,30 @@
 import { z } from "zod";
-import { StorageErrorCode } from "./error-codes.js";
-import { ErrorScope, ErrorType } from "../errors/types.js";
-const BaseBackendSchema = z.object({
-  maxConnections: z.number().int().positive().optional().describe("Maximum connections"),
-  idleTimeoutMillis: z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
-  connectionTimeoutMillis: z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
-  options: z.record(z.any()).optional().describe("Backend-specific options")
-});
-const InMemoryBackendSchema = BaseBackendSchema.extend({
-  type: z.literal("in-memory")
-  // In-memory backend doesn't need connection options, but inherits pool options for consistency
-}).strict();
-const RedisBackendSchema = BaseBackendSchema.extend({
-  type: z.literal("redis"),
-  url: z.string().optional().describe("Redis connection URL (redis://...)"),
-  host: z.string().optional().describe("Redis host"),
-  port: z.number().int().positive().optional().describe("Redis port"),
-  password: z.string().optional().describe("Redis password"),
-  database: z.number().int().nonnegative().optional().describe("Redis database number")
-}).strict();
-const SqliteBackendSchema = BaseBackendSchema.extend({
-  type: z.literal("sqlite"),
-  path: z.string().optional().describe(
-    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
-  ),
-  database: z.string().optional().describe("Database filename (default: dexto.db)")
-}).strict();
-const PostgresBackendSchema = BaseBackendSchema.extend({
-  type: z.literal("postgres"),
-  url: z.string().optional().describe("PostgreSQL connection URL (postgresql://...)"),
-  connectionString: z.string().optional().describe("PostgreSQL connection string"),
-  host: z.string().optional().describe("PostgreSQL host"),
-  port: z.number().int().positive().optional().describe("PostgreSQL port"),
-  database: z.string().optional().describe("PostgreSQL database name"),
-  password: z.string().optional().describe("PostgreSQL password")
-}).strict();
-const BackendConfigSchema = z.discriminatedUnion(
-  "type",
-  [InMemoryBackendSchema, RedisBackendSchema, SqliteBackendSchema, PostgresBackendSchema],
-  {
-    errorMap: (issue, ctx) => {
-      if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
-        return {
-          message: `Invalid backend type. Expected 'in-memory', 'redis', 'sqlite', or 'postgres'.`
-        };
-      }
-      return { message: ctx.defaultError };
-    }
-  }
-).describe("Backend configuration for storage system").superRefine((data, ctx) => {
-  if (data.type === "redis") {
-    if (!data.url && !data.host) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "Redis backend requires either 'url' or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: ErrorScope.STORAGE,
-          type: ErrorType.USER
-        }
-      });
-    }
-  }
-  if (data.type === "postgres") {
-    if (!data.url && !data.connectionString && !data.host) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "PostgreSQL backend requires one of 'url', 'connectionString', or 'host' to be specified",
-        path: ["url"],
-        params: {
-          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
-          scope: ErrorScope.STORAGE,
-          type: ErrorType.USER
-        }
-      });
-    }
-  }
-});
+import {
+  CACHE_TYPES,
+  CacheConfigSchema
+} from "./cache/schemas.js";
+import {
+  DATABASE_TYPES,
+  DatabaseConfigSchema
+} from "./database/schemas.js";
+import {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema
+} from "./blob/schemas.js";
+import { CacheConfigSchema as CacheConfigSchema2 } from "./cache/schemas.js";
+import { DatabaseConfigSchema as DatabaseConfigSchema2 } from "./database/schemas.js";
+import { BlobStoreConfigSchema as BlobStoreConfigSchema2 } from "./blob/schemas.js";
 const StorageSchema = z.object({
-  cache: BackendConfigSchema.describe("Cache backend configuration (fast, ephemeral)"),
-  database: BackendConfigSchema.describe(
-    "Database backend configuration (persistent, reliable)"
-  )
-}).strict().describe("Storage configuration with cache and database backends").brand();
+  cache: CacheConfigSchema2.describe("Cache configuration (fast, ephemeral)"),
+  database: DatabaseConfigSchema2.describe("Database configuration (persistent, reliable)"),
+  blob: BlobStoreConfigSchema2.optional().default({ type: "local" }).describe("Blob store configuration (for large, unstructured data)")
+}).strict().describe("Storage configuration with cache, database, and blob store").brand();
 export {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
   StorageSchema
 };

package/dist/storage/storage-manager.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,160 +15,168 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var storage_manager_exports = {};
 __export(storage_manager_exports, {
   StorageManager: () => StorageManager,
-  createStorageBackends: () => createStorageBackends
+  createStorageManager: () => createStorageManager
 });
 module.exports = __toCommonJS(storage_manager_exports);
-var import_memory_backend = require("./backend/memory-backend.js");
+var import_factory = require("./cache/factory.js");
+var import_factory2 = require("./database/factory.js");
+var import_factory3 = require("./blob/factory.js");
+var import_errors = require("./errors.js");
 var import_logger = require("../logger/index.js");
-let SQLiteBackend;
-let RedisBackend;
-let PostgresBackend;
 const HEALTH_CHECK_KEY = "storage_manager_health_check";
 class StorageManager {
   config;
   cache;
   database;
+  blobStore;
+  initialized = false;
   connected = false;
   constructor(config) {
     this.config = config;
   }
+  /**
+   * Initialize storage instances without connecting.
+   * This allows configuration and inspection before establishing connections.
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.cache = await (0, import_factory.createCache)(this.config.cache);
+    this.database = await (0, import_factory2.createDatabase)(this.config.database);
+    this.blobStore = (0, import_factory3.createBlobStore)(this.config.blob);
+    this.initialized = true;
+  }
+  /**
+   * Connect all storage backends.
+   * Must call initialize() first, or use createStorageManager() helper.
+   */
   async connect() {
+    if (!this.initialized) {
+      throw import_errors.StorageError.managerNotInitialized("connect");
+    }
     if (this.connected) {
-      return {
-        cache: this.cache,
-        database: this.database
-      };
+      return;
+    }
+    const connected = [];
+    try {
+      await this.cache.connect();
+      connected.push("cache");
+      await this.database.connect();
+      connected.push("database");
+      await this.blobStore.connect();
+      connected.push("blob");
+      this.connected = true;
+    } catch (error) {
+      import_logger.logger.warn(
+        `Storage connection failed, rolling back ${connected.length} connected stores`
+      );
+      for (const store of connected.reverse()) {
+        try {
+          if (store === "cache") await this.cache.disconnect();
+          else if (store === "database") await this.database.disconnect();
+          else if (store === "blob") await this.blobStore.disconnect();
+        } catch (disconnectError) {
+          import_logger.logger.error(
+            `Failed to rollback ${store} during connection failure: ${disconnectError}`
+          );
+        }
+      }
+      throw error;
     }
-    this.cache = await this.createCacheBackend();
-    await this.cache.connect();
-    this.database = await this.createDatabaseBackend();
-    await this.database.connect();
-    this.connected = true;
-    return {
-      cache: this.cache,
-      database: this.database
-    };
   }
   async disconnect() {
-    if (this.cache) {
-      await this.cache.disconnect();
-      delete this.cache;
-    }
-    if (this.database) {
-      await this.database.disconnect();
-      delete this.database;
-    }
+    if (!this.connected) return;
+    const results = await Promise.allSettled([
+      this.cache.disconnect(),
+      this.database.disconnect(),
+      this.blobStore.disconnect()
+    ]);
+    const errors = [];
+    const storeNames = ["cache", "database", "blob store"];
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        const storeName = storeNames[index];
+        const error = result.reason;
+        import_logger.logger.error(`Failed to disconnect ${storeName}: ${error}`);
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
     this.connected = false;
-  }
-  isConnected() {
-    return this.connected && this.cache?.isConnected() === true && this.database?.isConnected() === true;
-  }
-  getBackends() {
-    if (!this.connected) return null;
-    return {
-      cache: this.cache,
-      database: this.database
-    };
-  }
-  async createCacheBackend() {
-    const cacheConfig = this.config.cache;
-    switch (cacheConfig.type) {
-      case "redis":
-        return this.createRedisBackend(cacheConfig);
-      case "in-memory":
-      default:
-        import_logger.logger.info("Using in-memory cache backend");
-        return new import_memory_backend.MemoryBackend();
+    if (errors.length > 0) {
+      throw import_errors.StorageError.connectionFailed(
+        `Failed to disconnect ${errors.length} storage backend(s): ${errors.map((e) => e.message).join(", ")}`
+      );
     }
   }
-  async createDatabaseBackend() {
-    const dbConfig = this.config.database;
-    switch (dbConfig.type) {
-      case "postgres":
-        return this.createPostgresBackend(dbConfig);
-      case "sqlite":
-        return this.createSQLiteBackend(dbConfig);
-      case "in-memory":
-      default:
-        import_logger.logger.info("Using in-memory database backend");
-        return new import_memory_backend.MemoryBackend();
-    }
+  isConnected() {
+    return this.connected && this.cache.isConnected() && this.database.isConnected() && this.blobStore.isConnected();
   }
-  async createRedisBackend(config) {
-    try {
-      if (!RedisBackend) {
-        const module2 = await import("./backend/redis-backend.js");
-        RedisBackend = module2.RedisBackend;
-      }
-      import_logger.logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-      return new RedisBackend(config);
-    } catch (error) {
-      import_logger.logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
-      return new import_memory_backend.MemoryBackend();
+  /**
+   * Get the cache store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getCache() {
+    if (!this.connected) {
+      throw import_errors.StorageError.managerNotConnected("getCache");
     }
+    return this.cache;
   }
-  async createPostgresBackend(config) {
-    try {
-      if (!PostgresBackend) {
-        const module2 = await import("./backend/postgres-backend.js");
-        PostgresBackend = module2.PostgresBackend;
-      }
-      import_logger.logger.info("Connecting to PostgreSQL database");
-      return new PostgresBackend(config);
-    } catch (error) {
-      import_logger.logger.warn(`PostgreSQL not available, falling back to in-memory database: ${error}`);
-      return new import_memory_backend.MemoryBackend();
+  /**
+   * Get the database store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getDatabase() {
+    if (!this.connected) {
+      throw import_errors.StorageError.managerNotConnected("getDatabase");
     }
+    return this.database;
   }
-  async createSQLiteBackend(config) {
-    try {
-      if (!SQLiteBackend) {
-        const module2 = await import("./backend/sqlite-backend.js");
-        SQLiteBackend = module2.SQLiteBackend;
-      }
-      import_logger.logger.info(`Using SQLite database at ${config.path}`);
-      return new SQLiteBackend(config);
-    } catch (error) {
-      import_logger.logger.error(
-        `SQLite backend failed to load: ${error instanceof Error ? error.message : String(error)}`
-      );
-      import_logger.logger.error(`Full error details: ${JSON.stringify(error)}`);
-      import_logger.logger.warn("Falling back to in-memory database backend");
-      return new import_memory_backend.MemoryBackend();
+  /**
+   * Get the blob store instance.
+   * @throws {DextoRuntimeError} if not connected
+   */
+  getBlobStore() {
+    if (!this.connected) {
+      throw import_errors.StorageError.managerNotConnected("getBlobStore");
     }
+    return this.blobStore;
   }
   // Utility methods
   async getInfo() {
+    if (!this.connected) {
+      throw import_errors.StorageError.managerNotConnected("getInfo");
+    }
     return {
       cache: {
-        type: this.cache?.getBackendType() || "none",
-        connected: this.cache?.isConnected() || false
+        type: this.cache.getStoreType(),
+        connected: this.cache.isConnected()
       },
       database: {
-        type: this.database?.getBackendType() || "none",
-        connected: this.database?.isConnected() || false
+        type: this.database.getStoreType(),
+        connected: this.database.isConnected()
+      },
+      blob: {
+        type: this.blobStore.getStoreType(),
+        connected: this.blobStore.isConnected()
       },
       connected: this.connected
     };
   }
   // Health check
   async healthCheck() {
+    if (!this.connected) {
+      throw import_errors.StorageError.managerNotConnected("healthCheck");
+    }
     let cacheHealthy = false;
     let databaseHealthy = false;
+    let blobHealthy = false;
     try {
-      if (this.cache?.isConnected()) {
+      if (this.cache.isConnected()) {
         await this.cache.set(HEALTH_CHECK_KEY, "ok", 10);
         const result = await this.cache.get(HEALTH_CHECK_KEY);
         cacheHealthy = result === "ok";
@@ -180,7 +186,7 @@ class StorageManager {
       import_logger.logger.warn(`Cache health check failed: ${error}`);
     }
     try {
-      if (this.database?.isConnected()) {
+      if (this.database.isConnected()) {
         await this.database.set(HEALTH_CHECK_KEY, "ok");
         const result = await this.database.get(HEALTH_CHECK_KEY);
         databaseHealthy = result === "ok";
@@ -189,20 +195,29 @@ class StorageManager {
     } catch (error) {
       import_logger.logger.warn(`Database health check failed: ${error}`);
     }
+    try {
+      if (this.blobStore.isConnected()) {
+        blobHealthy = this.blobStore.isConnected();
+      }
+    } catch (error) {
+      import_logger.logger.warn(`Blob store health check failed: ${error}`);
+    }
     return {
       cache: cacheHealthy,
       database: databaseHealthy,
-      overall: cacheHealthy && databaseHealthy
+      blob: blobHealthy,
+      overall: cacheHealthy && databaseHealthy && blobHealthy
     };
   }
 }
-async function createStorageBackends(config) {
+async function createStorageManager(config) {
   const manager = new StorageManager(config);
-  const backends = await manager.connect();
-  return { manager, backends };
+  await manager.initialize();
+  await manager.connect();
+  return manager;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StorageManager,
-  createStorageBackends
+  createStorageManager
 });

package/dist/storage/storage-manager.d.ts

@@ -1,28 +1,52 @@
-import { StorageBackends } from './backend/types.js';
-import { ValidatedStorageConfig } from './schemas.js';
-import './backend/cache-backend.js';
-import './backend/database-backend.js';
-import 'zod';
-
+import type { Cache } from './cache/types.js';
+import type { Database } from './database/types.js';
+import type { BlobStore } from './blob/types.js';
+import type { ValidatedStorageConfig } from './schemas.js';
 /**
  * Storage manager that initializes and manages storage backends.
- * Handles both cache and database backends with automatic fallbacks.
+ * Handles cache, database, and blob backends with automatic fallbacks.
+ *
+ * Lifecycle:
+ * 1. new StorageManager(config) - Creates manager with config
+ * 2. await manager.initialize() - Creates store instances (without connecting)
+ * 3. await manager.connect() - Establishes connections to all stores
+ * 4. await manager.disconnect() - Closes all connections
  */
-declare class StorageManager {
+export declare class StorageManager {
     private config;
-    private cache?;
-    private database?;
+    private cache;
+    private database;
+    private blobStore;
+    private initialized;
     private connected;
     constructor(config: ValidatedStorageConfig);
-    connect(): Promise<StorageBackends>;
+    /**
+     * Initialize storage instances without connecting.
+     * This allows configuration and inspection before establishing connections.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Connect all storage backends.
+     * Must call initialize() first, or use createStorageManager() helper.
+     */
+    connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackends(): StorageBackends | null;
-    private createCacheBackend;
-    private createDatabaseBackend;
-    private createRedisBackend;
-    private createPostgresBackend;
-    private createSQLiteBackend;
+    /**
+     * Get the cache store instance.
+     * @throws {DextoRuntimeError} if not connected
+     */
+    getCache(): Cache;
+    /**
+     * Get the database store instance.
+     * @throws {DextoRuntimeError} if not connected
+     */
+    getDatabase(): Database;
+    /**
+     * Get the blob store instance.
+     * @throws {DextoRuntimeError} if not connected
+     */
+    getBlobStore(): BlobStore;
     getInfo(): Promise<{
         cache: {
             type: string;
@@ -32,21 +56,23 @@ declare class StorageManager {
             type: string;
             connected: boolean;
         };
+        blob: {
+            type: string;
+            connected: boolean;
+        };
         connected: boolean;
     }>;
     healthCheck(): Promise<{
         cache: boolean;
         database: boolean;
+        blob: boolean;
         overall: boolean;
     }>;
 }
 /**
- * Create storage backends without using singleton pattern
- * This allows multiple agent instances to have independent storage
+ * Create and initialize a storage manager.
+ * This is a convenience helper that combines initialization and connection.
+ * This allows multiple agent instances to have independent storage.
  */
-declare function createStorageBackends(config: ValidatedStorageConfig): Promise<{
-    manager: StorageManager;
-    backends: StorageBackends;
-}>;
-
-export { StorageManager, createStorageBackends };
+export declare function createStorageManager(config: ValidatedStorageConfig): Promise<StorageManager>;
+//# sourceMappingURL=storage-manager.d.ts.map

package/dist/storage/storage-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/storage/storage-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAS3D;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,sBAAsB;IAI1C;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCjC,WAAW,IAAI,OAAO;IAStB;;;OAGG;IACH,QAAQ,IAAI,KAAK;IAOjB;;;OAGG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,YAAY,IAAI,SAAS;IAQnB,OAAO,IAAI,OAAO,CAAC;QACrB,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC5C,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC/C,IAAI,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC3C,SAAS,EAAE,OAAO,CAAC;KACtB,CAAC;IAuBI,WAAW,IAAI,OAAO,CAAC;QACzB,KAAK,EAAE,OAAO,CAAC;QACf,QAAQ,EAAE,OAAO,CAAC;QAClB,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KACpB,CAAC;CA+CL;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACtC,MAAM,EAAE,sBAAsB,GAC/B,OAAO,CAAC,cAAc,CAAC,CAKzB"}