@pisell/pisellos 2.2.259 → 2.2.260

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

@@ -48,7 +48,6 @@ var ORDER_BUSINESS_WRITE_SOURCES = /* @__PURE__ */ new Set([
   "overwriteExistingOrder",
   "markOrderSyncedByExternalSaleNumber"
 ]);
-var ORDER_MERGE_SELF_CHECK = false;
 var OrderModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
@@ -57,6 +56,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.pendingSyncMessages = [];
     this.isProcessingSyncBatch = false;
     this.isIdlePhase = true;
+    // Map<resource_id, OrderId[]> 资源到订单的倒排索引
+    this.resourceIdIndex = /* @__PURE__ */ new Map();
     this.orderSQLiteSaveQueue = Promise.resolve();
     /** 按 storageKey 记录最近一次 SQLite 写入来源与时间，用于去重 */
     this.recentSqliteWriteByStorageKey = /* @__PURE__ */ new Map();
@@ -308,11 +309,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     };
   }
   updateCreateStore() {
+    var _a;
     const appPlugin = this.core.getPlugin("app");
     const app = appPlugin == null ? void 0 : appPlugin.getApp();
     if (app) {
       const coreData = app.data.store.getStore().getDataByModel("core");
-      if (coreData == null ? void 0 : coreData.core) {
+      if (!((_a = this.store.createdAtQuery) == null ? void 0 : _a.sales_time_between) && (coreData == null ? void 0 : coreData.core)) {
         const today = (0, import_dayjs.default)();
         if (coreData == null ? void 0 : coreData.core.operating_day_boundary) {
           const operatingDayBoundary = coreData.core.operating_day_boundary;
@@ -479,6 +481,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return this.store.list;
     }
   }
+  getOrdersByResourceId(resourceId) {
+    const ids = this.resourceIdIndex.get(String(resourceId)) || [];
+    return ids.map((id) => this.store.map.get(id)).filter((order) => !!order);
+  }
   normalizeOrderForMemoryList(order) {
     const externalSaleNumber = order == null ? void 0 : order.external_sale_number;
     if ((order == null ? void 0 : order.order_id) !== void 0 && (order == null ? void 0 : order.order_id) !== null && (order == null ? void 0 : order.order_id) !== "") {
@@ -611,33 +617,22 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const patchedOrders = [...pendingMap.values()];
     const mergeActions = {};
     const updatedList = [...this.store.list];
-    const identityKeyToIndex = /* @__PURE__ */ new Map();
-    for (let index = 0; index < updatedList.length; index += 1) {
-      for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
-        if (!identityKeyToIndex.has(key))
-          identityKeyToIndex.set(key, index);
-      }
-    }
     for (const [storageKey, pendingOrder] of memoryPendingMap.entries()) {
-      const matchIndex = this.lookupOrderIndexByIdentityKeys(
-        identityKeyToIndex,
-        this.getOrderIdentityMatchKeys(pendingOrder)
-      );
-      if (matchIndex >= 0) {
-        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], pendingOrder, {
-          preferIncomingProducts: true
-        });
-        updatedList[matchIndex] = mergedOrder;
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
-        mergeActions[storageKey] = "update";
+      const matchIndex = this.findOrderIndexByIdentity(updatedList, pendingOrder);
+      if (matchIndex < 0)
         continue;
-      }
-      const insertIndex = updatedList.length;
-      updatedList.push(pendingOrder);
-      this.registerOrderIdentityKeys(identityKeyToIndex, pendingOrder, insertIndex);
+      updatedList[matchIndex] = this.mergeOrderRecords(updatedList[matchIndex], pendingOrder, {
+        preferIncomingProducts: true
+      });
+      pendingMap.delete(storageKey);
+      memoryPendingMap.delete(storageKey);
+      mergeActions[storageKey] = "update";
+    }
+    for (const [storageKey, order] of memoryPendingMap.entries()) {
       mergeActions[storageKey] = "insert";
+      updatedList.push(order);
     }
-    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
+    this.store.list = this.compactOrderListByIdentity(updatedList, "upsertPendingSyncOrders.store").list;
     this.syncOrdersMap();
     await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
     this.logInfo("upsertPendingSyncOrders-结束", {
@@ -679,11 +674,21 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   }
   syncOrdersMap() {
     this.store.map.clear();
+    this.resourceIdIndex.clear();
     for (const order of this.store.list) {
       const primaryIdentity = this.getOrderMapKey(order);
       if (!primaryIdentity)
         continue;
       this.store.map.set(primaryIdentity, order);
+      const resourceIds = this.extractResourceIds(order);
+      for (const resourceId of resourceIds) {
+        const key = String(resourceId);
+        const existing = this.resourceIdIndex.get(key) || [];
+        if (existing.some((eid) => this.getIdKey(eid) === primaryIdentity))
+          continue;
+        existing.push(primaryIdentity);
+        this.resourceIdIndex.set(key, existing);
+      }
     }
   }
   getOrderMapKey(order) {
@@ -730,6 +735,24 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
     return keys;
   }
+  extractResourceIds(order) {
+    const ids = /* @__PURE__ */ new Set();
+    const visitResources = (resources) => {
+      if (!Array.isArray(resources))
+        return;
+      resources.forEach((resource) => {
+        const rid = resource == null ? void 0 : resource.relation_id;
+        if (rid !== void 0 && rid !== null && rid !== "")
+          ids.add(String(rid));
+        if (Array.isArray(resource == null ? void 0 : resource.children))
+          visitResources(resource.children);
+      });
+    };
+    if (Array.isArray(order == null ? void 0 : order.bookings)) {
+      order.bookings.forEach((booking) => visitResources((booking == null ? void 0 : booking.resources) || []));
+    }
+    return [...ids];
+  }
   getOrderDateKey(order) {
     var _a, _b, _c, _d;
     const candidates = [
@@ -948,10 +971,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * 将增量订单合并到 store
    */
   async mergeOrdersToStore(freshOrders, source) {
-    const storeOrderCountBefore = this.store.list.length;
     this.logInfo("mergeOrdersToStore-开始", {
       freshOrderCount: freshOrders.length,
-      storeOrderCountBefore,
+      storeOrderCountBefore: this.store.list.length,
       source
     });
     this.logDuplicateOrders(`${source}.beforeMerge`, this.store.list);
@@ -970,45 +992,19 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const patchedOrders = [];
     const mergeActions = {};
     const updatedList = [...this.store.list];
-    const identityKeyToIndex = /* @__PURE__ */ new Map();
-    for (let index = 0; index < updatedList.length; index += 1) {
-      const identityKeys = this.getOrderIdentityMatchKeys(updatedList[index]);
-      for (const key of identityKeys) {
-        if (!identityKeyToIndex.has(key))
-          identityKeyToIndex.set(key, index);
-      }
-    }
     for (const fresh of uniqueFreshOrders) {
-      const freshIdentityKeys = this.getOrderIdentityMatchKeys(fresh);
-      const matchIndex = this.lookupOrderIndexByIdentityKeys(identityKeyToIndex, freshIdentityKeys);
+      const matchIndex = this.findOrderIndexByIdentity(updatedList, fresh);
       const storageKey = this.getOrderStorageKey(fresh);
       const mergeKey = storageKey || (fresh.order_id !== void 0 && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : "");
       if (matchIndex >= 0) {
-        const existingOrder = updatedList[matchIndex];
-        if (this.isPendingSyncOrder(existingOrder) && this.isRemoteEchoMergeSource(source)) {
-          this.logInfo("mergeOrdersToStore-跳过 pending 订单远端覆盖", {
-            source,
-            order_id: existingOrder.order_id ?? fresh.order_id ?? null,
-            external_sale_number: existingOrder.external_sale_number ?? fresh.external_sale_number ?? null,
-            local_payment_status: existingOrder.payment_status ?? null,
-            remote_payment_status: fresh.payment_status ?? null,
-            local_need_sync: existingOrder.need_sync ?? null,
-            remote_need_sync: fresh.need_sync ?? null,
-            reason: "protect_pending_sync_order_from_remote_echo"
-          });
-          continue;
-        }
-        const mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
+        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], fresh);
         updatedList[matchIndex] = mergedOrder;
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
         patchedOrders.push(mergedOrder);
         if (mergeKey)
           mergeActions[mergeKey] = "update";
         continue;
       }
-      const insertIndex = updatedList.length;
       updatedList.push(fresh);
-      this.registerOrderIdentityKeys(identityKeyToIndex, fresh, insertIndex);
       patchedOrders.push(fresh);
       if (mergeKey)
         mergeActions[mergeKey] = "insert";
@@ -1020,7 +1016,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       updateCount,
       storeOrderCountAfter: this.store.list.length
     });
-    this.store.list = this.runOrderStoreSelfCheck(updatedList, `${source}.store`);
+    this.store.list = this.compactOrderListByIdentity(updatedList, `${source}.store`).list;
     this.syncOrdersMap();
     await this.patchOrdersInSQLite(patchedOrders, source, mergeActions);
     this.logInfo("mergeOrdersToStore-结束", {
@@ -1031,53 +1027,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     });
     await this.emitOrdersChanged(patchedOrders, source);
   }
-  /**
-   * 在身份索引中查找与目标订单共享任一身份键的已存在订单下标。
-   * 返回所有命中键里最小的下标，等价于原 findOrderIndexByIdentity 的「取首个匹配」语义。
-   *
-   * @example
-   * const idx = this.lookupOrderIndexByIdentityKeys(identityKeyToIndex, freshIdentityKeys)
-   */
-  lookupOrderIndexByIdentityKeys(identityKeyToIndex, identityKeys) {
-    let matchIndex = -1;
-    for (const key of identityKeys) {
-      const index = identityKeyToIndex.get(key);
-      if (index === void 0)
-        continue;
-      if (matchIndex < 0 || index < matchIndex)
-        matchIndex = index;
-    }
-    return matchIndex;
-  }
-  isRemoteEchoMergeSource(source) {
-    return source === "pubsub.bodyUpsert" || source === "pubsub.httpRefresh";
-  }
-  /**
-   * 将订单的全部身份键登记到索引并指向其在列表中的下标。
-   * 合并后订单新增的身份字段（如挂单同步后拿到 order_id）也会被登记。
-   *
-   * @example
-   * this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex)
-   */
-  registerOrderIdentityKeys(identityKeyToIndex, order, index) {
-    const identityKeys = this.getOrderIdentityMatchKeys(order);
-    for (const key of identityKeys) {
-      identityKeyToIndex.set(key, index);
-    }
-  }
-  /**
-   * 合并热路径去重兜底：默认直接返回原列表（增量索引已保证无重复）。
-   * 仅当 ORDER_MERGE_SELF_CHECK 开启时，额外做一次全表压缩并在发现残留重复时告警。
-   */
-  runOrderStoreSelfCheck(orders, source) {
-    if (!ORDER_MERGE_SELF_CHECK)
-      return orders;
-    const { list, removedCount } = this.compactOrderListByIdentity(orders, source);
-    if (removedCount > 0) {
-      this.logWarning("合并自检发现残留重复订单，已压缩", { source, removedCount });
-    }
-    return list;
-  }
   normalizeOrderSyncMessage(res) {
     const data = (res == null ? void 0 : res.data) || res;
     if (!data)
@@ -1691,6 +1640,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   async clear() {
     this.store.list = [];
     this.store.map = /* @__PURE__ */ new Map();
+    this.resourceIdIndex.clear();
     if (this.dbManager) {
       await this.runInOrderSQLiteSaveQueue(async () => {
         await this.dbManager.clear(INDEXDB_STORE_NAME);

package/lib/server/modules/products/index.d.ts

@@ -18,7 +18,8 @@ export declare class ProductsModule extends BaseModule implements Module {
     private productsPriceCache;
     private readonly CACHE_MAX_DAYS;
     private formatters;
-    private isPriceFormatterRegistered;
+    private isBuiltinFormatterRegistered;
+    private isLegacyPriceFormatterEnabled;
     private quotationPriceBridge?;
     private quotationBridgeChannel?;
     private quotationBridgeLoadedKey?;
@@ -36,6 +37,8 @@ export declare class ProductsModule extends BaseModule implements Module {
     private lastPreloadCompletedAtMs;
     /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
     private productIndexDBSaveQueue;
+    /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
+    private lastScheduleTimePoints;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     /**
@@ -108,6 +111,10 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     private prepareProductsWithPrice;
     private getProductsPriceCacheKey;
+    /**
+     * 稳定序列化策略上下文，避免对象 key 顺序不同导致缓存 key 抖动。
+     */
+    private stringifyStable;
     private normalizeProductIds;
     /**
      * 按轻量范围返回商品 ID，不做 structuredClone。
@@ -122,14 +129,26 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     private applyFormatters;
     /**
-     * 注册内置的价格格式化器
-     * 这个格式化器负责将价格数据应用到商品上
+     * 注册内置商品格式化器。
+     *
+     * 智能定价默认替代报价单逻辑；报价单 formatter 仅在 enableLegacyPriceFormatter=true 时启用。
      * @private
      */
-    private registerBuiltinPriceFormatter;
+    private registerBuiltinProductFormatters;
+    /**
+     * 是否启用旧报价单价格 formatter。
+     *
+     * 默认关闭，避免报价单逻辑覆盖智能定价结果。
+     */
+    private shouldEnableLegacyPriceFormatter;
+    /**
+     * 返回最近一次 prepareProductsWithPrice / DataVariant 评估提取的变价时间点（HH:mm）。
+     * 供 OS Server 商品 query 订阅定时刷新使用。
+     */
+    getLastScheduleTimePoints(): string[];
     /**
      * 注册商品格式化器
-     * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+     * 格式化器会按注册顺序依次执行；legacy 启用时先兜底报价，再由智能定价覆盖。
      * @param formatter 格式化函数
      * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
      * @example
@@ -144,8 +163,8 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     registerFormatter(formatter: ProductFormatter, prepend?: boolean): void;
     /**
-     * 清空所有格式化器（包括内置价格格式化器）
-     * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+     * 清空所有格式化器（包括内置智能定价格式化器）
+     * @param keepBuiltin 是否保留内置智能定价格式化器（默认 true）
      */
     clearFormatters(keepBuiltin?: boolean): void;
     /**

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

@@ -43,8 +43,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     // 最多缓存7天
     // 商品格式化器列表
     this.formatters = [];
-    // 是否已注册内置价格格式化器
-    this.isPriceFormatterRegistered = false;
+    // 是否已注册内置商品格式化器
+    this.isBuiltinFormatterRegistered = false;
+    // 旧报价单格式化器默认关闭，仅显式开启时作为兼容兜底注册
+    this.isLegacyPriceFormatterEnabled = false;
     this.quotationBridgeLoadedKey = "";
     this.quotationScheduleCache = /* @__PURE__ */ new Map();
     this.quotationScheduleCacheSource = null;
@@ -56,6 +58,8 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     this.lastPreloadCompletedAtMs = 0;
     /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
     this.productIndexDBSaveQueue = Promise.resolve();
+    /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
+    this.lastScheduleTimePoints = [];
   }
   async initialize(core, options) {
     var _a;
@@ -82,7 +86,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         console.warn("[Products] IndexDB Manager 未找到");
       }
     }
-    this.registerBuiltinPriceFormatter();
+    this.registerBuiltinProductFormatters();
     this.initProductDataSource();
     this.setupProductSync();
     this.logInfo("模块初始化完成", {
@@ -474,7 +478,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @private
    */
   async prepareProductsWithPrice(schedule_date, extraContext, options) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const tTotal = performance.now();
     const targetIds = options == null ? void 0 : options.productIds;
     const isIncremental = Array.isArray(targetIds);
@@ -499,21 +503,28 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         (0, import_product.perfMark)("prepareProducts.extractIds", performance.now() - tIds, { count: ids.length });
       }
       this.logInfo("获取到商品列表", { productCount: products.length });
-      const tPrice = performance.now();
-      const 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
-      });
-      (0, import_product.perfMark)("prepareProducts.loadPrice", performance.now() - tPrice, { count: ids.length });
-      this.logInfo("获取商品报价单价格成功", { priceDataCount: (priceData == null ? void 0 : priceData.length) ?? 0 });
+      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
+        });
+        (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,
         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,
         ...extraContext
       };
       const tFormat = performance.now();
@@ -553,7 +564,21 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
   getProductsPriceCacheKey(schedule_date, extraContext, productIds) {
     const datetime = (extraContext == null ? void 0 : extraContext.schedule_datetime) || schedule_date;
     const productScope = productIds ? `:products:${productIds.join(",")}` : "";
-    return `${datetime}:customer:${(extraContext == null ? void 0 : extraContext.customer_id) ?? ""}${productScope}`;
+    const strategyScope = this.stringifyStable((extraContext == null ? void 0 : extraContext.strategy_context) || {});
+    return `${datetime}:customer:${(extraContext == null ? void 0 : 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(",")}}`;
+    }
+    return String(value);
   }
   normalizeProductIds(productIds) {
     if (!Array.isArray(productIds))
@@ -637,21 +662,49 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     return result;
   }
   /**
-   * 注册内置的价格格式化器
-   * 这个格式化器负责将价格数据应用到商品上
+   * 注册内置商品格式化器。
+   *
+   * 智能定价默认替代报价单逻辑；报价单 formatter 仅在 enableLegacyPriceFormatter=true 时启用。
    * @private
    */
-  registerBuiltinPriceFormatter() {
-    if (this.isPriceFormatterRegistered) {
-      console.warn("[ProductsModule] 内置价格格式化器已注册，跳过");
+  registerBuiltinProductFormatters() {
+    if (this.isBuiltinFormatterRegistered) {
+      console.warn("[ProductsModule] 内置商品格式化器已注册，跳过");
       return;
     }
-    const priceFormatter = (products, context) => {
+    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") {
+        this.lastScheduleTimePoints = [];
+        this.logWarning("智能定价评估器未注入，跳过 DataVariant 格式化", {
+          productCount: products.length
+        });
+        return products;
+      }
+      const strategyContext = context.strategy_context || {};
+      const businessData = {
+        products,
+        scheduleDateTime: context.schedule_datetime || context.schedule_date,
+        scheduleList: context.scheduleList || [],
+        menuList: context.menuList || [],
+        customerId: context.customer_id,
+        channel: strategyContext.channel,
+        orderType: strategyContext.orderType || strategyContext.order_type,
+        businessCode: strategyContext.business_code ?? strategyContext.businessCode,
+        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;
+    };
+    const legacyPriceFormatter = (products, context) => {
       if (!context.priceData || context.priceData.length === 0) {
-        console.log("[ProductsModule] 💰 没有价格数据，跳过价格应用");
+        console.log("[ProductsModule] 💰 没有价格数据，跳过 legacy 报价单价格应用");
         return products;
       }
-      console.log(`[ProductsModule] 💰 应用价格数据到 ${products.length} 个商品`);
+      console.log(`[ProductsModule] 💰 应用 legacy 报价单价格到 ${products.length} 个商品`);
       return (0, import_product.applyPriceDataToProducts)(products, context.priceData);
     };
     const i18nFormatter = (products, context) => {
@@ -660,15 +713,34 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     const detailValueFormatter = (products, context) => {
       return (0, import_product.applyDetailValueToProducts)(products, context);
     };
-    this.formatters.unshift(priceFormatter);
+    if (this.isLegacyPriceFormatterEnabled) {
+      this.formatters.push(legacyPriceFormatter);
+    }
+    this.formatters.push(dataVariantFormatter);
     this.formatters.push(i18nFormatter);
     this.formatters.push(detailValueFormatter);
-    this.isPriceFormatterRegistered = true;
-    console.log("[ProductsModule] ✅ 内置价格格式化器已注册（第 1 个）");
+    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;
+  }
+  /**
+   * 返回最近一次 prepareProductsWithPrice / DataVariant 评估提取的变价时间点（HH:mm）。
+   * 供 OS Server 商品 query 订阅定时刷新使用。
+   */
+  getLastScheduleTimePoints() {
+    return [...this.lastScheduleTimePoints];
   }
   /**
    * 注册商品格式化器
-   * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+   * 格式化器会按注册顺序依次执行；legacy 启用时先兜底报价，再由智能定价覆盖。
    * @param formatter 格式化函数
    * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
    * @example
@@ -683,7 +755,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   registerFormatter(formatter, prepend = false) {
     if (prepend) {
-      const insertIndex = this.isPriceFormatterRegistered ? 1 : 0;
+      const insertIndex = this.isBuiltinFormatterRegistered ? this.isLegacyPriceFormatterEnabled ? 2 : 1 : 0;
       this.formatters.splice(insertIndex, 0, formatter);
       console.log(`[ProductsModule] 📌 已在位置 ${insertIndex + 1} 插入格式化器，当前共 ${this.formatters.length} 个`);
     } else {
@@ -692,16 +764,17 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 清空所有格式化器（包括内置价格格式化器）
-   * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+   * 清空所有格式化器（包括内置智能定价格式化器）
+   * @param keepBuiltin 是否保留内置智能定价格式化器（默认 true）
    */
   clearFormatters(keepBuiltin = true) {
-    if (keepBuiltin && this.isPriceFormatterRegistered) {
-      this.formatters = [this.formatters[0]];
-      console.log("[ProductsModule] 🧹 已清空自定义格式化器，保留内置价格格式化器");
+    if (keepBuiltin && this.isBuiltinFormatterRegistered) {
+      const builtinCount = this.isLegacyPriceFormatterEnabled ? 2 : 1;
+      this.formatters = this.formatters.slice(0, builtinCount);
+      console.log("[ProductsModule] 🧹 已清空自定义格式化器，保留内置智能定价格式化器");
     } else {
       this.formatters = [];
-      this.isPriceFormatterRegistered = false;
+      this.isBuiltinFormatterRegistered = false;
       console.log("[ProductsModule] 🧹 已清空所有格式化器");
     }
   }
@@ -802,7 +875,8 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
             "resourceRelation",
             "bundleGroup.bundleItem",
             "optionGroup.optionItem",
-            "variantGroup.variantItem"
+            "variantGroup.variantItem",
+            "dataVariants"
           ],
           open_deposit: 1,
           is_append_product_description: 1,
@@ -1227,7 +1301,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * Server 层监听该事件后对变更商品增量执行 prepareProductsWithPrice 并更新缓存
    */
   async processProductSyncMessages() {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const messages = [...this.pendingSyncMessages];
     this.pendingSyncMessages = [];
     if (messages.length === 0)
@@ -1281,6 +1355,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         if ((_f = msg.relation_product_ids) == null ? void 0 : _f.length) {
           sseRefreshIds.push(...msg.relation_product_ids);
         }
+      } else if (["product_data_variant"].includes(channelKey)) {
+        if ((_g = msg.product_ids) == null ? void 0 : _g.length) {
+          sseRefreshIds.push(...msg.product_ids);
+        }
       }
     }
     const uniqueDeleteIds = [...new Set(deleteIds)];

package/lib/server/modules/products/types.d.ts

@@ -110,6 +110,8 @@ export interface ProductSyncMessage {
     change_types?: string[];
     /** 关联商品 ID（product_collection / product_category / product_quotation 变更时携带） */
     relation_product_ids?: number[];
+    /** 关联商品 ID（product_data_variant 变更时携带） */
+    product_ids?: number[];
     message_uuid?: string;
     timestamp?: string;
     /** 内部标记：来源频道 key */
@@ -124,6 +126,18 @@ export interface ProductFormatterContext {
     customer_id?: number | string;
     priceData?: LoadProductsPriceData[];
     scheduleModule?: any;
+    /** 全量餐牌列表，供智能定价 menu_match 等条件判断使用 */
+    menuList?: any[];
+    /** 全量日程列表，供智能定价 schedule_match 等条件判断使用 */
+    scheduleList?: any[];
+    /** 外部传入的策略上下文，仅承载定价条件，不参与商品集合筛选 */
+    strategy_context?: Record<string, any>;
+    /** 智能定价评估器，由宿主统一注入到 PisellOS context */
+    dataVariantEvaluator?: {
+        resolveProducts: (businessData: any) => {
+            products: ProductData[];
+        };
+    };
     locale?: string;
 }
 /**