@pisell/pisellos 2.3.28 → 2.3.29

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

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(order_exports);
 var import_lodash_es = require("lodash-es");
 var import_dayjs = __toESM(require("dayjs"));
 var import_BaseModule = require("../../../modules/BaseModule");
+var import_orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
 var import_types = require("./types");
 var INDEXDB_STORE_NAME = "orders";
 var ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = "server_order_last_full_fetch_at";
@@ -49,6 +50,12 @@ var ORDER_BUSINESS_WRITE_SOURCES = /* @__PURE__ */ new Set([
   "markOrderSyncedByExternalSaleNumber"
 ]);
 var ORDER_MERGE_SELF_CHECK = false;
+var ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ["products", "bookings", "payments"];
+var ORDER_COLLECTION_KIND_BY_FIELD = {
+  products: "product",
+  bookings: "booking",
+  payments: "payment"
+};
 var OrderModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
@@ -154,6 +161,96 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     } catch {
     }
   }
+  /**
+   * 在订单进入内存或 SQLite 前统一压缩子项强身份重复并补齐协议 UID。
+   * 仅记录计数与订单标识，不输出商品、预约、支付或客户明细。
+   */
+  normalizeOrderCollectionsForIngress(order, source) {
+    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(order);
+    const kinds = ["product", "booking", "payment"];
+    const hasChanges = kinds.some((kind) => {
+      const stats = result.stats[kind];
+      return stats.backfilledUidCount > 0 || stats.collapsedDuplicateCount > 0 || stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
+    });
+    if (hasChanges) {
+      const summarize = (stats) => ({
+        backfilled_uid_count: stats.backfilledUidCount,
+        collapsed_duplicate_count: stats.collapsedDuplicateCount,
+        uid_conflict_count: stats.uidConflictCount,
+        anonymous_row_count: stats.anonymousRowCount
+      });
+      const context = {
+        source,
+        order_id: (order == null ? void 0 : order.order_id) ?? null,
+        external_sale_number: (order == null ? void 0 : order.external_sale_number) ?? null,
+        products: summarize(result.stats.product),
+        bookings: summarize(result.stats.booking),
+        payments: summarize(result.stats.payment)
+      };
+      const hasUnsafeIdentity = kinds.some((kind) => {
+        const stats = result.stats[kind];
+        return stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
+      });
+      if (hasUnsafeIdentity) {
+        this.logWarning("订单子项身份存在冲突或匿名行", context);
+      } else {
+        this.logInfo("订单子项身份已规范化", context);
+      }
+    }
+    return result.order;
+  }
+  /**
+   * incoming 决定权威成员集合；同一持久化行仍从 existing 补齐 incoming 省略的本地展示字段。
+   */
+  mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = []) {
+    const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
+    const existingItems = Array.isArray(existing) ? existing : [];
+    return incoming.map((incomingItem) => {
+      const existingItem = existingItems.find(
+        (item) => (0, import_orderCollectionIdentity.isSameOrderCollectionItem)(kind, item, incomingItem)
+      );
+      if (!existingItem)
+        return (0, import_lodash_es.cloneDeep)(incomingItem);
+      const mergedItem = (0, import_orderCollectionIdentity.mergeOrderCollectionItems)(kind, existingItem, incomingItem);
+      const mergedUid = (0, import_orderCollectionIdentity.getOrderCollectionUid)(kind, mergedItem);
+      if (mergedUid) {
+        for (const from of /* @__PURE__ */ new Set([
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, existingItem),
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, incomingItem)
+        ])) {
+          if (!from || from === mergedUid)
+            continue;
+          uidRemaps.push({
+            kind,
+            from,
+            to: mergedUid,
+            persistentId: (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, existingItem)
+          });
+        }
+      }
+      return mergedItem;
+    });
+  }
+  reconcileOverwriteOrderCollections(existing, incoming) {
+    const reconciled = (0, import_lodash_es.cloneDeep)(incoming);
+    const existingRecord = existing;
+    const incomingRecord = incoming;
+    const uidRemaps = [];
+    for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
+      if (!Array.isArray(incomingRecord[field]))
+        continue;
+      reconciled[field] = this.mergeAuthoritativeOrderCollection(
+        field,
+        existingRecord[field],
+        incomingRecord[field],
+        uidRemaps
+      );
+    }
+    return this.normalizeOrderCollectionsForIngress(
+      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(reconciled, uidRemaps),
+      "overwriteExistingOrder.reconciled"
+    );
+  }
   /**
    * 记录订单最近一次 SQLite 写入，供 pubsub 回声去重使用。
    *
@@ -479,16 +576,17 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return this.store.list;
     }
   }
-  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) !== "") {
-      return order;
+  normalizeOrderForMemoryList(order, source = "normalizeOrderForMemoryList") {
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, source);
+    const externalSaleNumber = normalizedOrder == null ? void 0 : normalizedOrder.external_sale_number;
+    if ((normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== void 0 && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== null && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== "") {
+      return normalizedOrder;
     }
     if (externalSaleNumber === void 0 || externalSaleNumber === null || externalSaleNumber === "") {
-      return order;
+      return normalizedOrder;
     }
     return {
-      ...order,
+      ...normalizedOrder,
       order_id: externalSaleNumber
     };
   }
@@ -511,19 +609,29 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       orderId,
       storeOrderCountBefore: this.store.list.length
     });
+    const normalizedFresh = this.normalizeOrderForMemoryList(
+      fresh,
+      "overwriteExistingOrder.incoming"
+    );
+    const existingOrder = this.store.map.get(key);
+    const reconciledFresh = this.reconcileOverwriteOrderCollections(
+      existingOrder,
+      normalizedFresh
+    );
     this.store.list = this.store.list.map((order) => {
       const id = order == null ? void 0 : order.order_id;
-      if (id === void 0 || id === null)
-        return order;
-      return this.getIdKey(id) === key ? fresh : order;
+      if (id === void 0 || id === null) {
+        return this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
+      }
+      return this.getIdKey(id) === key ? reconciledFresh : this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
     });
     this.syncOrdersMap();
-    await this.updateOrderInSQLite(fresh, "overwriteExistingOrder");
+    await this.updateOrderInSQLite(reconciledFresh, "overwriteExistingOrder");
     this.logInfo("overwriteExistingOrder-结束", {
       orderId,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged([fresh], "overwriteExistingOrder");
+    await this.emitOrdersChanged([reconciledFresh], "overwriteExistingOrder");
     return { overwritten: true };
   }
   /**
@@ -595,11 +703,21 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const pendingMap = /* @__PURE__ */ new Map();
     const memoryPendingMap = /* @__PURE__ */ new Map();
     for (const order of pendingOrders) {
-      const storageKey = this.getOrderStorageKey(order);
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+        order,
+        "upsertPendingSyncOrders.incoming"
+      );
+      const storageKey = this.getOrderStorageKey(normalizedOrder);
       if (!storageKey)
         continue;
