@dexto/core 1.1.9 → 1.1.11

package/dist/storage/{backend/sqlite-backend.cjs → database/sqlite-store.cjs}

@@ -26,20 +26,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var sqlite_backend_exports = {};
-__export(sqlite_backend_exports, {
-  SQLiteBackend: () => SQLiteBackend
+var sqlite_store_exports = {};
+__export(sqlite_store_exports, {
+  SQLiteStore: () => SQLiteStore
 });
-module.exports = __toCommonJS(sqlite_backend_exports);
+module.exports = __toCommonJS(sqlite_store_exports);
 var import_path = require("path");
 var import_fs = require("fs");
 var import_logger = require("../../logger/index.js");
 var import_path2 = require("../../utils/path.js");
 var path = __toESM(require("path"), 1);
 var import_errors = require("../errors.js");
-let Database;
-class SQLiteBackend {
-  db;
+let BetterSqlite3Database;
+class SQLiteStore {
+  db = null;
   // Database.Database
   dbPath;
   config;
@@ -93,10 +93,10 @@ class SQLiteBackend {
     }
   }
   async connect() {
-    if (!Database) {
+    if (!BetterSqlite3Database) {
       try {
         const module2 = await import("better-sqlite3");
-        Database = module2.default || module2;
+        BetterSqlite3Database = module2.default || module2;
       } catch (error) {
         throw import_errors.StorageError.connectionFailed(
           `Failed to import better-sqlite3: ${error instanceof Error ? error.message : String(error)}`
@@ -122,7 +122,7 @@ class SQLiteBackend {
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3
     });
-    this.db = new Database(this.dbPath, {
+    this.db = new BetterSqlite3Database(this.dbPath, {
       readonly: sqliteOptions.readonly || false,
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3,
@@ -136,17 +136,18 @@ class SQLiteBackend {
     this.db.pragma("journal_mode = WAL");
     import_logger.logger.debug("SQLite enabled WAL mode for better concurrency");
     this.initializeTables();
-    import_logger.logger.info(`\u2705 SQLite backend successfully connected to: ${this.dbPath}`);
+    import_logger.logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
   }
   async disconnect() {
     if (this.db) {
       this.db.close();
+      this.db = null;
     }
   }
   isConnected() {
     return this.db !== null;
   }
-  getBackendType() {
+  getStoreType() {
     return "sqlite";
   }
   // Core operations
@@ -243,7 +244,7 @@ class SQLiteBackend {
   // Schema management
   checkConnection() {
     if (!this.db) {
-      throw import_errors.StorageError.notConnected("SQLiteBackend");
+      throw import_errors.StorageError.notConnected("SQLiteStore");
     }
   }
   // Maintenance operations
@@ -267,5 +268,5 @@ class SQLiteBackend {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  SQLiteBackend
+  SQLiteStore
 });

package/dist/storage/{backend/sqlite-backend.d.ts → database/sqlite-store.d.ts}

@@ -1,22 +1,20 @@
-import { DatabaseBackend } from './database-backend.js';
-import { SqliteBackendConfig } from '../schemas.js';
-import 'zod';
-
+import type { Database } from './types.js';
+import type { SqliteDatabaseConfig } from './schemas.js';
 /**
- * SQLite storage backend for local development and production.
- * Implements the DatabaseBackend interface with proper schema and connection handling.
+ * SQLite database store for local development and production.
+ * Implements the Database interface with proper schema and connection handling.
  */
-declare class SQLiteBackend implements DatabaseBackend {
+export declare class SQLiteStore implements Database {
     private db;
     private dbPath;
     private config;
-    constructor(config: SqliteBackendConfig);
+    constructor(config: SqliteDatabaseConfig);
     private resolveDefaultPath;
     private initializeTables;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackendType(): string;
+    getStoreType(): string;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
@@ -31,5 +29,4 @@ declare class SQLiteBackend implements DatabaseBackend {
         dbSize: number;
     }>;
 }
-
-export { SQLiteBackend };
+//# sourceMappingURL=sqlite-store.d.ts.map

package/dist/storage/database/sqlite-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/sqlite-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAQzD;;;GAGG;AACH,qBAAa,WAAY,YAAW,QAAQ;IACxC,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAuB;gBAEzB,MAAM,EAAE,oBAAoB;IAMxC,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,gBAAgB;IA8ClB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkExB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAgB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAelC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA0BvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAqB1E,OAAO,CAAC,eAAe;IAOjB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKvB,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;CAqBL"}

package/dist/storage/{backend/sqlite-backend.js → database/sqlite-store.js}

@@ -4,9 +4,9 @@ import { logger } from "../../logger/index.js";
 import { getDextoPath } from "../../utils/path.js";
 import * as path from "path";
 import { StorageError } from "../errors.js";
-let Database;
-class SQLiteBackend {
-  db;
+let BetterSqlite3Database;
+class SQLiteStore {
+  db = null;
   // Database.Database
   dbPath;
   config;
@@ -60,10 +60,10 @@ class SQLiteBackend {
     }
   }
   async connect() {
-    if (!Database) {
+    if (!BetterSqlite3Database) {
       try {
         const module = await import("better-sqlite3");
-        Database = module.default || module;
+        BetterSqlite3Database = module.default || module;
       } catch (error) {
         throw StorageError.connectionFailed(
           `Failed to import better-sqlite3: ${error instanceof Error ? error.message : String(error)}`
@@ -89,7 +89,7 @@ class SQLiteBackend {
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3
     });
-    this.db = new Database(this.dbPath, {
+    this.db = new BetterSqlite3Database(this.dbPath, {
       readonly: sqliteOptions.readonly || false,
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3,
@@ -103,17 +103,18 @@ class SQLiteBackend {
     this.db.pragma("journal_mode = WAL");
     logger.debug("SQLite enabled WAL mode for better concurrency");
     this.initializeTables();
-    logger.info(`\u2705 SQLite backend successfully connected to: ${this.dbPath}`);
+    logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
   }
   async disconnect() {
     if (this.db) {
       this.db.close();
+      this.db = null;
     }
   }
   isConnected() {
     return this.db !== null;
   }
-  getBackendType() {
+  getStoreType() {
     return "sqlite";
   }
   // Core operations
@@ -210,7 +211,7 @@ class SQLiteBackend {
   // Schema management
   checkConnection() {
     if (!this.db) {
-      throw StorageError.notConnected("SQLiteBackend");
+      throw StorageError.notConnected("SQLiteStore");
     }
   }
   // Maintenance operations
@@ -233,5 +234,5 @@ class SQLiteBackend {
   }
 }
 export {
-  SQLiteBackend
+  SQLiteStore
 };

package/dist/storage/database/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/storage/{backend/database-backend.d.cts → database/types.d.ts}

@@ -2,7 +2,7 @@
  * Persistent, reliable storage for important data with list operations for message history.
  * Data survives restarts and supports enumeration for settings management.
  */
-interface DatabaseBackend {
+export interface Database {
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
@@ -13,7 +13,6 @@ interface DatabaseBackend {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackendType(): string;
+    getStoreType(): string;
 }
-
-export type { DatabaseBackend };
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/database/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/storage/database/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,QAAQ;IAErB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAGnC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAGxC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,2FAA2F;IAC3F,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAGrE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,IAAI,MAAM,CAAC;CAC1B"}

package/dist/storage/error-codes.cjs

@@ -22,12 +22,27 @@ __export(error_codes_exports, {
 });
 module.exports = __toCommonJS(error_codes_exports);
 var StorageErrorCode = /* @__PURE__ */ ((StorageErrorCode2) => {
+  StorageErrorCode2["MANAGER_NOT_INITIALIZED"] = "storage_manager_not_initialized";
+  StorageErrorCode2["MANAGER_NOT_CONNECTED"] = "storage_manager_not_connected";
   StorageErrorCode2["CONNECTION_FAILED"] = "storage_connection_failed";
   StorageErrorCode2["CONNECTION_CONFIG_MISSING"] = "storage_connection_config_missing";
   StorageErrorCode2["READ_FAILED"] = "storage_read_failed";
   StorageErrorCode2["WRITE_FAILED"] = "storage_write_failed";
   StorageErrorCode2["DELETE_FAILED"] = "storage_delete_failed";
   StorageErrorCode2["MIGRATION_FAILED"] = "storage_migration_failed";
+  StorageErrorCode2["BLOB_INVALID_CONFIG"] = "BLOB_INVALID_CONFIG";
+  StorageErrorCode2["BLOB_SIZE_EXCEEDED"] = "BLOB_SIZE_EXCEEDED";
+  StorageErrorCode2["BLOB_TOTAL_SIZE_EXCEEDED"] = "BLOB_TOTAL_SIZE_EXCEEDED";
+  StorageErrorCode2["BLOB_INVALID_INPUT"] = "BLOB_INVALID_INPUT";
+  StorageErrorCode2["BLOB_ENCODING_ERROR"] = "BLOB_ENCODING_ERROR";
+  StorageErrorCode2["BLOB_NOT_FOUND"] = "BLOB_NOT_FOUND";
+  StorageErrorCode2["BLOB_INVALID_REFERENCE"] = "BLOB_INVALID_REFERENCE";
+  StorageErrorCode2["BLOB_ACCESS_DENIED"] = "BLOB_ACCESS_DENIED";
+  StorageErrorCode2["BLOB_CORRUPTED"] = "BLOB_CORRUPTED";
+  StorageErrorCode2["BLOB_BACKEND_NOT_CONNECTED"] = "BLOB_BACKEND_NOT_CONNECTED";
+  StorageErrorCode2["BLOB_BACKEND_UNAVAILABLE"] = "BLOB_BACKEND_UNAVAILABLE";
+  StorageErrorCode2["BLOB_CLEANUP_FAILED"] = "BLOB_CLEANUP_FAILED";
+  StorageErrorCode2["BLOB_OPERATION_FAILED"] = "BLOB_OPERATION_FAILED";
   return StorageErrorCode2;
 })(StorageErrorCode || {});
 // Annotate the CommonJS export names for ESM import in node:

package/dist/storage/error-codes.d.ts

@@ -1,14 +1,28 @@
 /**
  * Storage-specific error codes
- * Includes database, file system, and persistence errors
+ * Includes cache, database, and blob storage errors
  */
-declare enum StorageErrorCode {
+export declare enum StorageErrorCode {
+    MANAGER_NOT_INITIALIZED = "storage_manager_not_initialized",
+    MANAGER_NOT_CONNECTED = "storage_manager_not_connected",
     CONNECTION_FAILED = "storage_connection_failed",
     CONNECTION_CONFIG_MISSING = "storage_connection_config_missing",
     READ_FAILED = "storage_read_failed",
     WRITE_FAILED = "storage_write_failed",
     DELETE_FAILED = "storage_delete_failed",
-    MIGRATION_FAILED = "storage_migration_failed"
+    MIGRATION_FAILED = "storage_migration_failed",
+    BLOB_INVALID_CONFIG = "BLOB_INVALID_CONFIG",
+    BLOB_SIZE_EXCEEDED = "BLOB_SIZE_EXCEEDED",
+    BLOB_TOTAL_SIZE_EXCEEDED = "BLOB_TOTAL_SIZE_EXCEEDED",
+    BLOB_INVALID_INPUT = "BLOB_INVALID_INPUT",
+    BLOB_ENCODING_ERROR = "BLOB_ENCODING_ERROR",
+    BLOB_NOT_FOUND = "BLOB_NOT_FOUND",
+    BLOB_INVALID_REFERENCE = "BLOB_INVALID_REFERENCE",
+    BLOB_ACCESS_DENIED = "BLOB_ACCESS_DENIED",
+    BLOB_CORRUPTED = "BLOB_CORRUPTED",
+    BLOB_BACKEND_NOT_CONNECTED = "BLOB_BACKEND_NOT_CONNECTED",
+    BLOB_BACKEND_UNAVAILABLE = "BLOB_BACKEND_UNAVAILABLE",
+    BLOB_CLEANUP_FAILED = "BLOB_CLEANUP_FAILED",
+    BLOB_OPERATION_FAILED = "BLOB_OPERATION_FAILED"
 }
-
-export { StorageErrorCode };
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/storage/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/storage/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAExB,uBAAuB,oCAAoC;IAC3D,qBAAqB,kCAAkC;IAGvD,iBAAiB,8BAA8B;IAC/C,yBAAyB,sCAAsC;IAG/D,WAAW,wBAAwB;IACnC,YAAY,yBAAyB;IACrC,aAAa,0BAA0B;IAGvC,gBAAgB,6BAA6B;IAG7C,mBAAmB,wBAAwB;IAG3C,kBAAkB,uBAAuB;IACzC,wBAAwB,6BAA6B;IACrD,kBAAkB,uBAAuB;IACzC,mBAAmB,wBAAwB;IAG3C,cAAc,mBAAmB;IACjC,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;IACzC,cAAc,mBAAmB;IAGjC,0BAA0B,+BAA+B;IACzD,wBAAwB,6BAA6B;IAGrD,mBAAmB,wBAAwB;IAC3C,qBAAqB,0BAA0B;CAClD"}

package/dist/storage/error-codes.js

@@ -1,10 +1,25 @@
 var StorageErrorCode = /* @__PURE__ */ ((StorageErrorCode2) => {
+  StorageErrorCode2["MANAGER_NOT_INITIALIZED"] = "storage_manager_not_initialized";
+  StorageErrorCode2["MANAGER_NOT_CONNECTED"] = "storage_manager_not_connected";
   StorageErrorCode2["CONNECTION_FAILED"] = "storage_connection_failed";
   StorageErrorCode2["CONNECTION_CONFIG_MISSING"] = "storage_connection_config_missing";
   StorageErrorCode2["READ_FAILED"] = "storage_read_failed";
   StorageErrorCode2["WRITE_FAILED"] = "storage_write_failed";
   StorageErrorCode2["DELETE_FAILED"] = "storage_delete_failed";
   StorageErrorCode2["MIGRATION_FAILED"] = "storage_migration_failed";
+  StorageErrorCode2["BLOB_INVALID_CONFIG"] = "BLOB_INVALID_CONFIG";
+  StorageErrorCode2["BLOB_SIZE_EXCEEDED"] = "BLOB_SIZE_EXCEEDED";
+  StorageErrorCode2["BLOB_TOTAL_SIZE_EXCEEDED"] = "BLOB_TOTAL_SIZE_EXCEEDED";
+  StorageErrorCode2["BLOB_INVALID_INPUT"] = "BLOB_INVALID_INPUT";
+  StorageErrorCode2["BLOB_ENCODING_ERROR"] = "BLOB_ENCODING_ERROR";
+  StorageErrorCode2["BLOB_NOT_FOUND"] = "BLOB_NOT_FOUND";
+  StorageErrorCode2["BLOB_INVALID_REFERENCE"] = "BLOB_INVALID_REFERENCE";
+  StorageErrorCode2["BLOB_ACCESS_DENIED"] = "BLOB_ACCESS_DENIED";
+  StorageErrorCode2["BLOB_CORRUPTED"] = "BLOB_CORRUPTED";
+  StorageErrorCode2["BLOB_BACKEND_NOT_CONNECTED"] = "BLOB_BACKEND_NOT_CONNECTED";
+  StorageErrorCode2["BLOB_BACKEND_UNAVAILABLE"] = "BLOB_BACKEND_UNAVAILABLE";
+  StorageErrorCode2["BLOB_CLEANUP_FAILED"] = "BLOB_CLEANUP_FAILED";
+  StorageErrorCode2["BLOB_OPERATION_FAILED"] = "BLOB_OPERATION_FAILED";
   return StorageErrorCode2;
 })(StorageErrorCode || {});
 export {

package/dist/storage/errors.cjs

@@ -21,7 +21,7 @@ __export(errors_exports, {
   StorageError: () => StorageError
 });
 module.exports = __toCommonJS(errors_exports);
-var import_DextoRuntimeError = require("../errors/DextoRuntimeError.cjs");
+var import_errors = require("../errors/index.cjs");
 var import_types = require("../errors/types.cjs");
 var import_error_codes = require("./error-codes.js");
 class StorageError {
@@ -29,7 +29,7 @@ class StorageError {
    * Connection failed error
    */
   static connectionFailed(reason, config) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.CONNECTION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.THIRD_PARTY,
@@ -41,7 +41,7 @@ class StorageError {
    * Backend not connected error
    */
   static notConnected(backendType) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.CONNECTION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -49,11 +49,35 @@ class StorageError {
       { backendType }
     );
   }
+  /**
+   * Storage manager not initialized
+   */
+  static managerNotInitialized(method) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.MANAGER_NOT_INITIALIZED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `StorageManager is not initialized. Call initialize() before ${method}()`,
+      { method, hint: "Call await manager.initialize() first" }
+    );
+  }
+  /**
+   * Storage manager not connected
+   */
+  static managerNotConnected(method) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.MANAGER_NOT_CONNECTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `StorageManager is not connected. Call connect() before ${method}()`,
+      { method, hint: "Call await manager.connect() after initialize()" }
+    );
+  }
   /**
    * Read operation failed
    */
   static readFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.READ_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -65,7 +89,7 @@ class StorageError {
    * Write operation failed
    */
   static writeFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.WRITE_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -77,7 +101,7 @@ class StorageError {
    * Delete operation failed
    */
   static deleteFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.DELETE_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -89,7 +113,7 @@ class StorageError {
    * Migration failed error
    */
   static migrationFailed(reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.MIGRATION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -97,6 +121,170 @@ class StorageError {
       { reason, ...details }
     );
   }
+  // ==================== Blob Storage Errors ====================
+  /**
+   * Invalid blob configuration
+   */
+  static blobInvalidConfig(message, context) {
+    return new import_errors.DextoValidationError([
+      {
+        code: import_error_codes.StorageErrorCode.BLOB_INVALID_CONFIG,
+        message,
+        scope: import_types.ErrorScope.STORAGE,
+        type: import_types.ErrorType.USER,
+        severity: "error",
+        context: context || {}
+      }
+    ]);
+  }
+  /**
+   * Blob size exceeded maximum
+   */
+  static blobSizeExceeded(size, maxSize) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_SIZE_EXCEEDED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Blob size ${size} bytes exceeds maximum ${maxSize} bytes`,
+      { size, maxSize }
+    );
+  }
+  /**
+   * Total blob storage size exceeded
+   */
+  static blobTotalSizeExceeded(totalSize, maxTotalSize) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_TOTAL_SIZE_EXCEEDED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Total storage size ${totalSize} bytes exceeds maximum ${maxTotalSize} bytes`,
+      { totalSize, maxTotalSize }
+    );
+  }
+  /**
+   * Invalid blob input
+   */
+  static blobInvalidInput(input, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_INVALID_INPUT,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Invalid blob input: ${reason}`,
+      { inputType: typeof input, reason }
+    );
+  }
+  /**
+   * Blob encoding error
+   */
+  static blobEncodingError(operation, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_ENCODING_ERROR,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob ${operation} failed: encoding error`,
+      { operation, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob not found
+   */
+  static blobNotFound(reference) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_NOT_FOUND,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.NOT_FOUND,
+      `Blob not found: ${reference}`,
+      { reference }
+    );
+  }
+  /**
+   * Invalid blob reference
+   */
+  static blobInvalidReference(reference, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_INVALID_REFERENCE,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Invalid blob reference '${reference}': ${reason}`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob access denied
+   */
+  static blobAccessDenied(reference, operation) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_ACCESS_DENIED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.FORBIDDEN,
+      `Access denied for blob ${operation}: ${reference}`,
+      { reference, operation }
+    );
+  }
+  /**
+   * Blob data corrupted
+   */
+  static blobCorrupted(reference, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_CORRUPTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob data corrupted: ${reference} (${reason})`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob backend not connected
+   */
+  static blobBackendNotConnected(backendType) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_BACKEND_NOT_CONNECTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is not connected`,
+      { backendType }
+    );
+  }
+  /**
+   * Blob backend unavailable
+   */
+  static blobBackendUnavailable(backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_BACKEND_UNAVAILABLE,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is unavailable`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob cleanup failed
+   */
+  static blobCleanupFailed(backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_CLEANUP_FAILED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob cleanup failed for backend ${backendType}`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob operation failed
+   */
+  static blobOperationFailed(operation, backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_OPERATION_FAILED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob ${operation} failed for backend ${backendType}`,
+      {
+        operation,
+        backendType,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {