sa2kit 1.0.0

package/dist/universalFile/server/index.mjs

@@ -0,0 +1,4518 @@
+export { LocalStorageProvider } from '../../chunk-GSTLV3MB.mjs';
+export { AliyunOSSProvider } from '../../chunk-YVBU7QDJ.mjs';
+import { CDNProviderError } from '../../chunk-ZGVB35L2.mjs';
+import { createLogger } from '../../chunk-KQGP6BTS.mjs';
+import { StorageProviderError, FileUploadError, FileProcessingError } from '../../chunk-3XG5OHFD.mjs';
+import { __require } from '../../chunk-BJTO5JO5.mjs';
+import { createHash } from 'crypto';
+import * as path3 from 'path';
+import { existsSync, promises } from 'fs';
+import { EventEmitter } from 'events';
+import { v4 } from 'uuid';
+import { LRUCache } from 'lru-cache';
+import { NextResponse } from 'next/server';
+import { sql, eq, and, desc } from 'drizzle-orm';
+
+// src/universalFile/server/factory.ts
+function createFileServiceConfig(options) {
+  let storage;
+  if (options.storage === "local") {
+    storage = {
+      type: "local",
+      enabled: true,
+      rootPath: process.env.UPLOAD_DIR || "./uploads",
+      baseUrl: process.env.BASE_URL || "http://localhost:3000"
+    };
+  } else {
+    storage = options.storage;
+  }
+  return {
+    storage,
+    cdn: options.cdn,
+    cache: options.cache || {
+      enabled: false
+    },
+    processors: options.processors || [],
+    db: options.db,
+    maxFileSize: options.maxFileSize || 10 * 1024 * 1024,
+    // 10MB
+    allowedMimeTypes: options.allowedMimeTypes || [
+      "image/*",
+      "video/*",
+      "audio/*",
+      "application/pdf"
+    ],
+    enableMonitoring: options.enableMonitoring !== false
+  };
+}
+function createUniversalFileService(options) {
+  const config = createFileServiceConfig(options);
+  console.warn(
+    "\u26A0\uFE0F  UniversalFileService \u7684\u5B8C\u6574\u5B9E\u73B0\u5C06\u5728\u540E\u7EED Phase \u4E2D\u8FC1\u79FB\u5230 Sa2kit\u3002\n    \u5F53\u524D\u7248\u672C\u4EC5\u5305\u542B\u7C7B\u578B\u5B9A\u4E49\u548C\u914D\u7F6E\u5DE5\u5382\u51FD\u6570\u3002\n    \u8BF7\u6682\u65F6\u7EE7\u7EED\u4ECE LyricNote \u7684 lib/universalFile \u5BFC\u5165\u670D\u52A1\u7C7B\u3002"
+  );
+  return {
+    config,
+    // 占位方法
+    async upload() {
+      throw new Error("UniversalFileService \u5C1A\u672A\u5B8C\u5168\u8FC1\u79FB\uFF0C\u8BF7\u4ECE LyricNote \u5BFC\u5165");
+    },
+    async download() {
+      throw new Error("UniversalFileService \u5C1A\u672A\u5B8C\u5168\u8FC1\u79FB\uFF0C\u8BF7\u4ECE LyricNote \u5BFC\u5165");
+    }
+  };
+}
+function createFileServiceFromEnv(db) {
+  const storageType = process.env.STORAGE_TYPE || "local";
+  let storage;
+  switch (storageType) {
+    case "local":
+      storage = {
+        type: "local",
+        enabled: true,
+        rootPath: process.env.UPLOAD_DIR || "./uploads",
+        baseUrl: process.env.BASE_URL || "http://localhost:3000"
+      };
+      break;
+    case "aliyun-oss":
+      if (!process.env.OSS_ACCESS_KEY_ID || !process.env.OSS_ACCESS_KEY_SECRET) {
+        throw new Error("Missing required OSS environment variables");
+      }
+      storage = {
+        type: "aliyun-oss",
+        enabled: true,
+        accessKeyId: process.env.OSS_ACCESS_KEY_ID,
+        accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
+        bucket: process.env.OSS_BUCKET,
+        region: process.env.OSS_REGION || "oss-cn-hangzhou"
+      };
+      break;
+    default:
+      throw new Error(`Unsupported storage type: ${storageType}`);
+  }
+  return createUniversalFileService({
+    storage,
+    db
+  });
+}
+
+// src/universalFile/server/presets.ts
+function createLocalDevPreset(baseUrl = "http://localhost:3000") {
+  return {
+    type: "local",
+    enabled: true,
+    rootPath: "./uploads",
+    baseUrl
+  };
+}
+function createAliyunOSSPreset(config) {
+  return {
+    type: "aliyun-oss",
+    enabled: true,
+    accessKeyId: config.accessKeyId,
+    accessKeySecret: config.accessKeySecret,
+    bucket: config.bucket,
+    region: config.region || "oss-cn-hangzhou"
+  };
+}
+function createSmartPreset() {
+  const isProduction = process.env.NODE_ENV === "production";
+  if (isProduction && process.env.OSS_ACCESS_KEY_ID) {
+    return createAliyunOSSPreset({
+      accessKeyId: process.env.OSS_ACCESS_KEY_ID,
+      accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
+      bucket: process.env.OSS_BUCKET,
+      region: process.env.OSS_REGION
+    });
+  }
+  return createLocalDevPreset(process.env.BASE_URL);
+}
+function createImageServicePreset(storage) {
+  return {
+    storage,
+    maxFileSize: 5 * 1024 * 1024,
+    // 5MB
+    allowedMimeTypes: [
+      "image/jpeg",
+      "image/png",
+      "image/webp",
+      "image/gif"
+    ]
+  };
+}
+function createVideoServicePreset(storage) {
+  return {
+    storage,
+    maxFileSize: 100 * 1024 * 1024,
+    // 100MB
+    allowedMimeTypes: [
+      "video/mp4",
+      "video/webm",
+      "video/quicktime"
+    ],
+    enableStreaming: true
+  };
+}
+function createDocumentServicePreset(storage) {
+  return {
+    storage,
+    maxFileSize: 20 * 1024 * 1024,
+    // 20MB
+    allowedMimeTypes: [
+      "application/pdf",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    ]
+  };
+}
+
+// src/universalFile/server/validation.ts
+var ConfigValidationError = class extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.name = "ConfigValidationError";
+  }
+};
+function validateStorageConfig(storage) {
+  if (!storage.type) {
+    throw new ConfigValidationError("Storage type is required", "storage.type");
+  }
+  switch (storage.type) {
+    case "local": {
+      const config = storage;
+      if (!config.rootPath) {
+        throw new ConfigValidationError(
+          "rootPath is required for local storage",
+          "storage.rootPath"
+        );
+      }
+      if (!config.baseUrl) {
+        throw new ConfigValidationError(
+          "baseUrl is required for local storage",
+          "storage.baseUrl"
+        );
+      }
+      break;
+    }
+    case "aliyun-oss": {
+      const config = storage;
+      if (!config.accessKeyId) {
+        throw new ConfigValidationError(
+          "accessKeyId is required for Aliyun OSS",
+          "storage.accessKeyId"
+        );
+      }
+      if (!config.accessKeySecret) {
+        throw new ConfigValidationError(
+          "accessKeySecret is required for Aliyun OSS",
+          "storage.accessKeySecret"
+        );
+      }
+      if (!config.bucket) {
+        throw new ConfigValidationError(
+          "bucket is required for Aliyun OSS",
+          "storage.bucket"
+        );
+      }
+      break;
+    }
+    default:
+      throw new ConfigValidationError(
+        `Unsupported storage type: ${storage.type}`,
+        "storage.type"
+      );
+  }
+}
+function validateServiceConfig(config) {
+  if (!config.storage) {
+    throw new ConfigValidationError("Storage config is required", "storage");
+  }
+  validateStorageConfig(config.storage);
+  if (config.maxFileSize && config.maxFileSize <= 0) {
+    throw new ConfigValidationError(
+      "maxFileSize must be greater than 0",
+      "maxFileSize"
+    );
+  }
+  if (config.allowedMimeTypes && config.allowedMimeTypes.length === 0) {
+    throw new ConfigValidationError(
+      "allowedMimeTypes must not be empty",
+      "allowedMimeTypes"
+    );
+  }
+}
+function validateEnvironment(requiredVars) {
+  const missing = [];
+  for (const varName of requiredVars) {
+    if (!process.env[varName]) {
+      missing.push(varName);
+    }
+  }
+  if (missing.length > 0) {
+    throw new ConfigValidationError(
+      `Missing required environment variables: ${missing.join(", ")}`,
+      "environment"
+    );
+  }
+}
+function getRequiredEnvVars(storageType) {
+  switch (storageType) {
+    case "local":
+      return ["UPLOAD_DIR", "BASE_URL"];
+    case "aliyun-oss":
+      return [
+        "OSS_ACCESS_KEY_ID",
+        "OSS_ACCESS_KEY_SECRET",
+        "OSS_BUCKET",
+        "OSS_REGION"
+      ];
+    default:
+      return [];
+  }
+}
+var logger = createLogger("AliyunCDNProvider");
+var AliyunCDNProvider = class {
+  constructor() {
+    this.type = "aliyun-cdn";
+    this.config = null;
+    this.client = null;
+    this.isInitialized = false;
+  }
+  /**
+   * 初始化CDN提供者
+   */
+  async initialize(config) {
+    if (config.type !== "aliyun-cdn") {
+      throw new CDNProviderError("\u914D\u7F6E\u7C7B\u578B\u4E0D\u5339\u914D\uFF1A\u671F\u671B aliyun-cdn");
+    }
+    this.config = config;
+    logger.info(`\u{1F310} [AliyunCDNProvider] \u521D\u59CB\u5316\u963F\u91CC\u4E91CDN\uFF0C\u57DF\u540D: ${this.config.domain}`);
+    try {
+      this.validateConfig();
+      try {
+        const CDN = __require("@alicloud/cdn20180510");
+        const OpenApi = __require("@alicloud/openapi-client");
+        const cdnConfig = new OpenApi.Config({
+          accessKeyId: this.config.accessKeyId,
+          accessKeySecret: this.config.accessKeySecret,
+          endpoint: "cdn.aliyuncs.com"
+        });
+        this.client = new CDN.default(cdnConfig);
+      } catch (sdkError) {
+        logger.warn("\u26A0\uFE0F [AliyunCDNProvider] \u963F\u91CC\u4E91CDN SDK\u672A\u5B89\u88C5\uFF0C\u4F7F\u7528\u6A21\u62DF\u6A21\u5F0F");
+        this.client = this.createMockClient();
+      }
+      await this.testConnection();
+      this.isInitialized = true;
+      logger.info("\u2705 [AliyunCDNProvider] \u963F\u91CC\u4E91CDN\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      logger.error("\u274C [AliyunCDNProvider] \u963F\u91CC\u4E91CDN\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw new CDNProviderError(
+        `\u963F\u91CC\u4E91CDN\u521D\u59CB\u5316\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+  }
+  /**
+   * 生成CDN URL
+   */
+  async generateUrl(originalUrl) {
+    this.ensureInitialized();
+    logger.info(`\u{1F517} [AliyunCDNProvider] \u751F\u6210CDN URL: ${originalUrl}`);
+    try {
+      const url = new URL(originalUrl);
+      const cdnUrl = `${url.protocol}//${this.config.domain}${url.pathname}${url.search}${url.hash}`;
+      logger.info(`\u2705 [AliyunCDNProvider] CDN URL\u751F\u6210\u5B8C\u6210: ${cdnUrl}`);
+      return cdnUrl;
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] CDN URL\u751F\u6210\u5931\u8D25: ${originalUrl}:`, error);
+      throw new CDNProviderError(
+        `CDN URL\u751F\u6210\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+  }
+  /**
+   * 刷新缓存
+   */
+  async refreshCache(urls) {
+    this.ensureInitialized();
+    logger.info(`\u{1F504} [AliyunCDNProvider] \u5F00\u59CB\u5237\u65B0CDN\u7F13\u5B58\uFF0CURL\u6570\u91CF: ${urls.length}`);
+    try {
+      const cdnUrls = await Promise.all(urls.map((url) => this.generateUrl(url)));
+      const result = await this.client.refreshObjectCaches({
+        domainName: this.config.domain,
+        objectPath: cdnUrls.join("\n"),
+        objectType: "File"
+        // File 或 Directory
+      });
+      logger.info(
+        `\u2705 [AliyunCDNProvider] CDN\u7F13\u5B58\u5237\u65B0\u5B8C\u6210\uFF0C\u4EFB\u52A1ID: ${result.RefreshTaskId || "unknown"}`
+      );
+      return {
+        success: true,
+        data: {
+          taskId: result.RefreshTaskId,
+          requestId: result.RequestId,
+          urls: cdnUrls
+        }
+      };
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] CDN\u7F13\u5B58\u5237\u65B0\u5931\u8D25:`, error);
+      return {
+        success: false,
+        error: `CDN\u7F13\u5B58\u5237\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  /**
+   * 预热缓存
+   */
+  async preheatCache(urls) {
+    this.ensureInitialized();
+    logger.info(`\u{1F525} [AliyunCDNProvider] \u5F00\u59CB\u9884\u70EDCDN\u7F13\u5B58\uFF0CURL\u6570\u91CF: ${urls.length}`);
+    try {
+      const cdnUrls = await Promise.all(urls.map((url) => this.generateUrl(url)));
+      const result = await this.client.pushObjectCache({
+        domainName: this.config.domain,
+        objectPath: cdnUrls.join("\n"),
+        area: "domestic"
+        // domestic, overseas, global
+      });
+      logger.info(
+        `\u2705 [AliyunCDNProvider] CDN\u7F13\u5B58\u9884\u70ED\u5B8C\u6210\uFF0C\u4EFB\u52A1ID: ${result.PushTaskId || "unknown"}`
+      );
+      return {
+        success: true,
+        data: {
+          taskId: result.PushTaskId,
+          requestId: result.RequestId,
+          urls: cdnUrls
+        }
+      };
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] CDN\u7F13\u5B58\u9884\u70ED\u5931\u8D25:`, error);
+      return {
+        success: false,
+        error: `CDN\u7F13\u5B58\u9884\u70ED\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  /**
+   * 获取访问统计
+   */
+  async getAccessStats(startTime, endTime) {
+    this.ensureInitialized();
+    logger.info(
+      `\u{1F4CA} [AliyunCDNProvider] \u83B7\u53D6CDN\u8BBF\u95EE\u7EDF\u8BA1: ${startTime.toISOString()} - ${endTime.toISOString()}`
+    );
+    try {
+      const formatTime = (date) => date.toISOString().slice(0, 19).replace("T", " ") + "Z";
+      const result = await this.client.describeDomainRealTimeData({
+        domainName: this.config.domain,
+        startTime: formatTime(startTime),
+        endTime: formatTime(endTime),
+        field: "bps,qps"
+        // 带宽和QPS
+      });
+      logger.info(`\u2705 [AliyunCDNProvider] CDN\u8BBF\u95EE\u7EDF\u8BA1\u83B7\u53D6\u5B8C\u6210`);
+      return {
+        success: true,
+        data: {
+          requestId: result.RequestId,
+          dataInterval: result.DataInterval,
+          realTimeData: result.RealTimeData,
+          domain: this.config.domain,
+          startTime: startTime.toISOString(),
+          endTime: endTime.toISOString()
+        }
+      };
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] CDN\u8BBF\u95EE\u7EDF\u8BA1\u83B7\u53D6\u5931\u8D25:`, error);
+      return {
+        success: false,
+        error: `CDN\u8BBF\u95EE\u7EDF\u8BA1\u83B7\u53D6\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  // ============= 高级功能 =============
+  /**
+   * 生成防盗链签名URL
+   */
+  async generateSignedUrl(originalUrl, expiresIn = 3600, authKey) {
+    this.ensureInitialized();
+    logger.info(`\u{1F510} [AliyunCDNProvider] \u751F\u6210\u9632\u76D7\u94FE\u7B7E\u540DURL: ${originalUrl}`);
+    try {
+      const cdnUrl = await this.generateUrl(originalUrl);
+      if (!authKey) {
+        logger.info(`\u26A0\uFE0F [AliyunCDNProvider] \u672A\u63D0\u4F9BauthKey\uFF0C\u8FD4\u56DE\u666E\u901ACDN URL`);
+        return cdnUrl;
+      }
+      const parsedUrl = new URL(cdnUrl);
+      const timestamp = Math.floor(Date.now() / 1e3) + expiresIn;
+      const signString = `${parsedUrl.pathname}-${timestamp}-0-0-${authKey}`;
+      const authValue = createHash("md5").update(signString).digest("hex");
+      const signedUrl = `${cdnUrl}?auth_key=${timestamp}-0-0-${authValue}`;
+      logger.info(`\u2705 [AliyunCDNProvider] \u9632\u76D7\u94FE\u7B7E\u540DURL\u751F\u6210\u5B8C\u6210`);
+      return signedUrl;
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] \u9632\u76D7\u94FE\u7B7E\u540DURL\u751F\u6210\u5931\u8D25: ${originalUrl}:`, error);
+      throw new CDNProviderError(
+        `\u9632\u76D7\u94FE\u7B7E\u540DURL\u751F\u6210\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+  }
+  /**
+   * 查询刷新任务状态
+   */
+  async getRefreshTaskStatus(taskId) {
+    this.ensureInitialized();
+    try {
+      const result = await this.client.describeRefreshTasks({
+        taskId
+      });
+      return {
+        success: true,
+        data: {
+          tasks: result.Tasks,
+          requestId: result.RequestId
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `\u67E5\u8BE2\u5237\u65B0\u4EFB\u52A1\u72B6\u6001\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  /**
+   * 查询预热任务状态
+   */
+  async getPreheatTaskStatus(taskId) {
+    this.ensureInitialized();
+    try {
+      const result = await this.client.describePushTasks({
+        taskId
+      });
+      return {
+        success: true,
+        data: {
+          tasks: result.Tasks,
+          requestId: result.RequestId
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `\u67E5\u8BE2\u9884\u70ED\u4EFB\u52A1\u72B6\u6001\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  /**
+   * 获取域名配置
+   */
+  async getDomainConfig() {
+    this.ensureInitialized();
+    try {
+      const result = await this.client.describeDomainConfigs({
+        domainName: this.config.domain
+      });
+      return {
+        success: true,
+        data: {
+          domainConfigs: result.DomainConfigs,
+          requestId: result.RequestId
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `\u83B7\u53D6\u57DF\u540D\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+  /**
+   * 优化URL (添加图像处理参数等)
+   */
+  async optimizeUrl(originalUrl, options = {}) {
+    this.ensureInitialized();
+    try {
+      const cdnUrl = await this.generateUrl(originalUrl);
+      const url = new URL(cdnUrl);
+      const params = new URLSearchParams(url.search);
+      if (options.imageQuality) {
+        params.set("x-oss-process", `image/quality,q_${options.imageQuality}`);
+      }
+      if (options.imageFormat) {
+        const formatParam = params.get("x-oss-process") || "image";
+        params.set("x-oss-process", `${formatParam}/format,${options.imageFormat}`);
+      }
+      if (options.imageResize) {
+        const resizeParam = params.get("x-oss-process") || "image";
+        let resize = "resize";
+        if (options.imageResize.width) resize += `,w_${options.imageResize.width}`;
+        if (options.imageResize.height) resize += `,h_${options.imageResize.height}`;
+        params.set("x-oss-process", `${resizeParam}/${resize}`);
+      }
+      url.search = params.toString();
+      return url.toString();
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] URL\u4F18\u5316\u5931\u8D25: ${originalUrl}:`, error);
+      return this.generateUrl(originalUrl);
+    }
+  }
+  // ============= 私有方法 =============
+  /**
+   * 确保已初始化
+   */
+  ensureInitialized() {
+    if (!this.isInitialized || !this.client || !this.config) {
+      throw new CDNProviderError("CDN\u63D0\u4F9B\u8005\u672A\u521D\u59CB\u5316");
+    }
+  }
+  /**
+   * 验证配置
+   */
+  validateConfig() {
+    if (!this.config) {
+      throw new CDNProviderError("CDN\u914D\u7F6E\u4E3A\u7A7A");
+    }
+    const required = ["domain", "accessKeyId", "accessKeySecret"];
+    const missing = required.filter((key) => !this.config[key]);
+    if (missing.length > 0) {
+      throw new CDNProviderError(`CDN\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u9879: ${missing.join(", ")}`);
+    }
+    if (!this.isValidDomain(this.config.domain)) {
+      throw new CDNProviderError(`\u65E0\u6548\u7684CDN\u57DF\u540D: ${this.config.domain}`);
+    }
+  }
+  /**
+   * 验证域名格式
+   */
+  isValidDomain(domain) {
+    const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return domainRegex.test(domain);
+  }
+  /**
+   * 测试连接
+   */
+  async testConnection() {
+    try {
+      await this.getDomainConfig();
+      logger.info(`\u2705 [AliyunCDNProvider] CDN\u8FDE\u63A5\u6D4B\u8BD5\u6210\u529F`);
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F [AliyunCDNProvider] CDN\u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25\uFF0C\u53EF\u80FD\u662F\u6743\u9650\u95EE\u9898:`, error);
+    }
+  }
+  /**
+   * 创建模拟客户端（用于开发测试）
+   */
+  createMockClient() {
+    logger.info("\u{1F9EA} [AliyunCDNProvider] \u521B\u5EFA\u6A21\u62DFCDN\u5BA2\u6237\u7AEF");
+    return {
+      async refreshObjectCaches(params) {
+        logger.info("\u{1F504} [MockCDN] \u6A21\u62DF\u5237\u65B0\u7F13\u5B58:", params);
+        return {
+          RefreshTaskId: `mock-refresh-${Date.now()}`,
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async pushObjectCache(params) {
+        logger.info("\u{1F525} [MockCDN] \u6A21\u62DF\u9884\u70ED\u7F13\u5B58:", params);
+        return {
+          PushTaskId: `mock-push-${Date.now()}`,
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async describeRefreshTasks(params) {
+        logger.info("\u{1F4CB} [MockCDN] \u6A21\u62DF\u67E5\u8BE2\u5237\u65B0\u4EFB\u52A1:", params);
+        return {
+          Tasks: {
+            Task: [
+              {
+                TaskId: params.taskId,
+                Status: "Complete",
+                Process: "100%",
+                CreateTime: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            ]
+          },
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async describePushTasks(params) {
+        logger.info("\u{1F4CB} [MockCDN] \u6A21\u62DF\u67E5\u8BE2\u9884\u70ED\u4EFB\u52A1:", params);
+        return {
+          Tasks: {
+            Task: [
+              {
+                TaskId: params.taskId,
+                Status: "Complete",
+                Process: "100%",
+                CreateTime: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            ]
+          },
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async describeDomainConfigs(params) {
+        logger.info("\u2699\uFE0F [MockCDN] \u6A21\u62DF\u83B7\u53D6\u57DF\u540D\u914D\u7F6E:", params);
+        return {
+          DomainConfigs: {
+            DomainConfig: [
+              {
+                FunctionName: "cache",
+                ConfigId: "mock-config-id",
+                Status: "success"
+              }
+            ]
+          },
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async describeCdnDomainLogs(params) {
+        logger.info("\u{1F4CA} [MockCDN] \u6A21\u62DF\u83B7\u53D6\u65E5\u5FD7:", params);
+        return {
+          DomainLogDetails: {
+            DomainLogDetail: []
+          },
+          RequestId: `mock-request-${Date.now()}`
+        };
+      },
+      async describeDomainRealTimeData(params) {
+        logger.info("\u{1F4C8} [MockCDN] \u6A21\u62DF\u83B7\u53D6\u5B9E\u65F6\u6570\u636E:", params);
+        return {
+          RealTimeData: {
+            UsageData: [
+              {
+                TimeStamp: (/* @__PURE__ */ new Date()).toISOString(),
+                Value: Math.random() * 1e3
+              }
+            ]
+          },
+          DataInterval: "60",
+          RequestId: `mock-request-${Date.now()}`
+        };
+      }
+    };
+  }
+  /**
+   * 批量刷新缓存（带进度回调）
+   */
+  async batchRefreshCache(urls, batchSize = 20, onProgress) {
+    this.ensureInitialized();
+    logger.info(
+      `\u{1F504} [AliyunCDNProvider] \u5F00\u59CB\u6279\u91CF\u5237\u65B0\u7F13\u5B58\uFF0C\u603BURL\u6570: ${urls.length}\uFF0C\u6279\u6B21\u5927\u5C0F: ${batchSize}`
+    );
+    try {
+      const results = [];
+      let completed = 0;
+      for (let i = 0; i < urls.length; i += batchSize) {
+        const batch = urls.slice(i, i + batchSize);
+        const batchResult = await this.refreshCache(batch);
+        results.push(batchResult);
+        completed += batch.length;
+        if (onProgress) {
+          onProgress(completed, urls.length);
+        }
+        if (i + batchSize < urls.length) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      }
+      const successCount = results.filter((r) => r.success).length;
+      logger.info(`\u2705 [AliyunCDNProvider] \u6279\u91CF\u5237\u65B0\u5B8C\u6210\uFF0C\u6210\u529F: ${successCount}/${results.length}`);
+      return {
+        success: successCount === results.length,
+        data: {
+          totalBatches: results.length,
+          successBatches: successCount,
+          results
+        }
+      };
+    } catch (error) {
+      logger.error(`\u274C [AliyunCDNProvider] \u6279\u91CF\u5237\u65B0\u5931\u8D25:`, error);
+      return {
+        success: false,
+        error: `\u6279\u91CF\u5237\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+      };
+    }
+  }
+};
+
+// src/universalFile/server/providers/CdnCacheStrategy.ts
+var CacheStrategyType = /* @__PURE__ */ ((CacheStrategyType3) => {
+  CacheStrategyType3["IMAGE"] = "image";
+  CacheStrategyType3["VIDEO"] = "video";
+  CacheStrategyType3["AUDIO"] = "audio";
+  CacheStrategyType3["DOCUMENT"] = "document";
+  CacheStrategyType3["ARCHIVE"] = "archive";
+  CacheStrategyType3["STATIC"] = "static";
+  CacheStrategyType3["OTHER"] = "other";
+  return CacheStrategyType3;
+})(CacheStrategyType || {});
+var CdnCacheStrategy = class {
+  constructor() {
+    this.strategies = /* @__PURE__ */ new Map();
+    this.stats = /* @__PURE__ */ new Map();
+    this.initializeDefaultStrategies();
+  }
+  /**
+   * 初始化默认缓存策略
+   */
+  initializeDefaultStrategies() {
+    this.strategies.set("image" /* IMAGE */, {
+      type: "image" /* IMAGE */,
+      ttl: 30 * 24 * 3600,
+      // 30天
+      browserCache: true,
+      browserCacheTtl: 7 * 24 * 3600,
+      // 7天
+      cdnCache: true,
+      cdnCacheTtl: 30 * 24 * 3600,
+      // 30天
+      enableWarmup: true,
+      cacheControl: "public, max-age=604800, s-maxage=2592000",
+      allowedMimeTypes: ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"],
+      maxFileSize: 50 * 1024 * 1024
+      // 50MB
+    });
+    this.strategies.set("video" /* VIDEO */, {
+      type: "video" /* VIDEO */,
+      ttl: 7 * 24 * 3600,
+      // 7天
+      browserCache: true,
+      browserCacheTtl: 24 * 3600,
+      // 1天
+      cdnCache: true,
+      cdnCacheTtl: 7 * 24 * 3600,
+      // 7天
+      enableWarmup: false,
+      // 视频文件通常较大，不预热
+      cacheControl: "public, max-age=86400, s-maxage=604800",
+      allowedMimeTypes: ["video/mp4", "video/avi", "video/mov", "video/wmv", "video/webm"],
+      maxFileSize: 500 * 1024 * 1024
+      // 500MB
+    });
+    this.strategies.set("audio" /* AUDIO */, {
+      type: "audio" /* AUDIO */,
+      ttl: 14 * 24 * 3600,
+      // 14天
+      browserCache: true,
+      browserCacheTtl: 3 * 24 * 3600,
+      // 3天
+      cdnCache: true,
+      cdnCacheTtl: 14 * 24 * 3600,
+      // 14天
+      enableWarmup: true,
+      cacheControl: "public, max-age=259200, s-maxage=1209600",
+      allowedMimeTypes: ["audio/mpeg", "audio/wav", "audio/ogg", "audio/m4a", "audio/flac"],
+      maxFileSize: 100 * 1024 * 1024
+      // 100MB
+    });
+    this.strategies.set("document" /* DOCUMENT */, {
+      type: "document" /* DOCUMENT */,
+      ttl: 24 * 3600,
+      // 1天
+      browserCache: true,
+      browserCacheTtl: 3600,
+      // 1小时
+      cdnCache: true,
+      cdnCacheTtl: 24 * 3600,
+      // 1天
+      enableWarmup: false,
+      cacheControl: "public, max-age=3600, s-maxage=86400",
+      allowedMimeTypes: [
+        "application/pdf",
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "text/plain",
+        "text/csv"
+      ],
+      maxFileSize: 50 * 1024 * 1024
+      // 50MB
+    });
+    this.strategies.set("archive" /* ARCHIVE */, {
+      type: "archive" /* ARCHIVE */,
+      ttl: 24 * 3600,
+      // 1天
+      browserCache: true,
+      browserCacheTtl: 1800,
+      // 30分钟
+      cdnCache: true,
+      cdnCacheTtl: 24 * 3600,
+      // 1天
+      enableWarmup: false,
+      cacheControl: "public, max-age=1800, s-maxage=86400",
+      allowedMimeTypes: [
+        "application/zip",
+        "application/x-rar-compressed",
+        "application/x-7z-compressed",
+        "application/gzip",
+        "application/x-tar"
+      ],
+      maxFileSize: 100 * 1024 * 1024
+      // 100MB
+    });
+    this.strategies.set("static" /* STATIC */, {
+      type: "static" /* STATIC */,
+      ttl: 365 * 24 * 3600,
+      // 1年
+      browserCache: true,
+      browserCacheTtl: 30 * 24 * 3600,
+      // 30天
+      cdnCache: true,
+      cdnCacheTtl: 365 * 24 * 3600,
+      // 1年
+      enableWarmup: true,
+      cacheControl: "public, max-age=2592000, s-maxage=31536000, immutable",
+      allowedMimeTypes: [
+        "text/css",
+        "application/javascript",
+        "application/json",
+        "font/woff",
+        "font/woff2",
+        "font/ttf"
+      ],
+      maxFileSize: 10 * 1024 * 1024
+      // 10MB
+    });
+    this.strategies.set("other" /* OTHER */, {
+      type: "other" /* OTHER */,
+      ttl: 3600,
+      // 1小时
+      browserCache: true,
+      browserCacheTtl: 300,
+      // 5分钟
+      cdnCache: false,
+      cdnCacheTtl: 0,
+      enableWarmup: false,
+      cacheControl: "public, max-age=300",
+      allowedMimeTypes: [],
+      maxFileSize: 10 * 1024 * 1024
+      // 10MB
+    });
+    for (const type of Object.values(CacheStrategyType)) {
+      this.stats.set(type, {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        totalRequests: 0,
+        estimatedSize: 0,
+        bandwidthSaved: 0
+      });
+    }
+  }
+  /**
+   * 根据MIME类型获取缓存策略
+   */
+  getStrategyByMimeType(mimeType) {
+    for (const [_type, strategy] of this.strategies.entries()) {
+      if (strategy.allowedMimeTypes.includes(mimeType)) {
+        return strategy;
+      }
+    }
+    if (mimeType.startsWith("image/")) {
+      return this.strategies.get("image" /* IMAGE */);
+    } else if (mimeType.startsWith("video/")) {
+      return this.strategies.get("video" /* VIDEO */);
+    } else if (mimeType.startsWith("audio/")) {
+      return this.strategies.get("audio" /* AUDIO */);
+    } else if (mimeType.includes("pdf") || mimeType.includes("document") || mimeType.includes("word") || mimeType.includes("excel")) {
+      return this.strategies.get("document" /* DOCUMENT */);
+    } else if (mimeType.includes("zip") || mimeType.includes("compressed") || mimeType.includes("archive")) {
+      return this.strategies.get("archive" /* ARCHIVE */);
+    }
+    return this.strategies.get("other" /* OTHER */);
+  }
+  /**
+   * 生成缓存控制头
+   */
+  generateCacheHeaders(mimeType, fileSize) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    if (fileSize && strategy.maxFileSize && fileSize > strategy.maxFileSize) {
+      return {
+        "Cache-Control": "public, max-age=300",
+        // 5分钟
+        Expires: new Date(Date.now() + 300 * 1e3).toUTCString()
+      };
+    }
+    const headers = {
+      "Cache-Control": strategy.cacheControl,
+      Expires: new Date(Date.now() + strategy.browserCacheTtl * 1e3).toUTCString()
+    };
+    if (strategy.browserCache) {
+      headers["ETag"] = `"${Date.now()}"`;
+    }
+    headers["Last-Modified"] = (/* @__PURE__ */ new Date()).toUTCString();
+    if (strategy.type === "static" /* STATIC */) {
+      headers["Cache-Control"] += ", immutable";
+    }
+    return headers;
+  }
+  /**
+   * 检查是否需要缓存预热
+   */
+  shouldWarmupCache(mimeType) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    return strategy.enableWarmup;
+  }
+  /**
+   * 记录缓存命中
+   */
+  recordCacheHit(mimeType, fileSize = 0) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    const stats = this.stats.get(strategy.type);
+    if (stats) {
+      stats.hits++;
+      stats.totalRequests++;
+      stats.bandwidthSaved += fileSize;
+      stats.hitRate = stats.hits / stats.totalRequests * 100;
+    }
+  }
+  /**
+   * 记录缓存未命中
+   */
+  recordCacheMiss(mimeType, fileSize = 0) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    const stats = this.stats.get(strategy.type);
+    if (stats) {
+      stats.misses++;
+      stats.totalRequests++;
+      stats.estimatedSize += fileSize;
+      stats.hitRate = stats.hits / stats.totalRequests * 100;
+    }
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  getCacheStats() {
+    return new Map(this.stats);
+  }
+  /**
+   * 获取总体缓存统计
+   */
+  getOverallStats() {
+    const overall = {
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      totalRequests: 0,
+      estimatedSize: 0,
+      bandwidthSaved: 0
+    };
+    for (const stats of this.stats.values()) {
+      overall.hits += stats.hits;
+      overall.misses += stats.misses;
+      overall.totalRequests += stats.totalRequests;
+      overall.estimatedSize += stats.estimatedSize;
+      overall.bandwidthSaved += stats.bandwidthSaved;
+    }
+    overall.hitRate = overall.totalRequests > 0 ? overall.hits / overall.totalRequests * 100 : 0;
+    return overall;
+  }
+  /**
+   * 生成缓存优化建议
+   */
+  generateOptimizationSuggestions() {
+    const suggestions = [];
+    for (const [type, stats] of this.stats.entries()) {
+      if (stats.totalRequests > 100) {
+        if (stats.hitRate < 60) {
+          suggestions.push({
+            type,
+            issue: `${type}\u7C7B\u578B\u6587\u4EF6\u7F13\u5B58\u547D\u4E2D\u7387\u8FC7\u4F4E (${stats.hitRate.toFixed(1)}%)`,
+            suggestion: "\u8003\u8651\u589E\u52A0\u7F13\u5B58\u65F6\u95F4\u6216\u542F\u7528\u9884\u70ED\u673A\u5236",
+            severity: stats.hitRate < 30 ? "high" : "medium"
+          });
+        }
+        if (stats.estimatedSize > 1024 * 1024 * 1024) {
+          suggestions.push({
+            type,
+            issue: `${type}\u7C7B\u578B\u6587\u4EF6\u7F13\u5B58\u5360\u7528\u7A7A\u95F4\u8FC7\u5927 (${(stats.estimatedSize / 1024 / 1024 / 1024).toFixed(2)}GB)`,
+            suggestion: "\u8003\u8651\u51CF\u5C11\u7F13\u5B58\u65F6\u95F4\u6216\u4F18\u5316\u6587\u4EF6\u538B\u7F29",
+            severity: "medium"
+          });
+        }
+      }
+    }
+    return suggestions;
+  }
+  /**
+   * 更新缓存策略
+   */
+  updateStrategy(type, config) {
+    const currentStrategy = this.strategies.get(type);
+    if (currentStrategy) {
+      this.strategies.set(type, { ...currentStrategy, ...config });
+    }
+  }
+  /**
+   * 重置统计信息
+   */
+  resetStats() {
+    for (const type of Object.values(CacheStrategyType)) {
+      this.stats.set(type, {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        totalRequests: 0,
+        estimatedSize: 0,
+        bandwidthSaved: 0
+      });
+    }
+  }
+};
+var cdnCacheStrategy = new CdnCacheStrategy();
+var logger2 = createLogger("ImageProcessor");
+var ImageProcessor = class {
+  constructor() {
+    this.type = "image";
+    this.sharp = null;
+    this.isInitialized = false;
+  }
+  /**
+   * 初始化图片处理器
+   */
+  async initialize() {
+    logger2.info("\u{1F5BC}\uFE0F [ImageProcessor] \u521D\u59CB\u5316\u56FE\u7247\u5904\u7406\u5668...");
+    try {
+      try {
+        this.sharp = __require("sharp");
+        logger2.info("\u2705 [ImageProcessor] Sharp\u5E93\u52A0\u8F7D\u6210\u529F");
+      } catch (error) {
+        console.warn("\u26A0\uFE0F [ImageProcessor] Sharp\u5E93\u672A\u5B89\u88C5\uFF0C\u4F7F\u7528\u6A21\u62DF\u6A21\u5F0F");
+        this.sharp = this.createMockSharp();
+      }
+      this.isInitialized = true;
+      logger2.info("\u2705 [ImageProcessor] \u56FE\u7247\u5904\u7406\u5668\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u274C [ImageProcessor] \u56FE\u7247\u5904\u7406\u5668\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 处理图片文件
+   */
+  async process(inputPath, outputPath, options) {
+    this.ensureInitialized();
+    if (options.type !== "image") {
+      throw new Error("\u5904\u7406\u9009\u9879\u7C7B\u578B\u4E0D\u5339\u914D\uFF1A\u671F\u671B image");
+    }
+    const imageOptions = options;
+    const startTime = Date.now();
+    logger2.info(`\u{1F5BC}\uFE0F [ImageProcessor] \u5F00\u59CB\u5904\u7406\u56FE\u7247: ${inputPath}`);
+    try {
+      if (!existsSync(inputPath)) {
+        throw new Error(`\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${inputPath}`);
+      }
+      const outputDir = path3.dirname(outputPath);
+      await promises.mkdir(outputDir, { recursive: true });
+      const metadata = await this.getImageMetadata(inputPath);
+      logger2.info(
+        `\u{1F4CA} [ImageProcessor] \u56FE\u7247\u4FE1\u606F: ${metadata.width}x${metadata.height}, \u683C\u5F0F: ${metadata.format}`
+      );
+      let sharpInstance = this.sharp(inputPath);
+      sharpInstance = await this.applyImageOperations(sharpInstance, imageOptions);
+      const outputFormat = this.determineOutputFormat(outputPath, imageOptions.format);
+      sharpInstance = this.applyOutputSettings(sharpInstance, outputFormat, imageOptions.quality);
+      const info = await sharpInstance.toFile(outputPath);
+      let thumbnailPath;
+      if (this.shouldGenerateThumbnail(imageOptions)) {
+        thumbnailPath = await this.generateThumbnail(inputPath, outputPath, imageOptions);
+      }
+      const processingTime = Date.now() - startTime;
+      logger2.info(`\u2705 [ImageProcessor] \u56FE\u7247\u5904\u7406\u5B8C\u6210: ${outputPath}, \u8017\u65F6: ${processingTime}ms`);
+      return {
+        success: true,
+        processedPath: outputPath,
+        processedSize: info.size,
+        thumbnailPath,
+        processingTime,
+        data: {
+          originalSize: (await promises.stat(inputPath)).size,
+          processedSize: info.size,
+          compressionRatio: ((await promises.stat(inputPath)).size - info.size) / (await promises.stat(inputPath)).size,
+          dimensions: {
+            original: { width: metadata.width, height: metadata.height },
+            processed: { width: info.width, height: info.height }
+          },
+          format: {
+            original: metadata.format,
+            processed: outputFormat
+          }
+        }
+      };
+    } catch (error) {
+      console.error(`\u274C [ImageProcessor] \u56FE\u7247\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+      return {
+        success: false,
+        error: `\u56FE\u7247\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`,
+        processingTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * 检查文件是否支持处理
+   */
+  supports(mimeType) {
+    const supportedTypes = [
+      "image/jpeg",
+      "image/jpg",
+      "image/png",
+      "image/webp",
+      "image/avif",
+      "image/gif",
+      "image/tiff",
+      "image/bmp"
+    ];
+    return supportedTypes.includes(mimeType.toLowerCase());
+  }
+  /**
+   * 获取图片文件信息
+   */
+  async getFileInfo(filePath) {
+    this.ensureInitialized();
+    try {
+      const metadata = await this.getImageMetadata(filePath);
+      const stats = await promises.stat(filePath);
+      return {
+        dimensions: {
+          width: metadata.width,
+          height: metadata.height
+        },
+        format: metadata.format,
+        channels: metadata.channels,
+        hasAlpha: metadata.hasAlpha,
+        density: metadata.density,
+        orientation: metadata.orientation,
+        fileSize: stats.size,
+        aspectRatio: metadata.width / metadata.height,
+        megapixels: metadata.width * metadata.height / 1e6
+      };
+    } catch (error) {
+      console.error(`\u274C [ImageProcessor] \u83B7\u53D6\u56FE\u7247\u4FE1\u606F\u5931\u8D25: ${filePath}:`, error);
+      throw error;
+    }
+  }
+  // ============= 私有方法 =============
+  /**
+   * 确保处理器已初始化
+   */
+  ensureInitialized() {
+    if (!this.isInitialized || !this.sharp) {
+      throw new Error("\u56FE\u7247\u5904\u7406\u5668\u672A\u521D\u59CB\u5316");
+    }
+  }
+  /**
+   * 获取图片元数据
+   */
+  async getImageMetadata(filePath) {
+    try {
+      const metadata = await this.sharp(filePath).metadata();
+      return {
+        format: metadata.format || "unknown",
+        width: metadata.width || 0,
+        height: metadata.height || 0,
+        channels: metadata.channels || 3,
+        density: metadata.density || 72,
+        hasAlpha: metadata.hasAlpha || false,
+        orientation: metadata.orientation
+      };
+    } catch (error) {
+      console.error(`\u274C [ImageProcessor] \u83B7\u53D6\u56FE\u7247\u5143\u6570\u636E\u5931\u8D25: ${filePath}:`, error);
+      throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247\u5143\u6570\u636E: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`);
+    }
+  }
+  /**
+   * 应用图片处理操作
+   */
+  async applyImageOperations(sharpInstance, options) {
+    if (options.width || options.height) {
+      const resizeOptions = {
+        width: options.width,
+        height: options.height,
+        fit: "inside",
+        // 保持纵横比
+        withoutEnlargement: true
+        // 不放大小图片
+      };
+      sharpInstance = sharpInstance.resize(resizeOptions);
+      logger2.info(
+        `\u{1F527} [ImageProcessor] \u5E94\u7528\u5C3A\u5BF8\u8C03\u6574: ${options.width || "auto"}x${options.height || "auto"}`
+      );
+    }
+    sharpInstance = sharpInstance.rotate();
+    if (options.watermark && options.watermarkOptions) {
+      sharpInstance = await this.applyWatermark(sharpInstance, options.watermarkOptions);
+    }
+    return sharpInstance;
+  }
+  /**
+   * 应用水印
+   */
+  async applyWatermark(sharpInstance, watermarkOptions) {
+    try {
+      if (watermarkOptions.text) {
+        logger2.info(`\u{1F4A7} [ImageProcessor] \u5E94\u7528\u6587\u5B57\u6C34\u5370: ${watermarkOptions.text}`);
+        const textSvg = this.createTextWatermarkSvg(
+          watermarkOptions.text,
+          watermarkOptions.opacity || 0.5
+        );
+        const textBuffer = Buffer.from(textSvg);
+        sharpInstance = sharpInstance.composite([
+          {
+            input: textBuffer,
+            gravity: this.getWatermarkGravity(watermarkOptions.position || "bottom-right")
+          }
+        ]);
+      } else if (watermarkOptions.image && existsSync(watermarkOptions.image)) {
+        logger2.info(`\u{1F4A7} [ImageProcessor] \u5E94\u7528\u56FE\u7247\u6C34\u5370: ${watermarkOptions.image}`);
+        let watermarkBuffer = await promises.readFile(watermarkOptions.image);
+        if (watermarkOptions.opacity && watermarkOptions.opacity < 1) {
+          const watermarkSharp = this.sharp(watermarkBuffer).png().modulate({ brightness: 1, saturation: 1, alpha: watermarkOptions.opacity });
+          watermarkBuffer = await watermarkSharp.toBuffer();
+        }
+        sharpInstance = sharpInstance.composite([
+          {
+            input: watermarkBuffer,
+            gravity: this.getWatermarkGravity(watermarkOptions.position || "bottom-right")
+          }
+        ]);
+      }
+      return sharpInstance;
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F [ImageProcessor] \u6C34\u5370\u5E94\u7528\u5931\u8D25\uFF0C\u8DF3\u8FC7\u6C34\u5370:`, error);
+      return sharpInstance;
+    }
+  }
+  /**
+   * 创建文字水印SVG
+   */
+  createTextWatermarkSvg(text, opacity) {
+    const fontSize = 24;
+    const padding = 10;
+    return `
+      <svg width="200" height="50" xmlns="http://www.w3.org/2000/svg">
+        <text
+          x="${padding}"
+          y="${fontSize + padding}"
+          font-family="Arial, sans-serif"
+          font-size="${fontSize}"
+          fill="white"
+          fill-opacity="${opacity}"
+          stroke="black"
+          stroke-width="1"
+          stroke-opacity="${opacity * 0.8}"
+        >
+          ${text}
+        </text>
+      </svg>
+    `.trim();
+  }
+  /**
+   * 获取水印位置对应的gravity值
+   */
+  getWatermarkGravity(position) {
+    const gravityMap = {
+      "top-left": "northwest",
+      "top-right": "northeast",
+      "bottom-left": "southwest",
+      "bottom-right": "southeast",
+      center: "center"
+    };
+    return gravityMap[position] || "southeast";
+  }
+  /**
+   * 确定输出格式
+   */
+  determineOutputFormat(outputPath, requestedFormat) {
+    if (requestedFormat) {
+      return requestedFormat;
+    }
+    const ext = path3.extname(outputPath).toLowerCase();
+    const formatMap = {
+      ".jpg": "jpeg",
+      ".jpeg": "jpeg",
+      ".png": "png",
+      ".webp": "webp",
+      ".avif": "avif"
+    };
+    return formatMap[ext] || "jpeg";
+  }
+  /**
+   * 应用输出设置
+   */
+  applyOutputSettings(sharpInstance, format, quality) {
+    const defaultQuality = 80;
+    const finalQuality = quality || defaultQuality;
+    switch (format) {
+      case "jpeg":
+        return sharpInstance.jpeg({
+          quality: finalQuality,
+          progressive: true,
+          mozjpeg: true
+        });
+      case "png":
+        return sharpInstance.png({
+          quality: finalQuality,
+          progressive: true,
+          compressionLevel: 6
+        });
+      case "webp":
+        return sharpInstance.webp({
+          quality: finalQuality,
+          effort: 4
+        });
+      case "avif":
+        return sharpInstance.avif({
+          quality: finalQuality,
+          effort: 4
+        });
+      default:
+        return sharpInstance.jpeg({ quality: finalQuality });
+    }
+  }
+  /**
+   * 是否需要生成缩略图
+   */
+  shouldGenerateThumbnail(options) {
+    const isSmallImage = options.width && options.width <= 300 || options.height && options.height <= 300;
+    return !isSmallImage;
+  }
+  /**
+   * 生成缩略图
+   */
+  async generateThumbnail(inputPath, outputPath, _options) {
+    try {
+      const thumbnailPath = this.getThumbnailPath(outputPath);
+      const thumbnailSize = 200;
+      await this.sharp(inputPath).resize({
+        width: thumbnailSize,
+        height: thumbnailSize,
+        fit: "cover",
+        position: "center"
+      }).jpeg({ quality: 70 }).toFile(thumbnailPath);
+      logger2.info(`\u{1F5BC}\uFE0F [ImageProcessor] \u7F29\u7565\u56FE\u751F\u6210\u5B8C\u6210: ${thumbnailPath}`);
+      return thumbnailPath;
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F [ImageProcessor] \u7F29\u7565\u56FE\u751F\u6210\u5931\u8D25:`, error);
+      throw error;
+    }
+  }
+  /**
+   * 获取缩略图路径
+   */
+  getThumbnailPath(originalPath) {
+    const ext = path3.extname(originalPath);
+    const basePath = originalPath.replace(ext, "");
+    return `${basePath}_thumb${ext}`;
+  }
+  /**
+   * 创建模拟Sharp对象（开发测试用）
+   */
+  createMockSharp() {
+    logger2.info("\u{1F9EA} [ImageProcessor] \u521B\u5EFA\u6A21\u62DFSharp\u5904\u7406\u5668");
+    const mockSharp = (input) => {
+      logger2.info(`\u{1F9EA} [MockSharp] \u5904\u7406\u56FE\u7247: ${input}`);
+      return {
+        metadata: async () => ({
+          format: "jpeg",
+          width: 1920,
+          height: 1080,
+          channels: 3,
+          density: 72,
+          hasAlpha: false
+        }),
+        resize: (options) => {
+          logger2.info(`\u{1F9EA} [MockSharp] \u8C03\u6574\u5C3A\u5BF8:`, options);
+          return mockSharp(input);
+        },
+        rotate: () => {
+          logger2.info(`\u{1F9EA} [MockSharp] \u81EA\u52A8\u65CB\u8F6C`);
+          return mockSharp(input);
+        },
+        composite: (operations) => {
+          logger2.info(`\u{1F9EA} [MockSharp] \u5408\u6210\u64CD\u4F5C:`, operations.length);
+          return mockSharp(input);
+        },
+        jpeg: (options) => {
+          logger2.info(`\u{1F9EA} [MockSharp] JPEG\u8F93\u51FA:`, options);
+          return mockSharp(input);
+        },
+        png: (options) => {
+          logger2.info(`\u{1F9EA} [MockSharp] PNG\u8F93\u51FA:`, options);
+          return mockSharp(input);
+        },
+        webp: (options) => {
+          logger2.info(`\u{1F9EA} [MockSharp] WebP\u8F93\u51FA:`, options);
+          return mockSharp(input);
+        },
+        avif: (options) => {
+          logger2.info(`\u{1F9EA} [MockSharp] AVIF\u8F93\u51FA:`, options);
+          return mockSharp(input);
+        },
+        toFile: async (outputPath) => {
+          logger2.info(`\u{1F9EA} [MockSharp] \u4FDD\u5B58\u5230\u6587\u4EF6: ${outputPath}`);
+          const outputDir = path3.dirname(outputPath);
+          await promises.mkdir(outputDir, { recursive: true });
+          await promises.writeFile(outputPath, `Mock processed image from ${input}`);
+          return {
+            format: "jpeg",
+            width: 800,
+            height: 600,
+            channels: 3,
+            premultiplied: false,
+            size: 1024 * 50
+            // 50KB
+          };
+        },
+        toBuffer: async () => {
+          logger2.info(`\u{1F9EA} [MockSharp] \u8F6C\u6362\u4E3ABuffer`);
+          return Buffer.from("Mock image buffer");
+        }
+      };
+    };
+    return mockSharp;
+  }
+  /**
+   * 批量图片处理
+   */
+  async batchProcess(inputPaths, outputDir, options, onProgress) {
+    this.ensureInitialized();
+    logger2.info(`\u{1F5BC}\uFE0F [ImageProcessor] \u5F00\u59CB\u6279\u91CF\u5904\u7406 ${inputPaths.length} \u5F20\u56FE\u7247`);
+    const results = [];
+    for (let i = 0; i < inputPaths.length; i++) {
+      const inputPath = inputPaths[i];
+      const fileName = path3.basename(inputPath);
+      const outputPath = path3.join(outputDir, fileName);
+      try {
+        const result = await this.process(inputPath, outputPath, options);
+        results.push(result);
+        if (onProgress) {
+          onProgress(i + 1, inputPaths.length);
+        }
+      } catch (error) {
+        console.error(`\u274C [ImageProcessor] \u6279\u91CF\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+        results.push({
+          success: false,
+          error: `\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+        });
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    logger2.info(`\u2705 [ImageProcessor] \u6279\u91CF\u5904\u7406\u5B8C\u6210\uFF0C\u6210\u529F: ${successCount}/${inputPaths.length}`);
+    return results;
+  }
+};
+var logger3 = createLogger("AudioProcessor");
+var AudioProcessor = class {
+  constructor() {
+    this.type = "audio";
+    this.ffmpeg = null;
+    this.isInitialized = false;
+  }
+  /**
+   * 初始化音频处理器
+   */
+  async initialize() {
+    logger3.info("\u{1F3B5} [AudioProcessor] \u521D\u59CB\u5316\u97F3\u9891\u5904\u7406\u5668...");
+    try {
+      try {
+        this.ffmpeg = __require("fluent-ffmpeg");
+        logger3.info("\u2705 [AudioProcessor] FFmpeg\u5E93\u52A0\u8F7D\u6210\u529F");
+      } catch (error) {
+        console.warn("\u26A0\uFE0F [AudioProcessor] FFmpeg\u5E93\u672A\u5B89\u88C5\uFF0C\u4F7F\u7528\u6A21\u62DF\u6A21\u5F0F");
+        this.ffmpeg = this.createMockFFmpeg();
+      }
+      this.isInitialized = true;
+      logger3.info("\u2705 [AudioProcessor] \u97F3\u9891\u5904\u7406\u5668\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u274C [AudioProcessor] \u97F3\u9891\u5904\u7406\u5668\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 处理音频文件
+   */
+  async process(inputPath, outputPath, options) {
+    this.ensureInitialized();
+    if (options.type !== "audio") {
+      throw new Error("\u5904\u7406\u9009\u9879\u7C7B\u578B\u4E0D\u5339\u914D\uFF1A\u671F\u671B audio");
+    }
+    const audioOptions = options;
+    const startTime = Date.now();
+    logger3.info(`\u{1F3B5} [AudioProcessor] \u5F00\u59CB\u5904\u7406\u97F3\u9891: ${inputPath}`);
+    try {
+      if (!existsSync(inputPath)) {
+        throw new Error(`\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${inputPath}`);
+      }
+      const outputDir = path3.dirname(outputPath);
+      await promises.mkdir(outputDir, { recursive: true });
+      const metadata = await this.getAudioMetadata(inputPath);
+      logger3.info(
+        `\u{1F4CA} [AudioProcessor] \u97F3\u9891\u4FE1\u606F: ${this.formatDuration(metadata.duration)}, ${metadata.bitrate}kbps, ${metadata.sampleRate}Hz`
+      );
+      const outputFormat = this.determineOutputFormat(outputPath, audioOptions.format);
+      await this.processAudio(inputPath, outputPath, audioOptions, outputFormat);
+      const processedStats = await promises.stat(outputPath);
+      const processingTime = Date.now() - startTime;
+      logger3.info(`\u2705 [AudioProcessor] \u97F3\u9891\u5904\u7406\u5B8C\u6210: ${outputPath}, \u8017\u65F6: ${processingTime}ms`);
+      return {
+        success: true,
+        processedPath: outputPath,
+        processedSize: processedStats.size,
+        processingTime,
+        data: {
+          originalSize: metadata.size,
+          processedSize: processedStats.size,
+          compressionRatio: (metadata.size - processedStats.size) / metadata.size,
+          duration: metadata.duration,
+          originalFormat: metadata.format,
+          processedFormat: outputFormat,
+          originalBitrate: metadata.bitrate,
+          processedBitrate: audioOptions.bitrate || metadata.bitrate,
+          sampleRate: audioOptions.sampleRate || metadata.sampleRate,
+          channels: audioOptions.channels || metadata.channels
+        }
+      };
+    } catch (error) {
+      console.error(`\u274C [AudioProcessor] \u97F3\u9891\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+      return {
+        success: false,
+        error: `\u97F3\u9891\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`,
+        processingTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * 检查文件是否支持处理
+   */
+  supports(mimeType) {
+    const supportedTypes = [
+      "audio/mpeg",
+      "audio/mp3",
+      "audio/wav",
+      "audio/wave",
+      "audio/x-wav",
+      "audio/ogg",
+      "audio/vorbis",
+      "audio/aac",
+      "audio/x-aac",
+      "audio/mp4",
+      "audio/m4a",
+      "audio/flac",
+      "audio/x-flac",
+      "audio/webm",
+      "audio/opus"
+    ];
+    return supportedTypes.includes(mimeType.toLowerCase());
+  }
+  /**
+   * 获取音频文件信息
+   */
+  async getFileInfo(filePath) {
+    this.ensureInitialized();
+    try {
+      const metadata = await this.getAudioMetadata(filePath);
+      return {
+        duration: metadata.duration,
+        durationFormatted: this.formatDuration(metadata.duration),
+        bitrate: metadata.bitrate,
+        sampleRate: metadata.sampleRate,
+        channels: metadata.channels,
+        channelsDescription: this.getChannelsDescription(metadata.channels),
+        format: metadata.format,
+        codec: metadata.codec,
+        fileSize: metadata.size,
+        quality: this.getQualityDescription(metadata.bitrate, metadata.sampleRate)
+      };
+    } catch (error) {
+      console.error(`\u274C [AudioProcessor] \u83B7\u53D6\u97F3\u9891\u4FE1\u606F\u5931\u8D25: ${filePath}:`, error);
+      throw error;
+    }
+  }
+  // ============= 私有方法 =============
+  /**
+   * 确保处理器已初始化
+   */
+  ensureInitialized() {
+    if (!this.isInitialized || !this.ffmpeg) {
+      throw new Error("\u97F3\u9891\u5904\u7406\u5668\u672A\u521D\u59CB\u5316");
+    }
+  }
+  /**
+   * 获取音频元数据
+   */
+  async getAudioMetadata(filePath) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ffmpeg.ffprobe(filePath, (err, metadata) => {
+          if (err) {
+            console.error(`\u274C [AudioProcessor] \u83B7\u53D6\u97F3\u9891\u5143\u6570\u636E\u5931\u8D25: ${filePath}:`, err);
+            reject(new Error(`\u65E0\u6CD5\u8BFB\u53D6\u97F3\u9891\u5143\u6570\u636E: ${err.message}`));
+            return;
+          }
+          const audioStream = metadata.streams?.find(
+            (stream) => stream.codec_type === "audio"
+          );
+          if (!audioStream) {
+            reject(new Error("\u6587\u4EF6\u4E2D\u672A\u627E\u5230\u97F3\u9891\u6D41"));
+            return;
+          }
+          const result = {
+            format: metadata.format?.format_name || "unknown",
+            duration: parseFloat(metadata.format?.duration || "0"),
+            bitrate: parseInt(audioStream.bit_rate || "0") / 1e3,
+            // 转换为kbps
+            sampleRate: parseInt(audioStream.sample_rate || "0"),
+            channels: parseInt(audioStream.channels || "0"),
+            codec: audioStream.codec_name || "unknown",
+            size: parseInt(metadata.format?.size || "0")
+          };
+          resolve(result);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 执行音频处理
+   */
+  async processAudio(inputPath, outputPath, options, outputFormat) {
+    return new Promise((resolve, reject) => {
+      try {
+        let command = this.ffmpeg(inputPath);
+        command = this.setAudioCodec(command, outputFormat);
+        if (options.bitrate) {
+          command = command.audioBitrate(options.bitrate);
+          logger3.info(`\u{1F527} [AudioProcessor] \u8BBE\u7F6E\u6BD4\u7279\u7387: ${options.bitrate}kbps`);
+        }
+        if (options.sampleRate) {
+          command = command.audioFrequency(options.sampleRate);
+          logger3.info(`\u{1F527} [AudioProcessor] \u8BBE\u7F6E\u91C7\u6837\u7387: ${options.sampleRate}Hz`);
+        }
+        if (options.channels) {
+          command = command.audioChannels(options.channels);
+          logger3.info(`\u{1F527} [AudioProcessor] \u8BBE\u7F6E\u58F0\u9053\u6570: ${options.channels}`);
+        }
+        command = command.format(outputFormat);
+        command.on("progress", (progress) => {
+          if (progress.percent) {
+            logger3.info(`\u{1F3B5} [AudioProcessor] \u5904\u7406\u8FDB\u5EA6: ${Math.round(progress.percent)}%`);
+          }
+        });
+        command.on("error", (err) => {
+          console.error(`\u274C [AudioProcessor] FFmpeg\u5904\u7406\u9519\u8BEF:`, err);
+          reject(new Error(`\u97F3\u9891\u5904\u7406\u5931\u8D25: ${err.message}`));
+        });
+        command.on("end", () => {
+          logger3.info(`\u2705 [AudioProcessor] FFmpeg\u5904\u7406\u5B8C\u6210: ${outputPath}`);
+          resolve();
+        });
+        command.save(outputPath);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 设置音频编解码器
+   */
+  setAudioCodec(command, format) {
+    switch (format) {
+      case "mp3":
+        return command.audioCodec("libmp3lame");
+      case "aac":
+        return command.audioCodec("aac");
+      case "ogg":
+        return command.audioCodec("libvorbis");
+      case "wav":
+        return command.audioCodec("pcm_s16le");
+      default:
+        return command;
+    }
+  }
+  /**
+   * 确定输出格式
+   */
+  determineOutputFormat(outputPath, requestedFormat) {
+    if (requestedFormat) {
+      return requestedFormat;
+    }
+    const ext = path3.extname(outputPath).toLowerCase();
+    const formatMap = {
+      ".mp3": "mp3",
+      ".wav": "wav",
+      ".ogg": "ogg",
+      ".aac": "aac",
+      ".m4a": "aac"
+    };
+    return formatMap[ext] || "mp3";
+  }
+  /**
+   * 格式化时长显示
+   */
+  formatDuration(seconds) {
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+    return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`;
+  }
+  /**
+   * 获取声道描述
+   */
+  getChannelsDescription(channels) {
+    switch (channels) {
+      case 1:
+        return "\u5355\u58F0\u9053";
+      case 2:
+        return "\u7ACB\u4F53\u58F0";
+      case 6:
+        return "5.1\u73AF\u7ED5\u58F0";
+      case 8:
+        return "7.1\u73AF\u7ED5\u58F0";
+      default:
+        return `${channels}\u58F0\u9053`;
+    }
+  }
+  /**
+   * 获取音质描述
+   */
+  getQualityDescription(bitrate, sampleRate) {
+    if (bitrate >= 320 && sampleRate >= 44100) {
+      return "\u9AD8\u97F3\u8D28";
+    } else if (bitrate >= 192 && sampleRate >= 44100) {
+      return "\u6807\u51C6\u97F3\u8D28";
+    } else if (bitrate >= 128) {
+      return "\u4E00\u822C\u97F3\u8D28";
+    } else {
+      return "\u4F4E\u97F3\u8D28";
+    }
+  }
+  /**
+   * 创建模拟FFmpeg对象（开发测试用）
+   */
+  createMockFFmpeg() {
+    logger3.info("\u{1F9EA} [AudioProcessor] \u521B\u5EFA\u6A21\u62DFFFmpeg\u5904\u7406\u5668");
+    const mockFFmpeg = (input) => {
+      logger3.info(`\u{1F9EA} [MockFFmpeg] \u5904\u7406\u97F3\u9891: ${input}`);
+      return {
+        audioBitrate: (bitrate) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u6BD4\u7279\u7387: ${bitrate}kbps`);
+          return mockFFmpeg(input);
+        },
+        audioFrequency: (sampleRate) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u91C7\u6837\u7387: ${sampleRate}Hz`);
+          return mockFFmpeg(input);
+        },
+        audioChannels: (channels) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u58F0\u9053\u6570: ${channels}`);
+          return mockFFmpeg(input);
+        },
+        audioCodec: (codec) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u7F16\u89E3\u7801\u5668: ${codec}`);
+          return mockFFmpeg(input);
+        },
+        format: (format) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u8F93\u51FA\u683C\u5F0F: ${format}`);
+          return mockFFmpeg(input);
+        },
+        on: (event, callback) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u6CE8\u518C\u4E8B\u4EF6\u76D1\u542C: ${event}`);
+          if (event === "progress") {
+            setTimeout(() => callback({ percent: 50 }), 100);
+            setTimeout(() => callback({ percent: 100 }), 200);
+          } else if (event === "end") {
+            setTimeout(() => callback(), 300);
+          }
+          return mockFFmpeg(input);
+        },
+        save: async (outputPath) => {
+          logger3.info(`\u{1F9EA} [MockFFmpeg] \u4FDD\u5B58\u97F3\u9891\u6587\u4EF6: ${outputPath}`);
+          const outputDir = path3.dirname(outputPath);
+          await promises.mkdir(outputDir, { recursive: true });
+          await promises.writeFile(outputPath, `Mock processed audio from ${input}`);
+        }
+      };
+    };
+    mockFFmpeg.ffprobe = (filePath, callback) => {
+      logger3.info(`\u{1F9EA} [MockFFmpeg] \u83B7\u53D6\u97F3\u9891\u5143\u6570\u636E: ${filePath}`);
+      setTimeout(() => {
+        const mockMetadata = {
+          streams: [
+            {
+              codec_type: "audio",
+              codec_name: "mp3",
+              bit_rate: "128000",
+              sample_rate: "44100",
+              channels: "2"
+            }
+          ],
+          format: {
+            format_name: "mp3",
+            duration: "180.5",
+            size: "1024000"
+          }
+        };
+        callback(null, mockMetadata);
+      }, 100);
+    };
+    return mockFFmpeg;
+  }
+  /**
+   * 批量音频处理
+   */
+  async batchProcess(inputPaths, outputDir, options, onProgress) {
+    this.ensureInitialized();
+    logger3.info(`\u{1F3B5} [AudioProcessor] \u5F00\u59CB\u6279\u91CF\u5904\u7406 ${inputPaths.length} \u4E2A\u97F3\u9891\u6587\u4EF6`);
+    const results = [];
+    for (let i = 0; i < inputPaths.length; i++) {
+      const inputPath = inputPaths[i];
+      const fileName = path3.basename(inputPath);
+      const nameWithoutExt = path3.parse(fileName).name;
+      const outputFormat = options.format || "mp3";
+      const outputPath = path3.join(outputDir, `${nameWithoutExt}.${outputFormat}`);
+      try {
+        const result = await this.process(inputPath, outputPath, options);
+        results.push(result);
+        if (onProgress) {
+          onProgress(i + 1, inputPaths.length);
+        }
+      } catch (error) {
+        console.error(`\u274C [AudioProcessor] \u6279\u91CF\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+        results.push({
+          success: false,
+          error: `\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+        });
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    logger3.info(`\u2705 [AudioProcessor] \u6279\u91CF\u5904\u7406\u5B8C\u6210\uFF0C\u6210\u529F: ${successCount}/${inputPaths.length}`);
+    return results;
+  }
+  /**
+   * 提取音频封面
+   */
+  async extractCover(inputPath, outputPath) {
+    this.ensureInitialized();
+    return new Promise((resolve) => {
+      try {
+        this.ffmpeg(inputPath).outputOptions(["-an", "-vcodec copy"]).on("error", (err) => {
+          console.warn(`\u26A0\uFE0F [AudioProcessor] \u63D0\u53D6\u5C01\u9762\u5931\u8D25: ${err.message}`);
+          resolve(false);
+        }).on("end", () => {
+          logger3.info(`\u{1F5BC}\uFE0F [AudioProcessor] \u97F3\u9891\u5C01\u9762\u63D0\u53D6\u5B8C\u6210: ${outputPath}`);
+          resolve(true);
+        }).save(outputPath);
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F [AudioProcessor] \u63D0\u53D6\u5C01\u9762\u5F02\u5E38:`, error);
+        resolve(false);
+      }
+    });
+  }
+  /**
+   * 音频降噪处理
+   */
+  async denoise(inputPath, outputPath) {
+    this.ensureInitialized();
+    const startTime = Date.now();
+    logger3.info(`\u{1F507} [AudioProcessor] \u5F00\u59CB\u97F3\u9891\u964D\u566A: ${inputPath}`);
+    return new Promise((resolve) => {
+      try {
+        this.ffmpeg(inputPath).audioFilters("highpass=f=200,lowpass=f=3000").on("error", (err) => {
+          resolve({
+            success: false,
+            error: `\u964D\u566A\u5904\u7406\u5931\u8D25: ${err.message}`,
+            processingTime: Date.now() - startTime
+          });
+        }).on("end", async () => {
+          const processedStats = await promises.stat(outputPath);
+          resolve({
+            success: true,
+            processedPath: outputPath,
+            processedSize: processedStats.size,
+            processingTime: Date.now() - startTime,
+            data: {
+              operation: "denoise",
+              filters: "highpass=f=200,lowpass=f=3000"
+            }
+          });
+        }).save(outputPath);
+      } catch (error) {
+        resolve({
+          success: false,
+          error: `\u964D\u566A\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`,
+          processingTime: Date.now() - startTime
+        });
+      }
+    });
+  }
+};
+var logger4 = createLogger("VideoProcessor");
+var VideoProcessor = class {
+  constructor() {
+    this.type = "video";
+    this.ffmpeg = null;
+    this.isInitialized = false;
+  }
+  /**
+   * 初始化视频处理器
+   */
+  async initialize() {
+    logger4.info("\u{1F3AC} [VideoProcessor] \u521D\u59CB\u5316\u89C6\u9891\u5904\u7406\u5668...");
+    try {
+      try {
+        this.ffmpeg = __require("fluent-ffmpeg");
+        logger4.info("\u2705 [VideoProcessor] FFmpeg\u5E93\u52A0\u8F7D\u6210\u529F");
+      } catch (error) {
+        console.warn("\u26A0\uFE0F [VideoProcessor] FFmpeg\u5E93\u672A\u5B89\u88C5\uFF0C\u4F7F\u7528\u6A21\u62DF\u6A21\u5F0F");
+        this.ffmpeg = this.createMockFFmpeg();
+      }
+      this.isInitialized = true;
+      logger4.info("\u2705 [VideoProcessor] \u89C6\u9891\u5904\u7406\u5668\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u274C [VideoProcessor] \u89C6\u9891\u5904\u7406\u5668\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 处理视频文件
+   */
+  async process(inputPath, outputPath, options) {
+    this.ensureInitialized();
+    if (options.type !== "video") {
+      throw new Error("\u5904\u7406\u9009\u9879\u7C7B\u578B\u4E0D\u5339\u914D\uFF1A\u671F\u671B video");
+    }
+    const videoOptions = options;
+    const startTime = Date.now();
+    logger4.info(`\u{1F3AC} [VideoProcessor] \u5F00\u59CB\u5904\u7406\u89C6\u9891: ${inputPath}`);
+    try {
+      if (!existsSync(inputPath)) {
+        throw new Error(`\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${inputPath}`);
+      }
+      const outputDir = path3.dirname(outputPath);
+      await promises.mkdir(outputDir, { recursive: true });
+      const metadata = await this.getVideoMetadata(inputPath);
+      logger4.info(
+        `\u{1F4CA} [VideoProcessor] \u89C6\u9891\u4FE1\u606F: ${metadata.width}x${metadata.height}, ${this.formatDuration(metadata.duration)}, ${metadata.fps}fps`
+      );
+      const outputFormat = this.determineOutputFormat(outputPath, videoOptions.format);
+      await this.processVideo(inputPath, outputPath, videoOptions, outputFormat);
+      let thumbnailPath;
+      if (videoOptions.generateThumbnail !== false) {
+        thumbnailPath = await this.generateThumbnail(
+          inputPath,
+          outputPath,
+          videoOptions.thumbnailTime || 1
+        );
+      }
+      const processedStats = await promises.stat(outputPath);
+      const processingTime = Date.now() - startTime;
+      logger4.info(`\u2705 [VideoProcessor] \u89C6\u9891\u5904\u7406\u5B8C\u6210: ${outputPath}, \u8017\u65F6: ${processingTime}ms`);
+      return {
+        success: true,
+        processedPath: outputPath,
+        processedSize: processedStats.size,
+        thumbnailPath,
+        processingTime,
+        data: {
+          originalSize: metadata.size,
+          processedSize: processedStats.size,
+          compressionRatio: (metadata.size - processedStats.size) / metadata.size,
+          duration: metadata.duration,
+          originalFormat: metadata.format,
+          processedFormat: outputFormat,
+          dimensions: {
+            original: { width: metadata.width, height: metadata.height },
+            processed: { width: metadata.width, height: metadata.height }
+            // 处理后可能会变化
+          },
+          fps: metadata.fps,
+          bitrate: metadata.bitrate
+        }
+      };
+    } catch (error) {
+      console.error(`\u274C [VideoProcessor] \u89C6\u9891\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+      return {
+        success: false,
+        error: `\u89C6\u9891\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`,
+        processingTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * 检查文件是否支持处理
+   */
+  supports(mimeType) {
+    const supportedTypes = [
+      "video/mp4",
+      "video/x-msvideo",
+      // avi
+      "video/quicktime",
+      // mov
+      "video/x-ms-wmv",
+      // wmv
+      "video/webm",
+      "video/ogg",
+      "video/3gpp",
+      // 3gp
+      "video/x-flv",
+      // flv
+      "video/x-matroska"
+      // mkv
+    ];
+    return supportedTypes.includes(mimeType.toLowerCase());
+  }
+  /**
+   * 获取视频文件信息
+   */
+  async getFileInfo(filePath) {
+    this.ensureInitialized();
+    try {
+      const metadata = await this.getVideoMetadata(filePath);
+      return {
+        duration: metadata.duration,
+        durationFormatted: this.formatDuration(metadata.duration),
+        dimensions: {
+          width: metadata.width,
+          height: metadata.height
+        },
+        resolution: this.getResolutionDescription(metadata.width, metadata.height),
+        aspectRatio: metadata.aspectRatio,
+        fps: metadata.fps,
+        bitrate: metadata.bitrate,
+        format: metadata.format,
+        codec: metadata.codec,
+        fileSize: metadata.size,
+        quality: this.getQualityDescription(metadata.width, metadata.height, metadata.bitrate)
+      };
+    } catch (error) {
+      console.error(`\u274C [VideoProcessor] \u83B7\u53D6\u89C6\u9891\u4FE1\u606F\u5931\u8D25: ${filePath}:`, error);
+      throw error;
+    }
+  }
+  // ============= 私有方法 =============
+  /**
+   * 确保处理器已初始化
+   */
+  ensureInitialized() {
+    if (!this.isInitialized || !this.ffmpeg) {
+      throw new Error("\u89C6\u9891\u5904\u7406\u5668\u672A\u521D\u59CB\u5316");
+    }
+  }
+  /**
+   * 获取视频元数据
+   */
+  async getVideoMetadata(filePath) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ffmpeg.ffprobe(filePath, (err, metadata) => {
+          if (err) {
+            console.error(`\u274C [VideoProcessor] \u83B7\u53D6\u89C6\u9891\u5143\u6570\u636E\u5931\u8D25: ${filePath}:`, err);
+            reject(new Error(`\u65E0\u6CD5\u8BFB\u53D6\u89C6\u9891\u5143\u6570\u636E: ${err.message}`));
+            return;
+          }
+          const videoStream = metadata.streams?.find(
+            (stream) => stream.codec_type === "video"
+          );
+          if (!videoStream) {
+            reject(new Error("\u6587\u4EF6\u4E2D\u672A\u627E\u5230\u89C6\u9891\u6D41"));
+            return;
+          }
+          const width = parseInt(videoStream.width || "0");
+          const height = parseInt(videoStream.height || "0");
+          const result = {
+            format: metadata.format?.format_name || "unknown",
+            duration: parseFloat(metadata.format?.duration || "0"),
+            bitrate: parseInt(metadata.format?.bit_rate || "0") / 1e3,
+            // 转换为kbps
+            width,
+            height,
+            fps: this.parseFPS(videoStream.r_frame_rate || "0/1"),
+            codec: videoStream.codec_name || "unknown",
+            size: parseInt(metadata.format?.size || "0"),
+            aspectRatio: width > 0 && height > 0 ? width / height : 16 / 9
+          };
+          resolve(result);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 解析帧率
+   */
+  parseFPS(frameRate) {
+    const parts = frameRate.split("/").map(Number);
+    const numerator = parts[0] || 0;
+    const denominator = parts[1] || 1;
+    return denominator > 0 ? numerator / denominator : 0;
+  }
+  /**
+   * 执行视频处理
+   */
+  async processVideo(inputPath, outputPath, options, outputFormat) {
+    return new Promise((resolve, reject) => {
+      try {
+        let command = this.ffmpeg(inputPath);
+        command = this.setVideoCodec(command, outputFormat);
+        if (options.quality) {
+          command = this.setVideoQuality(command, options.quality);
+          logger4.info(`\u{1F527} [VideoProcessor] \u8BBE\u7F6E\u89C6\u9891\u8D28\u91CF: ${options.quality}`);
+        }
+        command = command.format(outputFormat);
+        command.on("progress", (progress) => {
+          if (progress.percent) {
+            logger4.info(`\u{1F3AC} [VideoProcessor] \u5904\u7406\u8FDB\u5EA6: ${Math.round(progress.percent)}%`);
+          }
+        });
+        command.on("error", (err) => {
+          console.error(`\u274C [VideoProcessor] FFmpeg\u5904\u7406\u9519\u8BEF:`, err);
+          reject(new Error(`\u89C6\u9891\u5904\u7406\u5931\u8D25: ${err.message}`));
+        });
+        command.on("end", () => {
+          logger4.info(`\u2705 [VideoProcessor] FFmpeg\u5904\u7406\u5B8C\u6210: ${outputPath}`);
+          resolve();
+        });
+        command.save(outputPath);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 设置视频编解码器
+   */
+  setVideoCodec(command, format) {
+    switch (format) {
+      case "mp4":
+        return command.videoCodec("libx264").audioCodec("aac");
+      case "webm":
+        return command.videoCodec("libvpx-vp9").audioCodec("libvorbis");
+      case "avi":
+        return command.videoCodec("libx264").audioCodec("mp3");
+      case "mov":
+        return command.videoCodec("libx264").audioCodec("aac");
+      default:
+        return command.videoCodec("libx264").audioCodec("aac");
+    }
+  }
+  /**
+   * 设置视频质量
+   */
+  setVideoQuality(command, quality) {
+    const crf = Math.max(18, Math.min(51, 51 - Math.floor(quality * 0.33)));
+    return command.outputOptions([`-crf ${crf}`]);
+  }
+  /**
+   * 确定输出格式
+   */
+  determineOutputFormat(outputPath, requestedFormat) {
+    if (requestedFormat) {
+      return requestedFormat;
+    }
+    const ext = path3.extname(outputPath).toLowerCase();
+    const formatMap = {
+      ".mp4": "mp4",
+      ".avi": "avi",
+      ".mov": "mov",
+      ".webm": "webm"
+    };
+    return formatMap[ext] || "mp4";
+  }
+  /**
+   * 生成缩略图
+   */
+  async generateThumbnail(inputPath, outputPath, timeOffset) {
+    return new Promise((resolve, reject) => {
+      try {
+        const thumbnailPath = this.getThumbnailPath(outputPath);
+        this.ffmpeg(inputPath).seekInput(timeOffset).frames(1).size("320x240").on("error", (err) => {
+          console.warn(`\u26A0\uFE0F [VideoProcessor] \u7F29\u7565\u56FE\u751F\u6210\u5931\u8D25: ${err.message}`);
+          reject(err);
+        }).on("end", () => {
+          logger4.info(`\u{1F5BC}\uFE0F [VideoProcessor] \u89C6\u9891\u7F29\u7565\u56FE\u751F\u6210\u5B8C\u6210: ${thumbnailPath}`);
+          resolve(thumbnailPath);
+        }).save(thumbnailPath);
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F [VideoProcessor] \u7F29\u7565\u56FE\u751F\u6210\u5F02\u5E38:`, error);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 获取缩略图路径
+   */
+  getThumbnailPath(originalPath) {
+    const ext = path3.extname(originalPath);
+    const basePath = originalPath.replace(ext, "");
+    return `${basePath}_thumb.jpg`;
+  }
+  /**
+   * 格式化时长显示
+   */
+  formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+    if (hours > 0) {
+      return `${hours}:${minutes.toString().padStart(2, "0")}:${remainingSeconds.toString().padStart(2, "0")}`;
+    } else {
+      return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`;
+    }
+  }
+  /**
+   * 获取分辨率描述
+   */
+  getResolutionDescription(width, height) {
+    if (width >= 3840 && height >= 2160) {
+      return "4K UHD";
+    } else if (width >= 1920 && height >= 1080) {
+      return "1080p Full HD";
+    } else if (width >= 1280 && height >= 720) {
+      return "720p HD";
+    } else if (width >= 640 && height >= 480) {
+      return "480p SD";
+    } else {
+      return `${width}x${height}`;
+    }
+  }
+  /**
+   * 获取视频质量描述
+   */
+  getQualityDescription(width, height, bitrate) {
+    const pixels = width * height;
+    const bitratePerPixel = bitrate / pixels * 1e3;
+    if (pixels >= 1920 * 1080 && bitratePerPixel >= 0.1) {
+      return "\u9AD8\u6E05";
+    } else if (pixels >= 1280 * 720 && bitratePerPixel >= 0.05) {
+      return "\u6807\u6E05";
+    } else if (bitratePerPixel >= 0.02) {
+      return "\u4E00\u822C";
+    } else {
+      return "\u4F4E\u8D28\u91CF";
+    }
+  }
+  /**
+   * 创建模拟FFmpeg对象（开发测试用）
+   */
+  createMockFFmpeg() {
+    logger4.info("\u{1F9EA} [VideoProcessor] \u521B\u5EFA\u6A21\u62DFFFmpeg\u5904\u7406\u5668");
+    const mockFFmpeg = (input) => {
+      logger4.info(`\u{1F9EA} [MockFFmpeg] \u5904\u7406\u89C6\u9891: ${input}`);
+      return {
+        videoCodec: (codec) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u89C6\u9891\u7F16\u89E3\u7801\u5668: ${codec}`);
+          return mockFFmpeg(input);
+        },
+        audioCodec: (codec) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u97F3\u9891\u7F16\u89E3\u7801\u5668: ${codec}`);
+          return mockFFmpeg(input);
+        },
+        format: (format) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u8F93\u51FA\u683C\u5F0F: ${format}`);
+          return mockFFmpeg(input);
+        },
+        outputOptions: (options) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u8F93\u51FA\u9009\u9879:`, options);
+          return mockFFmpeg(input);
+        },
+        seekInput: (time) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8DF3\u8F6C\u5230\u65F6\u95F4: ${time}s`);
+          return mockFFmpeg(input);
+        },
+        frames: (count) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u63D0\u53D6\u5E27\u6570: ${count}`);
+          return mockFFmpeg(input);
+        },
+        size: (size) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u8BBE\u7F6E\u5C3A\u5BF8: ${size}`);
+          return mockFFmpeg(input);
+        },
+        on: (event, callback) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u6CE8\u518C\u4E8B\u4EF6\u76D1\u542C: ${event}`);
+          if (event === "progress") {
+            setTimeout(() => callback({ percent: 25 }), 100);
+            setTimeout(() => callback({ percent: 50 }), 200);
+            setTimeout(() => callback({ percent: 75 }), 300);
+            setTimeout(() => callback({ percent: 100 }), 400);
+          } else if (event === "end") {
+            setTimeout(() => callback(), 500);
+          }
+          return mockFFmpeg(input);
+        },
+        save: async (outputPath) => {
+          logger4.info(`\u{1F9EA} [MockFFmpeg] \u4FDD\u5B58\u89C6\u9891\u6587\u4EF6: ${outputPath}`);
+          const outputDir = path3.dirname(outputPath);
+          await promises.mkdir(outputDir, { recursive: true });
+          await promises.writeFile(outputPath, `Mock processed video from ${input}`);
+        }
+      };
+    };
+    mockFFmpeg.ffprobe = (filePath, callback) => {
+      logger4.info(`\u{1F9EA} [MockFFmpeg] \u83B7\u53D6\u89C6\u9891\u5143\u6570\u636E: ${filePath}`);
+      setTimeout(() => {
+        const mockMetadata = {
+          streams: [
+            {
+              codec_type: "video",
+              codec_name: "h264",
+              width: "1920",
+              height: "1080",
+              r_frame_rate: "30/1"
+            }
+          ],
+          format: {
+            format_name: "mp4",
+            duration: "300.0",
+            size: "50000000",
+            bit_rate: "1000000"
+          }
+        };
+        callback(null, mockMetadata);
+      }, 100);
+    };
+    return mockFFmpeg;
+  }
+  /**
+   * 批量视频处理
+   */
+  async batchProcess(inputPaths, outputDir, options, onProgress) {
+    this.ensureInitialized();
+    logger4.info(`\u{1F3AC} [VideoProcessor] \u5F00\u59CB\u6279\u91CF\u5904\u7406 ${inputPaths.length} \u4E2A\u89C6\u9891\u6587\u4EF6`);
+    const results = [];
+    for (let i = 0; i < inputPaths.length; i++) {
+      const inputPath = inputPaths[i];
+      const fileName = path3.basename(inputPath);
+      const nameWithoutExt = path3.parse(fileName).name;
+      const outputFormat = options.format || "mp4";
+      const outputPath = path3.join(outputDir, `${nameWithoutExt}.${outputFormat}`);
+      try {
+        const result = await this.process(inputPath, outputPath, options);
+        results.push(result);
+        if (onProgress) {
+          onProgress(i + 1, inputPaths.length);
+        }
+      } catch (error) {
+        console.error(`\u274C [VideoProcessor] \u6279\u91CF\u5904\u7406\u5931\u8D25: ${inputPath}:`, error);
+        results.push({
+          success: false,
+          error: `\u5904\u7406\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+        });
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    logger4.info(`\u2705 [VideoProcessor] \u6279\u91CF\u5904\u7406\u5B8C\u6210\uFF0C\u6210\u529F: ${successCount}/${inputPaths.length}`);
+    return results;
+  }
+  /**
+   * 提取视频帧
+   */
+  async extractFrames(inputPath, outputDir, options = {}) {
+    this.ensureInitialized();
+    const { count = 10, interval, format = "jpg" } = options;
+    logger4.info(`\u{1F5BC}\uFE0F [VideoProcessor] \u63D0\u53D6\u89C6\u9891\u5E27: ${inputPath}, \u6570\u91CF: ${count}`);
+    return new Promise((resolve, reject) => {
+      try {
+        let command = this.ffmpeg(inputPath);
+        if (interval) {
+          command = command.outputOptions([`-vf fps=1/${interval}`]);
+        } else {
+          command = command.frames(count);
+        }
+        const outputPattern = path3.join(outputDir, `frame_%03d.${format}`);
+        command.on("error", (err) => {
+          console.error(`\u274C [VideoProcessor] \u63D0\u53D6\u5E27\u5931\u8D25:`, err);
+          reject(new Error(`\u63D0\u53D6\u5E27\u5931\u8D25: ${err.message}`));
+        }).on("end", async () => {
+          try {
+            const files = await promises.readdir(outputDir);
+            const frameFiles = files.filter((file) => file.startsWith("frame_") && file.endsWith(`.${format}`)).sort().map((file) => path3.join(outputDir, file));
+            logger4.info(`\u2705 [VideoProcessor] \u5E27\u63D0\u53D6\u5B8C\u6210\uFF0C\u5171 ${frameFiles.length} \u5E27`);
+            resolve(frameFiles);
+          } catch (error) {
+            reject(error);
+          }
+        }).save(outputPattern);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 视频压缩
+   */
+  async compress(inputPath, outputPath, compressionLevel = "medium") {
+    this.ensureInitialized();
+    logger4.info(`\u{1F5DC}\uFE0F [VideoProcessor] \u5F00\u59CB\u89C6\u9891\u538B\u7F29: ${inputPath}, \u7EA7\u522B: ${compressionLevel}`);
+    const options = {
+      type: "video",
+      quality: this.getCompressionQuality(compressionLevel),
+      format: "mp4"
+    };
+    return this.process(inputPath, outputPath, options);
+  }
+  /**
+   * 获取压缩质量
+   */
+  getCompressionQuality(level) {
+    switch (level) {
+      case "low":
+        return 30;
+      case "medium":
+        return 60;
+      case "high":
+        return 85;
+      default:
+        return 60;
+    }
+  }
+};
+var logger5 = createLogger("ProcessingQueue");
+var ProcessingQueue = class extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.tasks = /* @__PURE__ */ new Map();
+    this.runningTasks = /* @__PURE__ */ new Set();
+    this.processors = /* @__PURE__ */ new Map();
+    this.isStarted = false;
+    this.processInterval = null;
+    this.options = {
+      maxConcurrentTasks: options.maxConcurrentTasks || 3,
+      maxRetries: options.maxRetries || 2,
+      retryDelay: options.retryDelay || 5e3,
+      taskTimeout: options.taskTimeout || 3e5,
+      // 5分钟
+      autoStart: options.autoStart !== false
+    };
+    logger5.info("\u{1F4CB} [ProcessingQueue] \u961F\u5217\u7BA1\u7406\u5668\u5DF2\u521B\u5EFA");
+    if (this.options.autoStart) {
+      this.start();
+    }
+  }
+  /**
+   * 注册文件处理器
+   */
+  registerProcessor(processor) {
+    this.processors.set(processor.type, processor);
+    logger5.info(`\u{1F527} [ProcessingQueue] \u6CE8\u518C\u5904\u7406\u5668: ${processor.type}`);
+  }
+  /**
+   * 添加任务到队列
+   */
+  addTask(inputPath, outputPath, options, taskOptions = {}) {
+    const taskId = this.generateTaskId();
+    const task = {
+      id: taskId,
+      inputPath,
+      outputPath,
+      options,
+      priority: taskOptions.priority || "normal",
+      status: "pending",
+      retries: 0,
+      maxRetries: taskOptions.maxRetries || this.options.maxRetries,
+      onProgress: taskOptions.onProgress,
+      onComplete: taskOptions.onComplete,
+      onError: taskOptions.onError
+    };
+    const processor = this.processors.get(options.type);
+    if (!processor) {
+      throw new Error(`\u672A\u627E\u5230\u7C7B\u578B\u4E3A ${options.type} \u7684\u6587\u4EF6\u5904\u7406\u5668`);
+    }
+    task.processor = processor;
+    this.tasks.set(taskId, task);
+    logger5.info(`\u{1F4DD} [ProcessingQueue] \u6DFB\u52A0\u4EFB\u52A1: ${taskId} (${inputPath})`);
+    this.emit("taskAdded", task);
+    if (this.isStarted) {
+      this.processNext();
+    }
+    return taskId;
+  }
+  /**
+   * 启动队列处理
+   */
+  start() {
+    if (this.isStarted) {
+      console.warn("\u26A0\uFE0F [ProcessingQueue] \u961F\u5217\u5DF2\u7ECF\u542F\u52A8");
+      return;
+    }
+    this.isStarted = true;
+    logger5.info("\u25B6\uFE0F [ProcessingQueue] \u542F\u52A8\u961F\u5217\u5904\u7406");
+    this.processInterval = setInterval(() => {
+      this.processNext();
+    }, 1e3);
+    this.emit("started");
+    this.processNext();
+  }
+  /**
+   * 停止队列处理
+   */
+  stop() {
+    if (!this.isStarted) {
+      console.warn("\u26A0\uFE0F [ProcessingQueue] \u961F\u5217\u672A\u542F\u52A8");
+      return;
+    }
+    this.isStarted = false;
+    if (this.processInterval) {
+      clearInterval(this.processInterval);
+      this.processInterval = null;
+    }
+    logger5.info("\u23F9\uFE0F [ProcessingQueue] \u505C\u6B62\u961F\u5217\u5904\u7406");
+    this.emit("stopped");
+  }
+  /**
+   * 暂停任务
+   */
+  pauseTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      console.warn(`\u26A0\uFE0F [ProcessingQueue] \u4EFB\u52A1\u4E0D\u5B58\u5728: ${taskId}`);
+      return false;
+    }
+    if (task.status === "running") {
+      console.warn(`\u26A0\uFE0F [ProcessingQueue] \u65E0\u6CD5\u6682\u505C\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1: ${taskId}`);
+      return false;
+    }
+    task.status = "cancelled";
+    logger5.info(`\u23F8\uFE0F [ProcessingQueue] \u6682\u505C\u4EFB\u52A1: ${taskId}`);
+    this.emit("taskCancelled", task);
+    return true;
+  }
+  /**
+   * 取消任务
+   */
+  cancelTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      console.warn(`\u26A0\uFE0F [ProcessingQueue] \u4EFB\u52A1\u4E0D\u5B58\u5728: ${taskId}`);
+      return false;
+    }
+    if (task.status === "running") {
+      console.warn(`\u26A0\uFE0F [ProcessingQueue] \u65E0\u6CD5\u53D6\u6D88\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1: ${taskId}`);
+      return false;
+    }
+    task.status = "cancelled";
+    logger5.info(`\u274C [ProcessingQueue] \u53D6\u6D88\u4EFB\u52A1: ${taskId}`);
+    this.emit("taskCancelled", task);
+    return true;
+  }
+  /**
+   * 获取任务状态
+   */
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * 获取所有任务
+   */
+  getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+  /**
+   * 获取待处理任务
+   */
+  getPendingTasks() {
+    return Array.from(this.tasks.values()).filter((task) => task.status === "pending");
+  }
+  /**
+   * 获取正在运行的任务
+   */
+  getRunningTasks() {
+    return Array.from(this.tasks.values()).filter((task) => task.status === "running");
+  }
+  /**
+   * 获取队列统计信息
+   */
+  getStats() {
+    const allTasks = Array.from(this.tasks.values());
+    const completedTasks = allTasks.filter((task) => task.status === "completed");
+    const totalProcessingTime = completedTasks.reduce((sum, task) => {
+      if (task.startTime && task.endTime) {
+        return sum + (task.endTime - task.startTime);
+      }
+      return sum;
+    }, 0);
+    return {
+      totalTasks: allTasks.length,
+      pendingTasks: allTasks.filter((task) => task.status === "pending").length,
+      runningTasks: allTasks.filter((task) => task.status === "running").length,
+      completedTasks: allTasks.filter((task) => task.status === "completed").length,
+      failedTasks: allTasks.filter((task) => task.status === "failed").length,
+      cancelledTasks: allTasks.filter((task) => task.status === "cancelled").length,
+      averageProcessingTime: completedTasks.length > 0 ? totalProcessingTime / completedTasks.length : 0,
+      successRate: allTasks.length > 0 ? completedTasks.length / allTasks.length : 0
+    };
+  }
+  /**
+   * 清理已完成的任务
+   */
+  cleanup() {
+    const beforeCount = this.tasks.size;
+    for (const [taskId, task] of Array.from(this.tasks.entries())) {
+      if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") {
+        this.tasks.delete(taskId);
+      }
+    }
+    const afterCount = this.tasks.size;
+    const cleanedCount = beforeCount - afterCount;
+    logger5.info(`\u{1F9F9} [ProcessingQueue] \u6E05\u7406\u5B8C\u6210\uFF0C\u79FB\u9664 ${cleanedCount} \u4E2A\u4EFB\u52A1`);
+    this.emit("cleanup", { cleaned: cleanedCount, remaining: afterCount });
+  }
+  // ============= 私有方法 =============
+  /**
+   * 处理下一个任务
+   */
+  async processNext() {
+    if (!this.isStarted) {
+      return;
+    }
+    if (this.runningTasks.size >= this.options.maxConcurrentTasks) {
+      return;
+    }
+    const nextTask = this.getNextTask();
+    if (!nextTask) {
+      return;
+    }
+    await this.processTask(nextTask);
+  }
+  /**
+   * 获取下一个待处理任务（按优先级排序）
+   */
+  getNextTask() {
+    const pendingTasks = this.getPendingTasks();
+    if (pendingTasks.length === 0) {
+      return null;
+    }
+    const priorityOrder = {
+      urgent: 4,
+      high: 3,
+      normal: 2,
+      low: 1
+    };
+    pendingTasks.sort((a, b) => {
+      const priorityDiff = priorityOrder[b.priority] - priorityOrder[a.priority];
+      if (priorityDiff !== 0) {
+        return priorityDiff;
+      }
+      return 0;
+    });
+    return pendingTasks[0] || null;
+  }
+  /**
+   * 处理单个任务
+   */
+  async processTask(task) {
+    if (!task.processor) {
+      this.failTask(task, "\u672A\u627E\u5230\u5BF9\u5E94\u7684\u6587\u4EF6\u5904\u7406\u5668");
+      return;
+    }
+    logger5.info(`\u{1F680} [ProcessingQueue] \u5F00\u59CB\u5904\u7406\u4EFB\u52A1: ${task.id}`);
+    task.status = "running";
+    task.startTime = Date.now();
+    this.runningTasks.add(task.id);
+    this.emit("taskStarted", task);
+    const timeoutId = setTimeout(() => {
+      if (task.status === "running") {
+        this.failTask(task, "\u4EFB\u52A1\u5904\u7406\u8D85\u65F6");
+      }
+    }, this.options.taskTimeout);
+    try {
+      const result = await task.processor.process(task.inputPath, task.outputPath, task.options);
+      clearTimeout(timeoutId);
+      if (result.success) {
+        this.completeTask(task, result);
+      } else {
+        this.retryOrFailTask(task, result.error || "\u5904\u7406\u5931\u8D25");
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      const errorMessage = error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF";
+      this.retryOrFailTask(task, errorMessage);
+    }
+  }
+  /**
+   * 完成任务
+   */
+  completeTask(task, result) {
+    task.status = "completed";
+    task.endTime = Date.now();
+    task.result = result;
+    this.runningTasks.delete(task.id);
+    logger5.info(`\u2705 [ProcessingQueue] \u4EFB\u52A1\u5B8C\u6210: ${task.id}`);
+    if (task.onComplete) {
+      try {
+        task.onComplete(task, result);
+      } catch (error) {
+        console.error("\u274C [ProcessingQueue] \u4EFB\u52A1\u5B8C\u6210\u56DE\u8C03\u9519\u8BEF:", error);
+      }
+    }
+    this.emit("taskCompleted", task, result);
+    setTimeout(() => this.processNext(), 0);
+  }
+  /**
+   * 重试或失败任务
+   */
+  retryOrFailTask(task, error) {
+    this.runningTasks.delete(task.id);
+    if (task.retries < task.maxRetries) {
+      task.retries++;
+      task.status = "pending";
+      task.error = void 0;
+      logger5.info(`\u{1F504} [ProcessingQueue] \u91CD\u8BD5\u4EFB\u52A1: ${task.id} (${task.retries}/${task.maxRetries})`);
+      this.emit("taskRetried", task);
+      setTimeout(() => {
+        if (this.isStarted) {
+          this.processNext();
+        }
+      }, this.options.retryDelay);
+    } else {
+      this.failTask(task, error);
+    }
+  }
+  /**
+   * 失败任务
+   */
+  failTask(task, error) {
+    task.status = "failed";
+    task.endTime = Date.now();
+    task.error = error;
+    this.runningTasks.delete(task.id);
+    console.error(`\u274C [ProcessingQueue] \u4EFB\u52A1\u5931\u8D25: ${task.id} - ${error}`);
+    if (task.onError) {
+      try {
+        task.onError(task, error);
+      } catch (callbackError) {
+        console.error("\u274C [ProcessingQueue] \u4EFB\u52A1\u5931\u8D25\u56DE\u8C03\u9519\u8BEF:", callbackError);
+      }
+    }
+    this.emit("taskFailed", task, error);
+    setTimeout(() => this.processNext(), 0);
+  }
+  /**
+   * 生成唯一任务ID
+   */
+  generateTaskId() {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * 批量添加任务
+   */
+  addBatchTasks(tasks, onBatchProgress, onBatchComplete) {
+    const taskIds = [];
+    const results = /* @__PURE__ */ new Map();
+    let completedCount = 0;
+    logger5.info(`\u{1F4E6} [ProcessingQueue] \u6279\u91CF\u6DFB\u52A0 ${tasks.length} \u4E2A\u4EFB\u52A1`);
+    for (const taskSpec of tasks) {
+      const taskId = this.addTask(taskSpec.inputPath, taskSpec.outputPath, taskSpec.options, {
+        priority: taskSpec.priority,
+        onComplete: (task, result) => {
+          results.set(task.id, result);
+          completedCount++;
+          if (onBatchProgress) {
+            onBatchProgress(completedCount, tasks.length);
+          }
+          if (completedCount === tasks.length && onBatchComplete) {
+            onBatchComplete(results);
+          }
+        },
+        onError: (task, error) => {
+          results.set(task.id, { success: false, error });
+          completedCount++;
+          if (onBatchProgress) {
+            onBatchProgress(completedCount, tasks.length);
+          }
+          if (completedCount === tasks.length && onBatchComplete) {
+            onBatchComplete(results);
+          }
+        }
+      });
+      taskIds.push(taskId);
+    }
+    return taskIds;
+  }
+  /**
+   * 获取队列健康状态
+   */
+  getHealthStatus() {
+    const stats = this.getStats();
+    const issues = [];
+    const recommendations = [];
+    if (stats.successRate < 0.8 && stats.totalTasks > 10) {
+      issues.push(`\u6210\u529F\u7387\u8FC7\u4F4E: ${(stats.successRate * 100).toFixed(1)}%`);
+      recommendations.push("\u68C0\u67E5\u6587\u4EF6\u5904\u7406\u5668\u914D\u7F6E\u548C\u8F93\u5165\u6587\u4EF6\u8D28\u91CF");
+    }
+    if (stats.pendingTasks > 50) {
+      issues.push(`\u5F85\u5904\u7406\u4EFB\u52A1\u79EF\u538B: ${stats.pendingTasks} \u4E2A`);
+      recommendations.push("\u8003\u8651\u589E\u52A0\u5E76\u53D1\u5904\u7406\u6570\u6216\u4F18\u5316\u5904\u7406\u6027\u80FD");
+    }
+    if (stats.averageProcessingTime > 6e4) {
+      issues.push(`\u5E73\u5747\u5904\u7406\u65F6\u95F4\u8FC7\u957F: ${(stats.averageProcessingTime / 1e3).toFixed(1)}\u79D2`);
+      recommendations.push("\u4F18\u5316\u6587\u4EF6\u5904\u7406\u903B\u8F91\u6216\u51CF\u5C11\u5904\u7406\u590D\u6742\u5EA6");
+    }
+    return {
+      isHealthy: issues.length === 0,
+      issues,
+      recommendations
+    };
+  }
+};
+var MIME_TYPES = {
+  // 图片
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  // 视频
+  ".mp4": "video/mp4",
+  ".avi": "video/x-msvideo",
+  ".mov": "video/quicktime",
+  ".wmv": "video/x-ms-wmv",
+  ".flv": "video/x-flv",
+  ".mkv": "video/x-matroska",
+  ".webm": "video/webm",
+  // 音频
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  // 文档
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".txt": "text/plain",
+  ".rtf": "application/rtf",
+  // 压缩文件
+  ".zip": "application/zip",
+  ".rar": "application/x-rar-compressed",
+  ".7z": "application/x-7z-compressed",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  // 代码文件
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".ts": "application/typescript",
+  // 其他
+  ".csv": "text/csv",
+  ".md": "text/markdown"
+};
+function getMimeType(filename) {
+  const ext = path3.extname(filename).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+var logger6 = createLogger("UniversalFileService");
+var UniversalFileService = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.storageProviders = /* @__PURE__ */ new Map();
+    this.cdnProviders = /* @__PURE__ */ new Map();
+    this.fileProcessors = /* @__PURE__ */ new Map();
+    this.uploadProgressMap = /* @__PURE__ */ new Map();
+    this.metadataCache = /* @__PURE__ */ new Map();
+    this.urlCache = /* @__PURE__ */ new Map();
+    this.processingQueue = [];
+    this.isProcessingQueueRunning = false;
+    this.config = config;
+    if (this.config.persistence?.enabled && this.config.persistence.repository) {
+      this.setupPersistenceListeners();
+    }
+  }
+  // ============= 持久化设置 =============
+  /**
+   * 设置数据库持久化监听器
+   *
+   * 当文件上传完成或删除时，自动触发数据库操作
+   */
+  setupPersistenceListeners() {
+    const { repository, autoPersist = true } = this.config.persistence;
+    if (!autoPersist) {
+      logger6.info("\u2699\uFE0F [UniversalFileService] \u81EA\u52A8\u6301\u4E45\u5316\u5DF2\u7981\u7528");
+      return;
+    }
+    logger6.info("\u2705 [UniversalFileService] \u5DF2\u542F\u7528\u6570\u636E\u5E93\u6301\u4E45\u5316\uFF0C\u81EA\u52A8\u76D1\u542C\u6587\u4EF6\u4E8B\u4EF6");
+    this.on("upload:complete", async (fileId, data) => {
+      try {
+        const metadata = data.metadata || data;
+        await repository.save(metadata);
+        logger6.info(`\u{1F4BE} [Persistence] \u6587\u4EF6\u5143\u6570\u636E\u5DF2\u81EA\u52A8\u4FDD\u5B58: ${fileId}`);
+      } catch (error) {
+        logger6.error(`\u274C [Persistence] \u4FDD\u5B58\u5931\u8D25: ${fileId}`, error);
+      }
+    });
+    this.on("file:deleted", async (fileId) => {
+      try {
+        await repository.delete(fileId);
+        logger6.info(`\u{1F5D1}\uFE0F [Persistence] \u6587\u4EF6\u5143\u6570\u636E\u5DF2\u81EA\u52A8\u5220\u9664: ${fileId}`);
+      } catch (error) {
+        logger6.error(`\u274C [Persistence] \u5220\u9664\u5931\u8D25: ${fileId}`, error);
+      }
+    });
+    this.on("files:batch-deleted", async (fileIds) => {
+      try {
+        await repository.batchDelete(fileIds);
+        logger6.info(`\u{1F5D1}\uFE0F [Persistence] \u6279\u91CF\u5220\u9664\u5143\u6570\u636E: ${fileIds.length} \u4E2A\u6587\u4EF6`);
+      } catch (error) {
+        logger6.error(`\u274C [Persistence] \u6279\u91CF\u5220\u9664\u5931\u8D25`, error);
+      }
+    });
+  }
+  // ============= 初始化方法 =============
+  /**
+   * 初始化文件服务
+   */
+  async initialize() {
+    logger6.info("\u{1F680} [UniversalFileService] \u5F00\u59CB\u521D\u59CB\u5316\u6587\u4EF6\u670D\u52A1...");
+    try {
+      await this.initializeStorageProviders();
+      await this.initializeCDNProviders();
+      await this.initializeFileProcessors();
+      logger6.info("\u2705 [UniversalFileService] \u6587\u4EF6\u670D\u52A1\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u274C [UniversalFileService] \u6587\u4EF6\u670D\u52A1\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 重新初始化存储提供者（支持配置热更新）
+   */
+  async reinitializeStorageProviders() {
+    logger6.info("\u{1F504} [UniversalFileService] \u91CD\u65B0\u521D\u59CB\u5316\u5B58\u50A8\u63D0\u4F9B\u8005...");
+    try {
+      const ossConfig = this.config.storageProviders["aliyun-oss"];
+      if (ossConfig && ossConfig.enabled) {
+        const ossProvider = this.storageProviders.get("aliyun-oss");
+        if (ossProvider && "reinitialize" in ossProvider) {
+          logger6.info("\u{1F504} [UniversalFileService] \u91CD\u65B0\u521D\u59CB\u5316\u963F\u91CC\u4E91OSS\u63D0\u4F9B\u8005...");
+          await ossProvider.reinitialize(ossConfig);
+        }
+      }
+      logger6.info("\u2705 [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005\u91CD\u65B0\u521D\u59CB\u5316\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u274C [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005\u91CD\u65B0\u521D\u59CB\u5316\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 注册存储提供者
+   */
+  registerStorageProvider(provider) {
+    this.storageProviders.set(provider.type, provider);
+    logger6.info(`\u{1F4E6} [UniversalFileService] \u6CE8\u518C\u5B58\u50A8\u63D0\u4F9B\u8005: ${provider.type}`);
+  }
+  /**
+   * 注册CDN提供者
+   */
+  registerCDNProvider(provider) {
+    this.cdnProviders.set(provider.type, provider);
+    logger6.info(`\u{1F310} [UniversalFileService] \u6CE8\u518CCDN\u63D0\u4F9B\u8005: ${provider.type}`);
+  }
+  /**
+   * 注册文件处理器
+   */
+  registerFileProcessor(processor) {
+    this.fileProcessors.set(processor.type, processor);
+    logger6.info(`\u2699\uFE0F [UniversalFileService] \u6CE8\u518C\u6587\u4EF6\u5904\u7406\u5668: ${processor.type}`);
+  }
+  // ============= 核心文件操作方法 =============
+  /**
+   * 上传文件
+   */
+  async uploadFile(fileInfo, storageType, onProgress) {
+    const fileId = v4();
+    const startTime = Date.now();
+    logger6.info(`\u{1F4E4} [UniversalFileService] \u5F00\u59CB\u4E0A\u4F20\u6587\u4EF6: ${fileInfo.file.name}, ID: ${fileId}`);
+    try {
+      await this.validateFile(fileInfo.file);
+      const progress = {
+        fileId,
+        status: "pending",
+        progress: 0,
+        uploadedBytes: 0,
+        totalBytes: fileInfo.file.size,
+        speed: 0,
+        remainingTime: 0
+      };
+      this.uploadProgressMap.set(fileId, progress);
+      this.emitFileEvent("upload:start", fileId, { fileName: fileInfo.file.name });
+      const metadata = await this.generateFileMetadata(fileId, fileInfo);
+      const selectedStorageType = storageType || this.config.defaultStorage;
+      let storageProvider = this.storageProviders.get(selectedStorageType);
+      if (!storageProvider) {
+        logger6.info(
+          `\u26A0\uFE0F [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005 ${selectedStorageType} \u4E0D\u53EF\u7528\uFF0C\u5C1D\u8BD5\u4F7F\u7528OSS`
+        );
+        storageProvider = this.storageProviders.get("aliyun-oss");
+        if (!storageProvider) {
+          logger6.info(`\u26A0\uFE0F [UniversalFileService] OSS\u4E0D\u53EF\u7528\uFF0C\u56DE\u9000\u5230\u672C\u5730\u5B58\u50A8`);
+          storageProvider = this.storageProviders.get("local");
+        }
+      }
+      if (!storageProvider) {
+        throw new StorageProviderError(`\u6CA1\u6709\u53EF\u7528\u7684\u5B58\u50A8\u63D0\u4F9B\u8005`);
+      }
+      const storagePath = this.generateStoragePath(metadata);
+      progress.status = "uploading";
+      progress.progress = 10;
+      this.uploadProgressMap.set(fileId, progress);
+      onProgress?.(progress);
+      this.emitFileEvent("upload:progress", fileId, { progress: progress.progress });
+      const uploadResult = await storageProvider.upload(fileInfo, storagePath);
+      if (!uploadResult.success) {
+        throw new FileUploadError(`\u4E0A\u4F20\u5931\u8D25: ${uploadResult.error}`);
+      }
+      metadata.storagePath = uploadResult.path || storagePath;
+      metadata.storageProvider = selectedStorageType;
+      if (this.config.defaultCDN !== "none") {
+        const cdnProvider = this.cdnProviders.get(this.config.defaultCDN);
+        if (cdnProvider && uploadResult.url) {
+          metadata.cdnUrl = await cdnProvider.generateUrl(uploadResult.url);
+        }
+      }
+      progress.status = fileInfo.needsProcessing ? "processing" : "completed";
+      progress.progress = fileInfo.needsProcessing ? 70 : 100;
+      this.uploadProgressMap.set(fileId, progress);
+      onProgress?.(progress);
+      if (fileInfo.needsProcessing && fileInfo.processingOptions) {
+        await this.queueFileProcessing(metadata, fileInfo.processingOptions);
+      }
+      this.cacheMetadata(metadata);
+      progress.status = "completed";
+      progress.progress = 100;
+      this.uploadProgressMap.set(fileId, progress);
+      onProgress?.(progress);
+      const uploadTime = Date.now() - startTime;
+      logger6.info(`\u2705 [UniversalFileService] \u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210: ${fileId}, \u8017\u65F6: ${uploadTime}ms`);
+      this.emitFileEvent("upload:complete", fileId, {
+        fileName: fileInfo.file.name,
+        size: fileInfo.file.size,
+        uploadTime
+      });
+      return metadata;
+    } catch (error) {
+      console.error(`\u274C [UniversalFileService] \u6587\u4EF6\u4E0A\u4F20\u5931\u8D25: ${fileId}:`, error);
+      const progress = this.uploadProgressMap.get(fileId);
+      if (progress) {
+        progress.status = "failed";
+        progress.error = error instanceof Error ? error.message : "\u4E0A\u4F20\u5931\u8D25";
+        this.uploadProgressMap.set(fileId, progress);
+        onProgress?.(progress);
+      }
+      this.emitFileEvent(
+        "upload:error",
+        fileId,
+        void 0,
+        error instanceof Error ? error.message : "\u4E0A\u4F20\u5931\u8D25"
+      );
+      throw error;
+    } finally {
+      setTimeout(
+        () => {
+          this.uploadProgressMap.delete(fileId);
+        },
+        5 * 60 * 1e3
+      );
+    }
+  }
+  /**
+   * 获取上传进度
+   */
+  getUploadProgress(fileId) {
+    return this.uploadProgressMap.get(fileId);
+  }
+  // ============= 事件处理方法 =============
+  /**
+   * 监听文件事件
+   */
+  onFileEvent(eventType, listener) {
+    this.on(eventType, listener);
+  }
+  /**
+   * 移除文件事件监听器
+   */
+  offFileEvent(eventType, listener) {
+    this.off(eventType, listener);
+  }
+  // ============= 私有方法 =============
+  async initializeStorageProviders() {
+    logger6.info("\u{1F4E6} [UniversalFileService] \u5F00\u59CB\u521D\u59CB\u5316\u5B58\u50A8\u63D0\u4F9B\u8005...");
+    if (this.storageProviders.size === 0) {
+      await this.registerDefaultStorageProviders();
+    }
+    for (const [type, config] of Object.entries(this.config.storageProviders)) {
+      if (config.enabled) {
+        const provider = this.storageProviders.get(type);
+        if (provider) {
+          try {
+            await provider.initialize(config);
+            logger6.info(`\u2705 [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005\u521D\u59CB\u5316\u5B8C\u6210: ${type}`);
+          } catch (error) {
+            console.warn(`\u26A0\uFE0F [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005\u521D\u59CB\u5316\u5931\u8D25: ${type}:`, error);
+          }
+        } else {
+          console.warn(`\u26A0\uFE0F [UniversalFileService] \u5B58\u50A8\u63D0\u4F9B\u8005\u672A\u6CE8\u518C: ${type}`);
+        }
+      }
+    }
+  }
+  async registerDefaultStorageProviders() {
+    logger6.info("\u{1F4E6} [UniversalFileService] \u6CE8\u518C\u9ED8\u8BA4\u5B58\u50A8\u63D0\u4F9B\u8005...");
+    const ossConfig = this.config.storageProviders["aliyun-oss"];
+    if (ossConfig && ossConfig.enabled) {
+      try {
+        const { AliyunOSSProvider: AliyunOSSProvider2 } = await import('../../AliyunOSSProvider-GQMSDJGZ.mjs');
+        const ossProvider = new AliyunOSSProvider2();
+        this.registerStorageProvider(ossProvider);
+        logger6.info("\u2705 [UniversalFileService] \u963F\u91CC\u4E91OSS\u63D0\u4F9B\u8005\u6CE8\u518C\u6210\u529F");
+      } catch (error) {
+        console.warn("\u26A0\uFE0F [UniversalFileService] \u963F\u91CC\u4E91OSS\u63D0\u4F9B\u8005\u6CE8\u518C\u5931\u8D25:", error);
+      }
+    }
+    const localConfig = this.config.storageProviders["local"];
+    if (localConfig && localConfig.enabled) {
+      try {
+        const { LocalStorageProvider: LocalStorageProvider2 } = await import('../../LocalStorageProvider-FVLLHBHO.mjs');
+        const localProvider = new LocalStorageProvider2();
+        this.registerStorageProvider(localProvider);
+        logger6.info("\u2705 [UniversalFileService] \u672C\u5730\u5B58\u50A8\u63D0\u4F9B\u8005\u6CE8\u518C\u6210\u529F");
+      } catch (error) {
+        console.warn("\u26A0\uFE0F [UniversalFileService] \u672C\u5730\u5B58\u50A8\u63D0\u4F9B\u8005\u6CE8\u518C\u5931\u8D25:", error);
+      }
+    }
+    if (this.storageProviders.size === 0) {
+      console.warn("\u26A0\uFE0F [UniversalFileService] \u6CA1\u6709\u53EF\u7528\u7684\u5B58\u50A8\u63D0\u4F9B\u8005\uFF0C\u5C1D\u8BD5\u6CE8\u518C\u672C\u5730\u5B58\u50A8\u4F5C\u4E3A\u5907\u7528");
+      try {
+        const { LocalStorageProvider: LocalStorageProvider2 } = await import('../../LocalStorageProvider-FVLLHBHO.mjs');
+        const localProvider = new LocalStorageProvider2();
+        this.registerStorageProvider(localProvider);
+        logger6.info("\u2705 [UniversalFileService] \u672C\u5730\u5B58\u50A8\u63D0\u4F9B\u8005\u6CE8\u518C\u6210\u529F\uFF08\u5907\u7528\uFF09");
+      } catch (error) {
+        console.error("\u274C [UniversalFileService] \u65E0\u6CD5\u6CE8\u518C\u4EFB\u4F55\u5B58\u50A8\u63D0\u4F9B\u8005:", error);
+        throw new Error("\u65E0\u6CD5\u521D\u59CB\u5316\u5B58\u50A8\u63D0\u4F9B\u8005");
+      }
+    }
+  }
+  async initializeCDNProviders() {
+    for (const [type, config] of Object.entries(this.config.cdnProviders)) {
+      if (config.enabled) {
+        const provider = this.cdnProviders.get(type);
+        if (provider) {
+          await provider.initialize(config);
+          logger6.info(`\u2705 [UniversalFileService] CDN\u63D0\u4F9B\u8005\u521D\u59CB\u5316\u5B8C\u6210: ${type}`);
+        }
+      }
+    }
+  }
+  async initializeFileProcessors() {
+    for (const processor of Array.from(this.fileProcessors.values())) {
+      await processor.initialize();
+      logger6.info(`\u2705 [UniversalFileService] \u6587\u4EF6\u5904\u7406\u5668\u521D\u59CB\u5316\u5B8C\u6210: ${processor.type}`);
+    }
+  }
+  async validateFile(file) {
+    if (file.size > this.config.maxFileSize) {
+      throw new FileUploadError(`\u6587\u4EF6\u5927\u5C0F\u8D85\u8FC7\u9650\u5236: ${file.size} > ${this.config.maxFileSize}`);
+    }
+    const mimeType = file.type || getMimeType(file.name);
+    if (this.config.allowedMimeTypes.length > 0 && !this.config.allowedMimeTypes.includes(mimeType)) {
+      throw new FileUploadError(`\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B: ${mimeType}`);
+    }
+  }
+  async generateFileMetadata(fileId, fileInfo) {
+    const now = /* @__PURE__ */ new Date();
+    const mimeType = fileInfo.file.type || getMimeType(fileInfo.file.name);
+    const extension = path3.extname(fileInfo.file.name).toLowerCase();
+    const hash = await this.generateFileHash(fileInfo.file);
+    return {
+      id: fileId,
+      originalName: fileInfo.file.name,
+      storageName: `${fileId}${extension}`,
+      size: fileInfo.file.size,
+      mimeType,
+      extension,
+      hash,
+      uploadTime: now,
+      permission: fileInfo.permission || "public",
+      uploaderId: fileInfo.metadata?.uploadedBy || "system",
+      moduleId: fileInfo.moduleId,
+      businessId: fileInfo.businessId,
+      storageProvider: this.config.defaultStorage,
+      storagePath: "",
+      accessCount: 0,
+      metadata: fileInfo.metadata || {}
+    };
+  }
+  generateStoragePath(metadata) {
+    const date = /* @__PURE__ */ new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${metadata.moduleId}/${year}/${month}/${day}/${metadata.storageName}`;
+  }
+  async generateFileHash(file) {
+    const buffer = await file.arrayBuffer();
+    const hash = createHash("sha256");
+    hash.update(Buffer.from(buffer));
+    return hash.digest("hex");
+  }
+  async queueFileProcessing(metadata, options) {
+    if (!this.config.processors?.length || 0 > 0) {
+      return;
+    }
+    const processor = this.fileProcessors.get(options.type);
+    if (!processor) {
+      console.warn(`\u26A0\uFE0F [UniversalFileService] \u6587\u4EF6\u5904\u7406\u5668\u4E0D\u5B58\u5728: ${options.type}`);
+      return;
+    }
+    if (this.processingQueue.length >= 1e3) {
+      throw new FileProcessingError("\u5904\u7406\u961F\u5217\u5DF2\u6EE1");
+    }
+    this.processingQueue.push({
+      fileId: metadata.id,
+      processor,
+      inputPath: metadata.storagePath,
+      outputPath: this.generateProcessedPath(metadata, options),
+      options
+    });
+    if (!this.isProcessingQueueRunning) {
+      this.processFileQueue();
+    }
+  }
+  generateProcessedPath(metadata, options) {
+    const basePath = metadata.storagePath;
+    const extension = path3.extname(basePath);
+    const basename4 = basePath.replace(extension, "");
+    return `${basename4}_processed${extension}`;
+  }
+  async processFileQueue() {
+    if (this.isProcessingQueueRunning || this.processingQueue.length === 0) {
+      return;
+    }
+    this.isProcessingQueueRunning = true;
+    while (this.processingQueue.length > 0) {
+      const task = this.processingQueue.shift();
+      if (!task) break;
+      try {
+        this.emitFileEvent("processing:start", task.fileId);
+        const result = await task.processor.process(task.inputPath, task.outputPath, task.options);
+        if (result.success) {
+          this.emitFileEvent("processing:complete", task.fileId, result);
+        } else {
+          this.emitFileEvent("processing:error", task.fileId, void 0, result.error);
+        }
+      } catch (error) {
+        console.error(`\u274C [UniversalFileService] \u6587\u4EF6\u5904\u7406\u5931\u8D25: ${task.fileId}:`, error);
+        this.emitFileEvent(
+          "processing:error",
+          task.fileId,
+          void 0,
+          error instanceof Error ? error.message : "\u5904\u7406\u5931\u8D25"
+        );
+      }
+    }
+    this.isProcessingQueueRunning = false;
+  }
+  cacheMetadata(metadata) {
+    const expires = Date.now() + (this.config.cache?.metadataTTL || 3600) * 1e3;
+    this.metadataCache.set(metadata.id, { data: metadata, expires });
+  }
+  _clearMetadataCache2(fileId) {
+    this.metadataCache.delete(fileId);
+  }
+  emitFileEvent(type, fileId, data, error) {
+    const event = {
+      type,
+      fileId,
+      timestamp: /* @__PURE__ */ new Date(),
+      data,
+      error
+    };
+    this.emit(type, event);
+    this.emit("*", event);
+  }
+};
+var logger7 = createLogger("CacheManager");
+var CacheManager = class {
+  constructor(options = {}) {
+    this.redisClient = null;
+    this.options = {
+      defaultTTL: options.defaultTTL || 300,
+      // 5分钟
+      maxMemoryItems: options.maxMemoryItems || 1e3,
+      enableRedis: options.enableRedis || false,
+      redisConfig: options.redisConfig || {
+        host: "localhost",
+        port: 6379,
+        db: 0
+      },
+      keyPrefix: options.keyPrefix || "universal-file:"
+    };
+    this.memoryCache = new LRUCache({
+      max: this.options.maxMemoryItems,
+      ttl: this.options.defaultTTL * 1e3,
+      // LRU缓存使用毫秒
+      updateAgeOnGet: true,
+      allowStale: false
+    });
+    this.stats = {
+      totalRequests: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      memorySize: 0,
+      redisConnected: false
+    };
+    if (this.options.enableRedis) {
+      this.initRedis();
+    }
+  }
+  /**
+   * 初始化Redis连接
+   */
+  async initRedis() {
+    try {
+      logger7.info("Redis\u7F13\u5B58\u5DF2\u7981\u7528 - \u8BF7\u5B89\u88C5\u5E76\u914D\u7F6ERedis\u5BA2\u6237\u7AEF");
+      this.stats.redisConnected = false;
+    } catch (error) {
+      console.error("Redis\u8FDE\u63A5\u5931\u8D25:", error);
+      this.stats.redisConnected = false;
+    }
+  }
+  /**
+   * 生成缓存键
+   */
+  generateKey(key) {
+    return `${this.options.keyPrefix}${key}`;
+  }
+  /**
+   * 获取缓存数据
+   */
+  async get(key) {
+    const cacheKey = this.generateKey(key);
+    this.stats.totalRequests++;
+    try {
+      const memoryItem = this.memoryCache.get(cacheKey);
+      if (memoryItem && memoryItem.expiresAt > Date.now()) {
+        memoryItem.accessCount++;
+        memoryItem.lastAccessAt = Date.now();
+        this.stats.hits++;
+        this.updateHitRate();
+        return memoryItem.data;
+      }
+      if (this.redisClient && this.stats.redisConnected) {
+        const redisData = await this.redisClient.get(cacheKey);
+        if (redisData) {
+          const parsedData = JSON.parse(redisData);
+          const cacheItem = {
+            data: parsedData.data,
+            createdAt: parsedData.createdAt,
+            expiresAt: parsedData.expiresAt,
+            accessCount: parsedData.accessCount + 1,
+            lastAccessAt: Date.now()
+          };
+          this.memoryCache.set(cacheKey, cacheItem);
+          this.stats.hits++;
+          this.updateHitRate();
+          return parsedData.data;
+        }
+      }
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    } catch (error) {
+      console.error("\u7F13\u5B58\u83B7\u53D6\u5931\u8D25:", error);
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    }
+  }
+  /**
+   * 设置缓存数据
+   */
+  async set(key, data, ttl) {
+    const cacheKey = this.generateKey(key);
+    const expireTime = ttl || this.options.defaultTTL;
+    const now = Date.now();
+    const cacheItem = {
+      data,
+      createdAt: now,
+      expiresAt: now + expireTime * 1e3,
+      accessCount: 0,
+      lastAccessAt: now
+    };
+    try {
+      this.memoryCache.set(cacheKey, cacheItem);
+      if (this.redisClient && this.stats.redisConnected) {
+        await this.redisClient.setex(cacheKey, expireTime, JSON.stringify(cacheItem));
+      }
+      this.updateMemorySize();
+    } catch (error) {
+      console.error("\u7F13\u5B58\u8BBE\u7F6E\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 删除缓存数据
+   */
+  async delete(key) {
+    const cacheKey = this.generateKey(key);
+    try {
+      this.memoryCache.delete(cacheKey);
+      if (this.redisClient && this.stats.redisConnected) {
+        await this.redisClient.del(cacheKey);
+      }
+      this.updateMemorySize();
+    } catch (error) {
+      console.error("\u7F13\u5B58\u5220\u9664\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 批量删除缓存（支持模式匹配）
+   */
+  async deletePattern(pattern) {
+    const cachePattern = this.generateKey(pattern);
+    try {
+      const keys = Array.from(this.memoryCache.keys());
+      for (const key of keys) {
+        if (this.matchPattern(key, cachePattern)) {
+          this.memoryCache.delete(key);
+        }
+      }
+      if (this.redisClient && this.stats.redisConnected) {
+        const redisKeys = await this.redisClient.keys(cachePattern);
+        if (redisKeys.length > 0) {
+          await this.redisClient.del(...redisKeys);
+        }
+      }
+      this.updateMemorySize();
+    } catch (error) {
+      console.error("\u6279\u91CF\u7F13\u5B58\u5220\u9664\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 清空所有缓存
+   */
+  async clear() {
+    try {
+      this.memoryCache.clear();
+      if (this.redisClient && this.stats.redisConnected) {
+        const keys = await this.redisClient.keys(`${this.options.keyPrefix}*`);
+        if (keys.length > 0) {
+          await this.redisClient.del(...keys);
+        }
+      }
+      this.stats.hits = 0;
+      this.stats.misses = 0;
+      this.stats.totalRequests = 0;
+      this.stats.hitRate = 0;
+      this.updateMemorySize();
+    } catch (error) {
+      console.error("\u6E05\u7A7A\u7F13\u5B58\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  getStats() {
+    this.updateMemorySize();
+    return { ...this.stats };
+  }
+  /**
+   * 获取缓存项详情（用于调试）
+   */
+  getCacheItem(key) {
+    const cacheKey = this.generateKey(key);
+    return this.memoryCache.get(cacheKey) || null;
+  }
+  /**
+   * 预热缓存
+   */
+  async warmup(items) {
+    logger7.info(`\u5F00\u59CB\u9884\u70ED\u7F13\u5B58\uFF0C\u5171 ${items.length} \u9879...`);
+    const promises = items.map((item) => this.set(item.key, item.data, item.ttl));
+    try {
+      await Promise.all(promises);
+      logger7.info("\u7F13\u5B58\u9884\u70ED\u5B8C\u6210");
+    } catch (error) {
+      console.error("\u7F13\u5B58\u9884\u70ED\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 更新命中率
+   */
+  updateHitRate() {
+    this.stats.hitRate = this.stats.totalRequests > 0 ? this.stats.hits / this.stats.totalRequests * 100 : 0;
+  }
+  /**
+   * 更新内存使用量
+   */
+  updateMemorySize() {
+    this.stats.memorySize = this.memoryCache.size;
+  }
+  /**
+   * 模式匹配函数
+   */
+  matchPattern(key, pattern) {
+    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(key);
+  }
+  /**
+   * 获取或设置缓存（如果不存在则调用生成函数）
+   */
+  async getOrSet(key, generator, ttl) {
+    const cachedData = await this.get(key);
+    if (cachedData !== null) {
+      return cachedData;
+    }
+    try {
+      const data = await generator();
+      await this.set(key, data, ttl);
+      return data;
+    } catch (error) {
+      console.error("\u7F13\u5B58\u751F\u6210\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+  /**
+   * 关闭缓存管理器
+   */
+  async close() {
+    try {
+      this.memoryCache.clear();
+      if (this.redisClient) {
+        await this.redisClient.quit();
+      }
+    } catch (error) {
+      console.error("\u5173\u95ED\u7F13\u5B58\u7BA1\u7406\u5668\u5931\u8D25:", error);
+    }
+  }
+};
+new CacheManager({
+  defaultTTL: 300,
+  // 5分钟
+  maxMemoryItems: 2e3,
+  enableRedis: false,
+  // 开发环境暂时禁用Redis
+  keyPrefix: "universal-file:"
+});
+
+// src/universalFile/server/monitoring/PerformanceMonitor.ts
+var PerformanceMonitor = class {
+  // 最大保存跟踪数量
+  constructor() {
+    this.metrics = [];
+    this.requestTraces = /* @__PURE__ */ new Map();
+    this.maxMetrics = 1e4;
+    // 最大保存指标数量
+    this.maxTraces = 1e3;
+    this.stats = this.initializeStats();
+    setInterval(() => {
+      this.cleanupOldData();
+    }, 6e4);
+  }
+  /**
+   * 初始化统计信息
+   */
+  initializeStats() {
+    return {
+      apiResponseTimes: {
+        average: 0,
+        min: 0,
+        max: 0,
+        p95: 0,
+        p99: 0,
+        totalRequests: 0
+      },
+      databasePerformance: {
+        averageQueryTime: 0,
+        slowQueries: 0,
+        totalQueries: 0,
+        queryErrors: 0
+      },
+      fileOperations: {
+        uploads: {
+          total: 0,
+          successful: 0,
+          failed: 0,
+          averageTime: 0,
+          averageSize: 0
+        },
+        downloads: {
+          total: 0,
+          successful: 0,
+          failed: 0,
+          averageTime: 0
+        }
+      },
+      systemResources: {
+        memoryUsage: 0,
+        cpuUsage: 0,
+        diskUsage: 0
+      }
+    };
+  }
+  /**
+   * 开始请求跟踪
+   */
+  startRequest(requestId, path6, method, userId) {
+    const trace = {
+      requestId,
+      path: path6,
+      method,
+      startTime: Date.now(),
+      userId
+    };
+    this.requestTraces.set(requestId, trace);
+  }
+  /**
+   * 结束请求跟踪
+   */
+  endRequest(requestId, statusCode, error, fileSize) {
+    const trace = this.requestTraces.get(requestId);
+    if (!trace) return;
+    const endTime = Date.now();
+    const duration = endTime - trace.startTime;
+    trace.endTime = endTime;
+    trace.duration = duration;
+    trace.statusCode = statusCode;
+    trace.error = error;
+    trace.fileSize = fileSize;
+    this.recordMetric("api_response_time", duration, "ms", {
+      path: trace.path,
+      method: trace.method,
+      status: statusCode.toString()
+    });
+    this.updateApiStats(duration);
+    if (trace.path.includes("upload")) {
+      this.updateUploadStats(statusCode < 400, duration, fileSize);
+    } else if (trace.path.includes("download")) {
+      this.updateDownloadStats(statusCode < 400, duration);
+    }
+    if (this.requestTraces.size > this.maxTraces) {
+      const oldestKey = this.requestTraces.keys().next().value;
+      if (oldestKey) {
+        this.requestTraces.delete(oldestKey);
+      }
+    }
+  }
+  /**
+   * 记录数据库查询性能
+   */
+  recordDatabaseQuery(queryTime, isError = false) {
+    this.recordMetric("db_query_time", queryTime, "ms");
+    this.stats.databasePerformance.totalQueries++;
+    if (isError) {
+      this.stats.databasePerformance.queryErrors++;
+    }
+    const total = this.stats.databasePerformance.totalQueries;
+    const currentAvg = this.stats.databasePerformance.averageQueryTime;
+    this.stats.databasePerformance.averageQueryTime = (currentAvg * (total - 1) + queryTime) / total;
+    if (queryTime > 1e3) {
+      this.stats.databasePerformance.slowQueries++;
+      this.recordMetric("slow_query", 1, "count");
+    }
+  }
+  /**
+   * 记录系统资源使用情况
+   */
+  recordSystemResources() {
+    try {
+      const memoryUsage = process.memoryUsage();
+      const memoryUsedMB = memoryUsage.heapUsed / 1024 / 1024;
+      this.stats.systemResources.memoryUsage = memoryUsedMB;
+      this.recordMetric("memory_usage", memoryUsedMB, "MB");
+      this.recordMetric("heap_total", memoryUsage.heapTotal / 1024 / 1024, "MB");
+      this.recordMetric("heap_used", memoryUsage.heapUsed / 1024 / 1024, "MB");
+      this.recordMetric("external", memoryUsage.external / 1024 / 1024, "MB");
+    } catch (error) {
+      console.error("\u8BB0\u5F55\u7CFB\u7EDF\u8D44\u6E90\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 记录自定义指标
+   */
+  recordMetric(name, value, unit, labels) {
+    const metric = {
+      name,
+      value,
+      unit,
+      timestamp: Date.now(),
+      labels
+    };
+    this.metrics.push(metric);
+    if (this.metrics.length > this.maxMetrics) {
+      this.metrics.shift();
+    }
+  }
+  /**
+   * 获取性能统计信息
+   */
+  getStats() {
+    this.recordSystemResources();
+    return { ...this.stats };
+  }
+  /**
+   * 获取指定时间范围内的指标
+   */
+  getMetrics(name, startTime, endTime) {
+    let filteredMetrics = this.metrics;
+    if (name) {
+      filteredMetrics = filteredMetrics.filter((m) => m.name === name);
+    }
+    if (startTime) {
+      filteredMetrics = filteredMetrics.filter((m) => m.timestamp >= startTime);
+    }
+    if (endTime) {
+      filteredMetrics = filteredMetrics.filter((m) => m.timestamp <= endTime);
+    }
+    return filteredMetrics;
+  }
+  /**
+   * 获取请求跟踪信息
+   */
+  getRequestTraces(limit = 100) {
+    const traces = Array.from(this.requestTraces.values());
+    return traces.sort((a, b) => b.startTime - a.startTime).slice(0, limit);
+  }
+  /**
+   * 获取慢请求列表
+   */
+  getSlowRequests(threshold = 1e3) {
+    return this.getRequestTraces().filter((trace) => trace.duration && trace.duration > threshold).sort((a, b) => (b.duration || 0) - (a.duration || 0));
+  }
+  /**
+   * 获取错误请求列表
+   */
+  getErrorRequests() {
+    return this.getRequestTraces().filter((trace) => trace.statusCode && trace.statusCode >= 400);
+  }
+  /**
+   * 生成性能报告
+   */
+  generateReport() {
+    const stats = this.getStats();
+    const slowRequests = this.getSlowRequests(500);
+    const errorRequests = this.getErrorRequests();
+    return {
+      summary: {
+        totalRequests: stats.apiResponseTimes.totalRequests,
+        averageResponseTime: stats.apiResponseTimes.average,
+        errorRate: errorRequests.length / Math.max(stats.apiResponseTimes.totalRequests, 1) * 100,
+        cacheHitRate: 0,
+        // 需要从缓存管理器获取
+        slowQueryCount: stats.databasePerformance.slowQueries
+      },
+      topSlowRequests: slowRequests.slice(0, 10),
+      recentErrors: errorRequests.slice(0, 10),
+      systemHealth: {
+        memoryUsage: stats.systemResources.memoryUsage,
+        queryPerformance: stats.databasePerformance.averageQueryTime,
+        uptime: process.uptime()
+      }
+    };
+  }
+  /**
+   * 更新API统计信息
+   */
+  updateApiStats(duration) {
+    const stats = this.stats.apiResponseTimes;
+    stats.totalRequests++;
+    stats.average = (stats.average * (stats.totalRequests - 1) + duration) / stats.totalRequests;
+    if (stats.totalRequests === 1 || duration < stats.min) {
+      stats.min = duration;
+    }
+    if (stats.totalRequests === 1 || duration > stats.max) {
+      stats.max = duration;
+    }
+    const recentDurations = this.getMetrics("api_response_time", Date.now() - 3e5).map((m) => m.value).sort((a, b) => a - b);
+    if (recentDurations.length > 0) {
+      stats.p95 = recentDurations[Math.floor(recentDurations.length * 0.95)] || 0;
+      stats.p99 = recentDurations[Math.floor(recentDurations.length * 0.99)] || 0;
+    }
+  }
+  /**
+   * 更新上传统计信息
+   */
+  updateUploadStats(success, duration, fileSize) {
+    const uploads = this.stats.fileOperations.uploads;
+    uploads.total++;
+    if (success) {
+      uploads.successful++;
+    } else {
+      uploads.failed++;
+    }
+    uploads.averageTime = (uploads.averageTime * (uploads.total - 1) + duration) / uploads.total;
+    if (fileSize) {
+      uploads.averageSize = (uploads.averageSize * (uploads.total - 1) + fileSize) / uploads.total;
+    }
+  }
+  /**
+   * 更新下载统计信息
+   */
+  updateDownloadStats(success, duration) {
+    const downloads = this.stats.fileOperations.downloads;
+    downloads.total++;
+    if (success) {
+      downloads.successful++;
+    } else {
+      downloads.failed++;
+    }
+    downloads.averageTime = (downloads.averageTime * (downloads.total - 1) + duration) / downloads.total;
+  }
+  /**
+   * 清理过期数据
+   */
+  cleanupOldData() {
+    const oneHourAgo = Date.now() - 36e5;
+    this.metrics = this.metrics.filter((m) => m.timestamp > oneHourAgo);
+    for (const [requestId, trace] of this.requestTraces.entries()) {
+      if (trace.startTime < oneHourAgo) {
+        this.requestTraces.delete(requestId);
+      }
+    }
+  }
+  /**
+   * 重置统计信息
+   */
+  reset() {
+    this.metrics = [];
+    this.requestTraces.clear();
+    this.stats = this.initializeStats();
+  }
+};
+new PerformanceMonitor();
+
+// src/universalFile/server/cdn/CdnCacheStrategy.ts
+var CacheStrategyType2 = /* @__PURE__ */ ((CacheStrategyType3) => {
+  CacheStrategyType3["IMAGE"] = "image";
+  CacheStrategyType3["VIDEO"] = "video";
+  CacheStrategyType3["AUDIO"] = "audio";
+  CacheStrategyType3["DOCUMENT"] = "document";
+  CacheStrategyType3["ARCHIVE"] = "archive";
+  CacheStrategyType3["STATIC"] = "static";
+  CacheStrategyType3["OTHER"] = "other";
+  return CacheStrategyType3;
+})(CacheStrategyType2 || {});
+var CdnCacheStrategy2 = class {
+  constructor() {
+    this.strategies = /* @__PURE__ */ new Map();
+    this.stats = /* @__PURE__ */ new Map();
+    this.initializeDefaultStrategies();
+  }
+  /**
+   * 初始化默认缓存策略
+   */
+  initializeDefaultStrategies() {
+    this.strategies.set("image" /* IMAGE */, {
+      type: "image" /* IMAGE */,
+      ttl: 30 * 24 * 3600,
+      // 30天
+      browserCache: true,
+      browserCacheTtl: 7 * 24 * 3600,
+      // 7天
+      cdnCache: true,
+      cdnCacheTtl: 30 * 24 * 3600,
+      // 30天
+      enableWarmup: true,
+      cacheControl: "public, max-age=604800, s-maxage=2592000",
+      allowedMimeTypes: ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"],
+      maxFileSize: 50 * 1024 * 1024
+      // 50MB
+    });
+    this.strategies.set("video" /* VIDEO */, {
+      type: "video" /* VIDEO */,
+      ttl: 7 * 24 * 3600,
+      // 7天
+      browserCache: true,
+      browserCacheTtl: 24 * 3600,
+      // 1天
+      cdnCache: true,
+      cdnCacheTtl: 7 * 24 * 3600,
+      // 7天
+      enableWarmup: false,
+      // 视频文件通常较大，不预热
+      cacheControl: "public, max-age=86400, s-maxage=604800",
+      allowedMimeTypes: ["video/mp4", "video/avi", "video/mov", "video/wmv", "video/webm"],
+      maxFileSize: 500 * 1024 * 1024
+      // 500MB
+    });
+    this.strategies.set("audio" /* AUDIO */, {
+      type: "audio" /* AUDIO */,
+      ttl: 14 * 24 * 3600,
+      // 14天
+      browserCache: true,
+      browserCacheTtl: 3 * 24 * 3600,
+      // 3天
+      cdnCache: true,
+      cdnCacheTtl: 14 * 24 * 3600,
+      // 14天
+      enableWarmup: true,
+      cacheControl: "public, max-age=259200, s-maxage=1209600",
+      allowedMimeTypes: ["audio/mpeg", "audio/wav", "audio/ogg", "audio/m4a", "audio/flac"],
+      maxFileSize: 100 * 1024 * 1024
+      // 100MB
+    });
+    this.strategies.set("document" /* DOCUMENT */, {
+      type: "document" /* DOCUMENT */,
+      ttl: 24 * 3600,
+      // 1天
+      browserCache: true,
+      browserCacheTtl: 3600,
+      // 1小时
+      cdnCache: true,
+      cdnCacheTtl: 24 * 3600,
+      // 1天
+      enableWarmup: false,
+      cacheControl: "public, max-age=3600, s-maxage=86400",
+      allowedMimeTypes: [
+        "application/pdf",
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "text/plain",
+        "text/csv"
+      ],
+      maxFileSize: 50 * 1024 * 1024
+      // 50MB
+    });
+    this.strategies.set("archive" /* ARCHIVE */, {
+      type: "archive" /* ARCHIVE */,
+      ttl: 24 * 3600,
+      // 1天
+      browserCache: true,
+      browserCacheTtl: 1800,
+      // 30分钟
+      cdnCache: true,
+      cdnCacheTtl: 24 * 3600,
+      // 1天
+      enableWarmup: false,
+      cacheControl: "public, max-age=1800, s-maxage=86400",
+      allowedMimeTypes: [
+        "application/zip",
+        "application/x-rar-compressed",
+        "application/x-7z-compressed",
+        "application/gzip",
+        "application/x-tar"
+      ],
+      maxFileSize: 100 * 1024 * 1024
+      // 100MB
+    });
+    this.strategies.set("static" /* STATIC */, {
+      type: "static" /* STATIC */,
+      ttl: 365 * 24 * 3600,
+      // 1年
+      browserCache: true,
+      browserCacheTtl: 30 * 24 * 3600,
+      // 30天
+      cdnCache: true,
+      cdnCacheTtl: 365 * 24 * 3600,
+      // 1年
+      enableWarmup: true,
+      cacheControl: "public, max-age=2592000, s-maxage=31536000, immutable",
+      allowedMimeTypes: [
+        "text/css",
+        "application/javascript",
+        "application/json",
+        "font/woff",
+        "font/woff2",
+        "font/ttf"
+      ],
+      maxFileSize: 10 * 1024 * 1024
+      // 10MB
+    });
+    this.strategies.set("other" /* OTHER */, {
+      type: "other" /* OTHER */,
+      ttl: 3600,
+      // 1小时
+      browserCache: true,
+      browserCacheTtl: 300,
+      // 5分钟
+      cdnCache: false,
+      cdnCacheTtl: 0,
+      enableWarmup: false,
+      cacheControl: "public, max-age=300",
+      allowedMimeTypes: [],
+      maxFileSize: 10 * 1024 * 1024
+      // 10MB
+    });
+    for (const type of Object.values(CacheStrategyType2)) {
+      this.stats.set(type, {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        totalRequests: 0,
+        estimatedSize: 0,
+        bandwidthSaved: 0
+      });
+    }
+  }
+  /**
+   * 根据MIME类型获取缓存策略
+   */
+  getStrategyByMimeType(mimeType) {
+    for (const [type, strategy] of this.strategies.entries()) {
+      if (strategy.allowedMimeTypes.includes(mimeType)) {
+        return strategy;
+      }
+    }
+    if (mimeType.startsWith("image/")) {
+      return this.strategies.get("image" /* IMAGE */);
+    } else if (mimeType.startsWith("video/")) {
+      return this.strategies.get("video" /* VIDEO */);
+    } else if (mimeType.startsWith("audio/")) {
+      return this.strategies.get("audio" /* AUDIO */);
+    } else if (mimeType.includes("pdf") || mimeType.includes("document") || mimeType.includes("word") || mimeType.includes("excel")) {
+      return this.strategies.get("document" /* DOCUMENT */);
+    } else if (mimeType.includes("zip") || mimeType.includes("compressed") || mimeType.includes("archive")) {
+      return this.strategies.get("archive" /* ARCHIVE */);
+    }
+    return this.strategies.get("other" /* OTHER */);
+  }
+  /**
+   * 生成缓存控制头
+   */
+  generateCacheHeaders(mimeType, fileSize) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    if (fileSize && strategy.maxFileSize && fileSize > strategy.maxFileSize) {
+      return {
+        "Cache-Control": "public, max-age=300",
+        // 5分钟
+        Expires: new Date(Date.now() + 300 * 1e3).toUTCString()
+      };
+    }
+    const headers = {
+      "Cache-Control": strategy.cacheControl,
+      Expires: new Date(Date.now() + strategy.browserCacheTtl * 1e3).toUTCString()
+    };
+    if (strategy.browserCache) {
+      headers["ETag"] = `"${Date.now()}"`;
+    }
+    headers["Last-Modified"] = (/* @__PURE__ */ new Date()).toUTCString();
+    if (strategy.type === "static" /* STATIC */) {
+      headers["Cache-Control"] += ", immutable";
+    }
+    return headers;
+  }
+  /**
+   * 检查是否需要缓存预热
+   */
+  shouldWarmupCache(mimeType) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    return strategy.enableWarmup;
+  }
+  /**
+   * 记录缓存命中
+   */
+  recordCacheHit(mimeType, fileSize = 0) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    const stats = this.stats.get(strategy.type);
+    if (stats) {
+      stats.hits++;
+      stats.totalRequests++;
+      stats.bandwidthSaved += fileSize;
+      stats.hitRate = stats.hits / stats.totalRequests * 100;
+    }
+  }
+  /**
+   * 记录缓存未命中
+   */
+  recordCacheMiss(mimeType, fileSize = 0) {
+    const strategy = this.getStrategyByMimeType(mimeType);
+    const stats = this.stats.get(strategy.type);
+    if (stats) {
+      stats.misses++;
+      stats.totalRequests++;
+      stats.estimatedSize += fileSize;
+      stats.hitRate = stats.hits / stats.totalRequests * 100;
+    }
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  getCacheStats() {
+    return new Map(this.stats);
+  }
+  /**
+   * 获取总体缓存统计
+   */
+  getOverallStats() {
+    const overall = {
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      totalRequests: 0,
+      estimatedSize: 0,
+      bandwidthSaved: 0
+    };
+    for (const stats of this.stats.values()) {
+      overall.hits += stats.hits;
+      overall.misses += stats.misses;
+      overall.totalRequests += stats.totalRequests;
+      overall.estimatedSize += stats.estimatedSize;
+      overall.bandwidthSaved += stats.bandwidthSaved;
+    }
+    overall.hitRate = overall.totalRequests > 0 ? overall.hits / overall.totalRequests * 100 : 0;
+    return overall;
+  }
+  /**
+   * 生成缓存优化建议
+   */
+  generateOptimizationSuggestions() {
+    const suggestions = [];
+    for (const [type, stats] of this.stats.entries()) {
+      if (stats.totalRequests > 100) {
+        if (stats.hitRate < 60) {
+          suggestions.push({
+            type,
+            issue: `${type}\u7C7B\u578B\u6587\u4EF6\u7F13\u5B58\u547D\u4E2D\u7387\u8FC7\u4F4E (${stats.hitRate.toFixed(1)}%)`,
+            suggestion: "\u8003\u8651\u589E\u52A0\u7F13\u5B58\u65F6\u95F4\u6216\u542F\u7528\u9884\u70ED\u673A\u5236",
+            severity: stats.hitRate < 30 ? "high" : "medium"
+          });
+        }
+        if (stats.estimatedSize > 1024 * 1024 * 1024) {
+          suggestions.push({
+            type,
+            issue: `${type}\u7C7B\u578B\u6587\u4EF6\u7F13\u5B58\u5360\u7528\u7A7A\u95F4\u8FC7\u5927 (${(stats.estimatedSize / 1024 / 1024 / 1024).toFixed(2)}GB)`,
+            suggestion: "\u8003\u8651\u51CF\u5C11\u7F13\u5B58\u65F6\u95F4\u6216\u4F18\u5316\u6587\u4EF6\u538B\u7F29",
+            severity: "medium"
+          });
+        }
+      }
+    }
+    return suggestions;
+  }
+  /**
+   * 更新缓存策略
+   */
+  updateStrategy(type, config) {
+    const currentStrategy = this.strategies.get(type);
+    if (currentStrategy) {
+      this.strategies.set(type, { ...currentStrategy, ...config });
+    }
+  }
+  /**
+   * 重置统计信息
+   */
+  resetStats() {
+    for (const type of Object.values(CacheStrategyType2)) {
+      this.stats.set(type, {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        totalRequests: 0,
+        estimatedSize: 0,
+        bandwidthSaved: 0
+      });
+    }
+  }
+};
+new CdnCacheStrategy2();
+
+// src/universalFile/server/types/api.ts
+var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
+  ApiErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  ApiErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ApiErrorCode2["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+  ApiErrorCode2["AUTHORIZATION_ERROR"] = "AUTHORIZATION_ERROR";
+  ApiErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ApiErrorCode2["CONFLICT"] = "CONFLICT";
+  ApiErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+  ApiErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+  ApiErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  ApiErrorCode2["FILE_TYPE_NOT_SUPPORTED"] = "FILE_TYPE_NOT_SUPPORTED";
+  ApiErrorCode2["FILE_UPLOAD_FAILED"] = "FILE_UPLOAD_FAILED";
+  ApiErrorCode2["FILE_PROCESSING_FAILED"] = "FILE_PROCESSING_FAILED";
+  ApiErrorCode2["FILE_ALREADY_EXISTS"] = "FILE_ALREADY_EXISTS";
+  ApiErrorCode2["FILE_CORRUPTED"] = "FILE_CORRUPTED";
+  ApiErrorCode2["FOLDER_NOT_FOUND"] = "FOLDER_NOT_FOUND";
+  ApiErrorCode2["FOLDER_NOT_EMPTY"] = "FOLDER_NOT_EMPTY";
+  ApiErrorCode2["FOLDER_NAME_CONFLICT"] = "FOLDER_NAME_CONFLICT";
+  ApiErrorCode2["FOLDER_DEPTH_EXCEEDED"] = "FOLDER_DEPTH_EXCEEDED";
+  ApiErrorCode2["STORAGE_PROVIDER_ERROR"] = "STORAGE_PROVIDER_ERROR";
+  ApiErrorCode2["STORAGE_QUOTA_EXCEEDED"] = "STORAGE_QUOTA_EXCEEDED";
+  ApiErrorCode2["STORAGE_UNAVAILABLE"] = "STORAGE_UNAVAILABLE";
+  ApiErrorCode2["SHARE_NOT_FOUND"] = "SHARE_NOT_FOUND";
+  ApiErrorCode2["SHARE_EXPIRED"] = "SHARE_EXPIRED";
+  ApiErrorCode2["SHARE_PASSWORD_INCORRECT"] = "SHARE_PASSWORD_INCORRECT";
+  ApiErrorCode2["SHARE_ACCESS_DENIED"] = "SHARE_ACCESS_DENIED";
+  ApiErrorCode2["SHARE_DOWNLOAD_LIMIT_EXCEEDED"] = "SHARE_DOWNLOAD_LIMIT_EXCEEDED";
+  return ApiErrorCode2;
+})(ApiErrorCode || {});
+var ErrorMessages = {
+  ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: "\u672A\u77E5\u9519\u8BEF",
+  ["VALIDATION_ERROR" /* VALIDATION_ERROR */]: "\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  ["AUTHENTICATION_ERROR" /* AUTHENTICATION_ERROR */]: "\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25",
+  ["AUTHORIZATION_ERROR" /* AUTHORIZATION_ERROR */]: "\u6743\u9650\u4E0D\u8DB3",
+  ["NOT_FOUND" /* NOT_FOUND */]: "\u8D44\u6E90\u4E0D\u5B58\u5728",
+  ["CONFLICT" /* CONFLICT */]: "\u8D44\u6E90\u51B2\u7A81",
+  ["RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */]: "\u8BF7\u6C42\u9891\u7387\u8D85\u9650",
+  ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: "\u6587\u4EF6\u4E0D\u5B58\u5728",
+  ["FILE_TOO_LARGE" /* FILE_TOO_LARGE */]: "\u6587\u4EF6\u8FC7\u5927",
+  ["FILE_TYPE_NOT_SUPPORTED" /* FILE_TYPE_NOT_SUPPORTED */]: "\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B",
+  ["FILE_UPLOAD_FAILED" /* FILE_UPLOAD_FAILED */]: "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25",
+  ["FILE_PROCESSING_FAILED" /* FILE_PROCESSING_FAILED */]: "\u6587\u4EF6\u5904\u7406\u5931\u8D25",
+  ["FILE_ALREADY_EXISTS" /* FILE_ALREADY_EXISTS */]: "\u6587\u4EF6\u5DF2\u5B58\u5728",
+  ["FILE_CORRUPTED" /* FILE_CORRUPTED */]: "\u6587\u4EF6\u5DF2\u635F\u574F",
+  ["FOLDER_NOT_FOUND" /* FOLDER_NOT_FOUND */]: "\u6587\u4EF6\u5939\u4E0D\u5B58\u5728",
+  ["FOLDER_NOT_EMPTY" /* FOLDER_NOT_EMPTY */]: "\u6587\u4EF6\u5939\u4E0D\u4E3A\u7A7A",
+  ["FOLDER_NAME_CONFLICT" /* FOLDER_NAME_CONFLICT */]: "\u6587\u4EF6\u5939\u540D\u79F0\u51B2\u7A81",
+  ["FOLDER_DEPTH_EXCEEDED" /* FOLDER_DEPTH_EXCEEDED */]: "\u6587\u4EF6\u5939\u5C42\u7EA7\u8FC7\u6DF1",
+  ["STORAGE_PROVIDER_ERROR" /* STORAGE_PROVIDER_ERROR */]: "\u5B58\u50A8\u670D\u52A1\u9519\u8BEF",
+  ["STORAGE_QUOTA_EXCEEDED" /* STORAGE_QUOTA_EXCEEDED */]: "\u5B58\u50A8\u914D\u989D\u5DF2\u6EE1",
+  ["STORAGE_UNAVAILABLE" /* STORAGE_UNAVAILABLE */]: "\u5B58\u50A8\u670D\u52A1\u4E0D\u53EF\u7528",
+  ["SHARE_NOT_FOUND" /* SHARE_NOT_FOUND */]: "\u5206\u4EAB\u4E0D\u5B58\u5728",
+  ["SHARE_EXPIRED" /* SHARE_EXPIRED */]: "\u5206\u4EAB\u5DF2\u8FC7\u671F",
+  ["SHARE_PASSWORD_INCORRECT" /* SHARE_PASSWORD_INCORRECT */]: "\u5206\u4EAB\u5BC6\u7801\u9519\u8BEF",
+  ["SHARE_ACCESS_DENIED" /* SHARE_ACCESS_DENIED */]: "\u5206\u4EAB\u8BBF\u95EE\u88AB\u62D2\u7EDD",
+  ["SHARE_DOWNLOAD_LIMIT_EXCEEDED" /* SHARE_DOWNLOAD_LIMIT_EXCEEDED */]: "\u5206\u4EAB\u4E0B\u8F7D\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650"
+};
+var ErrorHttpStatusMap = {
+  ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: 500,
+  ["VALIDATION_ERROR" /* VALIDATION_ERROR */]: 400,
+  ["AUTHENTICATION_ERROR" /* AUTHENTICATION_ERROR */]: 401,
+  ["AUTHORIZATION_ERROR" /* AUTHORIZATION_ERROR */]: 403,
+  ["NOT_FOUND" /* NOT_FOUND */]: 404,
+  ["CONFLICT" /* CONFLICT */]: 409,
+  ["RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */]: 429,
+  ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: 404,
+  ["FILE_TOO_LARGE" /* FILE_TOO_LARGE */]: 413,
+  ["FILE_TYPE_NOT_SUPPORTED" /* FILE_TYPE_NOT_SUPPORTED */]: 415,
+  ["FILE_UPLOAD_FAILED" /* FILE_UPLOAD_FAILED */]: 500,
+  ["FILE_PROCESSING_FAILED" /* FILE_PROCESSING_FAILED */]: 500,
+  ["FILE_ALREADY_EXISTS" /* FILE_ALREADY_EXISTS */]: 409,
+  ["FILE_CORRUPTED" /* FILE_CORRUPTED */]: 422,
+  ["FOLDER_NOT_FOUND" /* FOLDER_NOT_FOUND */]: 404,
+  ["FOLDER_NOT_EMPTY" /* FOLDER_NOT_EMPTY */]: 409,
+  ["FOLDER_NAME_CONFLICT" /* FOLDER_NAME_CONFLICT */]: 409,
+  ["FOLDER_DEPTH_EXCEEDED" /* FOLDER_DEPTH_EXCEEDED */]: 400,
+  ["STORAGE_PROVIDER_ERROR" /* STORAGE_PROVIDER_ERROR */]: 502,
+  ["STORAGE_QUOTA_EXCEEDED" /* STORAGE_QUOTA_EXCEEDED */]: 507,
+  ["STORAGE_UNAVAILABLE" /* STORAGE_UNAVAILABLE */]: 503,
+  ["SHARE_NOT_FOUND" /* SHARE_NOT_FOUND */]: 404,
+  ["SHARE_EXPIRED" /* SHARE_EXPIRED */]: 410,
+  ["SHARE_PASSWORD_INCORRECT" /* SHARE_PASSWORD_INCORRECT */]: 401,
+  ["SHARE_ACCESS_DENIED" /* SHARE_ACCESS_DENIED */]: 403,
+  ["SHARE_DOWNLOAD_LIMIT_EXCEEDED" /* SHARE_DOWNLOAD_LIMIT_EXCEEDED */]: 429
+};
+
+// src/universalFile/server/errors/ApiError.ts
+var ApiError = class _ApiError extends Error {
+  constructor(code, message, details, statusCode) {
+    super(message || ErrorMessages[code]);
+    this.name = "ApiError";
+    this.code = code;
+    this.statusCode = statusCode || ErrorHttpStatusMap[code] || 500;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ApiError);
+    }
+  }
+  /**
+   * 转换为API响应格式
+   */
+  toApiResponse() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details
+      },
+      meta: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * 转换为NextResponse
+   */
+  toNextResponse() {
+    return NextResponse.json(this.toApiResponse(), {
+      status: this.statusCode
+    });
+  }
+};
+var logger8 = createLogger("DrizzleFileRepository");
+function createDrizzleRepository(config) {
+  const { db, table, fieldMapping = {} } = config;
+  const getField = (field) => {
+    return fieldMapping[field] || field;
+  };
+  const toDbRecord = (metadata) => {
+    const record = {
+      [getField("id")]: metadata.id,
+      [getField("filename")]: metadata.filename,
+      [getField("originalName")]: metadata.originalName,
+      [getField("mimeType")]: metadata.mimeType,
+      [getField("size")]: metadata.size,
+      [getField("storageType")]: metadata.storageType,
+      [getField("storagePath")]: metadata.storagePath,
+      [getField("url")]: metadata.url,
+      [getField("moduleId")]: metadata.moduleId,
+      [getField("businessId")]: metadata.businessId,
+      [getField("uploadedAt")]: metadata.uploadedAt
+    };
+    if (metadata.hash !== void 0) record[getField("hash")] = metadata.hash;
+    if (metadata.cdnUrl !== void 0) record[getField("cdnUrl")] = metadata.cdnUrl;
+    if (metadata.userId !== void 0) record[getField("userId")] = metadata.userId;
+    if (metadata.expiresAt !== void 0) record[getField("expiresAt")] = metadata.expiresAt;
+    if (metadata.metadata !== void 0) record[getField("metadata")] = metadata.metadata;
+    if (metadata.status !== void 0) record[getField("status")] = metadata.status;
+    if (metadata.processingStatus !== void 0) record[getField("processingStatus")] = metadata.processingStatus;
+    if (metadata.versions !== void 0) record[getField("versions")] = metadata.versions;
+    if (metadata.tags !== void 0) record[getField("tags")] = metadata.tags;
+    return record;
+  };
+  const toFileMetadata = (record) => {
+    const metadata = {
+      id: record[getField("id")],
+      filename: record[getField("filename")],
+      originalName: record[getField("originalName")],
+      mimeType: record[getField("mimeType")],
+      size: record[getField("size")],
+      storageType: record[getField("storageType")],
+      storagePath: record[getField("storagePath")],
+      url: record[getField("url")],
+      moduleId: record[getField("moduleId")],
+      businessId: record[getField("businessId")],
+      uploadedAt: record[getField("uploadedAt")]
+    };
+    if (record[getField("hash")]) metadata.hash = record[getField("hash")];
+    if (record[getField("cdnUrl")]) metadata.cdnUrl = record[getField("cdnUrl")];
+    if (record[getField("userId")]) metadata.userId = record[getField("userId")];
+    if (record[getField("expiresAt")]) metadata.expiresAt = record[getField("expiresAt")];
+    if (record[getField("metadata")]) metadata.metadata = record[getField("metadata")];
+    if (record[getField("status")]) metadata.status = record[getField("status")];
+    if (record[getField("processingStatus")]) metadata.processingStatus = record[getField("processingStatus")];
+    if (record[getField("versions")]) metadata.versions = record[getField("versions")];
+    if (record[getField("tags")]) metadata.tags = record[getField("tags")];
+    return metadata;
+  };
+  return {
+    async save(metadata) {
+      try {
+        const record = toDbRecord(metadata);
+        const existing = await db.select().from(table).where(eq(table[getField("id")], metadata.id)).limit(1);
+        if (existing && existing.length > 0) {
+          await db.update(table).set(record).where(eq(table[getField("id")], metadata.id));
+          logger8.info(`\u2705 [DrizzleRepository] \u6587\u4EF6\u5143\u6570\u636E\u5DF2\u66F4\u65B0: ${metadata.id}`);
+        } else {
+          await db.insert(table).values(record);
+          logger8.info(`\u2705 [DrizzleRepository] \u6587\u4EF6\u5143\u6570\u636E\u5DF2\u63D2\u5165: ${metadata.id}`);
+        }
+      } catch (error) {
+        logger8.error(`\u274C [DrizzleRepository] \u4FDD\u5B58\u5931\u8D25: ${metadata.id}`, error);
+        throw error;
+      }
+    },
+    async get(fileId) {
+      try {
+        const result = await db.select().from(table).where(eq(table[getField("id")], fileId)).limit(1);
+        if (!result || result.length === 0) {
+          return null;
+        }
+        return toFileMetadata(result[0]);
+      } catch (error) {
+        logger8.error(`\u274C [DrizzleRepository] \u67E5\u8BE2\u5931\u8D25: ${fileId}`, error);
+        throw error;
+      }
+    },
+    async query(options) {
+      try {
+        const {
+          page = 1,
+          pageSize = 20,
+          moduleId,
+          businessId,
+          userId,
+          mimeType,
+          status,
+          startDate,
+          endDate,
+          tags
+        } = options;
+        const conditions = [];
+        if (moduleId) {
+          conditions.push(eq(table[getField("moduleId")], moduleId));
+        }
+        if (businessId) {
+          conditions.push(eq(table[getField("businessId")], businessId));
+        }
+        if (userId) {
+          conditions.push(eq(table[getField("userId")], userId));
+        }
+        if (mimeType) {
+          conditions.push(eq(table[getField("mimeType")], mimeType));
+        }
+        if (status) {
+          conditions.push(eq(table[getField("status")], status));
+        }
+        if (startDate) {
+          conditions.push(sql`${table[getField("uploadedAt")]} >= ${startDate}`);
+        }
+        if (endDate) {
+          conditions.push(sql`${table[getField("uploadedAt")]} <= ${endDate}`);
+        }
+        if (tags && tags.length > 0) {
+          for (const tag of tags) {
+            conditions.push(sql`${table[getField("tags")]} @> ${JSON.stringify([tag])}`);
+          }
+        }
+        const countResult = await db.select({ count: sql`count(*)` }).from(table).where(conditions.length > 0 ? and(...conditions) : void 0);
+        const total = Number(countResult[0]?.count || 0);
+        const offset = (page - 1) * pageSize;
+        const result = await db.select().from(table).where(conditions.length > 0 ? and(...conditions) : void 0).orderBy(desc(table[getField("uploadedAt")])).limit(pageSize).offset(offset);
+        const items = result.map(toFileMetadata);
+        return {
+          items,
+          total,
+          page,
+          pageSize,
+          totalPages: Math.ceil(total / pageSize)
+        };
+      } catch (error) {
+        logger8.error(`\u274C [DrizzleRepository] \u67E5\u8BE2\u5217\u8868\u5931\u8D25`, error);
+        throw error;
+      }
+    },
+    async delete(fileId) {
+      try {
+        await db.delete(table).where(eq(table[getField("id")], fileId));
+        logger8.info(`\u{1F5D1}\uFE0F [DrizzleRepository] \u6587\u4EF6\u5143\u6570\u636E\u5DF2\u5220\u9664: ${fileId}`);
+      } catch (error) {
+        logger8.error(`\u274C [DrizzleRepository] \u5220\u9664\u5931\u8D25: ${fileId}`, error);
+        throw error;
+      }
+    },
+    async batchDelete(fileIds) {
+      try {
+        if (fileIds.length === 0) return;
+        await db.delete(table).where(sql`${table[getField("id")]} = ANY(${fileIds})`);
+        logger8.info(`\u{1F5D1}\uFE0F [DrizzleRepository] \u6279\u91CF\u5220\u9664\u6210\u529F: ${fileIds.length} \u4E2A\u6587\u4EF6`);
+      } catch (error) {
+        logger8.error(`\u274C [DrizzleRepository] \u6279\u91CF\u5220\u9664\u5931\u8D25`, error);
+        throw error;
+      }
+    }
+  };
+}
+
+export { AliyunCDNProvider, ApiError, ApiErrorCode, AudioProcessor, CacheManager, CacheStrategyType, CdnCacheStrategy2 as CdnCacheStrategy, ConfigValidationError, ErrorHttpStatusMap, ErrorMessages, ImageProcessor, PerformanceMonitor, ProcessingQueue, UniversalFileService, VideoProcessor, cdnCacheStrategy, createAliyunOSSPreset, createDocumentServicePreset, createDrizzleRepository, createFileServiceConfig, createFileServiceFromEnv, createImageServicePreset, createLocalDevPreset, createSmartPreset, createUniversalFileService, createVideoServicePreset, getMimeType, getRequiredEnvVars, validateEnvironment, validateServiceConfig, validateStorageConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map