-      pendingMap.set(storageKey, order);
-      memoryPendingMap.set(storageKey, this.normalizeOrderForMemoryList(order));
+      pendingMap.set(storageKey, normalizedOrder);
+      memoryPendingMap.set(
+        storageKey,
+        this.normalizeOrderForMemoryList(
+          normalizedOrder,
+          "upsertPendingSyncOrders.memory"
+        )
+      );
     }
     if (pendingMap.size === 0) {
       this.logError("upsertPendingSyncOrders-订单缺少可落库标识", {
@@ -608,9 +726,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return;
     }
     this.logInfo("upsertPendingSyncOrders-开始", { count: pendingMap.size });
-    const patchedOrders = [...pendingMap.values()];
     const mergeActions = {};
-    const updatedList = [...this.store.list];
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, "upsertPendingSyncOrders.existingMemory")
+    );
     const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
@@ -624,10 +743,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         this.getOrderIdentityMatchKeys(pendingOrder)
       );
       if (matchIndex >= 0) {
-        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], pendingOrder, {
-          preferIncomingProducts: true
-        });
+        const existingOrder = updatedList[matchIndex];
+        const mergedOrder = this.mergeOrderRecords(existingOrder, pendingOrder);
         updatedList[matchIndex] = mergedOrder;
+        const pendingSnapshot = pendingMap.get(storageKey);
+        if (pendingSnapshot) {
+          pendingMap.set(
+            storageKey,
+            this.reconcileOverwriteOrderCollections(existingOrder, pendingSnapshot)
+          );
+        }
         this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
         mergeActions[storageKey] = "update";
         continue;
