cynx-lib 1.3.41 → 1.3.42

package/utils/utils/storage_manager.cjs

@@ -0,0 +1,1177 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __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, {
+  STORAGE_PROVIDERS: () => STORAGE_PROVIDERS,
+  StorageManager: () => StorageManager,
+  createStorageManager: () => createStorageManager,
+  default: () => storage_manager_default
+});
+module.exports = __toCommonJS(storage_manager_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_uid = require("./uid.js");
+var import_storage = require("./storage.js");
+const httpsAgent = new import_https.default.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 6e4,
+  maxSockets: 64,
+  maxFreeSockets: 32,
+  timeout: 3e4
+});
+const httpAgent = new import_http.default.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 6e4,
+  maxSockets: 64,
+  maxFreeSockets: 32,
+  timeout: 3e4
+});
+const STORAGE_PROVIDERS = [
+  {
+    id: "s3",
+    name: "Amazon S3",
+    description: "Amazon Web Services S3 Object Storage",
+    fields: [
+      { key: "bucket", label: "\u0418\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 (Bucket Name)", placeholder: "my-company-storage", required: true },
+      { key: "region", label: "\u0420\u0435\u0433\u0438\u043E\u043D AWS (Region)", placeholder: "us-east-1", required: true, default: "us-east-1" },
+      { key: "accessKeyId", label: "Access Key ID", placeholder: "AKIA...", required: true },
+      { key: "secretAccessKey", label: "Secret Access Key", type: "password", placeholder: "AWS Secret Key", required: true },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0434\u043E\u043C\u0435\u043D / CloudFront URL (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://cdn.mycompany.com" },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 \u0432 \u0431\u0430\u043A\u0435\u0442\u0435 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "uploads" },
+      { key: "endpoint", label: "\u041A\u0430\u0441\u0442\u043E\u043C\u043D\u044B\u0439 Endpoint URL (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E, \u0434\u043B\u044F MinIO/LocalStack)", placeholder: "https://s3.custom-domain.com" }
+    ]
+  },
+  {
+    id: "r2",
+    name: "Cloudflare R2",
+    description: "Cloudflare R2 S3-Compatible Storage (Zero egress fee)",
+    fields: [
+      { key: "bucket", label: "\u0418\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 R2 (Bucket Name)", placeholder: "my-r2-bucket", required: true },
+      { key: "accountId", label: "Cloudflare Account ID", placeholder: "f1234567890abcdef...", required: true },
+      { key: "accessKeyId", label: "R2 Access Key ID", placeholder: "24-character hex ID", required: true },
+      { key: "secretAccessKey", label: "R2 Secret Access Key", type: "password", placeholder: "64-character hex secret", required: true },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0434\u043E\u043C\u0435\u043D R2 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://pub-xxx.r2.dev \u0438\u043B\u0438 https://cdn.mycompany.com" },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 \u0432 \u0431\u0430\u043A\u0435\u0442\u0435 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "uploads" }
+    ]
+  },
+  {
+    id: "cloudinary",
+    name: "Cloudinary",
+    description: "Cloudinary Media Optimization & Storage",
+    fields: [
+      { key: "cloudName", label: "Cloud Name", placeholder: "dXXXXXXX", required: true },
+      { key: "apiKey", label: "API Key", placeholder: "1234567890", required: true },
+      { key: "apiSecret", label: "API Secret", type: "password", placeholder: "API Secret key", required: true },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 \u0432 Cloudinary (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "emp_storage" }
+    ]
+  },
+  {
+    id: "vercel_blob",
+    name: "Vercel Blob",
+    description: "Vercel Edge Global Blob Storage",
+    fields: [
+      { key: "readWriteToken", label: "Read/Write Token (BLOB_READ_WRITE_TOKEN)", type: "password", placeholder: "vercel_blob_rw_...", required: true },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 \u0432 Vercel Blob (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "emp-storage" }
+    ]
+  },
+  {
+    id: "supabase",
+    name: "Supabase Storage",
+    description: "Supabase S3-compatible REST Object Storage",
+    fields: [
+      { key: "projectUrl", label: "Project URL", placeholder: "https://xyzcompany.supabase.co", required: true },
+      { key: "serviceKey", label: "Service Role Key", type: "password", placeholder: "eyJhbGciOi...", required: true },
+      { key: "bucket", label: "\u0418\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 (Bucket Name)", placeholder: "storage", required: true },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "uploads" },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0434\u043E\u043C\u0435\u043D (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://cdn.supabase.com" }
+    ]
+  },
+  {
+    id: "gcs",
+    name: "Google Cloud Storage",
+    description: "Google Cloud Platform Storage Buckets",
+    fields: [
+      { key: "bucket", label: "\u0418\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 GCS (Bucket Name)", placeholder: "my-gcs-bucket", required: true },
+      { key: "projectId", label: "Project ID", placeholder: "my-gcp-project", required: true },
+      { key: "clientEmail", label: "Service Account Email", placeholder: "sa@project.iam.gserviceaccount.com", required: true },
+      { key: "privateKey", label: "Private Key (PEM)", type: "password", placeholder: "-----BEGIN PRIVATE KEY-----\n...", required: true },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0434\u043E\u043C\u0435\u043D (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://storage.googleapis.com/my-bucket" },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "uploads" }
+    ]
+  },
+  {
+    id: "azure_blob",
+    name: "Azure Blob Storage",
+    description: "Microsoft Azure Blob Storage",
+    fields: [
+      { key: "containerName", label: "Container Name", placeholder: "my-container", required: true },
+      { key: "connectionString", label: "Connection String (\u0438\u043B\u0438 \u043E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0441\u0442\u044B\u043C \u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 Account Key)", type: "password", placeholder: "DefaultEndpointsProtocol=https;AccountName=..." },
+      { key: "accountName", label: "Storage Account Name", placeholder: "mystorageaccount" },
+      { key: "accountKey", label: "Storage Account Key", type: "password", placeholder: "Account Key" },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0434\u043E\u043C\u0435\u043D / Azure CDN URL (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://mycdn.azureedge.net" },
+      { key: "folder", label: "\u041F\u0430\u043F\u043A\u0430 (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "uploads" }
+    ]
+  },
+  {
+    id: "local",
+    name: "Local Disk",
+    description: "\u041B\u043E\u043A\u0430\u043B\u044C\u043D\u043E\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0430 \u0434\u0438\u0441\u043A\u0435 \u0441\u0435\u0440\u0432\u0435\u0440\u0430",
+    fields: [
+      { key: "folderPath", label: "\u041F\u0443\u0442\u044C \u043A \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0438 \u043D\u0430 \u0434\u0438\u0441\u043A\u0435", placeholder: "uploads/local", default: "uploads/local" },
+      { key: "publicDomain", label: "\u041F\u0443\u0431\u043B\u0438\u0447\u043D\u044B\u0439 \u0431\u0430\u0437\u043E\u0432\u044B\u0439 URL (\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E)", placeholder: "https://storage.mycompany.com" }
+    ]
+  }
+];
+async function loadS3Sdk() {
+  try {
+    return await import("@aws-sdk/client-s3");
+  } catch {
+    throw new Error('Package "@aws-sdk/client-s3" is required for S3/R2 storage. Run "npm i @aws-sdk/client-s3".');
+  }
+}
+async function loadCloudinarySdk() {
+  try {
+    const mod = await import("cloudinary");
+    return mod.default?.v2 || mod.v2 || mod.default || mod;
+  } catch {
+    throw new Error('Package "cloudinary" is required for Cloudinary storage. Run "npm i cloudinary".');
+  }
+}
+async function loadVercelBlobSdk() {
+  try {
+    return await import("@vercel/blob");
+  } catch {
+    throw new Error('Package "@vercel/blob" is required for Vercel Blob storage. Run "npm i @vercel/blob".');
+  }
+}
+async function loadGcsSdk() {
+  try {
+    const mod = await import("@google-cloud/storage");
+    return mod.Storage || mod.default?.Storage || mod.default;
+  } catch {
+    throw new Error('Package "@google-cloud/storage" is required for GCS. Run "npm i @google-cloud/storage".');
+  }
+}
+async function loadAzureBlobSdk() {
+  try {
+    return await import("@azure/storage-blob");
+  } catch {
+    throw new Error('Package "@azure/storage-blob" is required for Azure Blob storage. Run "npm i @azure/storage-blob".');
+  }
+}
+class StorageManager {
+  /**
+   * @param {object} options
+   * @param {Function} options.query Database query function `(sql, params) => Promise<{ rows: any[], rowCount: number }>`
+   * @param {string} [options.storagesTable='storage_configs'] Storages table name ('storage_configs' or 'storages')
+   * @param {string} [options.filesTable='storage_files'] Files table name ('storage_files' or 'files')
+   * @param {string} [options.storageServerUrl] Remote storage-server base URL if proxying
+   * @param {string} [options.storageServerApiKey] Remote storage-server API Key
+   * @param {string} [options.publicCdnUrl] Public CDN base URL for link formatting
+   * @param {number} [options.cacheTtlMs=600000] In-memory file cache TTL (10 minutes)
+   * @param {number} [options.maxCacheEntries=5000] Maximum number of cached file metadata records
+   */
+  constructor(options = {}) {
+    this.query = options.query;
+    this.storagesTable = options.storagesTable || "storage_configs";
+    this.filesTable = options.filesTable || "storage_files";
+    this.storageServerUrl = (options.storageServerUrl || process.env.STORAGE_SERVER_URL || "").replace(/\/+$/, "");
+    this.storageServerApiKey = options.storageServerApiKey || process.env.STORAGE_SERVER_API_KEY || "";
+    this.publicCdnUrl = (options.publicCdnUrl || "").replace(/\/+$/, "");
+    this.cacheTtlMs = options.cacheTtlMs || 10 * 60 * 1e3;
+    this.maxCacheEntries = options.maxCacheEntries || 5e3;
+    this.fileMetadataCache = /* @__PURE__ */ new Map();
+    this.activeStorageCache = { data: null, ts: 0 };
+    this.storageCacheTtlMs = 3e4;
+  }
+  getProviders() {
+    return STORAGE_PROVIDERS;
+  }
+  invalidateFileCache(fileId) {
+    if (fileId) this.fileMetadataCache.delete(fileId);
+  }
+  invalidateStorageCache() {
+    this.activeStorageCache = { data: null, ts: 0 };
+  }
+  async getCachedFileRecord(fileId) {
+    if (!fileId) return null;
+    const now = Date.now();
+    const cached = this.fileMetadataCache.get(fileId);
+    if (cached && now - cached.ts < this.cacheTtlMs) {
+      return cached.data;
+    }
+    if (!this.query) return null;
+    const r = await this.query(`SELECT * FROM ${this.filesTable} WHERE id = $1`, [fileId]);
+    if (r.rows.length === 0) return null;
+    const file = r.rows[0];
+    if (this.fileMetadataCache.size >= this.maxCacheEntries) {
+      const firstKey = this.fileMetadataCache.keys().next().value;
+      this.fileMetadataCache.delete(firstKey);
+    }
+    this.fileMetadataCache.set(fileId, { data: file, ts: now });
+    return file;
+  }
+  formatFileRecord(f, reqBaseUrl = "") {
+    if (!f) return null;
+    const fileId = f.id;
+    const mimeType = f.mime_type || "application/octet-stream";
+    const fileType = f.file_type || (0, import_storage.getFileTypeCategory)(mimeType, f.original_name);
+    const base = this.publicCdnUrl || reqBaseUrl || "";
+    return {
+      id: fileId,
+      storageId: f.storage_id || null,
+      apiKeyId: f.api_key_id || null,
+      originalName: f.original_name || "file",
+      fileType,
+      mimeType,
+      fileSize: Number(f.file_size || 0),
+      cloudUrl: f.cloud_url,
+      viewUrl: `${base}/cdn/${fileId}/view`,
+      downloadUrl: `${base}/cdn/${fileId}/download`,
+      url: `${base}/cdn/${fileId}`,
+      entityType: f.entity_type || "general",
+      entityId: f.entity_id || f.inspection_id || null,
+      viewCount: Number(f.view_count || 0),
+      createdAt: f.created_at,
+      updatedAt: f.updated_at
+    };
+  }
+  async getAvailableStorage(fileSize = 0) {
+    if (!this.query) throw new Error("[cynx/storage] Database query function is required to resolve available storage.");
+    const now = Date.now();
+    let activeStorages = this.activeStorageCache.data;
+    if (!activeStorages || now - this.activeStorageCache.ts > this.storageCacheTtlMs) {
+      const res = await this.query(
+        `SELECT * FROM ${this.storagesTable} WHERE is_active = true ORDER BY sort_order ASC, created_at DESC`
+      );
+      activeStorages = res.rows;
+      this.activeStorageCache = { data: activeStorages, ts: now };
+    }
+    for (const storage of activeStorages) {
+      const maxBytes = BigInt(storage.max_bytes || "0");
+      const usedBytes = BigInt(storage.used_bytes || "0");
+      const needed = BigInt(fileSize);
+      if (usedBytes >= maxBytes) {
+        await this.query(
+          `UPDATE ${this.storagesTable} SET is_active = false, updated_at = NOW() WHERE id = $1`,
+          [storage.id]
+        );
+        this.invalidateStorageCache();
+        continue;
+      }
+      if (usedBytes + needed <= maxBytes) {
+        return storage;
+      }
+    }
+    throw new Error("\u041D\u0435\u0442 \u0430\u043A\u0442\u0438\u0432\u043D\u043E\u0433\u043E \u043E\u0431\u043B\u0430\u0447\u043D\u043E\u0433\u043E \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0441 \u0434\u043E\u0441\u0442\u0430\u0442\u043E\u0447\u043D\u044B\u043C \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u043C \u043C\u0435\u0441\u0442\u043E\u043C");
+  }
+  async updateStorageUsage(storageId, byteDelta) {
+    if (!storageId || !this.query) return;
+    const delta = BigInt(byteDelta);
+    const current = await this.query(`SELECT used_bytes, max_bytes FROM ${this.storagesTable} WHERE id = $1`, [storageId]);
+    if (current.rows.length === 0) return;
+    let newUsed = BigInt(current.rows[0].used_bytes || "0") + delta;
+    if (newUsed < 0n) newUsed = 0n;
+    const maxBytes = BigInt(current.rows[0].max_bytes || "0");
+    const isFull = newUsed >= maxBytes;
+    await this.query(
+      `UPDATE ${this.storagesTable} SET used_bytes = $1, is_active = CASE WHEN $2 THEN false ELSE is_active END, updated_at = NOW() WHERE id = $3`,
+      [newUsed.toString(), isFull, storageId]
+    );
+    this.invalidateStorageCache();
+  }
+  _resolveFolderPath(configFolder, customFolder) {
+    const parts = [];
+    if (configFolder && typeof configFolder === "string" && configFolder.trim()) {
+      parts.push(configFolder.trim().replace(/^\/+|\/+$/g, ""));
+    }
+    if (customFolder && typeof customFolder === "string" && customFolder.trim()) {
+      const cleanCustom = customFolder.trim().replace(/^\/+|\/+$/g, "");
+      if (!parts[0] || !cleanCustom.startsWith(parts[0])) {
+        parts.push(cleanCustom);
+      }
+    }
+    return parts.filter(Boolean).join("/");
+  }
+  async _getS3Client(storageConfig) {
+    const { S3Client } = await loadS3Sdk();
+    const { provider, credentials } = storageConfig;
+    if (provider === "r2") {
+      const { accountId, accessKeyId, secretAccessKey } = credentials || {};
+      if (!accountId || !accessKeyId || !secretAccessKey) {
+        throw new Error("\u041D\u0435\u043F\u043E\u043B\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F Cloudflare R2 (Account ID, Access Key ID, Secret Access Key)");
+      }
+      return new S3Client({
+        region: "auto",
+        endpoint: `https://${accountId.trim()}.r2.cloudflarestorage.com`,
+        credentials: {
+          accessKeyId: accessKeyId.trim(),
+          secretAccessKey: secretAccessKey.trim()
+        }
+      });
+    } else if (provider === "s3") {
+      const { region, accessKeyId, secretAccessKey, endpoint: endpoint2 } = credentials || {};
+      if (!region || !accessKeyId || !secretAccessKey) {
+        throw new Error("\u041D\u0435\u043F\u043E\u043B\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F Amazon S3 (Region, Access Key ID, Secret Access Key)");
+      }
+      const reg = region && region.trim() && region.trim().toLowerCase() !== "auto" ? region.trim() : "us-east-1";
+      const clientOpts = {
+        region: reg,
+        credentials: {
+          accessKeyId: accessKeyId.trim(),
+          secretAccessKey: secretAccessKey.trim()
+        }
+      };
+      if (endpoint2 && endpoint2.trim()) {
+        let cleanEndpoint = endpoint2.trim();
+        if (!/^https?:\/\//i.test(cleanEndpoint)) {
+          cleanEndpoint = `https://${cleanEndpoint}`;
+        }
+        try {
+          const parsed = new URL(cleanEndpoint);
+          cleanEndpoint = parsed.origin;
+        } catch {
+          cleanEndpoint = cleanEndpoint.replace(/\/+$/, "");
+        }
+        clientOpts.endpoint = cleanEndpoint;
+        clientOpts.forcePathStyle = true;
+      }
+      return new S3Client(clientOpts);
+    }
+    throw new Error(`\u041F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440 ${provider} \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0434\u043B\u044F S3-\u043A\u043B\u0438\u0435\u043D\u0442\u0430`);
+  }
+  async _getGcsClient(storageConfig) {
+    const GoogleCloudStorage = await loadGcsSdk();
+    const { credentials } = storageConfig;
+    const { projectId, clientEmail, privateKey } = credentials || {};
+    const opts = {};
+    if (projectId && projectId.trim()) opts.projectId = projectId.trim();
+    if (clientEmail && privateKey) {
+      opts.credentials = {
+        client_email: clientEmail.trim(),
+        private_key: privateKey.replace(/\\n/g, "\n")
+      };
+    }
+    return new GoogleCloudStorage(opts);
+  }
+  async _getAzureBlobClient(storageConfig) {
+    const { BlobServiceClient, StorageSharedKeyCredential } = await loadAzureBlobSdk();
+    const { credentials } = storageConfig;
+    const { connectionString, accountName, accountKey } = credentials || {};
+    if (connectionString && connectionString.trim()) {
+      return BlobServiceClient.fromConnectionString(connectionString.trim());
+    }
+    if (accountName && accountKey) {
+      const sharedKey = new StorageSharedKeyCredential(accountName.trim(), accountKey.trim());
+      return new BlobServiceClient(`https://${accountName.trim()}.blob.core.windows.net`, sharedKey);
+    }
+    throw new Error("\u041D\u0435\u043F\u043E\u043B\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F Azure Blob (Connection String \u0438\u043B\u0438 Account Name + Account Key)");
+  }
+  // ─── UPLOAD TO PROVIDER ────────────────────────────────────────────────────────
+  async uploadToFileStorage(storageConfig, fileBuffer, originalName, mimeType, customFolder = null) {
+    const { provider, credentials } = storageConfig;
+    const safeName = originalName ? originalName.replace(/[^a-zA-Z0-9_.-]/g, "_") : "file";
+    if (provider === "local") {
+      const basePath = credentials?.folderPath?.trim() || "uploads/local";
+      const folderPath = this._resolveFolderPath(basePath, customFolder);
+      const fullDirPath = import_path.default.resolve(process.cwd(), folderPath);
+      await import_fs.default.promises.mkdir(fullDirPath, { recursive: true });
+      const fileName = `${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const fullFilePath = import_path.default.join(fullDirPath, fileName);
+      const relativeKey = `${folderPath}/${fileName}`;
+      await import_fs.default.promises.writeFile(fullFilePath, fileBuffer);
+      let cloudUrl = "";
+      if (credentials?.publicDomain && credentials.publicDomain.trim()) {
+        const base = credentials.publicDomain.trim().replace(/\/+$/, "");
+        cloudUrl = `${base}/${relativeKey}`;
+      }
+      return {
+        cloudUrl: cloudUrl || relativeKey,
+        cloudPublicId: relativeKey,
+        resourceType: "local",
+        bytes: fileBuffer.length
+      };
+    } else if (provider === "gcs") {
+      const { bucket, folder, publicDomain } = credentials || {};
+      if (!bucket) throw new Error("\u041D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u043E \u0438\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 GCS (Bucket Name)");
+      const gcs = await this._getGcsClient(storageConfig);
+      const gcsBucket = gcs.bucket(bucket.trim());
+      const folderPath = this._resolveFolderPath(folder, customFolder);
+      const objectKey = `${folderPath ? folderPath + "/" : ""}${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const gcsFile = gcsBucket.file(objectKey);
+      await gcsFile.save(fileBuffer, {
+        contentType: mimeType || "application/octet-stream",
+        resumable: false
+      });
+      let cloudUrl = "";
+      if (publicDomain && publicDomain.trim()) {
+        let base = publicDomain.trim().replace(/\/+$/, "");
+        if (!/^https?:\/\//i.test(base)) base = `https://${base}`;
+        cloudUrl = `${base}/${objectKey}`;
+      } else {
+        cloudUrl = `https://storage.googleapis.com/${bucket.trim()}/${objectKey}`;
+      }
+      return {
+        cloudUrl,
+        cloudPublicId: objectKey,
+        resourceType: "gcs",
+        bytes: fileBuffer.length
+      };
+    } else if (provider === "azure_blob") {
+      const { containerName, folder, publicDomain } = credentials || {};
+      if (!containerName) throw new Error("\u041D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u043E \u0438\u043C\u044F \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430 Azure (Container Name)");
+      const blobService = await this._getAzureBlobClient(storageConfig);
+      const containerClient = blobService.getContainerClient(containerName.trim());
+      await containerClient.createIfNotExists();
+      const folderPath = this._resolveFolderPath(folder, customFolder);
+      const objectKey = `${folderPath ? folderPath + "/" : ""}${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const blockBlobClient = containerClient.getBlockBlobClient(objectKey);
+      await blockBlobClient.uploadData(fileBuffer, {
+        blobHTTPHeaders: {
+          blobContentType: mimeType || "application/octet-stream"
+        }
+      });
+      let cloudUrl = "";
+      if (publicDomain && publicDomain.trim()) {
+        let base = publicDomain.trim().replace(/\/+$/, "");
+        if (!/^https?:\/\//i.test(base)) base = `https://${base}`;
+        cloudUrl = `${base}/${objectKey}`;
+      } else {
+        cloudUrl = blockBlobClient.url;
+      }
+      return {
+        cloudUrl,
+        cloudPublicId: objectKey,
+        resourceType: "azure_blob",
+        bytes: fileBuffer.length
+      };
+    } else if (provider === "supabase") {
+      const { projectUrl, serviceKey, bucket, folder, publicDomain } = credentials || {};
+      if (!projectUrl || !serviceKey || !bucket) {
+        throw new Error("\u041D\u0435\u043F\u043E\u043B\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F Supabase (Project URL, Service Key, Bucket Name)");
+      }
+      const folderPath = this._resolveFolderPath(folder, customFolder);
+      const objectKey = `${folderPath ? folderPath + "/" : ""}${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const cleanUrl = projectUrl.trim().replace(/\/+$/, "");
+      const uploadUrl = new URL(`${cleanUrl}/storage/v1/object/${encodeURIComponent(bucket.trim())}/${objectKey}`);
+      const isHttps = uploadUrl.protocol === "https:";
+      const client = isHttps ? import_https.default : import_http.default;
+      const agent = isHttps ? httpsAgent : httpAgent;
+      await new Promise((resolve, reject) => {
+        const req = client.request(
+          uploadUrl,
+          {
+            method: "POST",
+            agent,
+            headers: {
+              Authorization: `Bearer ${serviceKey.trim()}`,
+              "Content-Type": mimeType || "application/octet-stream",
+              "Content-Length": fileBuffer.length,
+              "x-upsert": "true"
+            }
+          },
+          (res) => {
+            if (res.statusCode >= 200 && res.statusCode < 300) return resolve();
+            let errData = "";
+            res.on("data", (c) => errData += c);
+            res.on("end", () => reject(new Error(`Supabase Upload Error (${res.statusCode}): ${errData}`)));
+          }
+        );
+        req.on("error", reject);
+        req.write(fileBuffer);
+        req.end();
+      });
+      let cloudUrl = "";
+      if (publicDomain && publicDomain.trim()) {
+        let base = publicDomain.trim().replace(/\/+$/, "");
+        if (!/^https?:\/\//i.test(base)) base = `https://${base}`;
+        cloudUrl = `${base}/${objectKey}`;
+      } else {
+        cloudUrl = `${cleanUrl}/storage/v1/object/public/${encodeURIComponent(bucket.trim())}/${objectKey}`;
+      }
+      return {
+        cloudUrl,
+        cloudPublicId: objectKey,
+        resourceType: "supabase",
+        bytes: fileBuffer.length
+      };
+    } else if (provider === "cloudinary") {
+      const { cloudName, apiKey, apiSecret, folder } = credentials || {};
+      if (!cloudName || !apiKey || !apiSecret) {
+        throw new Error("\u041D\u0435\u043F\u043E\u043B\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F Cloudinary (Cloud Name, API Key, API Secret)");
+      }
+      const cloudinary = await loadCloudinarySdk();
+      cloudinary.config({
+        cloud_name: cloudName,
+        api_key: apiKey,
+        api_secret: apiSecret,
+        secure: true
+      });
+      const isRaw = !mimeType.startsWith("image/");
+      const resourceType = isRaw ? "raw" : "image";
+      const uploadFolder = this._resolveFolderPath(folder, customFolder) || "emp_storage";
+      const uniquePublicId = `${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const result = await new Promise((resolve, reject) => {
+        const uploadStream = cloudinary.uploader.upload_stream(
+          {
+            folder: uploadFolder,
+            resource_type: resourceType,
+            public_id: uniquePublicId
+          },
+          (error, res) => {
+            if (error) return reject(error);
+            resolve(res);
+          }
+        );
+        uploadStream.end(fileBuffer);
+      });
+      return {
+        cloudUrl: result.secure_url,
+        cloudPublicId: result.public_id,
+        resourceType,
+        bytes: result.bytes || fileBuffer.length
+      };
+    } else if (provider === "vercel_blob") {
+      const { readWriteToken, folder } = credentials || {};
+      if (!readWriteToken) {
+        throw new Error("\u041E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 Read/Write Token \u0434\u043B\u044F Vercel Blob");
+      }
+      const { put } = await loadVercelBlobSdk();
+      const folderPath = this._resolveFolderPath(folder, customFolder) || "emp-storage";
+      const pathKey = `${folderPath}/${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      const blobResult = await put(pathKey, fileBuffer, {
+        access: "public",
+        token: readWriteToken,
+        contentType: mimeType || "application/octet-stream"
+      });
+      return {
+        cloudUrl: blobResult.url,
+        cloudPublicId: blobResult.url,
+        resourceType: "blob",
+        bytes: fileBuffer.length
+      };
+    } else if (provider === "s3" || provider === "r2") {
+      const { bucket, folder, publicDomain, region } = credentials || {};
+      if (!bucket) {
+        throw new Error(`\u041D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u043E \u0438\u043C\u044F \u0431\u0430\u043A\u0435\u0442\u0430 (Bucket Name) \u0434\u043B\u044F ${provider === "r2" ? "Cloudflare R2" : "Amazon S3"}`);
+      }
+      const { PutObjectCommand } = await loadS3Sdk();
+      const s3 = await this._getS3Client(storageConfig);
+      const folderPath = this._resolveFolderPath(folder, customFolder);
+      const objectKey = `${folderPath ? folderPath + "/" : ""}${(0, import_uid.genUid)()}_${Date.now()}_${safeName}`;
+      await s3.send(
+        new PutObjectCommand({
+          Bucket: bucket.trim(),
+          Key: objectKey,
+          Body: fileBuffer,
+          ContentType: mimeType || "application/octet-stream",
+          ContentLength: fileBuffer.length
+        })
+      );
+      let cloudUrl = "";
+      if (publicDomain && publicDomain.trim()) {
+        let base = publicDomain.trim().replace(/\/+$/, "");
+        if (!/^https?:\/\//i.test(base)) base = `https://${base}`;
+        cloudUrl = `${base}/${objectKey}`;
+      } else if (endpoint && endpoint.trim()) {
+        let base = endpoint.trim().replace(/\/+$/, "");
+        if (!/^https?:\/\//i.test(base)) base = `https://${base}`;
+        cloudUrl = `${base}/${bucket.trim()}/${objectKey}`;
+      } else if (provider === "s3") {
+        const reg = region ? region.trim() : "us-east-1";
+        cloudUrl = `https://${bucket.trim()}.s3.${reg}.amazonaws.com/${objectKey}`;
+      } else {
+        cloudUrl = `https://${bucket.trim()}.${credentials.accountId?.trim() || ""}.r2.cloudflarestorage.com/${objectKey}`;
+      }
+      return {
+        cloudUrl,
+        cloudPublicId: objectKey,
+        resourceType: "s3",
+        bytes: fileBuffer.length
+      };
+    } else {
+      throw new Error(`\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430: ${provider}`);
+    }
+  }
+  // ─── DELETE FROM PROVIDER ──────────────────────────────────────────────────────
+  async deleteFromFileStorage(storageConfig, cloudPublicId, cloudUrl, mimeType = "") {
+    if (!storageConfig) return;
+    const { provider, credentials } = storageConfig;
+    try {
+      if (provider === "local") {
+        if (cloudPublicId) {
+          const fullPath = import_path.default.resolve(process.cwd(), cloudPublicId);
+          if (import_fs.default.existsSync(fullPath)) {
+            await import_fs.default.promises.unlink(fullPath);
+          }
+        }
+      } else if (provider === "gcs") {
+        const { bucket } = credentials || {};
+        if (bucket && cloudPublicId) {
+          const gcs = await this._getGcsClient(storageConfig);
+          await gcs.bucket(bucket.trim()).file(cloudPublicId).delete({ ignoreNotFound: true });
+        }
+      } else if (provider === "azure_blob") {
+        const { containerName } = credentials || {};
+        if (containerName && cloudPublicId) {
+          const blobService = await this._getAzureBlobClient(storageConfig);
+          await blobService.getContainerClient(containerName.trim()).getBlockBlobClient(cloudPublicId).deleteIfExists();
+        }
+      } else if (provider === "supabase") {
+        const { projectUrl, serviceKey, bucket } = credentials || {};
+        if (projectUrl && serviceKey && bucket && cloudPublicId) {
+          const cleanUrl = projectUrl.trim().replace(/\/+$/, "");
+          const deleteUrl = new URL(`${cleanUrl}/storage/v1/object/${encodeURIComponent(bucket.trim())}`);
+          const isHttps = deleteUrl.protocol === "https:";
+          const client = isHttps ? import_https.default : import_http.default;
+          const agent = isHttps ? httpsAgent : httpAgent;
+          const payload = JSON.stringify({ prefixes: [cloudPublicId] });
+          await new Promise((resolve) => {
+            const req = client.request(
+              deleteUrl,
+              {
+                method: "DELETE",
+                agent,
+                headers: {
+                  Authorization: `Bearer ${serviceKey.trim()}`,
+                  "Content-Type": "application/json",
+                  "Content-Length": Buffer.byteLength(payload)
+                }
+              },
+              () => resolve()
+            );
+            req.on("error", () => resolve());
+            req.write(payload);
+            req.end();
+          });
+        }
+      } else if (provider === "cloudinary") {
+        const { cloudName, apiKey, apiSecret } = credentials || {};
+        if (!cloudName || !apiKey || !apiSecret) return;
+        const cloudinary = await loadCloudinarySdk();
+        cloudinary.config({
+          cloud_name: cloudName,
+          api_key: apiKey,
+          api_secret: apiSecret,
+          secure: true
+        });
+        const isRaw = mimeType && !mimeType.startsWith("image/");
+        await cloudinary.uploader.destroy(cloudPublicId, {
+          resource_type: isRaw ? "raw" : "image"
+        });
+      } else if (provider === "vercel_blob") {
+        const { readWriteToken } = credentials || {};
+        if (!readWriteToken) return;
+        const { del } = await loadVercelBlobSdk();
+        await del(cloudUrl || cloudPublicId, { token: readWriteToken });
+      } else if (provider === "s3" || provider === "r2") {
+        const { bucket } = credentials || {};
+        if (!bucket || !cloudPublicId) return;
+        const { DeleteObjectCommand } = await loadS3Sdk();
+        const s3 = await this._getS3Client(storageConfig);
+        await s3.send(
+          new DeleteObjectCommand({
+            Bucket: bucket.trim(),
+            Key: cloudPublicId
+          })
+        );
+      }
+    } catch (err) {
+      console.error(`[cynx/storage] Failed to delete file from ${provider}:`, err.message);
+    }
+  }
+  async testStorageConnection(storageConfig) {
+    const testBuffer = Buffer.from("CYNX_STORAGE_CONNECTION_TEST");
+    const uploaded = await this.uploadToFileStorage(
+      storageConfig,
+      testBuffer,
+      "test_connection.txt",
+      "text/plain",
+      "test"
+    );
+    await this.deleteFromFileStorage(
+      storageConfig,
+      uploaded.cloudPublicId,
+      uploaded.cloudUrl,
+      "text/plain"
+    );
+    return true;
+  }
+  // ─── STREAMING & SERVE ────────────────────────────────────────────────────────
+  async _streamFromS3(file, req, res, isInline) {
+    try {
+      const storageRes = await this.query(`SELECT * FROM ${this.storagesTable} WHERE id = $1`, [file.storage_id]);
+      const storageConfig = storageRes.rows[0];
+      if (!storageConfig || storageConfig.provider !== "s3" && storageConfig.provider !== "r2") {
+        return res.status(404).send("Storage not found");
+      }
+      const { bucket } = storageConfig.credentials || {};
+      if (!bucket) return res.status(500).send("Bucket name missing in storage configuration");
+      const { GetObjectCommand } = await loadS3Sdk();
+      const s3 = await this._getS3Client(storageConfig);
+      const objectKey = file.cloud_public_id || file.cloud_url?.split("/").slice(3).join("/");
+      const commandParams = {
+        Bucket: bucket.trim(),
+        Key: objectKey
+      };
+      if (req?.headers && req.headers["range"]) {
+        commandParams.Range = req.headers["range"];
+      }
+      const s3Res = await s3.send(new GetObjectCommand(commandParams));
+      const etag = `"${file.id}-${file.file_size || "0"}"`;
+      const filename = file.original_name || "file";
+      const safeFilename = filename.replace(/["\r\n]/g, "_");
+      const encodedFilename = encodeURIComponent(filename);
+      const disposition = isInline ? "inline" : "attachment";
+      res.setHeader("ETag", etag);
+      res.setHeader("Content-Type", s3Res.ContentType || file.mime_type || "application/octet-stream");
+      res.setHeader("Accept-Ranges", "bytes");
+      res.setHeader(
+        "Content-Disposition",
+        `${disposition}; filename="${safeFilename}"; filename*=UTF-8''${encodedFilename}`
+      );
+      res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+      if (s3Res.ContentRange) {
+        res.setHeader("Content-Range", s3Res.ContentRange);
+        res.status(206);
+      } else {
+        res.status(200);
+      }
+      if (s3Res.ContentLength) {
+        res.setHeader("Content-Length", s3Res.ContentLength);
+      }
+      s3Res.Body.pipe(res);
+    } catch (err) {
+      console.error("[cynx/storage] S3/R2 stream error:", err.message);
+      if (!res.headersSent) {
+        res.status(500).send("Error streaming file from storage");
+      }
+    }
+  }
+  _streamFromLocal(file, req, res, isInline) {
+    const filePath = import_path.default.resolve(process.cwd(), file.cloud_public_id);
+    if (!import_fs.default.existsSync(filePath)) {
+      return res.status(404).send("Local file not found on disk");
+    }
+    const stat = import_fs.default.statSync(filePath);
+    const etag = `"${file.id}-${stat.size}"`;
+    const ifNoneMatch = req?.headers ? req.headers["if-none-match"] : null;
+    if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === `W/${etag}`)) {
+      return res.status(304).end();
+    }
+    const filename = file.original_name || "file";
+    const safeFilename = filename.replace(/["\r\n]/g, "_");
+    const encodedFilename = encodeURIComponent(filename);
+    const disposition = isInline ? "inline" : "attachment";
+    res.setHeader("ETag", etag);
+    res.setHeader("Content-Type", file.mime_type || "application/octet-stream");
+    res.setHeader("Accept-Ranges", "bytes");
+    res.setHeader(
+      "Content-Disposition",
+      `${disposition}; filename="${safeFilename}"; filename*=UTF-8''${encodedFilename}`
+    );
+    res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    const range = req?.headers ? req.headers["range"] : null;
+    if (range) {
+      const parts = range.replace(/bytes=/, "").split("-");
+      const start = parseInt(parts[0], 10);
+      const end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
+      const chunksize = end - start + 1;
+      res.setHeader("Content-Range", `bytes ${start}-${end}/${stat.size}`);
+      res.setHeader("Content-Length", chunksize);
+      res.status(206);
+      import_fs.default.createReadStream(filePath, { start, end }).pipe(res);
+    } else {
+      res.setHeader("Content-Length", stat.size);
+      res.status(200);
+      import_fs.default.createReadStream(filePath).pipe(res);
+    }
+  }
+  async _extractFileFromCloudinaryArchive(file, req, res, isInline) {
+    try {
+      const storageRes = await this.query(`SELECT * FROM ${this.storagesTable} WHERE id = $1`, [file.storage_id]);
+      const storageConfig = storageRes.rows[0];
+      if (!storageConfig || storageConfig.provider !== "cloudinary") {
+        return res.status(401).send("Error loading file from storage");
+      }
+      const { cloudName, apiKey, apiSecret } = storageConfig.credentials || {};
+      if (!cloudName || !apiKey || !apiSecret) {
+        return res.status(500).send("Storage credentials missing");
+      }
+      const cloudinary = await loadCloudinarySdk();
+      cloudinary.config({
+        cloud_name: cloudName,
+        api_key: apiKey,
+        api_secret: apiSecret,
+        secure: true
+      });
+      const publicId = file.cloud_public_id || "";
+      const fullyQualifiedId = publicId.startsWith("raw/upload/") ? publicId : `raw/upload/${publicId}`;
+      const archiveUrl = cloudinary.utils.download_archive_url({
+        fully_qualified_public_ids: [fullyQualifiedId]
+      });
+      const client = archiveUrl.startsWith("https") ? import_https.default : import_http.default;
+      const agent = archiveUrl.startsWith("https") ? httpsAgent : httpAgent;
+      client.get(archiveUrl, { agent }, (cloudRes) => {
+        if (cloudRes.statusCode >= 400) {
+          return res.status(cloudRes.statusCode).send("Error loading file from storage");
+        }
+        const chunks = [];
+        cloudRes.on("data", (c) => chunks.push(c));
+        cloudRes.on("end", () => {
+          const buf = Buffer.concat(chunks);
+          if (buf.length > 30 && buf.slice(0, 4).toString("hex") === "504b0304") {
+            try {
+              const comp = buf.readUInt16LE(8);
+              const nameLen = buf.readUInt16LE(26);
+              const extraLen = buf.readUInt16LE(28);
+              const dataStart = 30 + nameLen + extraLen;
+              const cdIdx = buf.indexOf(Buffer.from("504b0102", "hex"));
+              const dataEnd = cdIdx !== -1 ? cdIdx - 16 : buf.length;
+              const compData = buf.slice(dataStart, dataEnd);
+              const decomp = comp === 8 ? import_zlib.default.inflateRawSync(compData) : compData;
+              const filename = file.original_name || "file";
+              const safeFilename = filename.replace(/["\r\n]/g, "_");
+              const encodedFilename = encodeURIComponent(filename);
+              const disposition = isInline ? "inline" : "attachment";
+              const etag = `"${file.id}-${decomp.length}"`;
+              res.setHeader("ETag", etag);
+              res.setHeader("Content-Type", file.mime_type || "application/octet-stream");
+              res.setHeader(
+                "Content-Disposition",
+                `${disposition}; filename="${safeFilename}"; filename*=UTF-8''${encodedFilename}`
+              );
+              res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+              res.setHeader("Content-Length", decomp.length);
+              return res.send(decomp);
+            } catch (err) {
+              console.error("[cynx/storage] ZIP extraction error:", err);
+            }
+          }
+          res.status(500).send("Error processing file");
+        });
+      }).on("error", (err) => {
+        console.error("[cynx/storage] Cloudinary archive stream error:", err);
+        res.status(500).send("Error fetching file");
+      });
+    } catch (err) {
+      console.error("[cynx/storage] extractFileFromCloudinaryArchive error:", err);
+      res.status(500).send("Internal server error");
+    }
+  }
+  handleFileStream(file, req, res, isInline = false, redirectCount = 0) {
+    if (redirectCount > 5) {
+      return res.status(500).send("Too many redirects");
+    }
+    const etag = `"${file.id}-${file.file_size || "0"}"`;
+    const ifNoneMatch = req?.headers ? req.headers["if-none-match"] : null;
+    if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === `W/${etag}`)) {
+      res.status(304).end();
+      return;
+    }
+    if (file.storage_id) {
+      this.query(`SELECT provider FROM ${this.storagesTable} WHERE id = $1`, [file.storage_id]).then((stRes) => {
+        const prov = stRes.rows[0]?.provider;
+        if (prov === "local") {
+          return this._streamFromLocal(file, req, res, isInline);
+        }
+        if (prov === "s3" || prov === "r2") {
+          return this._streamFromS3(file, req, res, isInline);
+        }
+        this._streamHttp(file, req, res, isInline, redirectCount, prov);
+      }).catch(() => {
+        this._streamHttp(file, req, res, isInline, redirectCount);
+      });
+      return;
+    }
+    this._streamHttp(file, req, res, isInline, redirectCount);
+  }
+  _streamHttp(file, req, res, isInline, redirectCount = 0, knownProvider = null) {
+    let targetUrl = file.cloud_url;
+    if (!targetUrl) {
+      if (file.storage_id && file.cloud_public_id) {
+        return this._streamFromS3(file, req, res, isInline);
+      }
+      return res.status(404).send("File URL not found");
+    }
+    if (!/^https?:\/\//i.test(targetUrl)) {
+      targetUrl = `https://${targetUrl}`;
+    }
+    const isHttps = targetUrl.startsWith("https");
+    const client = isHttps ? import_https.default : import_http.default;
+    const agent = isHttps ? httpsAgent : httpAgent;
+    const requestHeaders = {};
+    if (req?.headers && req.headers["range"]) {
+      requestHeaders["Range"] = req.headers["range"];
+    }
+    client.get(targetUrl, { agent, headers: requestHeaders }, (cloudRes) => {
+      if (cloudRes.statusCode >= 300 && cloudRes.statusCode < 400 && cloudRes.headers.location) {
+        const redirectUrl = new URL(cloudRes.headers.location, targetUrl).toString();
+        return this.handleFileStream({ ...file, cloud_url: redirectUrl }, req, res, isInline, redirectCount + 1);
+      }
+      if (cloudRes.statusCode === 401 || cloudRes.statusCode === 403) {
+        if (knownProvider === "cloudinary" || !knownProvider && file.storage_id) {
+          return this._extractFileFromCloudinaryArchive(file, req, res, isInline);
+        }
+      }
+      if (cloudRes.statusCode >= 400) {
+        return res.status(cloudRes.statusCode).send("Error loading file from storage");
+      }
+      const mimeType = cloudRes.headers["content-type"] || file.mime_type || "application/octet-stream";
+      const filename = file.original_name || "file";
+      const safeFilename = filename.replace(/["\r\n]/g, "_");
+      const encodedFilename = encodeURIComponent(filename);
+      const disposition = isInline ? "inline" : "attachment";
+      res.setHeader("ETag", `"${file.id}-${file.file_size || "0"}"`);
+      res.setHeader("Content-Type", mimeType);
+      res.setHeader("Accept-Ranges", "bytes");
+      res.setHeader(
+        "Content-Disposition",
+        `${disposition}; filename="${safeFilename}"; filename*=UTF-8''${encodedFilename}`
+      );
+      res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+      if (cloudRes.headers["content-range"]) {
+        res.setHeader("Content-Range", cloudRes.headers["content-range"]);
+        res.status(206);
+      } else {
+        res.status(cloudRes.statusCode || 200);
+      }
+      if (cloudRes.headers["content-length"]) {
+        res.setHeader("Content-Length", cloudRes.headers["content-length"]);
+      }
+      cloudRes.pipe(res);
+    }).on("error", (err) => {
+      console.error("[cynx/storage] File stream error:", err.message);
+      if (file.storage_id && file.cloud_public_id) {
+        return this._streamFromS3(file, req, res, isInline);
+      }
+      if (!res.headersSent) {
+        res.status(500).send("Error streaming file");
+      }
+    });
+  }
+  // ─── ENTITY OPERATIONS ─────────────────────────────────────────────────────────
+  async uploadEntityFiles({ entityType, entityId = null, files = [], reqUserId = null, folder = null }) {
+    if (!files || files.length === 0) return [];
+    const targetFolder = folder || entityType || "general";
+    if (this.storageServerUrl && this.storageServerApiKey) {
+      const formData = new FormData();
+      formData.append("entityType", entityType);
+      if (entityId) formData.append("entityId", String(entityId));
+      if (targetFolder) formData.append("folder", targetFolder);
+      for (const f of files) {
+        const blob = new Blob([f.buffer], { type: f.mimetype || "application/octet-stream" });
+        formData.append("files", blob, f.originalname);
+      }
+      const response = await fetch(`${this.storageServerUrl}/api/v1/upload`, {
+        method: "POST",
+        headers: {
+          "x-api-key": this.storageServerApiKey
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errJson = await response.json().catch(() => ({}));
+        throw new Error(errJson.error || `Storage server upload failed with status ${response.status}`);
+      }
+      const result = await response.json();
+      const rawFiles = result.files || (result.id ? [result] : []);
+      const isInspection = entityType === "dot_inspection" || entityType === "inspection";
+      const inspectionId = isInspection ? entityId : null;
+      const localRecords = await Promise.all(
+        rawFiles.map(async (rf) => {
+          const fileId = rf.id;
+          const mimeType = rf.mimeType || rf.mime_type || "application/octet-stream";
+          const fileType = rf.fileType || rf.file_type || (0, import_storage.getFileTypeCategory)(mimeType, rf.originalName || rf.original_name);
+          const originalName = rf.originalName || rf.original_name || "file";
+          const fileSize = Number(rf.fileSize || rf.file_size || 0);
+          const cloudUrl = rf.cloudUrl || rf.cloud_url;
+          const cloudPublicId = rf.cloudPublicId || rf.cloud_public_id || fileId;
+          const storageId = rf.storageId || rf.storage_id || null;
+          if (this.query) {
+            const hasInspectionCol = this.filesTable === "storage_files";
+            const insertSql = hasInspectionCol ? `INSERT INTO ${this.filesTable} (
+                  id, entity_type, entity_id, inspection_id, storage_id,
+                  original_name, file_type, mime_type, file_size, cloud_url, cloud_public_id, created_at, updated_at
+                ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NOW(), NOW())
+                ON CONFLICT (id) DO UPDATE SET
+                  entity_type = EXCLUDED.entity_type,
+                  entity_id = EXCLUDED.entity_id,
+                  inspection_id = EXCLUDED.inspection_id,
+                  cloud_url = EXCLUDED.cloud_url,
+                  cloud_public_id = EXCLUDED.cloud_public_id,
+                  updated_at = NOW()
+                RETURNING *` : `INSERT INTO ${this.filesTable} (
+                  id, entity_type, entity_id, storage_id,
+                  original_name, file_type, mime_type, file_size, cloud_url, cloud_public_id, created_at, updated_at
+                ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, NOW(), NOW())
+                ON CONFLICT (id) DO UPDATE SET
+                  entity_type = EXCLUDED.entity_type,
+                  entity_id = EXCLUDED.entity_id,
+                  cloud_url = EXCLUDED.cloud_url,
+                  cloud_public_id = EXCLUDED.cloud_public_id,
+                  updated_at = NOW()
+                RETURNING *`;
+            const params = hasInspectionCol ? [fileId, entityType, entityId, inspectionId, storageId, originalName, fileType, mimeType, fileSize, cloudUrl, cloudPublicId] : [fileId, entityType, entityId, storageId, originalName, fileType, mimeType, fileSize, cloudUrl, cloudPublicId];
+            const r = await this.query(insertSql, params);
+            this.fileMetadataCache.set(fileId, { data: r.rows[0], ts: Date.now() });
+            return this.formatFileRecord(r.rows[0]);
+          }
+          return this.formatFileRecord({
+            id: fileId,
+            entity_type: entityType,
+            entity_id: entityId,
+            storage_id: storageId,
+            original_name: originalName,
+            file_type: fileType,
+            mime_type: mimeType,
+            file_size: fileSize,
+            cloud_url: cloudUrl,
+            cloud_public_id: cloudPublicId
+          });
+        })
+      );
+      return localRecords;
+    }
+    const uploadTasks = files.map(async (file) => {
+      const fileCategory = (0, import_storage.getFileTypeCategory)(file.mimetype, file.originalname);
+      const storage = await this.getAvailableStorage(file.size);
+      const uploaded = await this.uploadToFileStorage(
+        storage,
+        file.buffer,
+        file.originalname,
+        file.mimetype,
+        targetFolder
+      );
+      const fileId = (0, import_uid.genUid)();
+      const isInspection = entityType === "dot_inspection" || entityType === "inspection";
+      const inspectionId = isInspection ? entityId : null;
+      const hasInspectionCol = this.filesTable === "storage_files";
+      const insertSql = hasInspectionCol ? `INSERT INTO ${this.filesTable} (
+            id, entity_type, entity_id, inspection_id, storage_id,
+            original_name, file_type, mime_type, file_size, cloud_url, cloud_public_id
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+          RETURNING *` : `INSERT INTO ${this.filesTable} (
+            id, entity_type, entity_id, storage_id,
+            original_name, file_type, mime_type, file_size, cloud_url, cloud_public_id
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+          RETURNING *`;
+      const params = hasInspectionCol ? [fileId, entityType, entityId, inspectionId, storage.id, file.originalname, fileCategory, file.mimetype, file.size, uploaded.cloudUrl, uploaded.cloudPublicId] : [fileId, entityType, entityId, storage.id, file.originalname, fileCategory, file.mimetype, file.size, uploaded.cloudUrl, uploaded.cloudPublicId];
+      const r = await this.query(insertSql, params);
+      await this.updateStorageUsage(storage.id, file.size);
+      const formatted = this.formatFileRecord(r.rows[0]);
+      this.fileMetadataCache.set(fileId, { data: r.rows[0], ts: Date.now() });
+      return formatted;
+    });
+    return await Promise.all(uploadTasks);
+  }
+  async deleteFileById(fileId) {
+    const file = await this.getCachedFileRecord(fileId);
+    if (!file) return false;
+    if (this.storageServerUrl && this.storageServerApiKey) {
+      try {
+        await fetch(`${this.storageServerUrl}/api/v1/files/${encodeURIComponent(fileId)}`, {
+          method: "DELETE",
+          headers: { "x-api-key": this.storageServerApiKey }
+        });
+      } catch (err) {
+        console.warn("[cynx/storage] StorageServer Delete Warning:", err.message);
+      }
+    } else if (file.storage_id && this.query) {
+      const storageRes = await this.query(`SELECT * FROM ${this.storagesTable} WHERE id = $1`, [file.storage_id]);
+      const storage = storageRes.rows[0];
+      if (storage) {
+        await this.deleteFromFileStorage(storage, file.cloud_public_id, file.cloud_url, file.mime_type);
+        await this.updateStorageUsage(storage.id, -Number(file.file_size || 0));
+      }
+    }
+    if (this.query) {
+      await this.query(`DELETE FROM ${this.filesTable} WHERE id = $1`, [fileId]);
+    }
+    this.invalidateFileCache(fileId);
+    return true;
+  }
+  async deleteFilesByEntity(entityType, entityId) {
+    const types = entityType === "errors" || entityType === "employee_error" || entityType === "emp_errors" ? ["errors", "employee_error", "emp_errors"] : [entityType];
+    if (this.storageServerUrl && this.storageServerApiKey) {
+      try {
+        await fetch(`${this.storageServerUrl}/api/v1/entity/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}`, {
+          method: "DELETE",
+          headers: { "x-api-key": this.storageServerApiKey }
+        });
+      } catch (err) {
+        console.warn("[cynx/storage] StorageServer Delete Entity Warning:", err.message);
+      }
+    } else if (this.query) {
+      const hasInspectionCol = this.filesTable === "storage_files";
+      const selectSql = hasInspectionCol ? `SELECT * FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND (entity_id = $2 OR inspection_id = $2)` : `SELECT * FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND entity_id = $2`;
+      const filesRes = await this.query(selectSql, [types, String(entityId)]);
+      for (const file of filesRes.rows) {
+        this.invalidateFileCache(file.id);
+        if (file.storage_id) {
+          const storageRes = await this.query(`SELECT * FROM ${this.storagesTable} WHERE id = $1`, [file.storage_id]);
+          const storage = storageRes.rows[0];
+          if (storage) {
+            await this.deleteFromFileStorage(storage, file.cloud_public_id, file.cloud_url, file.mime_type);
+            await this.updateStorageUsage(storage.id, -Number(file.file_size || 0));
+          }
+        }
+      }
+    }
+    if (this.query) {
+      const hasInspectionCol = this.filesTable === "storage_files";
+      const deleteSql = hasInspectionCol ? `DELETE FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND (entity_id = $2 OR inspection_id = $2)` : `DELETE FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND entity_id = $2`;
+      await this.query(deleteSql, [types, String(entityId)]);
+    }
+  }
+  async getEntityFiles(entityType, entityId) {
+    if (!this.query) return [];
+    const types = entityType === "errors" || entityType === "employee_error" || entityType === "emp_errors" ? ["errors", "employee_error", "emp_errors"] : [entityType];
+    const hasInspectionCol = this.filesTable === "storage_files";
+    const selectSql = hasInspectionCol ? `SELECT * FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND (entity_id = $2 OR inspection_id = $2) ORDER BY created_at ASC` : `SELECT * FROM ${this.filesTable} WHERE entity_type = ANY($1::text[]) AND entity_id = $2 ORDER BY created_at ASC`;
+    const r = await this.query(selectSql, [types, String(entityId)]);
+    return r.rows.map((row) => this.formatFileRecord(row));
+  }
+}
+function createStorageManager(options = {}) {
+  return new StorageManager(options);
+}
+var storage_manager_default = {
+  StorageManager,
+  createStorageManager,
+  STORAGE_PROVIDERS
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STORAGE_PROVIDERS,
+  StorageManager,
+  createStorageManager
+});