@pisell/pisellos 2.3.73 → 2.3.75

package/lib/server/modules/products/index.js

@@ -1,100 +1,117 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/server/modules/products/index.ts
-var products_exports = {};
-__export(products_exports, {
-  ProductsModule: () => ProductsModule
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(products_exports);
-var import_BaseModule = require("../../../modules/BaseModule");
-var import_Quotation = require("../../../modules/Quotation");
-var import_types = require("./types");
-var import_product = require("../../utils/product");
-var INDEXDB_STORE_NAME = "products";
-var PRODUCT_SYNC_DEBOUNCE_MS = 1e4;
-var PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS = 3e4;
-var ProductsModule = class extends import_BaseModule.BaseModule {
+exports.ProductsModule = void 0;
+var _BaseModule = require("../../../modules/BaseModule");
+var _Quotation = require("../../../modules/Quotation");
+var _types = require("./types");
+var _product = require("../../utils/product");
+/**
+ * IndexDB 存储名称
+ */
+const INDEXDB_STORE_NAME = 'products';
+/** 商品同步防抖时间（毫秒） */
+const PRODUCT_SYNC_DEBOUNCE_MS = 10_000;
+/** silentRefresh 最小间隔，避免 preload 后立即全量重拉 */
+const PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS = 30_000;
+
+/**
+ * Products 模块 - 用于获取和管理完整的商品详细数据
+ * 相比 ProductList 模块，Products 会获取所有详细信息并缓存
+ */
+class ProductsModule extends _BaseModule.BaseModule {
+  defaultName = 'products';
+  defaultVersion = '1.0.0';
+  store;
+  request;
+  dbManager; // IndexDBManager 实例
+  logger; // LoggerManager 实例
+  otherParams = {};
+
+  // 商品价格缓存：Map<日期, 应用了价格的商品列表>
+  productsPriceCache = new Map();
+
+  // 缓存配置
+  CACHE_MAX_DAYS = 7; // 最多缓存7天
+
+  // 商品格式化器列表
+  formatters = [];
+
+  // 是否已注册内置商品格式化器
+  isBuiltinFormatterRegistered = false;
+  // 旧报价单格式化器默认关闭，仅显式开启时作为兼容兜底注册
+  isLegacyPriceFormatterEnabled = false;
+
+  // 普通层 QuotationModule 桥接器：本地计算报价单价格，替代 /product/query/price
+  quotationPriceBridge;
+  quotationBridgeChannel;
+  quotationBridgeLoadedKey = '';
+  quotationBridgeRefreshPromise;
+  quotationBridgeRefreshKey;
+  quotationBridgeUpdatedCallback;
+  quotationScheduleCache = new Map();
+  quotationScheduleCacheSource = null;
+  quotationScheduleCacheLoaded = false;
+
+  // ---- 商品数据同步相关 ----
+  productDataSource;
+  pendingSyncMessages = [];
+  syncTimer;
+  /** 最近一次 SSE 全量拉取完成时间 */
+  lastServerFullFetchAtMs = 0;
+  /** 最近一次 preload 完成时间（含 IndexDB 命中） */
+  lastPreloadCompletedAtMs = 0;
+  /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
+  productIndexDBSaveQueue = Promise.resolve();
+
+  /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
+  lastScheduleTimePoints = [];
   constructor(name, version) {
     super(name, version);
-    this.defaultName = "products";
-    this.defaultVersion = "1.0.0";
-    // LoggerManager 实例
-    this.otherParams = {};
-    // 商品价格缓存：Map<日期, 应用了价格的商品列表>
-    this.productsPriceCache = /* @__PURE__ */ new Map();
-    // 缓存配置
-    this.CACHE_MAX_DAYS = 7;
-    // 最多缓存7天
-    // 商品格式化器列表
-    this.formatters = [];
-    // 是否已注册内置商品格式化器
-    this.isBuiltinFormatterRegistered = false;
-    // 旧报价单格式化器默认关闭，仅显式开启时作为兼容兜底注册
-    this.isLegacyPriceFormatterEnabled = false;
-    this.quotationBridgeLoadedKey = "";
-    this.quotationScheduleCache = /* @__PURE__ */ new Map();
-    this.quotationScheduleCacheSource = null;
-    this.quotationScheduleCacheLoaded = false;
-    this.pendingSyncMessages = [];
-    /** 最近一次 SSE 全量拉取完成时间 */
-    this.lastServerFullFetchAtMs = 0;
-    /** 最近一次 preload 完成时间（含 IndexDB 命中） */
-    this.lastPreloadCompletedAtMs = 0;
-    /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
-    this.productIndexDBSaveQueue = Promise.resolve();
-    /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
-    this.lastScheduleTimePoints = [];
   }
   async initialize(core, options) {
-    var _a;
     this.core = core;
     this.store = options.store;
     this.otherParams = options.otherParams || {};
-    if (Array.isArray((_a = options.initialState) == null ? void 0 : _a.list)) {
+    if (Array.isArray(options.initialState?.list)) {
       this.store.list = options.initialState.list;
+      // 同步更新 Map 缓存
       this.syncProductsMap();
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
     } else {
       this.store.list = [];
-      this.store.map = /* @__PURE__ */ new Map();
+      this.store.map = new Map();
     }
-    this.request = core.getPlugin("request");
-    const appPlugin = core.getPlugin("app");
+    this.request = core.getPlugin('request');
+
+    // 获取并存储 dbManager 和 logger
+    const appPlugin = core.getPlugin('app');
     if (appPlugin) {
       const app = appPlugin.getApp();
       this.dbManager = app.dbManager;
       this.logger = app.logger;
-      if (this.dbManager) {
-        console.log("[Products] IndexDB Manager 已初始化");
-      } else {
-        console.warn("[Products] IndexDB Manager 未找到");
+      if (this.dbManager) {} else {
+        console.warn('[Products] IndexDB Manager 未找到');
       }
     }
+
+    // 注册内置商品格式化器；智能定价默认替代报价单价格逻辑
     this.registerBuiltinProductFormatters();
+
+    // 初始化 ProductDataSource 实例
     this.initProductDataSource();
+
+    // 初始化商品数据同步（pubsub 订阅）
     this.setupProductSync();
-    this.logInfo("模块初始化完成", {
+    this.logInfo('模块初始化完成', {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
       initialProductCount: this.store.list.length
     });
   }
+
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -104,14 +121,16 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "info",
+          type: 'info',
           title: `[ProductsModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录警告日志
    * @param title 日志标题
@@ -121,14 +140,16 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "warning",
+          type: 'warning',
           title: `[ProductsModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -138,14 +159,16 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "error",
+          type: 'error',
           title: `[ProductsModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 加载商品价格（原始方法，不带缓存）
    * @private
@@ -156,7 +179,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     schedule_datetime,
     customer_id
   }) {
-    this.logInfo("开始加载商品价格", {
+    this.logInfo('开始加载商品价格', {
       productCount: ids.length,
       schedule_date,
       schedule_datetime,
@@ -167,10 +190,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     try {
       await this.ensureQuotationBridgeReady(customer_id);
       const idSet = new Set(ids);
-      const products = this.getProductsRef().filter((product) => idSet.has(product.id));
-      const priceData = products.map((product) => this.buildPriceDataFromQuotation(product, datetime, customer_id));
+      const products = this.getProductsRef().filter(product => idSet.has(product.id));
+      const priceData = products.map(product => this.buildPriceDataFromQuotation(product, datetime, customer_id));
       const duration = Date.now() - startTime;
-      this.logInfo("加载商品价格成功", {
+      this.logInfo('加载商品价格成功', {
         productCount: ids.length,
         priceDataCount: priceData.length,
         duration: `${duration}ms`
@@ -179,7 +202,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("加载商品价格失败", {
+      this.logError('加载商品价格失败', {
         productCount: ids.length,
         duration: `${duration}ms`,
         error: errorMessage
@@ -187,20 +210,20 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       return [];
     }
   }
+
   /**
    * 设置报价单价格桥接器。
    * Server 层负责传入完整 schedule 模块，Products 只负责把报价单计算结果转成价格响应形状。
    */
   async setupQuotationPriceBridge(params) {
-    var _a;
     if (!this.core) {
-      this.logWarning("setupQuotationPriceBridge: core 尚未初始化");
+      this.logWarning('setupQuotationPriceBridge: core 尚未初始化');
       return;
     }
-    const channel = params.channel || ((_a = this.otherParams) == null ? void 0 : _a.channel);
+    const channel = params.channel || this.otherParams?.channel;
     this.quotationBridgeChannel = channel;
     if (!this.quotationPriceBridge) {
-      const quotation = new import_Quotation.QuotationModule(`${this.name}_quotation_price_bridge`);
+      const quotation = new _Quotation.QuotationModule(`${this.name}_quotation_price_bridge`);
       await quotation.initialize(this.core, {});
       this.quotationPriceBridge = quotation;
     }
@@ -210,14 +233,13 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         this.quotationScheduleCacheLoaded = false;
         this.quotationScheduleCacheSource = params.scheduleModule;
       }
-      this.quotationPriceBridge.setScheduleResolver((id) => {
-        var _a2, _b, _c, _d, _e, _f;
+      this.quotationPriceBridge.setScheduleResolver(id => {
         const scheduleId = String(id);
         if (this.quotationScheduleCache.has(scheduleId)) {
           return this.quotationScheduleCache.get(scheduleId);
         }
         if (!this.quotationScheduleCacheLoaded) {
-          const scheduleList = ((_b = (_a2 = params.scheduleModule).getScheduleList) == null ? void 0 : _b.call(_a2)) || [];
+          const scheduleList = params.scheduleModule.getScheduleList?.() || [];
           for (const schedule of scheduleList) {
             this.quotationScheduleCache.set(String(schedule.id), schedule);
           }
@@ -226,20 +248,29 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         if (this.quotationScheduleCache.has(scheduleId)) {
           return this.quotationScheduleCache.get(scheduleId);
         }
-        const schedules = ((_d = (_c = params.scheduleModule).getScheduleListByIds) == null ? void 0 : _d.call(_c, [id])) || ((_f = (_e = params.scheduleModule).getScheduleByIds) == null ? void 0 : _f.call(_e, [id])) || [];
-        if (schedules[0])
-          this.quotationScheduleCache.set(scheduleId, schedules[0]);
+        const schedules = params.scheduleModule.getScheduleListByIds?.([id]) || params.scheduleModule.getScheduleByIds?.([id]) || [];
+        if (schedules[0]) this.quotationScheduleCache.set(scheduleId, schedules[0]);
         return schedules[0];
       });
     }
-    await this.refreshQuotationPriceBridge({ customer_id: params.customer_id });
+    if (params.onQuotationUpdated) {
+      this.quotationBridgeUpdatedCallback = params.onQuotationUpdated;
+    }
+    this.quotationPriceBridge.setQuotationListUpdatedListener?.(() => {
+      this.quotationBridgeLoadedKey = this.getQuotationBridgeScopeKey();
+      this.clearPriceCache();
+      this.quotationBridgeUpdatedCallback?.();
+    });
+    await this.refreshQuotationPriceBridge({
+      customer_id: params.customer_id
+    });
   }
+
   /**
    * 刷新桥接器内的报价单列表。
    */
   async refreshQuotationPriceBridge(params) {
-    if (!this.quotationPriceBridge)
-      return;
+    if (!this.quotationPriceBridge) return;
     const refreshKey = this.getQuotationBridgeScopeKey();
     if (this.quotationBridgeRefreshPromise && this.quotationBridgeRefreshKey === refreshKey) {
       await this.quotationBridgeRefreshPromise;
@@ -254,16 +285,15 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     }).then(() => {
       this.quotationBridgeLoadedKey = refreshKey;
     }).finally(() => {
-      this.quotationBridgeRefreshPromise = void 0;
-      this.quotationBridgeRefreshKey = void 0;
+      this.quotationBridgeRefreshPromise = undefined;
+      this.quotationBridgeRefreshKey = undefined;
     });
     await this.quotationBridgeRefreshPromise;
   }
   async ensureQuotationBridgeReady(customerId) {
-    var _a;
     if (!this.quotationPriceBridge) {
       await this.setupQuotationPriceBridge({
-        channel: (_a = this.otherParams) == null ? void 0 : _a.channel,
+        channel: this.otherParams?.channel,
         customer_id: customerId
       });
       return;
@@ -272,27 +302,27 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       await this.quotationBridgeRefreshPromise;
     }
     if (this.getQuotationBridgeScopeKey() !== this.quotationBridgeLoadedKey) {
-      await this.refreshQuotationPriceBridge({ customer_id: customerId });
+      await this.refreshQuotationPriceBridge({
+        customer_id: customerId
+      });
     }
   }
   getQuotationBridgeScopeKey() {
-    return this.quotationBridgeChannel || "";
+    return this.quotationBridgeChannel || '';
   }
   getQuotedPrice(params) {
-    var _a;
     const quotation = this.quotationPriceBridge;
-    if (!quotation)
-      return null;
+    if (!quotation) return null;
     const query = {
       productId: params.productId,
       variantId: params.variantId,
       datetime: params.datetime,
       customer_id: params.customerId
     };
-    if (typeof quotation.getQuotationMatchForProduct === "function") {
-      return ((_a = quotation.getQuotationMatchForProduct(query)) == null ? void 0 : _a.price) ?? null;
+    if (typeof quotation.getQuotationMatchForProduct === 'function') {
+      return quotation.getQuotationMatchForProduct(query)?.price ?? null;
     }
-    if (typeof quotation.getPriceForProduct === "function") {
+    if (typeof quotation.getPriceForProduct === 'function') {
       return quotation.getPriceForProduct(query);
     }
     return null;
@@ -314,9 +344,8 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     };
   }
   buildVariantPriceData(product, datetime, customerId) {
-    if (!Array.isArray(product.variant))
-      return [];
-    return product.variant.map((variant) => {
+    if (!Array.isArray(product.variant)) return [];
+    return product.variant.map(variant => {
       const quotedPrice = this.getQuotedPrice({
         productId: product.id,
         variantId: Number(variant.id),
@@ -334,11 +363,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     });
   }
   buildBundleGroupPriceData(product, datetime, customerId) {
-    if (!Array.isArray(product.bundle_group))
-      return [];
-    return product.bundle_group.map((group) => ({
+    if (!Array.isArray(product.bundle_group)) return [];
+    return product.bundle_group.map(group => ({
       id: Number(group.id),
-      bundle_item: (group.bundle_item || []).map((item) => {
+      bundle_item: (group.bundle_item || []).map(item => {
         const bundleProductId = Number(item.bundle_product_id);
         const bundleVariantId = Number(item.bundle_variant_id || 0);
         const quotedPrice = this.getQuotedPrice({
@@ -363,6 +391,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       })
     }));
   }
+
   /**
    * 获取应用了价格的商品列表（带缓存）
    * 使用日期作为缓存 key，同一天的商品价格会被缓存
@@ -375,28 +404,28 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @returns 应用了价格的商品列表
    */
   async getProductsWithPrice(schedule_date, extraContext, options) {
-    var _a;
     const t0 = performance.now();
-    const scopedProductIds = this.normalizeProductIds(options == null ? void 0 : options.productIds);
+    const scopedProductIds = this.normalizeProductIds(options?.productIds);
     const cacheKey = this.getProductsPriceCacheKey(schedule_date, extraContext, scopedProductIds);
-    const scopedProductIdSet = scopedProductIds ? new Set(scopedProductIds) : void 0;
-    const changedIds = scopedProductIdSet ? (_a = options == null ? void 0 : options.changedIds) == null ? void 0 : _a.filter((id) => scopedProductIdSet.has(id)) : options == null ? void 0 : options.changedIds;
+    const scopedProductIdSet = scopedProductIds ? new Set(scopedProductIds) : undefined;
+    const changedIds = scopedProductIdSet ? options?.changedIds?.filter(id => scopedProductIdSet.has(id)) : options?.changedIds;
     if (this.productsPriceCache.has(cacheKey)) {
       const cachedProducts = this.productsPriceCache.get(cacheKey);
+
+      // 有变更的商品 → 增量 prepare 后 merge 回缓存
       if (changedIds && changedIds.length > 0) {
-        this.logInfo("商品价格缓存命中，增量更新变更商品", {
+        this.logInfo('商品价格缓存命中，增量更新变更商品', {
           cacheKey,
           changedIds,
           cachedProductCount: cachedProducts.length
         });
         try {
-          const updatedProducts = await this.prepareProductsWithPrice(
-            schedule_date,
-            extraContext,
-            { productIds: changedIds }
-          );
+          const updatedProducts = await this.prepareProductsWithPrice(schedule_date, extraContext, {
+            productIds: changedIds
+          });
           if (updatedProducts.length > 0) {
-            const updatedMap = new Map(updatedProducts.map((p) => [p.id, p]));
+            // merge：用更新结果替换缓存中对应的商品，新增的追加
+            const updatedMap = new Map(updatedProducts.map(p => [p.id, p]));
             const mergedCache = [];
             for (const p of cachedProducts) {
               if (updatedMap.has(p.id)) {
@@ -406,16 +435,17 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
                 mergedCache.push(p);
               }
             }
+            // 剩余的是新增商品（create 场景）
             for (const p of updatedMap.values()) {
               mergedCache.push(p);
             }
             this.productsPriceCache.set(cacheKey, mergedCache);
-            this.logInfo("增量更新完成", {
+            this.logInfo('增量更新完成', {
               cacheKey,
               changedCount: updatedProducts.length,
               totalCount: mergedCache.length
             });
-            (0, import_product.perfMark)("getProductsWithPrice(incrementalUpdate)", performance.now() - t0, {
+            (0, _product.perfMark)('getProductsWithPrice(incrementalUpdate)', performance.now() - t0, {
               cacheKey,
               changedCount: changedIds.length,
               count: mergedCache.length
@@ -424,50 +454,49 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          this.logError("增量更新失败，返回现有缓存", {
+          this.logError('增量更新失败，返回现有缓存', {
             cacheKey,
             changedIds,
             error: errorMessage
           });
         }
-        (0, import_product.perfMark)("getProductsWithPrice(incrementalUpdate)", performance.now() - t0, {
+        (0, _product.perfMark)('getProductsWithPrice(incrementalUpdate)', performance.now() - t0, {
           cacheKey,
           changedCount: changedIds.length,
           count: cachedProducts.length
         });
         return cachedProducts;
       }
-      (0, import_product.perfMark)("getProductsWithPrice(cacheHit)", performance.now() - t0, {
+      (0, _product.perfMark)('getProductsWithPrice(cacheHit)', performance.now() - t0, {
         cacheKey,
         count: cachedProducts.length
       });
-      this.logInfo("商品价格缓存命中", {
+      this.logInfo('商品价格缓存命中', {
         cacheKey,
         productCount: cachedProducts.length
       });
       return cachedProducts;
     }
-    this.logInfo("商品价格缓存未命中，准备获取", {
+    this.logInfo('商品价格缓存未命中，准备获取', {
       cacheKey,
-      scopedProductCount: scopedProductIds == null ? void 0 : scopedProductIds.length
+      scopedProductCount: scopedProductIds?.length
     });
-    const result = await this.prepareProductsWithPrice(
-      schedule_date,
-      extraContext,
-      scopedProductIds ? { productIds: scopedProductIds } : void 0
-    );
+    const result = await this.prepareProductsWithPrice(schedule_date, extraContext, scopedProductIds ? {
+      productIds: scopedProductIds
+    } : undefined);
     this.productsPriceCache.set(cacheKey, result);
-    this.logInfo("商品价格已缓存", {
+    this.logInfo('商品价格已缓存', {
       cacheKey,
       productCount: result.length
     });
     this.cleanExpiredPriceCache();
-    (0, import_product.perfMark)("getProductsWithPrice(cacheMiss)", performance.now() - t0, {
+    (0, _product.perfMark)('getProductsWithPrice(cacheMiss)', performance.now() - t0, {
       cacheKey,
       count: result.length
     });
     return result;
   }
+
   /**
    * 准备带价格的商品数据（通过格式化器流程处理）
    * @param schedule_date 日期
@@ -478,21 +507,21 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @private
    */
   async prepareProductsWithPrice(schedule_date, extraContext, options) {
-    var _a, _b, _c, _d;
     const tTotal = performance.now();
-    const targetIds = options == null ? void 0 : options.productIds;
+    const targetIds = options?.productIds;
     const isIncremental = Array.isArray(targetIds);
-    this.logInfo("prepareProductsWithPrice 开始处理", {
+    this.logInfo('prepareProductsWithPrice 开始处理', {
       schedule_date,
-      mode: isIncremental ? "incremental" : "full",
-      targetIdsCount: targetIds == null ? void 0 : targetIds.length
+      mode: isIncremental ? 'incremental' : 'full',
+      targetIdsCount: targetIds?.length
     });
     try {
+      // 1. 获取商品列表：指定 IDs 时从 store 取子集，否则取全量
       let products;
       let ids;
       if (isIncremental) {
         products = this.getProductsRefByIds(targetIds);
-        ids = products.map((p) => p.id);
+        ids = products.map(p => p.id);
       } else {
         products = this.getProductsRef();
         const tIds = performance.now();
@@ -500,61 +529,69 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         for (let i = 0; i < products.length; i++) {
           ids[i] = products[i].id;
         }
-        (0, import_product.perfMark)("prepareProducts.extractIds", performance.now() - tIds, { count: ids.length });
+        (0, _product.perfMark)('prepareProducts.extractIds', performance.now() - tIds, {
+          count: ids.length
+        });
       }
-      this.logInfo("获取到商品列表", { productCount: products.length });
+      this.logInfo('获取到商品列表', {
+        productCount: products.length
+      });
+
+      // 2. 仅在 legacy 报价单 formatter 启用时加载报价单价格；默认由智能定价覆盖商品价格。
       let priceData = [];
       if (this.isLegacyPriceFormatterEnabled) {
         const tPrice = performance.now();
         priceData = await this.loadProductsPrice({
           ids,
           schedule_date,
-          schedule_datetime: extraContext == null ? void 0 : extraContext.schedule_datetime,
-          customer_id: extraContext == null ? void 0 : extraContext.customer_id
+          schedule_datetime: extraContext?.schedule_datetime,
+          customer_id: extraContext?.customer_id
+        });
+        (0, _product.perfMark)('prepareProducts.loadPrice', performance.now() - tPrice, {
+          count: ids.length
+        });
+        this.logInfo('获取商品报价单价格成功', {
+          priceDataCount: priceData?.length ?? 0
         });
-        (0, import_product.perfMark)("prepareProducts.loadPrice", performance.now() - tPrice, { count: ids.length });
-        this.logInfo("获取商品报价单价格成功", { priceDataCount: (priceData == null ? void 0 : priceData.length) ?? 0 });
       }
       const context = {
         schedule_date,
-        schedule_datetime: extraContext == null ? void 0 : extraContext.schedule_datetime,
-        customer_id: extraContext == null ? void 0 : extraContext.customer_id,
+        schedule_datetime: extraContext?.schedule_datetime,
+        customer_id: extraContext?.customer_id,
         priceData,
-        locale: (_b = (_a = this.core) == null ? void 0 : _a.context) == null ? void 0 : _b.locale,
-        dataVariantEvaluator: (extraContext == null ? void 0 : extraContext.dataVariantEvaluator) || ((_d = (_c = this.core) == null ? void 0 : _c.context) == null ? void 0 : _d.dataVariantEvaluator),
-        menuList: (extraContext == null ? void 0 : extraContext.menuList) || [],
-        scheduleList: (extraContext == null ? void 0 : extraContext.scheduleList) || [],
-        strategy_context: extraContext == null ? void 0 : extraContext.strategy_context,
+        locale: this.core?.context?.locale,
+        dataVariantEvaluator: extraContext?.dataVariantEvaluator || this.core?.context?.dataVariantEvaluator,
+        menuList: extraContext?.menuList || [],
+        scheduleList: extraContext?.scheduleList || [],
+        strategy_context: extraContext?.strategy_context,
         ...extraContext
       };
+
+      // 3. 通过格式化器流程处理商品
       const tFormat = performance.now();
       const processedProducts = await this.applyFormatters(products, context);
-      (0, import_product.perfMark)("prepareProducts.applyFormatters", performance.now() - tFormat, {
+      (0, _product.perfMark)('prepareProducts.applyFormatters', performance.now() - tFormat, {
         count: products.length,
         formatterCount: this.formatters.length
       });
-      this.logInfo("prepareProductsWithPrice 处理完成", {
-        mode: isIncremental ? "incremental" : "full",
+      this.logInfo('prepareProductsWithPrice 处理完成', {
+        mode: isIncremental ? 'incremental' : 'full',
         originalProductCount: products.length,
         processedProductCount: processedProducts.length,
         formatterCount: this.formatters.length
       });
       if (!isIncremental) {
-        await this.core.effects.emit(
-          import_types.ProductsHooks.onProductsPriceApplied,
-          processedProducts
-        );
+        await this.core.effects.emit(_types.ProductsHooks.onProductsPriceApplied, processedProducts);
       }
-      (0, import_product.perfMark)("prepareProductsWithPrice", performance.now() - tTotal, {
+      (0, _product.perfMark)('prepareProductsWithPrice', performance.now() - tTotal, {
         productCount: products.length,
         formatterCount: this.formatters.length,
-        mode: isIncremental ? "incremental" : "full"
+        mode: isIncremental ? 'incremental' : 'full'
       });
       return processedProducts;
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
-      console.log(`[ProductsModule] 🌐 ERROR`, err);
-      this.logError("prepareProductsWithPrice 处理失败", {
+      this.logError('prepareProductsWithPrice 处理失败', {
         schedule_date,
         error: errorMessage
       });
@@ -562,31 +599,28 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     return [];
   }
   getProductsPriceCacheKey(schedule_date, extraContext, productIds) {
-    const datetime = (extraContext == null ? void 0 : extraContext.schedule_datetime) || schedule_date;
-    const productScope = productIds ? `:products:${productIds.join(",")}` : "";
-    const strategyScope = this.stringifyStable((extraContext == null ? void 0 : extraContext.strategy_context) || {});
-    return `${datetime}:customer:${(extraContext == null ? void 0 : extraContext.customer_id) ?? ""}:strategy:${strategyScope}${productScope}`;
+    const datetime = extraContext?.schedule_datetime || schedule_date;
+    const productScope = productIds ? `:products:${productIds.join(',')}` : '';
+    const strategyScope = this.stringifyStable(extraContext?.strategy_context || {});
+    return `${datetime}:customer:${extraContext?.customer_id ?? ''}:strategy:${strategyScope}${productScope}`;
   }
+
   /**
    * 稳定序列化策略上下文，避免对象 key 顺序不同导致缓存 key 抖动。
    */
   stringifyStable(value) {
-    if (value == null)
-      return "";
-    if (Array.isArray(value))
-      return `[${value.map((item) => this.stringifyStable(item)).join(",")}]`;
-    if (typeof value === "object") {
-      return `{${Object.keys(value).sort().map((key) => `${key}:${this.stringifyStable(value[key])}`).join(",")}}`;
+    if (value == null) return '';
+    if (Array.isArray(value)) return `[${value.map(item => this.stringifyStable(item)).join(',')}]`;
+    if (typeof value === 'object') {
+      return `{${Object.keys(value).sort().map(key => `${key}:${this.stringifyStable(value[key])}`).join(',')}}`;
     }
     return String(value);
   }
   normalizeProductIds(productIds) {
-    if (!Array.isArray(productIds))
-      return void 0;
-    return Array.from(new Set(
-      productIds.map((id) => Number(id)).filter((id) => Number.isFinite(id))
-    )).sort((a, b) => a - b);
+    if (!Array.isArray(productIds)) return undefined;
+    return Array.from(new Set(productIds.map(id => Number(id)).filter(id => Number.isFinite(id)))).sort((a, b) => a - b);
   }
+
   /**
    * 按轻量范围返回商品 ID，不做 structuredClone。
    */
@@ -594,29 +628,24 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     const productIds = this.normalizeProductIds(scope.productIds) || [];
     const collectionIds = this.normalizeProductIds(scope.collectionIds) || [];
     if (scope.isAllProducts) {
-      return this.getProductsRef().map((product) => product.id);
+      return this.getProductsRef().map(product => product.id);
     }
-    if (productIds.length === 0 && collectionIds.length === 0)
-      return [];
-    const result = /* @__PURE__ */ new Set();
+    if (productIds.length === 0 && collectionIds.length === 0) return [];
+    const result = new Set();
     for (const id of productIds) {
-      if (this.store.map.has(id))
-        result.add(id);
+      if (this.store.map.has(id)) result.add(id);
     }
-    if (collectionIds.length === 0)
-      return Array.from(result);
+    if (collectionIds.length === 0) return Array.from(result);
     const collectionIdSet = new Set(collectionIds);
     for (const product of this.getProductsRef()) {
-      if (result.has(product.id))
-        continue;
-      if (!Array.isArray(product.collection))
-        continue;
-      const isInCollection = product.collection.some((collection) => collectionIdSet.has(collection.id));
-      if (isInCollection)
-        result.add(product.id);
+      if (result.has(product.id)) continue;
+      if (!Array.isArray(product.collection)) continue;
+      const isInCollection = product.collection.some(collection => collectionIdSet.has(collection.id));
+      if (isInCollection) result.add(product.id);
     }
     return Array.from(result);
   }
+
   /**
    * 应用所有已注册的格式化器
    * @param products 商品列表
@@ -627,11 +656,13 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   async applyFormatters(products, context) {
     let result = products;
     if (this.formatters.length === 0) {
-      console.warn("[ProductsModule] ⚠️ 没有注册任何格式化器");
-      this.logWarning("没有注册任何格式化器", { productCount: products.length });
+      console.warn('[ProductsModule] ⚠️ 没有注册任何格式化器');
+      this.logWarning('没有注册任何格式化器', {
+        productCount: products.length
+      });
       return result;
     }
-    this.logInfo("开始应用格式化器", {
+    this.logInfo('开始应用格式化器', {
       productCount: products.length,
       formatterCount: this.formatters.length
     });
@@ -640,7 +671,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       try {
         const tF = performance.now();
         result = await formatter(result, context);
-        (0, import_product.perfMark)(`applyFormatters[${i}]`, performance.now() - tF, {
+        (0, _product.perfMark)(`applyFormatters[${i}]`, performance.now() - tF, {
           index: i,
           total: this.formatters.length,
           productCount: result.length
@@ -655,12 +686,13 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         });
       }
     }
-    this.logInfo("所有格式化器已应用", {
+    this.logInfo('所有格式化器已应用', {
       formatterCount: this.formatters.length,
       resultProductCount: result.length
     });
     return result;
   }
+
   /**
    * 注册内置商品格式化器。
    *
@@ -669,16 +701,15 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   registerBuiltinProductFormatters() {
     if (this.isBuiltinFormatterRegistered) {
-      console.warn("[ProductsModule] 内置商品格式化器已注册，跳过");
+      console.warn('[ProductsModule] 内置商品格式化器已注册，跳过');
       return;
     }
     this.isLegacyPriceFormatterEnabled = this.shouldEnableLegacyPriceFormatter();
     const dataVariantFormatter = (products, context) => {
-      var _a, _b;
-      const evaluator = context.dataVariantEvaluator || ((_b = (_a = this.core) == null ? void 0 : _a.context) == null ? void 0 : _b.dataVariantEvaluator);
-      if (!evaluator || typeof evaluator.resolveProducts !== "function") {
+      const evaluator = context.dataVariantEvaluator || this.core?.context?.dataVariantEvaluator;
+      if (!evaluator || typeof evaluator.resolveProducts !== 'function') {
         this.lastScheduleTimePoints = [];
-        this.logWarning("智能定价评估器未注入，跳过 DataVariant 格式化", {
+        this.logWarning('智能定价评估器未注入，跳过 DataVariant 格式化', {
           productCount: products.length
         });
         return products;
@@ -697,22 +728,22 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         custom: strategyContext
       };
       const result = evaluator.resolveProducts(businessData);
-      this.lastScheduleTimePoints = Array.isArray(result == null ? void 0 : result.scheduleTimePoints) ? [...result.scheduleTimePoints] : [];
-      return Array.isArray(result == null ? void 0 : result.products) ? result.products : products;
+      this.lastScheduleTimePoints = Array.isArray(result?.scheduleTimePoints) ? [...result.scheduleTimePoints] : [];
+      return Array.isArray(result?.products) ? result.products : products;
     };
+
+    // 创建 legacy 报价单格式化器
     const legacyPriceFormatter = (products, context) => {
       if (!context.priceData || context.priceData.length === 0) {
-        console.log("[ProductsModule] 💰 没有价格数据，跳过 legacy 报价单价格应用");
         return products;
       }
-      console.log(`[ProductsModule] 💰 应用 legacy 报价单价格到 ${products.length} 个商品`);
-      return (0, import_product.applyPriceDataToProducts)(products, context.priceData);
+      return (0, _product.applyPriceDataToProducts)(products, context.priceData);
     };
     const i18nFormatter = (products, context) => {
-      return (0, import_product.applyI18nToProducts)(products, context.locale);
+      return (0, _product.applyI18nToProducts)(products, context.locale);
     };
     const detailValueFormatter = (products, context) => {
-      return (0, import_product.applyDetailValueToProducts)(products, context);
+      return (0, _product.applyDetailValueToProducts)(products, context);
     };
     if (this.isLegacyPriceFormatterEnabled) {
       this.formatters.push(legacyPriceFormatter);
@@ -721,17 +752,17 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     this.formatters.push(i18nFormatter);
     this.formatters.push(detailValueFormatter);
     this.isBuiltinFormatterRegistered = true;
-    console.log("[ProductsModule] ✅ 内置商品格式化器已注册（智能定价优先）");
   }
+
   /**
    * 是否启用旧报价单价格 formatter。
    *
    * 默认关闭，避免报价单逻辑覆盖智能定价结果。
    */
   shouldEnableLegacyPriceFormatter() {
-    var _a, _b, _c;
-    return ((_a = this.otherParams) == null ? void 0 : _a.enableLegacyPriceFormatter) === true || ((_c = (_b = this.core) == null ? void 0 : _b.context) == null ? void 0 : _c.enableLegacyPriceFormatter) === true;
+    return this.otherParams?.enableLegacyPriceFormatter === true || this.core?.context?.enableLegacyPriceFormatter === true;
   }
+
   /**
    * 返回最近一次 prepareProductsWithPrice / DataVariant 评估提取的变价时间点（HH:mm）。
    * 供 OS Server 商品 query 订阅定时刷新使用。
@@ -739,6 +770,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   getLastScheduleTimePoints() {
     return [...this.lastScheduleTimePoints];
   }
+
   /**
    * 注册商品格式化器
    * 格式化器会按注册顺序依次执行；legacy 启用时先兜底报价，再由智能定价覆盖。
@@ -756,29 +788,30 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   registerFormatter(formatter, prepend = false) {
     if (prepend) {
+      // 插入到内置智能定价格式化器之后；legacy 报价单启用时需跳过它。
       const insertIndex = this.isBuiltinFormatterRegistered ? this.isLegacyPriceFormatterEnabled ? 2 : 1 : 0;
       this.formatters.splice(insertIndex, 0, formatter);
-      console.log(`[ProductsModule] 📌 已在位置 ${insertIndex + 1} 插入格式化器，当前共 ${this.formatters.length} 个`);
     } else {
+      // 追加到末尾
       this.formatters.push(formatter);
-      console.log(`[ProductsModule] 📌 已注册格式化器，当前共 ${this.formatters.length} 个`);
     }
   }
+
   /**
    * 清空所有格式化器（包括内置智能定价格式化器）
    * @param keepBuiltin 是否保留内置智能定价格式化器（默认 true）
    */
   clearFormatters(keepBuiltin = true) {
     if (keepBuiltin && this.isBuiltinFormatterRegistered) {
+      // 保留 legacy 兜底（如果启用）和智能定价格式化器。
       const builtinCount = this.isLegacyPriceFormatterEnabled ? 2 : 1;
       this.formatters = this.formatters.slice(0, builtinCount);
-      console.log("[ProductsModule] 🧹 已清空自定义格式化器，保留内置智能定价格式化器");
     } else {
       this.formatters = [];
       this.isBuiltinFormatterRegistered = false;
-      console.log("[ProductsModule] 🧹 已清空所有格式化器");
     }
   }
+
   /**
    * 清理过期的价格缓存
    * 当缓存数量超过限制时，删除最老的缓存
@@ -789,59 +822,72 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       const keys = Array.from(this.productsPriceCache.keys());
       const oldestKey = keys[0];
       this.productsPriceCache.delete(oldestKey);
-      console.log(`[ProductsModule] 🧹 清理过期商品价格缓存: ${oldestKey}`);
     }
   }
+
   /**
    * 清空商品价格缓存
    * 可用于手动刷新价格数据
    */
   clearPriceCache() {
     this.productsPriceCache.clear();
-    console.log("[ProductsModule] 🗑️ 商品价格缓存已清空");
+    this.quotationScheduleCache.clear();
+    this.quotationScheduleCacheLoaded = false;
   }
+
   /**
    * 通过 ProductDataSource SSE 加载完整商品列表
    */
-  async loadProductsByServer() {
+  async loadProductsByServer(options = {}) {
     if (!this.productDataSource) {
-      this.logWarning("loadProductsByServer: ProductDataSource 不可用");
+      this.logWarning('loadProductsByServer: ProductDataSource 不可用');
       return [];
     }
-    this.logInfo("开始通过 DataSource SSE 加载商品列表");
+    const trigger = options.trigger || 'unknown';
+    this.logInfo('开始通过 DataSource SSE 加载商品列表', {
+      trigger
+    });
     const t0 = performance.now();
     try {
       const tSSE = performance.now();
-      const productList = await this.productDataSource.run({ sse: {} });
+      const productList = await this.productDataSource.run({
+        sse: {}
+      });
       const list = productList || [];
-      (0, import_product.perfMark)("loadProductsByServer.SSE", performance.now() - tSSE, { count: list.length });
-      this.logInfo("通过 DataSource SSE 加载商品列表成功", {
+      (0, _product.perfMark)('loadProductsByServer.SSE', performance.now() - tSSE, {
+        count: list.length
+      });
+      this.logInfo('通过 DataSource SSE 加载商品列表成功', {
+        trigger,
         productCount: list.length,
         duration: `${Math.round(performance.now() - t0)}ms`
       });
-      await this.replaceProductsSnapshotInIndexDB(list, "loadProductsByServer");
+      await this.replaceProductsSnapshotInIndexDB(list, 'loadProductsByServer');
       this.lastServerFullFetchAtMs = Date.now();
-      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, list);
-      (0, import_product.perfMark)("loadProductsByServer", performance.now() - t0, { count: list.length });
+      await this.core.effects.emit(_types.ProductsHooks.onProductsLoaded, list);
+      (0, _product.perfMark)('loadProductsByServer', performance.now() - t0, {
+        count: list.length
+      });
       return list;
     } catch (error) {
       const duration = Math.round(performance.now() - t0);
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Products] 加载商品数据失败:", error);
-      this.logError("通过 DataSource SSE 加载商品列表失败", {
+      console.error('[Products] 加载商品数据失败:', error);
+      this.logError('通过 DataSource SSE 加载商品列表失败', {
+        trigger,
         duration: `${duration}ms`,
         error: errorMessage
       });
       return [];
     }
   }
+
   /**
    * 纯请求方法：通过 HTTP 接口获取商品列表（无副作用，不触发事件、不写 IndexDB）
    * @param params 查询参数
    * @returns 商品列表
    */
   async fetchProductsByHttp(params) {
-    var _a, _b;
     const {
       category_ids = [],
       product_ids = [],
@@ -849,7 +895,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       customer_id,
       cacheId
     } = params || {};
-    this.logInfo("fetchProductsByHttp: 开始请求", {
+    this.logInfo('fetchProductsByHttp: 开始请求', {
       categoryIdsCount: category_ids.length,
       productIdsCount: product_ids.length,
       collectionCount: Array.isArray(collection) ? collection.length : collection ? 1 : 0,
@@ -857,46 +903,29 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     });
     const startTime = Date.now();
     try {
-      const productsData = await this.request.post(
-        `/product/query`,
-        {
-          open_bundle: 1,
-          exclude_extension_type: [
-            "product_party",
-            "product_event",
-            "product_series_event",
-            "product_package_ticket",
-            "ticket",
-            "event_item"
-          ],
-          force_ignore_cache_flag: 1,
-          with: [
-            "category",
-            "collection",
-            "resourceRelation",
-            "bundleGroup.bundleItem",
-            "optionGroup.optionItem",
-            "variantGroup.variantItem",
-            "dataVariants"
-          ],
-          open_deposit: 1,
-          is_append_product_description: 1,
-          with_count: ["bundleGroup", "optionGroup"],
-          with_category_tree: 1,
-          status: "published",
-          num: 500,
-          skip: 1,
-          category_ids,
-          ids: product_ids,
-          collection,
-          front_end_cache_id: cacheId,
-          application_code: (_a = this.otherParams) == null ? void 0 : _a.channel
-        },
-        { cache: void 0 }
-      );
-      const productList = ((_b = productsData == null ? void 0 : productsData.data) == null ? void 0 : _b.list) || [];
+      const productsData = await this.request.post(`/product/query`, {
+        open_bundle: 1,
+        exclude_extension_type: ['product_party', 'product_event', 'product_series_event', 'product_package_ticket', 'ticket', 'event_item'],
+        force_ignore_cache_flag: 1,
+        with: ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem', 'dataVariants'],
+        open_deposit: 1,
+        is_append_product_description: 1,
+        with_count: ['bundleGroup', 'optionGroup'],
+        with_category_tree: 1,
+        status: 'published',
+        num: 500,
+        skip: 1,
+        category_ids,
+        ids: product_ids,
+        collection,
+        front_end_cache_id: cacheId,
+        application_code: this.otherParams?.channel
+      }, {
+        cache: undefined
+      });
+      const productList = productsData?.data?.list || [];
       const duration = Date.now() - startTime;
-      this.logInfo("fetchProductsByHttp: 请求成功", {
+      this.logInfo('fetchProductsByHttp: 请求成功', {
         productCount: productList.length,
         duration: `${duration}ms`
       });
@@ -904,14 +933,15 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Products] fetchProductsByHttp 失败:", error);
-      this.logError("fetchProductsByHttp: 请求失败", {
+      console.error('[Products] fetchProductsByHttp 失败:', error);
+      this.logError('fetchProductsByHttp: 请求失败', {
         duration: `${duration}ms`,
         error: errorMessage
       });
       return [];
     }
   }
+
   /**
    * 加载完整商品列表通过接口（包含所有详细数据）
    * 包含副作用：保存到 IndexDB + 触发 onProductsLoaded 事件
@@ -920,34 +950,36 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   async loadProductsByServerHttp(params) {
     const productList = await this.fetchProductsByHttp(params);
     if (productList.length > 0) {
-      await this.replaceProductsSnapshotInIndexDB(productList, "loadProductsByServerHttp");
+      await this.replaceProductsSnapshotInIndexDB(productList, 'loadProductsByServerHttp');
       this.lastServerFullFetchAtMs = Date.now();
-      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, productList);
+      await this.core.effects.emit(_types.ProductsHooks.onProductsLoaded, productList);
     }
     return productList;
   }
+
   /**
    * 获取商品列表（深拷贝，供外部安全使用）
    */
   async getProducts() {
     const t0 = performance.now();
     const result = structuredClone(this.store.list);
-    (0, import_product.perfMark)("ProductsModule.getProducts(structuredClone)", performance.now() - t0, { count: result.length });
+    (0, _product.perfMark)('ProductsModule.getProducts(structuredClone)', performance.now() - t0, {
+      count: result.length
+    });
     return result;
   }
+
   /**
    * 批量获取商品轻量快照，供订单详情等响应补齐展示协议字段。
    */
   async getProductSnapshotsByIds(ids) {
     const snapshots = {};
-    const seen = /* @__PURE__ */ new Set();
+    const seen = new Set();
     for (const id of ids) {
-      if (!Number.isFinite(id) || seen.has(id))
-        continue;
+      if (!Number.isFinite(id) || seen.has(id)) continue;
       seen.add(id);
       const product = this.store.map.get(id);
-      if (!product)
-        continue;
+      if (!product) continue;
       snapshots[String(id)] = {
         cover: product.cover,
         holder_config: product.holder_config
@@ -955,6 +987,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     }
     return snapshots;
   }
+
   /**
    * 内部获取商品列表的直接引用（无拷贝）
    * 仅供内部 formatter 流程使用，因为 formatter 会创建新对象
@@ -962,6 +995,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   getProductsRef() {
     return this.store.list;
   }
+
   /**
    * 按 ID 从 Map 取商品引用，供内部 formatter 流程使用。
    */
@@ -969,27 +1003,31 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     const products = [];
     for (const id of ids) {
       const product = this.store.map.get(id);
-      if (product)
-        products.push(product);
+      if (product) products.push(product);
     }
     return products;
   }
+
   /**
    * 根据ID获取单个商品（从内存缓存）
    * 使用 Map 快速查询，时间复杂度 O(1)
    */
   async getProductById(id) {
     const product = this.store.map.get(id);
-    return product ? structuredClone(product) : void 0;
+    return product ? structuredClone(product) : undefined;
   }
+
   /**
    * 根据 ID 列表删除商品（用于 pubsub 同步删除场景）
    * 同时更新 store.list、store.map、IndexDB 和价格缓存
    */
   async removeProductsByIds(ids) {
     const idSet = new Set(ids);
-    this.logInfo("removeProductsByIds", { ids, count: ids.length });
-    this.store.list = this.store.list.filter((p) => !idSet.has(p.id));
+    this.logInfo('removeProductsByIds', {
+      ids,
+      count: ids.length
+    });
+    this.store.list = this.store.list.filter(p => !idSet.has(p.id));
     for (const id of ids) {
       this.store.map.delete(id);
     }
@@ -1000,85 +1038,107 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("removeProductsByIds: IndexDB 删除失败", { ids, error: errorMessage });
+        this.logError('removeProductsByIds: IndexDB 删除失败', {
+          ids,
+          error: errorMessage
+        });
       }
     }
     for (const [dateKey, cachedProducts] of this.productsPriceCache.entries()) {
-      this.productsPriceCache.set(
-        dateKey,
-        cachedProducts.filter((p) => !idSet.has(p.id))
-      );
+      this.productsPriceCache.set(dateKey, cachedProducts.filter(p => !idSet.has(p.id)));
     }
-    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-    this.logInfo("removeProductsByIds 完成", { remaining: this.store.list.length });
+    this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    this.logInfo('removeProductsByIds 完成', {
+      remaining: this.store.list.length
+    });
   }
+
   /**
    * 重新从服务器加载全量商品列表并更新本地 store
    * 用于 pubsub 同步 create / update / batch_update 场景
    */
   async refreshProducts() {
     const tTotal = performance.now();
-    this.logInfo("refreshProducts 开始");
-    const products = await this.loadProductsByServer();
+    this.logInfo('refreshProducts 开始');
+    const products = await this.loadProductsByServer({
+      trigger: 'product_sync'
+    });
     if (products && products.length > 0) {
+      // 服务器返回的数据已经是全新的，无需 cloneDeep
       this.store.list = products;
       this.syncProductsMap();
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-      this.logInfo("refreshProducts 完成", { productCount: products.length });
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+      this.logInfo('refreshProducts 完成', {
+        productCount: products.length
+      });
     } else {
-      this.logWarning("refreshProducts: 服务器未返回数据");
+      this.logWarning('refreshProducts: 服务器未返回数据');
     }
-    (0, import_product.perfMark)("refreshProducts", performance.now() - tTotal, { count: this.store.list.length });
+    (0, _product.perfMark)('refreshProducts', performance.now() - tTotal, {
+      count: this.store.list.length
+    });
     return this.store.list;
   }
+
   /**
    * 清空缓存
    */
   async clear() {
-    this.logInfo("开始清空缓存", {
+    this.logInfo('开始清空缓存', {
       currentProductCount: this.store.list.length,
       priceCacheCount: this.productsPriceCache.size
     });
     this.store.list = [];
     this.store.map.clear();
+
+    // 同时清空 IndexDB 中的所有数据（包括商品和元数据）
     if (this.dbManager) {
       try {
         await this.dbManager.clear(INDEXDB_STORE_NAME);
-        console.log("[Products] IndexDB 缓存已清空");
-        this.logInfo("IndexDB 缓存已清空");
+        this.logInfo('IndexDB 缓存已清空');
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("[Products] 清空 IndexDB 缓存失败:", error);
-        this.logError("清空 IndexDB 缓存失败", { error: errorMessage });
+        console.error('[Products] 清空 IndexDB 缓存失败:', error);
+        this.logError('清空 IndexDB 缓存失败', {
+          error: errorMessage
+        });
       }
     }
-    console.log("[Products] 缓存已清空");
-    this.logInfo("缓存清空完成");
+    this.logInfo('缓存清空完成');
   }
+
   /**
    * 从 IndexDB 加载商品数据
    * @private
    */
   async loadProductsFromIndexDB() {
     if (!this.dbManager) {
-      this.logWarning("loadProductsFromIndexDB: dbManager 不可用");
+      this.logWarning('loadProductsFromIndexDB: dbManager 不可用');
       return [];
     }
+    const startedAt = performance.now();
     try {
-      const t0 = performance.now();
       const products = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      (0, import_product.perfMark)("loadProductsFromIndexDB", performance.now() - t0, { count: (products == null ? void 0 : products.length) ?? 0 });
-      this.logInfo("从 IndexDB 加载商品数据", {
-        productCount: (products == null ? void 0 : products.length) ?? 0
+      const durationMs = +(performance.now() - startedAt).toFixed(2);
+      (0, _product.perfMark)('loadProductsFromIndexDB', durationMs, {
+        count: products?.length ?? 0
+      });
+      this.logInfo('从 IndexDB 加载商品数据', {
+        productCount: products?.length ?? 0,
+        durationMs
       });
       return products || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Products] 从 IndexDB 读取数据失败:", error);
-      this.logError("从 IndexDB 读取数据失败", { error: errorMessage });
+      console.error('[Products] 从 IndexDB 读取数据失败:', error);
+      this.logError('从 IndexDB 读取数据失败', {
+        durationMs: +(performance.now() - startedAt).toFixed(2),
+        error: errorMessage
+      });
       return [];
     }
   }
+
   /**
    * 串行执行商品 IndexDB 写入，避免快照替换与增量 patch 并发交错。
    *
@@ -1089,9 +1149,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   async runInProductIndexDBSaveQueue(task) {
     const queuedTask = this.productIndexDBSaveQueue.then(task, task);
-    this.productIndexDBSaveQueue = queuedTask.then(() => void 0, () => void 0);
+    this.productIndexDBSaveQueue = queuedTask.then(() => undefined, () => undefined);
     return queuedTask;
   }
+
   /**
    * 全量快照写入 IndexDB：clear + bulkUpdate，仅用于 SSE/HTTP 全量拉取。
    *
@@ -1100,29 +1161,64 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   async replaceProductsSnapshotInIndexDB(products, source) {
     if (!this.dbManager) {
-      this.logWarning("replaceProductsSnapshotInIndexDB: dbManager 不可用");
+      this.logWarning('replaceProductsSnapshotInIndexDB: dbManager 不可用');
       return;
     }
+    const enqueuedAt = performance.now();
+    let queueWaitMs = 0;
+    let clearDurationMs = 0;
+    let writeDurationMs = 0;
     try {
       await this.runInProductIndexDBSaveQueue(async () => {
-        this.logInfo("replaceProductsSnapshotInIndexDB 开始", { source, productCount: products.length });
-        const t0 = performance.now();
-        await this.dbManager.clear(INDEXDB_STORE_NAME);
+        const operationStartedAt = performance.now();
+        queueWaitMs = +(operationStartedAt - enqueuedAt).toFixed(2);
+        this.logInfo('replaceProductsSnapshotInIndexDB 开始', {
+          source,
+          productCount: products.length,
+          queueWaitMs
+        });
+        const clearStartedAt = performance.now();
+        try {
+          await this.dbManager.clear(INDEXDB_STORE_NAME);
+        } finally {
+          clearDurationMs = +(performance.now() - clearStartedAt).toFixed(2);
+        }
         if (products.length > 0) {
-          await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products);
+          const writeStartedAt = performance.now();
+          try {
+            await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products);
+          } finally {
+            writeDurationMs = +(performance.now() - writeStartedAt).toFixed(2);
+          }
         }
-        (0, import_product.perfMark)("replaceProductsSnapshotInIndexDB", performance.now() - t0, { count: products.length });
-        this.logInfo("replaceProductsSnapshotInIndexDB 完成", { source, productCount: products.length });
+        const executeDurationMs = +(performance.now() - operationStartedAt).toFixed(2);
+        (0, _product.perfMark)('replaceProductsSnapshotInIndexDB', executeDurationMs, {
+          count: products.length
+        });
+        this.logInfo('replaceProductsSnapshotInIndexDB 完成', {
+          source,
+          productCount: products.length,
+          queueWaitMs,
+          clearDurationMs,
+          writeDurationMs,
+          executeDurationMs,
+          totalDurationMs: +(performance.now() - enqueuedAt).toFixed(2)
+        });
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("全量保存商品到 IndexDB 失败", {
+      this.logError('全量保存商品到 IndexDB 失败', {
         source,
         productCount: products.length,
+        queueWaitMs,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - enqueuedAt).toFixed(2),
         error: errorMessage
       });
     }
   }
+
   /**
    * 增量 upsert 商品到 IndexDB，不清空表；用于 pubsub 批次合并后的变更商品。
    *
@@ -1133,33 +1229,42 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     if (!this.dbManager || products.length === 0) {
       return;
     }
-    const validProducts = products.filter((p) => (p == null ? void 0 : p.id) !== void 0 && (p == null ? void 0 : p.id) !== null);
+    const validProducts = products.filter(p => p?.id !== undefined && p?.id !== null);
     if (validProducts.length === 0) {
       return;
     }
     try {
       await this.runInProductIndexDBSaveQueue(async () => {
-        this.logInfo("patchProductsInIndexDB 开始", { source, count: validProducts.length });
+        this.logInfo('patchProductsInIndexDB 开始', {
+          source,
+          count: validProducts.length
+        });
         const t0 = performance.now();
-        if (typeof this.dbManager.bulkUpdate === "function") {
+        if (typeof this.dbManager.bulkUpdate === 'function') {
           await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, validProducts);
-        } else if (typeof this.dbManager.update === "function") {
+        } else if (typeof this.dbManager.update === 'function') {
           for (const product of validProducts) {
             await this.dbManager.update(INDEXDB_STORE_NAME, product);
           }
         }
-        (0, import_product.perfMark)("patchProductsInIndexDB", performance.now() - t0, { count: validProducts.length });
-        this.logInfo("patchProductsInIndexDB 完成", { source, count: validProducts.length });
+        (0, _product.perfMark)('patchProductsInIndexDB', performance.now() - t0, {
+          count: validProducts.length
+        });
+        this.logInfo('patchProductsInIndexDB 完成', {
+          source,
+          count: validProducts.length
+        });
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("增量保存商品到 IndexDB 失败", {
+      this.logError('增量保存商品到 IndexDB 失败', {
         source,
         error: errorMessage,
         productCount: validProducts.length
       });
     }
   }
+
   /**
    * 同步更新商品 Map 缓存
    * 将 list 中的商品同步到 map，以 id 为 key
@@ -1171,92 +1276,109 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     for (const product of this.store.list) {
       this.store.map.set(product.id, product);
     }
-    (0, import_product.perfMark)("syncProductsMap", performance.now() - t0, { count: this.store.map.size });
+    (0, _product.perfMark)('syncProductsMap', performance.now() - t0, {
+      count: this.store.map.size
+    });
   }
+
   /**
    * 预加载模块数据（统一接口）
    * 在模块注册后自动调用
    */
   async preload() {
-    console.log("[Products] 开始预加载数据...");
     const tTotal = performance.now();
-    this.logInfo("开始预加载数据");
+    this.logInfo('开始预加载数据');
     try {
       const tIndexDB = performance.now();
       const cachedData = await this.loadProductsFromIndexDB();
-      (0, import_product.perfMark)("preload.loadFromIndexDB", performance.now() - tIndexDB, { count: (cachedData == null ? void 0 : cachedData.length) ?? 0 });
+      (0, _product.perfMark)('preload.loadFromIndexDB', performance.now() - tIndexDB, {
+        count: cachedData?.length ?? 0
+      });
       if (cachedData && cachedData.length > 0) {
-        console.log(`[Products] 从 IndexDB 加载了 ${cachedData.length} 个商品`);
+        // IndexDB 反序列化的数据已经是全新的，无需 cloneDeep
         this.store.list = cachedData;
         const tSync = performance.now();
         this.syncProductsMap();
-        (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: cachedData.length });
-        this.core.effects.emit(
-          import_types.ProductsHooks.onProductsChanged,
-          this.store.list
-        );
-        (0, import_product.perfMark)("preload(IndexDB)", performance.now() - tTotal, {
+        (0, _product.perfMark)('preload.syncProductsMap', performance.now() - tSync, {
+          count: cachedData.length
+        });
+        this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+        (0, _product.perfMark)('preload(IndexDB)', performance.now() - tTotal, {
           count: cachedData.length,
-          source: "IndexDB"
+          source: 'IndexDB'
         });
-        this.logInfo("预加载完成（从 IndexDB）", {
+        this.logInfo('预加载完成（从 IndexDB）', {
+          trigger: 'preload',
           productCount: cachedData.length,
           duration: `${Math.round(performance.now() - tTotal)}ms`,
-          source: "IndexDB"
+          source: 'IndexDB'
         });
         this.lastPreloadCompletedAtMs = Date.now();
         return;
       }
-      console.log("[Products] IndexDB 中没有缓存数据，从服务器加载...");
-      this.logInfo("IndexDB 中没有缓存数据，准备从服务器加载");
+      this.logInfo('IndexDB 中没有缓存数据，准备从服务器加载');
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn("[Products] 从 IndexDB 加载数据失败:", error);
-      this.logWarning("从 IndexDB 加载数据失败，准备从服务器加载", { error: errorMessage });
+      console.warn('[Products] 从 IndexDB 加载数据失败:', error);
+      this.logWarning('从 IndexDB 加载数据失败，准备从服务器加载', {
+        error: errorMessage
+      });
     }
     const tServer = performance.now();
-    const products = await this.loadProductsByServer();
-    (0, import_product.perfMark)("preload.loadFromServer", performance.now() - tServer, { count: (products == null ? void 0 : products.length) ?? 0 });
+    const products = await this.loadProductsByServer({
+      trigger: 'preload'
+    });
+    (0, _product.perfMark)('preload.loadFromServer', performance.now() - tServer, {
+      count: products?.length ?? 0
+    });
     if (products && products.length > 0) {
+      // 服务器返回的数据已经是全新的，无需 cloneDeep
       this.store.list = products;
       const tSync = performance.now();
       this.syncProductsMap();
-      (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: products.length });
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-      (0, import_product.perfMark)("preload(Server)", performance.now() - tTotal, {
+      (0, _product.perfMark)('preload.syncProductsMap', performance.now() - tSync, {
+        count: products.length
+      });
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+      (0, _product.perfMark)('preload(Server)', performance.now() - tTotal, {
         count: products.length,
-        source: "Server"
+        source: 'Server'
       });
-      this.logInfo("预加载完成（从服务器）", {
+      this.logInfo('预加载完成（从服务器）', {
+        trigger: 'preload',
         productCount: products.length,
         duration: `${Math.round(performance.now() - tTotal)}ms`,
-        source: "Server"
+        source: 'Server'
       });
       this.lastPreloadCompletedAtMs = Date.now();
     } else {
-      (0, import_product.perfMark)("preload(empty)", performance.now() - tTotal, { source: "empty" });
-      this.logWarning("预加载完成但未获取到数据", {
+      (0, _product.perfMark)('preload(empty)', performance.now() - tTotal, {
+        source: 'empty'
+      });
+      this.logWarning('预加载完成但未获取到数据', {
         duration: `${Math.round(performance.now() - tTotal)}ms`
       });
     }
   }
+
   // =============================================
   // 商品数据同步（pubsub）
   // =============================================
+
   /**
    * 初始化 ProductDataSource 实例
    * 与 pubsub 订阅和数据获取分开，仅负责创建实例
    */
   initProductDataSource() {
-    var _a, _b;
-    const ProductDataSourceClass = (_b = (_a = this.core.serverOptions) == null ? void 0 : _a.All_DATA_SOURCES) == null ? void 0 : _b.ProductDataSource;
+    const ProductDataSourceClass = this.core.serverOptions?.All_DATA_SOURCES?.ProductDataSource;
     if (!ProductDataSourceClass) {
-      this.logWarning("initProductDataSource: ProductDataSource 不可用");
+      this.logWarning('initProductDataSource: ProductDataSource 不可用');
       return;
     }
     this.productDataSource = new ProductDataSourceClass();
-    this.logInfo("ProductDataSource 实例已创建");
+    this.logInfo('ProductDataSource 实例已创建');
   }
+
   /**
    * 初始化 pubsub 订阅，监听管理后台商品变更
    * 仅负责订阅 product / product_quotation 频道，消息通过防抖合并后批量处理
@@ -1264,21 +1386,22 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   setupProductSync() {
     if (!this.productDataSource) {
-      this.logWarning("setupProductSync: ProductDataSource 不可用，跳过同步初始化");
+      this.logWarning('setupProductSync: ProductDataSource 不可用，跳过同步初始化');
       return;
     }
-    const createHandler = (channelKey) => (message) => {
-      const data = (message == null ? void 0 : message.data) || message;
-      if (!data)
-        return;
-      console.log(`[ProductsModule] 收到同步消息 [${channelKey}]:`, data);
-      this.logInfo("收到同步消息", {
+    const createHandler = channelKey => message => {
+      const data = message?.data || message;
+      if (!data) return;
+      this.logInfo('收到同步消息', {
         channelKey,
         action: data.action,
         id: data.id,
         action_filed: data.action_filed
       });
-      this.pendingSyncMessages.push({ ...data, _channelKey: channelKey });
+      this.pendingSyncMessages.push({
+        ...data,
+        _channelKey: channelKey
+      });
       if (this.syncTimer) {
         clearTimeout(this.syncTimer);
       }
@@ -1288,21 +1411,25 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     };
     this.productDataSource.run({
       pubsub: {
-        callback: (res) => {
-          if (!(res == null ? void 0 : res.data))
-            return;
+        callback: res => {
+          // console.log('sse_products_callback', res)
+          // this.logInfo('sse_products_callback: 收到同步消息', {
+          //   data: res?.data,
+          // });
+          if (!res?.data) return;
           const data = res.data;
-          const channelKey = data.module || "product";
+          const channelKey = data.module || 'product';
           createHandler(channelKey)(data);
         }
       }
-    }).catch((err) => {
-      this.logError("setupProductSync: DataSource run 出错", {
+    }).catch(err => {
+      this.logError('setupProductSync: DataSource run 出错', {
         error: err instanceof Error ? err.message : String(err)
       });
     });
-    this.logInfo("setupProductSync: pubsub 订阅已建立");
+    this.logInfo('setupProductSync: pubsub 订阅已建立');
   }
+
   /**
    * 处理防抖后的同步消息批次
    *
@@ -1322,62 +1449,65 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * Server 层监听该事件后对变更商品增量执行 prepareProductsWithPrice 并更新缓存
    */
   async processProductSyncMessages() {
-    var _a, _b, _c, _d, _e, _f, _g;
     const messages = [...this.pendingSyncMessages];
     this.pendingSyncMessages = [];
-    if (messages.length === 0)
-      return;
-    this.logInfo("processProductSyncMessages: 开始处理", { count: messages.length });
+    if (messages.length === 0) return;
+    this.logInfo('processProductSyncMessages: 开始处理', {
+      count: messages.length
+    });
     const deleteIds = [];
-    const bodyUpdates = /* @__PURE__ */ new Map();
+    const bodyUpdates = new Map();
     const sseRefreshIds = [];
     const priceRefreshIds = [];
     let shouldClearPriceCache = false;
     for (const msg of messages) {
-      const channelKey = msg._channelKey || msg.module || "product";
-      if (channelKey === "product") {
-        if ((_a = msg.relation_product_ids) == null ? void 0 : _a.length) {
+      const channelKey = msg._channelKey || msg.module || 'product';
+      if (channelKey === 'product') {
+        if (msg.relation_product_ids?.length) {
           sseRefreshIds.push(...msg.relation_product_ids);
         }
-        if (msg.operation === "delete" || msg.action === "delete") {
-          if ((_b = msg.ids) == null ? void 0 : _b.length)
-            deleteIds.push(...msg.ids);
-          else if (msg.id)
-            deleteIds.push(msg.id);
+        // 1. 删除场景：operation === 'delete' 或 action === 'delete'
+        if (msg.operation === 'delete' || msg.action === 'delete') {
+          if (msg.ids?.length) deleteIds.push(...msg.ids);else if (msg.id) deleteIds.push(msg.id);
           continue;
         }
-        if ((_c = msg.change_types) == null ? void 0 : _c.includes("price")) {
+
+        // 2. change_types 包含 price → 仅收集需要刷新价格的 IDs（不走 SSE 拉取）
+        if (msg.change_types?.includes('price')) {
           const ids = msg.ids || (msg.id ? [msg.id] : []);
           priceRefreshIds.push(...ids);
           if (msg.body) {
             const bodyId = msg.body.id;
-            if (bodyId)
-              bodyUpdates.set(bodyId, msg.body);
+            if (bodyId) bodyUpdates.set(bodyId, msg.body);
           }
           continue;
         }
+
+        // 3. 有 body → 完整数据直接覆盖本地
         if (msg.body) {
           const bodyId = msg.body.id || msg.id;
-          if (bodyId)
-            bodyUpdates.set(bodyId, msg.body);
+          if (bodyId) bodyUpdates.set(bodyId, msg.body);
           continue;
         }
-        if ((_d = msg.ids) == null ? void 0 : _d.length) {
+
+        // 4. 其他情况（有 ids 无 body 无 change_types）→ SSE 拉取
+        if (msg.ids?.length) {
           sseRefreshIds.push(...msg.ids);
         } else if (msg.id) {
           sseRefreshIds.push(msg.id);
         }
-      } else if (channelKey === "product_quotation") {
+      } else if (channelKey === 'product_quotation') {
+        // 报价单变更影响范围大，标记清除全量价格缓存
         shouldClearPriceCache = true;
-        if ((_e = msg.relation_product_ids) == null ? void 0 : _e.length) {
+        if (msg.relation_product_ids?.length) {
           sseRefreshIds.push(...msg.relation_product_ids);
         }
-      } else if (["product_collection", "product_category"].includes(channelKey)) {
-        if ((_f = msg.relation_product_ids) == null ? void 0 : _f.length) {
+      } else if (['product_collection', 'product_category'].includes(channelKey)) {
+        if (msg.relation_product_ids?.length) {
           sseRefreshIds.push(...msg.relation_product_ids);
         }
-      } else if (["product_data_variant"].includes(channelKey)) {
-        if ((_g = msg.product_ids) == null ? void 0 : _g.length) {
+      } else if (['product_data_variant'].includes(channelKey)) {
+        if (msg.product_ids?.length) {
           sseRefreshIds.push(...msg.product_ids);
         }
       }
@@ -1385,12 +1515,18 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     const uniqueDeleteIds = [...new Set(deleteIds)];
     const uniqueSSEIds = [...new Set(sseRefreshIds)];
     const uniquePriceIds = [...new Set(priceRefreshIds)];
+
+    // 1. 处理删除
     if (uniqueDeleteIds.length > 0) {
       await this.removeProductsByIds(uniqueDeleteIds);
     }
-    const patchProductMap = /* @__PURE__ */ new Map();
+
+    /** 本批次待 patch 的商品（按 id 去重，SSE 覆盖 body） */
+    const patchProductMap = new Map();
     const patchMergeActions = {};
     let storeMutated = uniqueDeleteIds.length > 0;
+
+    // 2. 处理 body 直接覆盖（仅内存，IndexDB 批次末统一 patch）
     if (bodyUpdates.size > 0) {
       const bodyResult = await this.applyBodyUpdatesToStore(bodyUpdates, {
         skipIndexDB: true,
@@ -1402,6 +1538,8 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       }
       storeMutated = true;
     }
+
+    // 3. 处理 SSE 增量拉取（仅内存，IndexDB 批次末统一 patch）
     let freshProducts = [];
     if (uniqueSSEIds.length > 0) {
       freshProducts = await this.fetchProductsBySSE(uniqueSSEIds);
@@ -1416,28 +1554,22 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         }
         storeMutated = true;
       }
-      this.logInfo("processProductSyncMessages: SSE 增量更新完成123", {
+      this.logInfo('processProductSyncMessages: SSE 增量更新完成123', {
         requestedCount: uniqueSSEIds.length,
         receivedCount: freshProducts.length
       });
     }
     const patchProducts = [...patchProductMap.values()];
     if (patchProducts.length > 0) {
-      await this.patchProductsInIndexDB(
-        patchProducts,
-        "pubsub.processProductSyncMessages",
-        patchMergeActions
-      );
+      await this.patchProductsInIndexDB(patchProducts, 'pubsub.processProductSyncMessages', patchMergeActions);
     }
     if (storeMutated) {
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-    }
-    const allChangedIds = [.../* @__PURE__ */ new Set([
-      ...Array.from(bodyUpdates.keys()),
-      ...uniqueSSEIds,
-      ...uniquePriceIds
-    ])];
-    this.logInfo("processProductSyncMessages: 处理完成123", {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    }
+
+    // 收集所有非 delete 的变更 IDs（body + SSE + price），用于增量更新价格缓存
+    const allChangedIds = [...new Set([...Array.from(bodyUpdates.keys()), ...uniqueSSEIds, ...uniquePriceIds])];
+    this.logInfo('processProductSyncMessages: 处理完成123', {
       deleteCount: uniqueDeleteIds.length,
       bodyUpdateCount: bodyUpdates.size,
       sseRefreshCount: uniqueSSEIds.length,
@@ -1447,40 +1579,55 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     });
     const hasChanges = uniqueDeleteIds.length > 0 || allChangedIds.length > 0 || shouldClearPriceCache;
     if (!hasChanges) {
-      this.logInfo("processProductSyncMessages: 没有变更，不触发 onProductsSyncCompleted");
+      this.logInfo('processProductSyncMessages: 没有变更，不触发 onProductsSyncCompleted');
       return;
     }
+
+    // 报价单变更 → 清除全量价格缓存，后续走全量重建
     if (shouldClearPriceCache) {
       try {
         await this.refreshQuotationPriceBridge();
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("报价单桥接刷新失败，将继续清理价格缓存", { error: errorMessage });
+        this.logError('报价单桥接刷新失败，将继续清理价格缓存', {
+          error: errorMessage
+        });
       }
       this.clearPriceCache();
     }
-    await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, {
+    await this.core.effects.emit(_types.ProductsHooks.onProductsSyncCompleted, {
       changedIds: allChangedIds
     });
   }
+
   /**
    * 通过 SSE 按 ids 增量拉取商品数据
    * 请求 GET /shop/core/stream?type=product&ids={ids}
    */
   async fetchProductsBySSE(ids) {
     if (!this.productDataSource) {
-      this.logWarning("fetchProductsBySSE: ProductDataSource 不可用");
+      this.logWarning('fetchProductsBySSE: ProductDataSource 不可用');
       return [];
     }
-    this.logInfo("fetchProductsBySSE: 开始", { ids, count: ids.length });
+    this.logInfo('fetchProductsBySSE: 开始', {
+      ids,
+      count: ids.length
+    });
     const t0 = performance.now();
     try {
       const productList = await this.productDataSource.run({
-        sse: { query: { type: "product", ids } }
+        sse: {
+          query: {
+            type: 'product',
+            ids
+          }
+        }
       });
       const list = productList || [];
-      (0, import_product.perfMark)("fetchProductsBySSE", performance.now() - t0, { count: list.length });
-      this.logInfo("fetchProductsBySSE: 成功", {
+      (0, _product.perfMark)('fetchProductsBySSE', performance.now() - t0, {
+        count: list.length
+      });
+      this.logInfo('fetchProductsBySSE: 成功', {
         requestedCount: ids.length,
         receivedCount: list.length,
         duration: `${Math.round(performance.now() - t0)}ms`
@@ -1488,10 +1635,14 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       return list;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("fetchProductsBySSE: 失败", { ids, error: errorMessage });
+      this.logError('fetchProductsBySSE: 失败', {
+        ids,
+        error: errorMessage
+      });
       return [];
     }
   }
+
   /**
    * 将 body 完整数据直接覆盖到本地 store（不调用报价单接口）
    * 已存在的 → 直接替换；不存在的 → 追加
@@ -1501,17 +1652,19 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   async applyBodyUpdatesToStore(bodyUpdates, options) {
     const changedProductIds = [...bodyUpdates.keys()];
-    this.logInfo("applyBodyUpdatesToStore: 开始", { count: bodyUpdates.size });
+    this.logInfo('applyBodyUpdatesToStore: 开始', {
+      count: bodyUpdates.size
+    });
     let updatedCount = 0;
     let newCount = 0;
-    const appliedIds = /* @__PURE__ */ new Set();
+    const appliedIds = new Set();
     const mergeActions = {};
     const changedProducts = [];
-    this.store.list = this.store.list.map((p) => {
+    this.store.list = this.store.list.map(p => {
       if (bodyUpdates.has(p.id)) {
         updatedCount++;
         appliedIds.add(p.id);
-        mergeActions[p.id] = "update";
+        mergeActions[p.id] = 'update';
         const next = bodyUpdates.get(p.id);
         changedProducts.push(next);
         return next;
@@ -1522,24 +1675,30 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       if (!appliedIds.has(id)) {
         this.store.list.push(body);
         newCount++;
-        mergeActions[id] = "insert";
+        mergeActions[id] = 'insert';
         changedProducts.push(body);
       }
     }
     this.syncProductsMap();
-    if (!(options == null ? void 0 : options.skipIndexDB)) {
-      await this.patchProductsInIndexDB(changedProducts, "pubsub.bodyUpdate", mergeActions);
+    if (!options?.skipIndexDB) {
+      await this.patchProductsInIndexDB(changedProducts, 'pubsub.bodyUpdate', mergeActions);
     }
-    if (!(options == null ? void 0 : options.skipEmit)) {
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
+    if (!options?.skipEmit) {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
     }
-    this.logInfo("applyBodyUpdatesToStore: 完成", {
+    this.logInfo('applyBodyUpdatesToStore: 完成', {
       updatedCount,
       newCount,
       totalCount: this.store.list.length
     });
-    return { changedProducts, mergeActions, updatedCount, newCount };
+    return {
+      changedProducts,
+      mergeActions,
+      updatedCount,
+      newCount
+    };
   }
+
   /**
    * 将增量拉取的商品合并到 store
    * 已存在的 → 替换；新的 → 追加
@@ -1548,100 +1707,129 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * await this.mergeProductsToStore(freshProducts, { skipIndexDB: true })
    */
   async mergeProductsToStore(freshProducts, options) {
-    const freshMap = /* @__PURE__ */ new Map();
+    const freshMap = new Map();
     for (const p of freshProducts) {
       freshMap.set(p.id, p);
     }
     const mergeActions = {};
     const changedProducts = [];
-    const updatedList = this.store.list.map((p) => {
+    const updatedList = this.store.list.map(p => {
       if (freshMap.has(p.id)) {
         const fresh = freshMap.get(p.id);
         freshMap.delete(p.id);
-        mergeActions[p.id] = "update";
+        mergeActions[p.id] = 'update';
         changedProducts.push(fresh);
         return fresh;
       }
       return p;
     });
+
+    // freshMap 中剩余的是新商品（create 场景）
     const newCount = freshMap.size;
     for (const p of freshMap.values()) {
       updatedList.push(p);
-      mergeActions[p.id] = "insert";
+      mergeActions[p.id] = 'insert';
       changedProducts.push(p);
     }
     const updatedCount = freshProducts.length - newCount;
-    const changedProductIds = freshProducts.map((p) => p.id);
+    const changedProductIds = freshProducts.map(p => p.id);
     this.store.list = updatedList;
     this.syncProductsMap();
-    if (!(options == null ? void 0 : options.skipIndexDB)) {
-      await this.patchProductsInIndexDB(changedProducts, "pubsub.mergeProductsToStore", mergeActions);
+    if (!options?.skipIndexDB) {
+      await this.patchProductsInIndexDB(changedProducts, 'pubsub.mergeProductsToStore', mergeActions);
     }
-    if (!(options == null ? void 0 : options.skipEmit)) {
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
+    if (!options?.skipEmit) {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
     }
-    this.logInfo("mergeProductsToStore: 合并完成", {
+    this.logInfo('mergeProductsToStore: 合并完成', {
       updatedCount,
       newCount,
       totalCount: this.store.list.length
     });
-    return { changedProducts, mergeActions, updatedCount, newCount };
+    return {
+      changedProducts,
+      mergeActions,
+      updatedCount,
+      newCount
+    };
   }
+
   /**
    * 静默全量刷新：后台重新拉取全量 SSE 数据并更新本地
    * 拿到完整数据后一次性替换 store，清除价格缓存，触发 onProductsSyncCompleted
    * @returns 刷新后的商品列表
    */
-  async silentRefresh() {
+  async silentRefresh(options = {}) {
     const t0 = performance.now();
     const now = Date.now();
-    const elapsedSincePreload = now - this.lastPreloadCompletedAtMs;
-    const elapsedSinceFullFetch = now - this.lastServerFullFetchAtMs;
-    if (this.lastPreloadCompletedAtMs > 0 && elapsedSincePreload < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS || this.lastServerFullFetchAtMs > 0 && elapsedSinceFullFetch < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS) {
+    const trigger = options.trigger || 'background';
+    const elapsedSincePreloadMs = now - this.lastPreloadCompletedAtMs;
+    const elapsedSinceFullFetchMs = now - this.lastServerFullFetchAtMs;
+    if (this.lastPreloadCompletedAtMs > 0 && elapsedSincePreloadMs < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS || this.lastServerFullFetchAtMs > 0 && elapsedSinceFullFetchMs < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS) {
+      this.logInfo('silentRefresh 跳过全量 SSE', {
+        trigger,
+        reason: 'within_min_interval',
+        minIntervalMs: PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS,
+        elapsedSincePreloadMs,
+        elapsedSinceFullFetchMs,
+        productCount: this.store.list.length
+      });
       return this.store.list;
     }
-    this.logInfo("silentRefresh 开始");
+    this.logInfo('silentRefresh 开始', {
+      trigger,
+      elapsedSincePreloadMs,
+      elapsedSinceFullFetchMs,
+      productCount: this.store.list.length
+    });
     try {
-      const products = await this.loadProductsByServer();
+      const products = await this.loadProductsByServer({
+        trigger
+      });
       if (products && products.length > 0) {
         this.store.list = products;
         this.syncProductsMap();
         this.clearPriceCache();
-        this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-        await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, null);
-        this.logInfo("silentRefresh 完成", {
+        this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+        await this.core.effects.emit(_types.ProductsHooks.onProductsSyncCompleted, null);
+        this.logInfo('silentRefresh 完成', {
+          trigger,
           productCount: products.length,
           duration: `${Math.round(performance.now() - t0)}ms`
         });
       } else {
-        this.logWarning("silentRefresh: 服务器未返回数据");
+        this.logWarning('silentRefresh: 服务器未返回数据');
       }
-      (0, import_product.perfMark)("silentRefresh", performance.now() - t0, { count: this.store.list.length });
+      (0, _product.perfMark)('silentRefresh', performance.now() - t0, {
+        count: this.store.list.length
+      });
       return this.store.list;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("silentRefresh 失败", {
+      this.logError('silentRefresh 失败', {
+        trigger,
         duration: `${Math.round(performance.now() - t0)}ms`,
         error: errorMessage
       });
       return this.store.list;
     }
   }
+
   /**
    * 销毁同步资源（取消 pubsub 订阅、清除定时器）
    */
   destroyProductSync() {
-    var _a;
     if (this.syncTimer) {
       clearTimeout(this.syncTimer);
-      this.syncTimer = void 0;
+      this.syncTimer = undefined;
     }
-    if ((_a = this.productDataSource) == null ? void 0 : _a.destroy) {
+    if (this.productDataSource?.destroy) {
       this.productDataSource.destroy();
     }
     this.pendingSyncMessages = [];
-    this.logInfo("destroyProductSync: 同步资源已销毁");
+    this.logInfo('destroyProductSync: 同步资源已销毁');
   }
+
   /**
    * 获取模块的路由定义
    * Products 模块暂不提供路由，由 Server 层统一处理
@@ -1649,8 +1837,5 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   getRoutes() {
     return [];
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ProductsModule
-});
+}
+exports.ProductsModule = ProductsModule;