@@ -637,6 +762,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       this.registerOrderIdentityKeys(identityKeyToIndex, pendingOrder, insertIndex);
       mergeActions[storageKey] = "insert";
     }
+    const patchedOrders = [...pendingMap.values()];
     this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
     this.syncOrdersMap();
     await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
@@ -969,7 +1095,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const uniqueFreshCount = uniqueFreshOrders.length;
     const patchedOrders = [];
     const mergeActions = {};
-    const updatedList = [...this.store.list];
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, `${source}.existingMemory`)
+    );
     const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       const identityKeys = this.getOrderIdentityMatchKeys(updatedList[index]);
@@ -1192,100 +1320,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return right;
     return left;
   }
-  getProductIdentityKeys(product) {
-    var _a;
-    const record = product;
-    if (!record)
-      return [];
-    const keys = [];
-    const metadataUid = (_a = record.metadata) == null ? void 0 : _a.unique_identification_number;
-    if (!this.isBlankIdentityValue(metadataUid))
-      keys.push(`uid:${String(metadataUid)}`);
-    const topLevelUid = record.unique_identification_number;
-    if (!this.isBlankIdentityValue(topLevelUid))
-      keys.push(`uid:${String(topLevelUid)}`);
-    const orderDetailId = record.order_detail_id;
-    if (!this.isBlankIdentityValue(orderDetailId))
-      keys.push(`detail:${String(orderDetailId)}`);
-    const bookingUid = record.booking_uid;
-    if (!this.isBlankIdentityValue(bookingUid))
-      keys.push(`booking:${String(bookingUid)}`);
-    return keys;
-  }
-  mergeOrderProductLists(preferred, secondary) {
-    const preferredList = Array.isArray(preferred) ? preferred : [];
-    const secondaryList = Array.isArray(secondary) ? secondary : [];
-    if (secondaryList.length === 0)
-      return preferredList;
-    if (preferredList.length === 0)
-      return secondaryList;
-    const seenKeys = /* @__PURE__ */ new Set();
-    for (const item of preferredList) {
-      const keys = this.getProductIdentityKeys(item);
-      for (const key of keys)
-        seenKeys.add(key);
-    }
-    const result = [...preferredList];
-    for (const item of secondaryList) {
-      const keys = this.getProductIdentityKeys(item);
-      if (keys.length === 0 || keys.some((key) => seenKeys.has(key)))
-        continue;
-      for (const key of keys)
-        seenKeys.add(key);
-      result.push((0, import_lodash_es.cloneDeep)(item));
-    }
-    return result;
-  }
-  getPaymentMergeKey(payment) {
-    var _a;
-    const record = payment;
-    if (!record)
-      return "";
-    const uniquePaymentNumber = (_a = record.metadata) == null ? void 0 : _a.unique_payment_number;
-    if (!this.isBlankIdentityValue(uniquePaymentNumber)) {
-      return `unique:${String(uniquePaymentNumber)}`;
-    }
-    const orderPaymentId = record.order_payment_id;
-    if (!this.isBlankIdentityValue(orderPaymentId))
-      return `order_payment:${String(orderPaymentId)}`;
-    const code = record.code;
-    const customPaymentId = record.custom_payment_id;
-    if (!this.isBlankIdentityValue(code) && !this.isBlankIdentityValue(customPaymentId)) {
-      return `custom:${String(code)}#${String(customPaymentId)}`;
-    }
-    return "";
-  }
-  mergeOrderPaymentLists(existing, incoming) {
-    const existingList = Array.isArray(existing) ? existing : [];
-    const incomingList = Array.isArray(incoming) ? incoming : [];
-    if (incomingList.length === 0)
-      return (0, import_lodash_es.cloneDeep)(existingList);
-    if (existingList.length === 0)
-      return (0, import_lodash_es.cloneDeep)(incomingList);
-    const existingByKey = /* @__PURE__ */ new Map();
-    for (const payment of existingList) {
-      const key = this.getPaymentMergeKey(payment);
-      if (!key)
-        continue;
-      existingByKey.set(key, payment);
-    }
-    return incomingList.map((payment) => {
-      const incomingPayment = payment;
-      const key = this.getPaymentMergeKey(incomingPayment);
-      const existingPayment = key ? existingByKey.get(key) : void 0;
-      if (!existingPayment)
-        return (0, import_lodash_es.cloneDeep)(incomingPayment);
-      return {
-        ...(0, import_lodash_es.cloneDeep)(existingPayment),
-        ...(0, import_lodash_es.cloneDeep)(incomingPayment),
-        metadata: {
-          ...(0, import_lodash_es.cloneDeep)(existingPayment.metadata || {}),
-          ...(0, import_lodash_es.cloneDeep)(incomingPayment.metadata || {})
-        }
-      };
-    });
-  }
-  mergeOrderRecords(existing, incoming, options) {
+  mergeOrderRecords(existing, incoming) {
     const preferred = this.pickPreferredOrder(existing, incoming);
     const secondary = preferred === existing ? incoming : existing;
     const merged = {
@@ -1306,8 +1341,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       "updated_at",
       "shop_discount",
       "summary",
-      "products",
-      "bookings",
       "note",
       "customer_id",
       "customer_name",
@@ -1321,8 +1354,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const mergedRecord = merged;
     const preferredRecord = preferred;
     const secondaryRecord = secondary;
+    const existingRecord = existing;
     const incomingRecord = incoming;
-    const previousRecord = preferred === incoming ? secondaryRecord : preferredRecord;
+    const childUidRemaps = [];
     for (const field of fieldsToPreserve) {
       if (!this.isBlankIdentityValue(preferredRecord[field])) {
         mergedRecord[field] = preferredRecord[field];
@@ -1332,8 +1366,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         mergedRecord[field] = secondaryRecord[field];
       }
     }
-    const hasIncomingProducts = Object.prototype.hasOwnProperty.call(incomingRecord, "products");
-    const shouldUseIncomingProductsSnapshot = (options == null ? void 0 : options.preferIncomingProducts) === true && hasIncomingProducts && incomingRecord.products !== void 0 && incomingRecord.products !== null;
     for (const field of incomingPatchFields) {
       if (!Object.prototype.hasOwnProperty.call(incomingRecord, field))
         continue;
@@ -1343,21 +1375,29 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         continue;
       mergedRecord[field] = (0, import_lodash_es.cloneDeep)(incomingRecord[field]);
     }
-    mergedRecord.products = shouldUseIncomingProductsSnapshot ? (0, import_lodash_es.cloneDeep)(incomingRecord.products) : this.mergeOrderProductLists(preferredRecord.products, secondaryRecord.products);
-    if (Object.prototype.hasOwnProperty.call(incomingRecord, "payments")) {
-      if (Array.isArray(incomingRecord.payments)) {
-        mergedRecord.payments = this.mergeOrderPaymentLists(
-          previousRecord.payments,
-          incomingRecord.payments
+    for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
+      if (Array.isArray(incomingRecord[field])) {
+        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(
+          field,
+          existingRecord[field],
+          incomingRecord[field],
+          childUidRemaps
         );
-      } else if (incomingRecord.payments !== void 0 && incomingRecord.payments !== null) {
-        mergedRecord.payments = (0, import_lodash_es.cloneDeep)(incomingRecord.payments);
+        continue;
+      }
+      if (Object.prototype.hasOwnProperty.call(existingRecord, field)) {
+        mergedRecord[field] = (0, import_lodash_es.cloneDeep)(existingRecord[field]);
+      } else {
+        delete mergedRecord[field];
       }
     }
     if (!this.isPendingSyncOrder(preferred) || !this.isPendingSyncOrder(secondary)) {
       merged.need_sync = 0;
     }
-    return merged;
+    return this.normalizeOrderCollectionsForIngress(
+      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps),
+      "mergeOrderRecords"
+    );
   }
   summarizeDuplicateOrders(orders) {
     const groups = /* @__PURE__ */ new Map();
@@ -1394,12 +1434,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const list = [];
     let removedCount = 0;
     for (const order of orders) {
-      const matchIndex = this.findOrderIndexByIdentity(list, order);
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+        order,
+        `${source}.order`
+      );
+      const matchIndex = this.findOrderIndexByIdentity(list, normalizedOrder);
       if (matchIndex < 0) {
-        list.push(order);
+        list.push(normalizedOrder);
         continue;
       }
-      list[matchIndex] = this.mergeOrderRecords(list[matchIndex], order);
+      list[matchIndex] = this.mergeOrderRecords(list[matchIndex], normalizedOrder);
       removedCount += 1;
     }
     if (removedCount > 0) {
@@ -1479,7 +1523,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return [];
     try {
       const orders = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      return orders || [];
+      return (orders || []).map(
+        (order) => this.normalizeOrderCollectionsForIngress(order, "loadOrdersFromSQLite")
+      );
     } catch {
       return [];
     }
@@ -1488,16 +1534,24 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return Number(order == null ? void 0 : order.need_sync) === 1;
   }
   normalizeRemoteSyncedOrder(order) {
-    if (this.isPendingSyncOrder(order))
-      return order;
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+      order,
+      "normalizeRemoteSyncedOrder"
+    );
+    if (this.isPendingSyncOrder(normalizedOrder))
+      return normalizedOrder;
     return {
-      ...order,
+      ...normalizedOrder,
       need_sync: 0
     };
   }
   mergeRemoteSnapshotWithPendingOrders(remoteOrders, existingOrders) {
     const merged = remoteOrders.map((order) => this.normalizeRemoteSyncedOrder(order));
-    for (const order of existingOrders) {
+    for (const rawOrder of existingOrders) {
+      const order = this.normalizeOrderCollectionsForIngress(
+        rawOrder,
+        "mergeRemoteSnapshotWithPendingOrders.existingSQLite"
+      );
       if (!this.isPendingSyncOrder(order))
         continue;
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
@@ -1534,7 +1588,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (!this.dbManager || orders.length === 0) {
       return;
     }
-    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).filter((order) => this.getOrderStorageKey(order));
+    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).map((order) => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).filter((order) => this.getOrderStorageKey(order));
     if (ordersSnapshot.length === 0) {
       return;
     }
@@ -1595,7 +1649,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (!this.dbManager || !this.getOrderStorageKey(order)) {
       return;
     }
-    const orderSnapshot = (0, import_lodash_es.cloneDeep)(order);
+    const orderSnapshot = this.normalizeOrderCollectionsForIngress(
+      (0, import_lodash_es.cloneDeep)(order),
+      `${source}.sqliteIngress`
+    );
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         let writeMethod = "none";
@@ -1641,7 +1698,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         `${source}.snapshotNoDb`
       ).list;
     }
-    const remoteSnapshot = (0, import_lodash_es.cloneDeep)(orderList);
+    const remoteSnapshot = (0, import_lodash_es.cloneDeep)(orderList).map(
+      (order) => this.normalizeOrderCollectionsForIngress(order, `${source}.remoteIngress`)
+    );
     let mergedSnapshot = this.compactOrderListByIdentity(
       remoteSnapshot.map((order) => this.normalizeRemoteSyncedOrder(order)),
       `${source}.remoteSnapshot`

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;
     /**