@pisell/pisellos 0.10.15 → 0.10.17

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

@@ -1,80 +1,69 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/server/modules/order/index.ts
-var order_exports = {};
-__export(order_exports, {
-  OrderModule: () => OrderModule
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-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 import_payment_utils = require("../../../modules/Order/payment-utils");
-var INDEXDB_STORE_NAME = "orders";
-var ORDER_STORAGE_KEY_FIELD = "__order_storage_key";
-var ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = "server_order_last_full_fetch_at";
-var ORDER_SYNC_THROTTLE_MS_STORAGE_KEY = "order_sync_throttle_ms";
-var DEFAULT_ORDER_SYNC_THROTTLE_MS = 2e3;
-var ORDER_SQLITE_DEDUPE_MS = 15e3;
-var ORDER_SILENT_REFRESH_MIN_INTERVAL_MS = 3e4;
-var ORDER_BUSINESS_WRITE_SOURCES = /* @__PURE__ */ new Set([
-  "upsertOrdersFromRemote",
-  "upsertPendingSyncOrders",
-  "upsertLocalDraftOrders",
-  "overwriteExistingOrder",
-  "markOrderSyncedByExternalSaleNumber",
-  "updateLocalPayment"
-]);
-var ORDER_MERGE_SELF_CHECK = false;
-var PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER = "__pisell_os_pending_payment_without_unique_number__";
-var ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ["products", "bookings", "payments"];
-var ORDER_COLLECTION_KIND_BY_FIELD = {
-  products: "product",
-  bookings: "booking",
-  payments: "payment"
+exports.OrderModule = void 0;
+var _lodashEs = require("lodash-es");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _BaseModule = require("../../../modules/BaseModule");
+var _orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
+var _types = require("./types");
+var _paymentUtils = require("../../../modules/Order/payment-utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * SQLite 存储名称
+ */
+const INDEXDB_STORE_NAME = 'orders';
+const ORDER_STORAGE_KEY_FIELD = '__order_storage_key';
+const ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = 'server_order_last_full_fetch_at';
+const ORDER_SYNC_THROTTLE_MS_STORAGE_KEY = 'order_sync_throttle_ms';
+const DEFAULT_ORDER_SYNC_THROTTLE_MS = 2_000;
+/** pubsub 回声写入去重窗口：业务 API 刚写入后，跳过同单 SQLite patch */
+const ORDER_SQLITE_DEDUPE_MS = 15_000;
+/** silentRefresh 最小间隔，避免 preload 后立即全量重拉 */
+const ORDER_SILENT_REFRESH_MIN_INTERVAL_MS = 30_000;
+/** 视为「业务侧刚写入」的来源，pubsub 回声可跳过 SQLite */
+const ORDER_BUSINESS_WRITE_SOURCES = new Set(['upsertOrdersFromRemote', 'upsertPendingSyncOrders', 'upsertLocalDraftOrders', 'overwriteExistingOrder', 'markOrderSyncedByExternalSaleNumber', 'updateLocalPayment']);
+
+/**
+ * 合并热路径全表去重自检开关：默认关闭。
+ * 开启后每次合并会额外对整张 store 做一次 O(n^2) 重复检测并告警，
+ * 仅用于排查增量身份索引是否遗漏了重复订单，不应在生产常开。
+ */
+const ORDER_MERGE_SELF_CHECK = false;
+const PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER = '__pisell_os_pending_payment_without_unique_number__';
+const ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ['products', 'bookings', 'payments'];
+const ORDER_COLLECTION_KIND_BY_FIELD = {
+  products: 'product',
+  bookings: 'booking',
+  payments: 'payment'
 };
-var OrderModule = class extends import_BaseModule.BaseModule {
+/**
+ * Order 模块 - 基础框架
+ */
+class OrderModule extends _BaseModule.BaseModule {
+  defaultName = 'order';
+  defaultVersion = '1.0.0';
+  store;
+  dbManager;
+  orderDataSource;
+  pendingSyncMessages = [];
+  syncTimer;
+  isProcessingSyncBatch = false;
+  isIdlePhase = true;
+  logger; // LoggerManager 实例
+  storage;
+  orderSQLiteSaveQueue = Promise.resolve(); /** 按 storageKey 记录最近一次 SQLite 写入来源与时间，用于去重 */
+  recentSqliteWriteByStorageKey = new Map();
+  /** 最近一次清理过期 SQLite 去重记录的时间，避免每次写入都遍历 Map */
+  lastRecentSqliteWriteCleanupAtMs = 0;
+  /** 最近一次 SSE 全量拉取完成时间 */
+  lastServerFullFetchAtMs = 0;
   constructor(name, version) {
     super(name, version);
-    this.defaultName = "order";
-    this.defaultVersion = "1.0.0";
-    this.pendingSyncMessages = [];
-    this.isProcessingSyncBatch = false;
-    this.isIdlePhase = true;
-    this.orderSQLiteSaveQueue = Promise.resolve();
-    /** 按 storageKey 记录最近一次 SQLite 写入来源与时间，用于去重 */
-    this.recentSqliteWriteByStorageKey = /* @__PURE__ */ new Map();
-    /** 最近一次 SSE 全量拉取完成时间 */
-    this.lastServerFullFetchAtMs = 0;
   }
+
   /**
    * 广播订单变更事件，兼容全量列表订阅并额外携带本次变更订单。
    *
@@ -82,23 +71,23 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * await this.emitOrdersChanged([freshOrder], 'pubsub.bodyUpsert')
    */
   async emitOrdersChanged(changedOrders = [], source) {
-    console.log("触发emitOrdersChanged");
     const payload = {
       list: this.store.list,
-      changedOrders: changedOrders.map((order) => this.normalizeOrderForMemoryList(order)),
+      changedOrders: changedOrders.map(order => this.normalizeOrderForMemoryList(order)),
       source
     };
-    await this.core.effects.emit(import_types.OrderHooks.onOrdersChanged, payload);
+    await this.core.effects.emit(_types.OrderHooks.onOrdersChanged, payload);
   }
+
   /**
    * 广播远端商品成员增删。监听器异常必须与订单落库和原有订单广播隔离。
    */
   async emitRemoteProductMembershipChanges(changes) {
     for (const payload of changes) {
       try {
-        await this.core.effects.emit(import_types.OrderHooks.onRemoteProductMembershipChanged, payload);
+        await this.core.effects.emit(_types.OrderHooks.onRemoteProductMembershipChanged, payload);
       } catch (error) {
-        this.logError("广播远端订单商品成员变更失败", {
+        this.logError('广播远端订单商品成员变更失败', {
           order_id: payload.order_id,
           source: payload.source,
           added_product_count: payload.added_product_keys.length,
@@ -109,38 +98,34 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
   }
   async initialize(core, options) {
-    var _a;
     this.core = core;
-    this.store = options == null ? void 0 : options.store;
-    if (!this.store.map)
-      this.store.map = /* @__PURE__ */ new Map();
-    const appPlugin = core.getPlugin("app");
-    const app = appPlugin == null ? void 0 : appPlugin.getApp();
+    this.store = options?.store;
+    if (!this.store.map) this.store.map = new Map();
+    const appPlugin = core.getPlugin('app');
+    const app = appPlugin?.getApp();
     if (app) {
       this.dbManager = app.sqlite;
       this.logger = app.logger;
       this.storage = app.storage;
       this.updateCreateStore();
     }
-    if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.list)) {
-      this.store.list = this.normalizeOrdersForMemoryList(
-        options.initialState.list,
-        "initialState"
-      );
+    if (Array.isArray(options?.initialState?.list)) {
+      this.store.list = this.normalizeOrdersForMemoryList(options.initialState.list, 'initialState');
       this.syncOrdersMap();
-      this.emitOrdersChanged([], "initialState");
+      this.emitOrdersChanged([], 'initialState');
     } else {
       this.store.list = [];
-      this.store.map = /* @__PURE__ */ new Map();
+      this.store.map = new Map();
     }
     this.initOrderDataSource();
     this.setupOrderSync();
-    this.logInfo("OrderServer模块初始化完成", {
+    this.logInfo('OrderServer模块初始化完成', {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
       initialOrderCount: this.store.list.length
     });
   }
+
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -150,14 +135,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "info",
+          type: 'info',
           title: `[OrderServerModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -167,36 +154,39 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "error",
+          type: 'error',
           title: `[OrderServerModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
   logWarning(title, metadata) {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "warning",
+          type: 'warning',
           title: `[OrderServerModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 在订单进入内存或 SQLite 前统一压缩子项强身份重复并补齐协议 UID。
    * 仅记录计数与订单标识，不输出商品、预约、支付或客户明细。
    */
   normalizeOrderCollectionsForIngress(order, source) {
-    const sourceOrder = (0, import_lodash_es.cloneDeep)(order);
+    const sourceOrder = (0, _lodashEs.cloneDeep)(order);
     const sourceOrderRecord = sourceOrder;
     if (Array.isArray(sourceOrderRecord.payments)) {
-      sourceOrderRecord.payments = sourceOrderRecord.payments.map((payment) => {
-        if (!(0, import_payment_utils.isPendingOrderPayment)(payment) || (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => key.startsWith("unique_payment_number:"))) {
+      sourceOrderRecord.payments = sourceOrderRecord.payments.map(payment => {
+        if (!(0, _paymentUtils.isPendingOrderPayment)(payment) || (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => key.startsWith('unique_payment_number:'))) {
           return payment;
         }
         return {
@@ -205,29 +195,30 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         };
       });
     }
-    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(sourceOrder);
+    const result = (0, _orderCollectionIdentity.normalizeOrderCollections)(sourceOrder);
     const normalizedOrderRecord = result.order;
     if (Array.isArray(normalizedOrderRecord.payments)) {
-      normalizedOrderRecord.payments = normalizedOrderRecord.payments.map(
-        (payment) => {
-          if (!(payment == null ? void 0 : payment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]))
-            return payment;
-          const nextPayment = { ...payment };
-          const metadata = { ...nextPayment.metadata || {} };
-          delete metadata.unique_payment_number;
-          delete nextPayment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER];
-          nextPayment.metadata = metadata;
-          return nextPayment;
-        }
-      );
+      normalizedOrderRecord.payments = normalizedOrderRecord.payments.map(payment => {
+        if (!payment?.[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]) return payment;
+        const nextPayment = {
+          ...payment
+        };
+        const metadata = {
+          ...(nextPayment.metadata || {})
+        };
+        delete metadata.unique_payment_number;
+        delete nextPayment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER];
+        nextPayment.metadata = metadata;
+        return nextPayment;
+      });
     }
-    const kinds = ["product", "booking", "payment"];
-    const hasChanges = kinds.some((kind) => {
+    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) => ({
+      const summarize = stats => ({
         backfilled_uid_count: stats.backfilledUidCount,
         collapsed_duplicate_count: stats.collapsedDuplicateCount,
         uid_conflict_count: stats.uidConflictCount,
@@ -235,57 +226,49 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       });
       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,
+        order_id: order?.order_id ?? null,
+        external_sale_number: 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 hasUnsafeIdentity = kinds.some(kind => {
         const stats = result.stats[kind];
         return stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
       });
       if (hasUnsafeIdentity) {
-        this.logWarning("订单子项身份存在冲突或匿名行", context);
+        this.logWarning('订单子项身份存在冲突或匿名行', context);
       } else {
-        this.logInfo("订单子项身份已规范化", context);
+        this.logInfo('订单子项身份已规范化', context);
       }
     }
     return result.order;
   }
+
   /**
    * incoming 决定权威成员集合；同一持久化行仍从 existing 补齐 incoming 省略的本地展示字段。
    */
   mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = [], options = {}) {
     const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
     const existingItems = Array.isArray(existing) ? existing : [];
-    if (field === "payments" && options.preserveIdentifiedPendingPayments) {
-      return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(
-        existingItems,
-        incoming,
-        { preserveUnmatchedExistingWhen: import_payment_utils.isIdentifiedPendingOrderPayment }
-      );
-    }
-    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 (field === 'payments' && options.preserveIdentifiedPendingPayments) {
+      return (0, _paymentUtils.mergeOrderPaymentListsByIdentity)(existingItems, incoming, {
+        preserveUnmatchedExistingWhen: _paymentUtils.isIdentifiedPendingOrderPayment
+      });
+    }
+    return incoming.map(incomingItem => {
+      const existingItem = existingItems.find(item => (0, _orderCollectionIdentity.isSameOrderCollectionItem)(kind, item, incomingItem));
+      if (!existingItem) return (0, _lodashEs.cloneDeep)(incomingItem);
+      const mergedItem = (0, _orderCollectionIdentity.mergeOrderCollectionItems)(kind, existingItem, incomingItem);
+      const mergedUid = (0, _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;
+        for (const from of new Set([(0, _orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, existingItem), (0, _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)
+            persistentId: (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, existingItem)
           });
         }
       }
@@ -293,25 +276,35 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     });
   }
   reconcileOverwriteOrderCollections(existing, incoming) {
-    const reconciled = (0, import_lodash_es.cloneDeep)(incoming);
+    const reconciled = (0, _lodashEs.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"
-    );
+      if (!Array.isArray(incomingRecord[field])) continue;
+      reconciled[field] = this.mergeAuthoritativeOrderCollection(field, existingRecord[field], incomingRecord[field], uidRemaps);
+    }
+    return this.normalizeOrderCollectionsForIngress((0, _orderCollectionIdentity.applyOrderCollectionUidRemaps)(reconciled, uidRemaps), 'overwriteExistingOrder.reconciled');
   }
+
+  /**
+   * 惰性清理已经超过去重窗口的 SQLite 写入记录。
+   *
+   * 清理频率与去重窗口一致，既限制 Map 长期增长，也不会移除仍参与去重的记录。
+   */
+  cleanupExpiredRecentSqliteWrites(now) {
+    const elapsedSinceCleanup = now - this.lastRecentSqliteWriteCleanupAtMs;
+    if (this.lastRecentSqliteWriteCleanupAtMs > 0 && elapsedSinceCleanup >= 0 && elapsedSinceCleanup < ORDER_SQLITE_DEDUPE_MS) {
+      return;
+    }
+    for (const [storageKey, recentWrite] of this.recentSqliteWriteByStorageKey) {
+      if (now - recentWrite.ts >= ORDER_SQLITE_DEDUPE_MS) {
+        this.recentSqliteWriteByStorageKey.delete(storageKey);
+      }
+    }
+    this.lastRecentSqliteWriteCleanupAtMs = now;
+  }
+
   /**
    * 记录订单最近一次 SQLite 写入，供 pubsub 回声去重使用。
    *
@@ -320,23 +313,30 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   recordRecentSqliteWrite(source, orders) {
     const now = Date.now();
+    this.cleanupExpiredRecentSqliteWrites(now);
     for (const order of orders) {
       const storageKey = this.getOrderStorageKey(order);
-      if (!storageKey)
-        continue;
-      this.recentSqliteWriteByStorageKey.set(storageKey, { source, ts: now });
+      if (!storageKey) continue;
+      this.recentSqliteWriteByStorageKey.set(storageKey, {
+        source,
+        ts: now
+      });
     }
   }
+
   /**
    * 过滤 pubsub 触发的冗余 SQLite patch（业务 API 刚写入过的 update 回声）。
    *
    * @example
    * const { toWrite, skipped } = this.filterRedundantPatchOrders('pubsub.bodyUpsert', orders, mergeActions)
    */
-  filterRedundantPatchOrders(source, orders, mergeActions, forceWriteStorageKeys = /* @__PURE__ */ new Set()) {
-    const eligibleSkipSources = /* @__PURE__ */ new Set(["pubsub.bodyUpsert", "pubsub.httpRefresh"]);
+  filterRedundantPatchOrders(source, orders, mergeActions, forceWriteStorageKeys = new Set()) {
+    const eligibleSkipSources = new Set(['pubsub.bodyUpsert', 'pubsub.httpRefresh']);
     if (!eligibleSkipSources.has(source)) {
-      return { toWrite: orders, skipped: [] };
+      return {
+        toWrite: orders,
+        skipped: []
+      };
     }
     const now = Date.now();
     const toWrite = [];
@@ -347,12 +347,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         toWrite.push(order);
         continue;
       }
-      const orderKey = order.order_id !== void 0 && order.order_id !== null ? this.getIdKey(order.order_id) : "";
-      const mergeAction = orderKey ? mergeActions[orderKey] : void 0;
-      if (mergeAction === "insert") {
+      const orderKey = order.order_id !== undefined && order.order_id !== null ? this.getIdKey(order.order_id) : '';
+      const mergeAction = orderKey ? mergeActions[orderKey] : undefined;
+
+      // 新增单必须落库，不参与去重
+      if (mergeAction === 'insert') {
         toWrite.push(order);
         continue;
       }
+
+      // 远端商品成员确实发生增删时必须落库，避免内存已更新但 SQLite 仍被回声窗口跳过。
       if (forceWriteStorageKeys.has(storageKey)) {
         toWrite.push(order);
         continue;
@@ -362,7 +366,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         skipped.push({
           orderId: order.order_id ?? null,
           storageKey,
-          reason: "skip_pubsub_echo_after_business_write",
+          reason: 'skip_pubsub_echo_after_business_write',
           lastSource: recent.source,
           elapsedMs: now - recent.ts
         });
@@ -370,8 +374,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
       toWrite.push(order);
     }
-    return { toWrite, skipped };
+    return {
+      toWrite,
+      skipped
+    };
   }
+
   /**
    * 过滤 pubsub HTTP 增量拉取 ids：本地刚由业务 API 写入的单可跳过 HTTP。
    *
@@ -389,8 +397,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         continue;
       }
       const storageKey = this.getOrderStorageKey(existing);
-      const recent = storageKey ? this.recentSqliteWriteByStorageKey.get(storageKey) : void 0;
-      if (recent && recent.source === "upsertOrdersFromRemote" && now - recent.ts < ORDER_SQLITE_DEDUPE_MS) {
+      const recent = storageKey ? this.recentSqliteWriteByStorageKey.get(storageKey) : undefined;
+      if (recent && recent.source === 'upsertOrdersFromRemote' && now - recent.ts < ORDER_SQLITE_DEDUPE_MS) {
         skipped.push({
           orderId: id,
           lastSource: recent.source,
@@ -400,8 +408,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
       toFetch.push(id);
     }
-    return { toFetch, skipped };
+    return {
+      toFetch,
+      skipped
+    };
   }
+
   /**
    * 解析 pubsub 消息会走哪条同步分支，便于对照为何触发 HTTP 重拉或 body 直写。
    *
@@ -410,25 +422,24 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * // => { route: 'httpRefresh.batchIds', ... }
    */
   resolveSyncMessageRoute(msg) {
-    var _a;
     const hasBatchIds = Array.isArray(msg.ids) && msg.ids.length > 0;
     const singleIdRaw = msg.id ?? msg.order_id;
-    const hasSingleId = !hasBatchIds && singleIdRaw !== void 0 && singleIdRaw !== null;
+    const hasSingleId = !hasBatchIds && singleIdRaw !== undefined && singleIdRaw !== null;
     const normalizedBody = this.normalizeOrderSyncPayload(msg.body || msg.data);
     if (hasBatchIds) {
       return {
-        route: "httpRefresh.batchIds",
+        route: 'httpRefresh.batchIds',
         hasBatchIds: true,
         hasSingleId: false,
         hasNormalizedBody: !!normalizedBody,
         singleId: null,
         batchIds: msg.ids || [],
-        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
+        bodyOrderId: normalizedBody?.order_id ?? null
       };
     }
     if (hasSingleId && normalizedBody) {
       return {
-        route: "bodyUpsert",
+        route: 'bodyUpsert',
         hasBatchIds: false,
         hasSingleId: true,
         hasNormalizedBody: true,
@@ -439,77 +450,70 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
     if (hasSingleId) {
       return {
-        route: "httpRefresh.singleId",
+        route: 'httpRefresh.singleId',
         hasBatchIds: false,
         hasSingleId: true,
         hasNormalizedBody: !!normalizedBody,
         singleId: singleIdRaw,
         batchIds: [],
-        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
+        bodyOrderId: normalizedBody?.order_id ?? null
       };
     }
-    if ((_a = msg.relation_order_ids) == null ? void 0 : _a.length) {
+    if (msg.relation_order_ids?.length) {
       return {
-        route: "httpRefresh.relationIds",
+        route: 'httpRefresh.relationIds',
         hasBatchIds: false,
         hasSingleId: false,
         hasNormalizedBody: !!normalizedBody,
         singleId: null,
         batchIds: msg.relation_order_ids,
-        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
+        bodyOrderId: normalizedBody?.order_id ?? null
       };
     }
     return {
-      route: "noop",
+      route: 'noop',
       hasBatchIds: false,
       hasSingleId: false,
       hasNormalizedBody: !!normalizedBody,
       singleId: null,
       batchIds: [],
-      bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
+      bodyOrderId: normalizedBody?.order_id ?? null
     };
   }
   updateCreateStore() {
-    const appPlugin = this.core.getPlugin("app");
-    const app = appPlugin == null ? void 0 : appPlugin.getApp();
+    const appPlugin = this.core.getPlugin('app');
+    const app = appPlugin?.getApp();
     if (app) {
-      const coreData = app.data.store.getStore().getDataByModel("core");
-      if (coreData == null ? void 0 : coreData.core) {
-        const today = (0, import_dayjs.default)();
-        if (coreData == null ? void 0 : coreData.core.operating_day_boundary) {
+      const coreData = app.data.store.getStore().getDataByModel('core');
+      if (coreData?.core) {
+        const today = (0, _dayjs.default)();
+        if (coreData?.core.operating_day_boundary) {
           const operatingDayBoundary = coreData.core.operating_day_boundary;
-          if (operatingDayBoundary.type === "start_time") {
-            const boundaryTime = String(operatingDayBoundary.time || "").trim();
-            const boundaryStart = (0, import_dayjs.default)(`${today.format("YYYY-MM-DD")} ${boundaryTime}`);
+          if (operatingDayBoundary.type === 'start_time') {
+            const boundaryTime = String(operatingDayBoundary.time || '').trim();
+            const boundaryStart = (0, _dayjs.default)(`${today.format('YYYY-MM-DD')} ${boundaryTime}`);
             if (boundaryStart.isValid()) {
               const isAfterBoundary = today.isAfter(boundaryStart);
-              const queryStart = isAfterBoundary ? today.startOf("day") : today.subtract(1, "day").startOf("day");
-              const queryEnd = isAfterBoundary ? today.add(1, "day").endOf("day") : today.endOf("day");
+              const queryStart = isAfterBoundary ? today.startOf('day') : today.subtract(1, 'day').startOf('day');
+              const queryEnd = isAfterBoundary ? today.add(1, 'day').endOf('day') : today.endOf('day');
               this.store.createdAtQuery = {
-                sales_time_between: [
-                  queryStart.format("YYYY-MM-DD HH:mm:ss"),
-                  queryEnd.format("YYYY-MM-DD HH:mm:ss")
-                ]
+                sales_time_between: [queryStart.format('YYYY-MM-DD HH:mm:ss'), queryEnd.format('YYYY-MM-DD HH:mm:ss')]
               };
             } else {
+              // 边界时间异常时回退到自然日，避免 createdAtQuery 为空导致后续查询异常
               this.store.createdAtQuery = {
-                sales_time_between: [
-                  today.startOf("day").format("YYYY-MM-DD HH:mm:ss"),
-                  today.endOf("day").format("YYYY-MM-DD HH:mm:ss")
-                ]
+                sales_time_between: [today.startOf('day').format('YYYY-MM-DD HH:mm:ss'), today.endOf('day').format('YYYY-MM-DD HH:mm:ss')]
               };
             }
           } else {
             this.store.createdAtQuery = {
-              sales_time_between: [
-                today.startOf("day").format("YYYY-MM-DD HH:mm:ss"),
-                today.endOf("day").format("YYYY-MM-DD HH:mm:ss")
-              ]
+              sales_time_between: [today.startOf('day').format('YYYY-MM-DD HH:mm:ss'), today.endOf('day').format('YYYY-MM-DD HH:mm:ss')]
             };
           }
         } else {
+          // TODO: 这里后续可能需要使用店铺营业时间查询
           this.store.createdAtQuery = {
-            sales_time_between: [today.startOf("day").format("YYYY-MM-DD HH:mm:ss"), today.endOf("day").format("YYYY-MM-DD HH:mm:ss")]
+            sales_time_between: [today.startOf('day').format('YYYY-MM-DD HH:mm:ss'), today.endOf('day').format('YYYY-MM-DD HH:mm:ss')]
           };
         }
       }
@@ -519,17 +523,32 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const raw = localStorage.getItem(ORDER_SYNC_THROTTLE_MS_STORAGE_KEY);
     if (raw !== null) {
       const parsed = Number(raw);
-      if (Number.isFinite(parsed) && parsed >= 0)
-        return parsed;
+      if (Number.isFinite(parsed) && parsed >= 0) return parsed;
     }
     return DEFAULT_ORDER_SYNC_THROTTLE_MS;
   }
   async preload() {
+    // const hasPulledInCurrentWindow = this.hasPulledOrdersToday()
+    // // 仅当缓存属于当前统计窗口时才直接复用，避免跨天/跨营业日窗口继续使用旧数据
+    // if (cachedOrders.length > 0 && hasPulledInCurrentWindow) {
+    //   this.store.list = cloneDeep(cachedOrders)
+    //   this.syncOrdersMap()
+    //   this.core.effects.emit(OrderHooks.onOrdersChanged, this.store.list)
+    //   return
+    // }
+
+    // if (hasPulledInCurrentWindow) {
+    //   this.logInfo('当天已完成全量订单拉取，跳过本次全量拉取', {
+    //     lastFullFetchAt: this.getStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY),
+    //   })
+    //   return
+    // }
+
     const orders = await this.loadOrdersByServer();
-    this.store.list = (0, import_lodash_es.cloneDeep)(orders);
+    this.store.list = (0, _lodashEs.cloneDeep)(orders);
     this.syncOrdersMap();
-    await this.emitOrdersChanged([], "preload");
-    await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
+    await this.emitOrdersChanged([], 'preload');
+    await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
   }
   getOrders() {
     return this.store.list;
@@ -537,13 +556,13 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   getOrderById(id) {
     return this.store.map.get(this.getIdKey(id));
   }
+
   /** 按 order_id 查询内存订单。 */
   getOrderByOrderId(orderId) {
     return this.store.map.get(this.getIdKey(orderId));
   }
   buildLocalPaymentOrderLogContext(order) {
-    if (!order)
-      return {};
+    if (!order) return {};
     return {
       order_id: order.order_id ?? null,
       external_sale_number: order.external_sale_number ?? null,
@@ -565,9 +584,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   getLocalOrderFromMemoryByLookup(lookup) {
     const key = this.getIdKey(lookup);
     const memoryOrderById = this.store.map.get(key);
-    if (memoryOrderById)
-      return memoryOrderById;
-    const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
+    if (memoryOrderById) return memoryOrderById;
+    const memoryOrder = this.store.list.find(order => this.isOrderLookupMatch(order, key));
     return memoryOrder || null;
   }
   async getLocalOrderByLookup(lookup, options = {}) {
@@ -578,22 +596,22 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       memory_order_count: this.store.list.length
     };
     if (options.operationId) {
-      this.logInfo("getLocalOrderByLookup-localPayment-开始", logContext);
+      this.logInfo('getLocalOrderByLookup-localPayment-开始', logContext);
     }
     const memoryOrderById = this.store.map.get(key);
     if (memoryOrderById) {
       if (options.operationId) {
-        this.logInfo("getLocalOrderByLookup-localPayment-命中内存映射", {
+        this.logInfo('getLocalOrderByLookup-localPayment-命中内存映射', {
           ...logContext,
           ...this.buildLocalPaymentOrderLogContext(memoryOrderById)
         });
       }
       return memoryOrderById;
     }
-    const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
+    const memoryOrder = this.store.list.find(order => this.isOrderLookupMatch(order, key));
     if (memoryOrder) {
       if (options.operationId) {
-        this.logInfo("getLocalOrderByLookup-localPayment-命中内存列表", {
+        this.logInfo('getLocalOrderByLookup-localPayment-命中内存列表', {
           ...logContext,
           ...this.buildLocalPaymentOrderLogContext(memoryOrder)
         });
@@ -601,27 +619,24 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return memoryOrder;
     }
     if (options.operationId) {
-      this.logInfo("getLocalOrderByLookup-localPayment-开始读取SQLite", logContext);
+      this.logInfo('getLocalOrderByLookup-localPayment-开始读取SQLite', logContext);
     }
     const orders = await this.loadOrdersFromSQLite();
-    const localOrder = orders.find((order) => this.isOrderLookupMatch(order, key));
+    const localOrder = orders.find(order => this.isOrderLookupMatch(order, key));
     if (!localOrder) {
       if (options.operationId) {
-        this.logWarning("getLocalOrderByLookup-localPayment-SQLite未命中", {
+        this.logWarning('getLocalOrderByLookup-localPayment-SQLite未命中', {
           ...logContext,
           sqlite_order_count: orders.length
         });
       }
       return null;
     }
-    this.store.list = this.normalizeOrdersForMemoryList(
-      orders,
-      "getLocalOrderByLookup.sqliteMemory"
-    );
+    this.store.list = this.normalizeOrdersForMemoryList(orders, 'getLocalOrderByLookup.sqliteMemory');
     this.syncOrdersMap();
     const normalizedOrder = this.normalizeOrderForMemoryList(localOrder);
     if (options.operationId) {
-      this.logInfo("getLocalOrderByLookup-localPayment-SQLite命中", {
+      this.logInfo('getLocalOrderByLookup-localPayment-SQLite命中', {
         ...logContext,
         sqlite_order_count: orders.length,
         ...this.buildLocalPaymentOrderLogContext(normalizedOrder)
@@ -635,30 +650,26 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       sale_id: params.saleId,
       payment_number: params.paymentNumber
     };
-    this.logInfo("getLocalPayment-开始", logContext);
+    this.logInfo('getLocalPayment-开始', logContext);
     try {
       const order = await this.getLocalOrderByLookup(params.saleId, {
         operationId: params.operationId
       });
       if (!order) {
-        this.logWarning("getLocalPayment-订单未命中", logContext);
+        this.logWarning('getLocalPayment-订单未命中', logContext);
         return null;
       }
       const payments = order.payments || [];
-      const match = (0, import_payment_utils.resolveOrderPaymentIdentity)(
-        payments,
-        params.paymentNumber,
-        "compat"
-      );
+      const match = (0, _paymentUtils.resolveOrderPaymentIdentity)(payments, params.paymentNumber, 'compat');
       if (!match) {
-        this.logWarning("getLocalPayment-支付项未命中", {
+        this.logWarning('getLocalPayment-支付项未命中', {
           ...logContext,
           ...this.buildLocalPaymentOrderLogContext(order),
           payments
         });
         return null;
       }
-      this.logInfo("getLocalPayment-支付项命中", {
+      this.logInfo('getLocalPayment-支付项命中', {
         ...logContext,
         ...this.buildLocalPaymentOrderLogContext(order),
         matched_by: match.matchedBy,
@@ -672,7 +683,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         matchedBy: match.matchedBy
       };
     } catch (error) {
-      this.logError("getLocalPayment-查询失败", {
+      this.logError('getLocalPayment-查询失败', {
         ...logContext,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -686,21 +697,21 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       payment_number: params.paymentNumber,
       incoming_payment_update: params.updates
     };
-    this.logInfo("updateLocalPayment-开始", logContext);
+    this.logInfo('updateLocalPayment-开始', logContext);
     const found = await this.getLocalPayment(params);
     if (!found) {
-      this.logWarning("updateLocalPayment-支付项未命中", logContext);
+      this.logWarning('updateLocalPayment-支付项未命中', logContext);
       return null;
     }
-    const previousPayment = (0, import_lodash_es.cloneDeep)(found.payment);
-    const nextPayment = (0, import_payment_utils.mergeOrderPaymentRecord)(found.payment, {
+    const previousPayment = (0, _lodashEs.cloneDeep)(found.payment);
+    const nextPayment = (0, _paymentUtils.mergeOrderPaymentRecord)(found.payment, {
       ...params.updates,
-      updated_at: params.updates.updated_at || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+      updated_at: params.updates.updated_at || (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss')
     });
     const nextOrder = {
       ...found.order,
       payments: (found.order.payments || []).map((payment, index) => index === found.paymentIndex ? nextPayment : payment),
-      updated_at: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+      updated_at: (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss')
     };
     const paymentContext = {
       ...logContext,
@@ -710,11 +721,11 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       previous_payment: previousPayment,
       payment: nextPayment
     };
-    this.logInfo("updateLocalPayment-支付项合并完成", paymentContext);
+    this.logInfo('updateLocalPayment-支付项合并完成', paymentContext);
     const targetIndex = this.findOrderIndexByIdentity(this.store.list, found.order);
     const shouldKeepInMemory = this.shouldKeepOrderInMemory(nextOrder);
     if (targetIndex < 0 && shouldKeepInMemory) {
-      this.logError("updateLocalPayment-订单Store索引未命中", paymentContext);
+      this.logError('updateLocalPayment-订单Store索引未命中', paymentContext);
       return null;
     }
     const previousList = this.store.list;
@@ -722,19 +733,21 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.syncOrdersMap();
     const storageOrder = this.withoutSyntheticDraftOrderId(nextOrder);
     try {
-      this.logInfo("updateLocalPayment-SQLite写入开始", {
+      this.logInfo('updateLocalPayment-SQLite写入开始', {
         ...paymentContext,
         storage_order_id: storageOrder.order_id ?? null
       });
-      await this.updateOrderInSQLite(storageOrder, "updateLocalPayment", { throwOnError: true });
-      this.logInfo("updateLocalPayment-SQLite写入完成", {
+      await this.updateOrderInSQLite(storageOrder, 'updateLocalPayment', {
+        throwOnError: true
+      });
+      this.logInfo('updateLocalPayment-SQLite写入完成', {
         ...paymentContext,
         storage_order_id: storageOrder.order_id ?? null
       });
     } catch (error) {
       this.store.list = previousList;
       this.syncOrdersMap();
-      this.logError("updateLocalPayment-SQLite写入失败并回滚内存", {
+      this.logError('updateLocalPayment-SQLite写入失败并回滚内存', {
         ...paymentContext,
         storage_order_id: storageOrder.order_id ?? null,
         error: error instanceof Error ? error.message : String(error)
@@ -742,28 +755,23 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       throw error;
     }
     if (shouldKeepInMemory || targetIndex >= 0) {
-      await this.emitOrdersChanged(
-        shouldKeepInMemory ? [nextOrder] : [],
-        shouldKeepInMemory ? "updateLocalPayment" : "updateLocalPayment.sqliteOnlyDraft"
-      );
+      await this.emitOrdersChanged(shouldKeepInMemory ? [nextOrder] : [], shouldKeepInMemory ? 'updateLocalPayment' : 'updateLocalPayment.sqliteOnlyDraft');
     }
-    this.logInfo("updateLocalPayment-变更事件完成", paymentContext);
-    return { order: nextOrder, payment: nextPayment, previousPayment };
+    this.logInfo('updateLocalPayment-变更事件完成', paymentContext);
+    return {
+      order: nextOrder,
+      payment: nextPayment,
+      previousPayment
+    };
   }
   async loadOrdersByServer() {
-    var _a;
     let orderList = [];
-    const protectedOrdersBeforeRemoteFetch = (await this.loadOrdersFromSQLite()).filter(
-      (order) => this.shouldProtectLocalOrderFromRemoteSnapshot(order)
-    );
-    this.logInfo("loadOrdersByServer-开始", {
+    const protectedOrdersBeforeRemoteFetch = (await this.loadOrdersFromSQLite()).filter(order => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
+    this.logInfo('loadOrdersByServer-开始', {
       hasOrderDataSource: !!this.orderDataSource,
-      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null,
+      query: this.store?.createdAtQuery || null,
       protectedLocalOrderCount: protectedOrdersBeforeRemoteFetch.length,
-      protectedPendingPaymentCount: protectedOrdersBeforeRemoteFetch.reduce(
-        (count, order) => count + this.getIdentifiedPendingPayments(order).length,
-        0
-      )
+      protectedPendingPaymentCount: protectedOrdersBeforeRemoteFetch.reduce((count, order) => count + this.getIdentifiedPendingPayments(order).length, 0)
     });
     if (this.orderDataSource) {
       try {
@@ -773,33 +781,27 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           }
         });
         orderList = data || [];
-        this.logInfo("loadOrdersByServer-SSE拉取成功", {
+        this.logInfo('loadOrdersByServer-SSE拉取成功', {
           count: orderList.length
         });
         this.markOrderPulledAtNow();
         this.lastServerFullFetchAtMs = Date.now();
       } catch {
-        this.logInfo("loadOrdersByServer-SSE拉取失败，保持当前内存订单");
+        this.logInfo('loadOrdersByServer-SSE拉取失败，保持当前内存订单');
         return this.store.list;
       }
     }
-    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(
-      orderList,
-      "loadOrdersByServer",
-      protectedOrdersBeforeRemoteFetch
-    );
-    const memoryOrders = this.normalizeOrdersForMemoryList(
-      mergedOrders,
-      "loadOrdersByServer.memory"
-    );
-    this.logInfo("loadOrdersByServer-结束", {
+    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(orderList, 'loadOrdersByServer', protectedOrdersBeforeRemoteFetch);
+    const memoryOrders = this.normalizeOrdersForMemoryList(mergedOrders, 'loadOrdersByServer.memory');
+    this.logInfo('loadOrdersByServer-结束', {
       count: memoryOrders.length,
       persistedCount: mergedOrders.length,
       sqliteOnlyDraftCount: mergedOrders.length - memoryOrders.length
     });
-    await this.core.effects.emit(import_types.OrderHooks.onOrdersLoaded, memoryOrders);
+    await this.core.effects.emit(_types.OrderHooks.onOrdersLoaded, memoryOrders);
     return memoryOrders;
   }
+
   /**
    * 静默全量刷新：后台重新拉取全量 SSE 订单数据并更新本地
    * 拿到完整数据后一次性替换 store，触发订单变更与同步完成事件
@@ -811,38 +813,39 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (this.lastServerFullFetchAtMs > 0 && elapsedSinceFullFetch < ORDER_SILENT_REFRESH_MIN_INTERVAL_MS) {
       return this.store.list;
     }
-    this.logInfo("silentRefresh 开始");
+    this.logInfo('silentRefresh 开始');
     try {
+      // 刷新前，需要更新当前营业日边界（store.createdAtQuery）
       this.updateCreateStore();
       const orders = await this.loadOrdersByServer();
-      this.store.list = (0, import_lodash_es.cloneDeep)(orders);
+      this.store.list = (0, _lodashEs.cloneDeep)(orders);
       this.syncOrdersMap();
-      await this.emitOrdersChanged([], "silentRefresh");
-      await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
-      this.logInfo("silentRefresh 完成", {
+      await this.emitOrdersChanged([], 'silentRefresh');
+      await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
+      this.logInfo('silentRefresh 完成', {
         orderCount: orders.length,
         duration: `${Date.now() - startTime}ms`
       });
       return this.store.list;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("silentRefresh 失败", {
+      this.logError('silentRefresh 失败', {
         duration: `${Date.now() - startTime}ms`,
         error: errorMessage
       });
       return this.store.list;
     }
   }
-  normalizeOrderForMemoryList(order, source = "normalizeOrderForMemoryList") {
+  normalizeOrderForMemoryList(order, source = 'normalizeOrderForMemoryList') {
     const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, source);
-    const externalSaleNumber = normalizedOrder == null ? void 0 : normalizedOrder.external_sale_number;
+    const externalSaleNumber = normalizedOrder?.external_sale_number;
     if (this.isDraftOrder(normalizedOrder) && !this.hasRealOrderId(normalizedOrder)) {
       return normalizedOrder;
     }
-    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) !== "") {
+    if (normalizedOrder?.order_id !== undefined && normalizedOrder?.order_id !== null && normalizedOrder?.order_id !== '') {
       return normalizedOrder;
     }
-    if (externalSaleNumber === void 0 || externalSaleNumber === null || externalSaleNumber === "") {
+    if (externalSaleNumber === undefined || externalSaleNumber === null || externalSaleNumber === '') {
       return normalizedOrder;
     }
     return {
@@ -851,11 +854,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     };
   }
   normalizeOrdersForMemoryList(orders, source) {
-    return orders.map((order) => this.normalizeOrderForMemoryList(order, source)).filter((order) => this.shouldKeepOrderInMemory(order));
+    return orders.map(order => this.normalizeOrderForMemoryList(order, source)).filter(order => this.shouldKeepOrderInMemory(order));
   }
   hasRealOrderId(order) {
-    if (!order || this.isBlankIdentityValue(order.order_id))
-      return false;
+    if (!order || this.isBlankIdentityValue(order.order_id)) return false;
     const externalSaleNumber = order.external_sale_number;
     return !(this.isDraftOrder(order) && !this.isBlankIdentityValue(externalSaleNumber) && String(order.order_id) === String(externalSaleNumber));
   }
@@ -864,67 +866,75 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   }
   withoutSyntheticDraftOrderId(order) {
     const externalSaleNumber = order.external_sale_number;
-    if (Number(order.is_draft_order || 0) !== 1 || order.order_id === void 0 || externalSaleNumber === void 0 || String(order.order_id) !== String(externalSaleNumber)) {
+    if (Number(order.is_draft_order || 0) !== 1 || order.order_id === undefined || externalSaleNumber === undefined || String(order.order_id) !== String(externalSaleNumber)) {
       return order;
     }
-    const next = { ...order };
+    const next = {
+      ...order
+    };
     delete next.order_id;
     return next;
   }
+
   /**
    * 仅覆盖本地已存在的订单；不存在则直接跳过，不落库、不 emit。
    * 适用于"按 order_id 主动刷新本地订单详情"的代理场景。
    */
   async overwriteExistingOrder(fresh) {
-    const orderId = fresh == null ? void 0 : fresh.order_id;
-    if (orderId === void 0 || orderId === null) {
-      this.logError("overwriteExistingOrder-入参缺少 order_id");
-      return { overwritten: false };
+    const orderId = fresh?.order_id;
+    if (orderId === undefined || orderId === null) {
+      this.logError('overwriteExistingOrder-入参缺少 order_id');
+      return {
+        overwritten: false
+      };
     }
     const key = this.getIdKey(orderId);
     if (!this.store.map.has(key)) {
-      this.logInfo("overwriteExistingOrder-本地不存在该订单，跳过", { orderId });
-      return { overwritten: false };
+      this.logInfo('overwriteExistingOrder-本地不存在该订单，跳过', {
+        orderId
+      });
+      return {
+        overwritten: false
+      };
     }
-    this.logInfo("overwriteExistingOrder-开始覆盖", {
+    this.logInfo('overwriteExistingOrder-开始覆盖', {
       orderId,
       storeOrderCountBefore: this.store.list.length
     });
-    const normalizedFresh = this.normalizeOrderForMemoryList(
-      fresh,
-      "overwriteExistingOrder.incoming"
-    );
+    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 this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
+    const reconciledFresh = this.reconcileOverwriteOrderCollections(existingOrder, normalizedFresh);
+    this.store.list = this.store.list.map(order => {
+      const id = order?.order_id;
+      if (id === undefined || id === null) {
+        return this.normalizeOrderForMemoryList(order, 'overwriteExistingOrder.existingMemory');
       }
-      return this.getIdKey(id) === key ? reconciledFresh : this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
+      return this.getIdKey(id) === key ? reconciledFresh : this.normalizeOrderForMemoryList(order, 'overwriteExistingOrder.existingMemory');
     });
     this.syncOrdersMap();
-    await this.updateOrderInSQLite(reconciledFresh, "overwriteExistingOrder");
-    this.logInfo("overwriteExistingOrder-结束", {
+    await this.updateOrderInSQLite(reconciledFresh, 'overwriteExistingOrder');
+    this.logInfo('overwriteExistingOrder-结束', {
       orderId,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged([reconciledFresh], "overwriteExistingOrder");
-    return { overwritten: true };
+    await this.emitOrdersChanged([reconciledFresh], 'overwriteExistingOrder');
+    return {
+      overwritten: true
+    };
   }
+
   /**
    * 将远端拉取的订单合并进本地 store（已存在则更新，不存在则追加），落库并 emit onOrdersChanged。
    * 供 /update/localOrder 等在「本地尚无该单」时写入新建单。
    */
-  async upsertOrdersFromRemote(freshOrders, source = "upsertOrdersFromRemote") {
-    if (!(freshOrders == null ? void 0 : freshOrders.length)) {
-      this.logInfo("upsertOrdersFromRemote-订单列表为空", { source });
+  async upsertOrdersFromRemote(freshOrders, source = 'upsertOrdersFromRemote') {
+    if (!freshOrders?.length) {
+      this.logInfo('upsertOrdersFromRemote-订单列表为空', {
+        source
+      });
       return;
     }
-    this.logInfo("upsertOrdersFromRemote-开始", {
+    this.logInfo('upsertOrdersFromRemote-开始', {
       count: freshOrders.length,
       source
     });
@@ -932,106 +942,100 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   }
   async markOrderSyncedByExternalSaleNumber(params) {
     const externalSaleNumber = params.externalSaleNumber;
-    if (externalSaleNumber === void 0 || externalSaleNumber === null || externalSaleNumber === "") {
-      this.logError("markOrderSyncedByExternalSaleNumber-缺少 external_sale_number");
-      return { updated: false };
+    if (externalSaleNumber === undefined || externalSaleNumber === null || externalSaleNumber === '') {
+      this.logError('markOrderSyncedByExternalSaleNumber-缺少 external_sale_number');
+      return {
+        updated: false
+      };
     }
     const key = this.getIdKey(externalSaleNumber);
-    const targetIndex = this.store.list.findIndex((order) => {
-      const value = order == null ? void 0 : order.external_sale_number;
-      if (value === void 0 || value === null || value === "")
-        return false;
+    const targetIndex = this.store.list.findIndex(order => {
+      const value = order?.external_sale_number;
+      if (value === undefined || value === null || value === '') return false;
       return this.getIdKey(value) === key;
     });
     if (targetIndex < 0) {
-      this.logInfo("markOrderSyncedByExternalSaleNumber-本地订单不存在，跳过", {
+      this.logInfo('markOrderSyncedByExternalSaleNumber-本地订单不存在，跳过', {
         external_sale_number: externalSaleNumber
       });
-      return { updated: false };
+      return {
+        updated: false
+      };
     }
     const existing = this.store.list[targetIndex];
     const nextOrder = this.normalizeRemoteSyncedOrder({
       ...existing,
-      ...params.patch || {},
+      ...(params.patch || {}),
       external_sale_number: existing.external_sale_number ?? externalSaleNumber,
       need_sync: 0,
       is_draft_order: 0
     });
     const storageKey = this.getOrderStorageKey(nextOrder) || key;
     this.store.list = this.store.list.map((order, index) => {
-      if (index !== targetIndex)
-        return order;
+      if (index !== targetIndex) return order;
       return nextOrder;
     });
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(
-      [nextOrder],
-      "markOrderSyncedByExternalSaleNumber",
-      { [storageKey]: "update" }
-    );
-    this.logInfo("markOrderSyncedByExternalSaleNumber-完成", {
+    await this.patchOrdersInSQLite([nextOrder], 'markOrderSyncedByExternalSaleNumber', {
+      [storageKey]: 'update'
+    });
+    this.logInfo('markOrderSyncedByExternalSaleNumber-完成', {
       external_sale_number: externalSaleNumber,
       order_id: nextOrder.order_id ?? null
     });
-    await this.emitOrdersChanged([nextOrder], "markOrderSyncedByExternalSaleNumber");
-    return { updated: true, order: nextOrder };
+    await this.emitOrdersChanged([nextOrder], 'markOrderSyncedByExternalSaleNumber');
+    return {
+      updated: true,
+      order: nextOrder
+    };
   }
+
   /**
    * 将本地待同步订单按 SQLite storage key 合并进 store 并落库。
    * checkout 离线兜底可能没有 order_id，但通常会有 external_sale_number。
    */
   async upsertPendingSyncOrders(pendingOrders, options = {}) {
-    if (!(pendingOrders == null ? void 0 : pendingOrders.length)) {
-      this.logInfo("upsertPendingSyncOrders-订单列表为空", {});
+    if (!pendingOrders?.length) {
+      this.logInfo('upsertPendingSyncOrders-订单列表为空', {});
       return;
     }
-    const pendingMap = /* @__PURE__ */ new Map();
-    const memoryPendingMap = /* @__PURE__ */ new Map();
+    const pendingMap = new Map();
+    const memoryPendingMap = new Map();
     for (const order of pendingOrders) {
-      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
-        order,
-        "upsertPendingSyncOrders.incoming"
-      );
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, 'upsertPendingSyncOrders.incoming');
       const pendingOrder = {
         ...normalizedOrder,
         need_sync: 1,
         is_draft_order: 0
       };
       const storageKey = this.getOrderStorageKey(pendingOrder);
-      if (!storageKey)
-        continue;
+      if (!storageKey) continue;
       pendingMap.set(storageKey, pendingOrder);
-      memoryPendingMap.set(
-        storageKey,
-        this.normalizeOrderForMemoryList(
-          pendingOrder,
-          "upsertPendingSyncOrders.memory"
-        )
-      );
+      memoryPendingMap.set(storageKey, this.normalizeOrderForMemoryList(pendingOrder, 'upsertPendingSyncOrders.memory'));
     }
     if (pendingMap.size === 0) {
-      this.logError("upsertPendingSyncOrders-订单缺少可落库标识", {
+      this.logError('upsertPendingSyncOrders-订单缺少可落库标识', {
         count: pendingOrders.length
       });
       return;
     }
-    this.logInfo("upsertPendingSyncOrders-开始", { count: pendingMap.size });
+    this.logInfo('upsertPendingSyncOrders-开始', {
+      count: pendingMap.size
+    });
     const mergeActions = {};
-    const updatedList = this.store.list.map(
-      (order) => this.normalizeOrderForMemoryList(order, "upsertPendingSyncOrders.existingMemory")
-    );
-    const identityKeyToIndex = /* @__PURE__ */ new Map();
+    const updatedList = this.store.list.map(order => this.normalizeOrderForMemoryList(order, 'upsertPendingSyncOrders.existingMemory'));
+
+    // 与 mergeOrdersToStore 一致：基于身份键（field:value）建立索引，把「查找已存在订单」
+    // 从 O(n) 线性扫描降为 O(1)，整体复杂度由 O(n^2) 降为 O(n + m)。
+    const identityKeyToIndex = 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);
+        // 同一 key 命中多张时保留最靠前的下标，与原 findIndex「取首个匹配」一致
+        if (!identityKeyToIndex.has(key)) identityKeyToIndex.set(key, index);
       }
     }
     for (const [storageKey, pendingOrder] of memoryPendingMap.entries()) {
-      const matchIndex = this.lookupOrderIndexByIdentityKeys(
-        identityKeyToIndex,
-        this.getOrderIdentityMatchKeys(pendingOrder)
-      );
+      const matchIndex = this.lookupOrderIndexByIdentityKeys(identityKeyToIndex, this.getOrderIdentityMatchKeys(pendingOrder));
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
         const mergedOrder = this.mergeOrderRecords(existingOrder, pendingOrder);
@@ -1043,53 +1047,48 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         updatedList[matchIndex] = nextOrder;
         const pendingSnapshot = pendingMap.get(storageKey);
         if (pendingSnapshot) {
-          pendingMap.set(
-            storageKey,
-            this.reconcileOverwriteOrderCollections(existingOrder, pendingSnapshot)
-          );
+          pendingMap.set(storageKey, this.reconcileOverwriteOrderCollections(existingOrder, pendingSnapshot));
         }
+        // 合并后身份字段可能新增（如挂单拿到 order_id），同步登记，供同批后续 pending 命中同一槽位
         this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
-        mergeActions[storageKey] = "update";
+        mergeActions[storageKey] = 'update';
         continue;
       }
       const insertIndex = updatedList.length;
       updatedList.push(pendingOrder);
       this.registerOrderIdentityKeys(identityKeyToIndex, pendingOrder, insertIndex);
-      mergeActions[storageKey] = "insert";
+      mergeActions[storageKey] = 'insert';
     }
     const patchedOrders = [...pendingMap.values()];
+    // 增量索引已保证 store 去重不变量，无需再对全表做 O(n^2) 压缩；仅自检开关开启时兜底。
     const previousList = this.store.list;
-    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
+    this.store.list = this.runOrderStoreSelfCheck(updatedList, 'upsertPendingSyncOrders.store');
     this.syncOrdersMap();
     try {
-      await this.patchOrdersInSQLite(
-        patchedOrders,
-        "upsertPendingSyncOrders",
-        mergeActions,
-        options
-      );
+      await this.patchOrdersInSQLite(patchedOrders, 'upsertPendingSyncOrders', mergeActions, options);
     } catch (error) {
       this.store.list = previousList;
       this.syncOrdersMap();
       throw error;
     }
-    this.logInfo("upsertPendingSyncOrders-结束", {
+    this.logInfo('upsertPendingSyncOrders-结束', {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
+    await this.emitOrdersChanged(patchedOrders, 'upsertPendingSyncOrders');
   }
+
   /**
    * 将 POS 草稿订单按 SQLite storage key 落库。
    * 只有具备真实 order_id 的草稿进入 store；其余草稿仅供本地恢复查询。
    */
   async upsertLocalDraftOrders(draftOrders) {
-    if (!(draftOrders == null ? void 0 : draftOrders.length)) {
-      this.logInfo("upsertLocalDraftOrders-订单列表为空", {});
+    if (!draftOrders?.length) {
+      this.logInfo('upsertLocalDraftOrders-订单列表为空', {});
       return;
     }
-    const draftMap = /* @__PURE__ */ new Map();
-    const memoryDraftMap = /* @__PURE__ */ new Map();
+    const draftMap = new Map();
+    const memoryDraftMap = new Map();
     for (const order of draftOrders) {
       const draftOrder = {
         ...order,
@@ -1097,8 +1096,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         is_draft_order: 1
       };
       const storageKey = this.getOrderStorageKey(draftOrder);
-      if (!storageKey)
-        continue;
+      if (!storageKey) continue;
       draftMap.set(storageKey, draftOrder);
       const memoryDraftOrder = this.normalizeOrderForMemoryList(draftOrder);
       if (this.shouldKeepOrderInMemory(memoryDraftOrder)) {
@@ -1106,36 +1104,29 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
     }
     if (draftMap.size === 0) {
-      this.logError("upsertLocalDraftOrders-订单缺少可落库标识", {
+      this.logError('upsertLocalDraftOrders-订单缺少可落库标识', {
         count: draftOrders.length
       });
       return;
     }
-    this.logInfo("upsertLocalDraftOrders-开始", {
+    this.logInfo('upsertLocalDraftOrders-开始', {
       count: draftMap.size,
       memoryDraftCount: memoryDraftMap.size,
       sqliteOnlyDraftCount: draftMap.size - memoryDraftMap.size
     });
     const mergeActions = {};
-    const updatedList = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
-    const identityKeyToIndex = /* @__PURE__ */ new Map();
+    const updatedList = this.store.list.filter(order => this.shouldKeepOrderInMemory(order));
+    const identityKeyToIndex = 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);
+        if (!identityKeyToIndex.has(key)) identityKeyToIndex.set(key, index);
       }
     }
     for (const [storageKey, draftOrder] of memoryDraftMap.entries()) {
-      const matchIndex = this.lookupOrderIndexByIdentityKeys(
-        identityKeyToIndex,
-        this.getOrderIdentityMatchKeys(draftOrder)
-      );
+      const matchIndex = this.lookupOrderIndexByIdentityKeys(identityKeyToIndex, this.getOrderIdentityMatchKeys(draftOrder));
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
-        const reconciledDraftOrder = this.preserveExistingBusinessCodeForDraft(
-          existingOrder,
-          draftOrder
-        );
+        const reconciledDraftOrder = this.preserveExistingBusinessCodeForDraft(existingOrder, draftOrder);
         const mergedOrder = this.mergeOrderRecords(existingOrder, reconciledDraftOrder);
         const nextOrder = {
           ...mergedOrder,
@@ -1143,57 +1134,54 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           is_draft_order: 1
         };
         updatedList[matchIndex] = nextOrder;
+        // SQLite 必须与内存中的草稿保持同一份 business_code，避免下次 hydrate 再次丢失分类。
         draftMap.set(storageKey, reconciledDraftOrder);
         this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
-        mergeActions[storageKey] = "update";
+        mergeActions[storageKey] = 'update';
         continue;
       }
       const insertIndex = updatedList.length;
       updatedList.push(draftOrder);
       this.registerOrderIdentityKeys(identityKeyToIndex, draftOrder, insertIndex);
-      mergeActions[storageKey] = "insert";
+      mergeActions[storageKey] = 'insert';
     }
     const patchedOrders = [...draftMap.values()];
     const previousList = this.store.list;
-    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertLocalDraftOrders.store");
+    this.store.list = this.runOrderStoreSelfCheck(updatedList, 'upsertLocalDraftOrders.store');
     this.syncOrdersMap();
     try {
-      await this.patchOrdersInSQLite(
-        patchedOrders,
-        "upsertLocalDraftOrders",
-        mergeActions,
-        { throwOnError: true }
-      );
+      await this.patchOrdersInSQLite(patchedOrders, 'upsertLocalDraftOrders', mergeActions, {
+        throwOnError: true
+      });
     } catch (error) {
       this.store.list = previousList;
       this.syncOrdersMap();
       throw error;
     }
-    this.logInfo("upsertLocalDraftOrders-结束", {
+    this.logInfo('upsertLocalDraftOrders-结束', {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
-    const removedLegacyMemoryDraft = previousList.some(
-      (order) => !this.shouldKeepOrderInMemory(order)
-    );
+    const removedLegacyMemoryDraft = previousList.some(order => !this.shouldKeepOrderInMemory(order));
     if (memoryDraftMap.size > 0 || removedLegacyMemoryDraft) {
-      await this.emitOrdersChanged(
-        patchedOrders.filter((order) => this.shouldKeepOrderInMemory(order)),
-        "upsertLocalDraftOrders"
-      );
+      await this.emitOrdersChanged(patchedOrders.filter(order => this.shouldKeepOrderInMemory(order)), 'upsertLocalDraftOrders');
     }
   }
+
   /**
    * 通过 SSE 按自定义 query 拉取订单（支持 select/with 精简字段）
    */
   async fetchOrdersBySSE(query = {}) {
-    if (!this.orderDataSource)
-      return [];
+    if (!this.orderDataSource) return [];
     try {
-      const data = await this.orderDataSource.run({ sse: { query } });
+      const data = await this.orderDataSource.run({
+        sse: {
+          query
+        }
+      });
       return data || [];
     } catch (error) {
-      this.logError("fetchOrdersBySSE-失败", {
+      this.logError('fetchOrdersBySSE-失败', {
         error: error instanceof Error ? error.message : String(error)
       });
       return [];
@@ -1203,30 +1191,28 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return [];
   }
   destroy() {
-    var _a;
     if (this.syncTimer) {
       clearTimeout(this.syncTimer);
-      this.syncTimer = void 0;
+      this.syncTimer = undefined;
     }
     this.isProcessingSyncBatch = false;
     this.pendingSyncMessages = [];
-    if ((_a = this.orderDataSource) == null ? void 0 : _a.destroy)
-      this.orderDataSource.destroy();
+    this.recentSqliteWriteByStorageKey.clear();
+    this.lastRecentSqliteWriteCleanupAtMs = 0;
+    if (this.orderDataSource?.destroy) this.orderDataSource.destroy();
     super.destroy();
   }
   syncOrdersMap() {
-    this.store.list = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
+    this.store.list = this.store.list.filter(order => this.shouldKeepOrderInMemory(order));
     this.store.map.clear();
     for (const order of this.store.list) {
       const primaryIdentity = this.getOrderMapKey(order);
-      if (!primaryIdentity)
-        continue;
+      if (!primaryIdentity) continue;
       this.store.map.set(primaryIdentity, order);
     }
   }
   getOrderMapKey(order) {
-    if (!order)
-      return "";
+    if (!order) return '';
     if (!this.isBlankIdentityValue(order.order_id)) {
       return this.getIdKey(order.order_id);
     }
@@ -1234,11 +1220,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (!this.isBlankIdentityValue(externalSaleNumber)) {
       return this.getIdKey(externalSaleNumber);
     }
-    return "";
+    return '';
   }
   isBlankIdentityValue(value) {
-    return value === void 0 || value === null || value === "";
+    return value === undefined || value === null || value === '';
   }
+
   /**
    * `/sales/draft` 的旧调用方可能把未设置的 business_code 传成空串。
    * 对同一真实订单，空值不能覆盖已有的分类，否则 booking 查询会把该订单从 Party 列表过滤掉。
@@ -1246,92 +1233,85 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   preserveExistingBusinessCodeForDraft(existingOrder, draftOrder) {
     const existingBusinessCode = existingOrder.business_code;
     const draftBusinessCode = draftOrder.business_code;
-    const hasExistingBusinessCode = typeof existingBusinessCode === "string" && existingBusinessCode.trim() !== "";
-    const hasDraftBusinessCode = typeof draftBusinessCode === "string" && draftBusinessCode.trim() !== "";
-    if (!hasExistingBusinessCode || hasDraftBusinessCode)
-      return draftOrder;
+    const hasExistingBusinessCode = typeof existingBusinessCode === 'string' && existingBusinessCode.trim() !== '';
+    const hasDraftBusinessCode = typeof draftBusinessCode === 'string' && draftBusinessCode.trim() !== '';
+    if (!hasExistingBusinessCode || hasDraftBusinessCode) return draftOrder;
     return {
       ...draftOrder,
       business_code: existingBusinessCode
     };
   }
   getOrderIdentityEntries(order) {
-    if (!order)
-      return [];
+    if (!order) return [];
     const record = order;
-    const candidates = [
-      { field: "order_id", value: order.order_id },
-      { field: "external_sale_number", value: record.external_sale_number },
-      { field: "order_number", value: record.order_number },
-      { field: "shop_order_number", value: record.shop_order_number }
-    ];
+    const candidates = [{
+      field: 'order_id',
+      value: order.order_id
+    }, {
+      field: 'external_sale_number',
+      value: record.external_sale_number
+    }, {
+      field: 'order_number',
+      value: record.order_number
+    }, {
+      field: 'shop_order_number',
+      value: record.shop_order_number
+    }];
     const entries = [];
     for (const candidate of candidates) {
-      if (this.isBlankIdentityValue(candidate.value))
-        continue;
+      if (this.isBlankIdentityValue(candidate.value)) continue;
       const key = this.getIdKey(candidate.value);
-      if (entries.some((entry) => entry.field === candidate.field && entry.key === key))
-        continue;
-      entries.push({ field: candidate.field, key });
+      if (entries.some(entry => entry.field === candidate.field && entry.key === key)) continue;
+      entries.push({
+        field: candidate.field,
+        key
+      });
     }
     return entries;
   }
   getOrderIdentityKeys(order) {
     const keys = [];
     for (const entry of this.getOrderIdentityEntries(order)) {
-      if (!keys.includes(entry.key))
-        keys.push(entry.key);
+      if (!keys.includes(entry.key)) keys.push(entry.key);
     }
     return keys;
   }
   getOrderDateKey(order) {
-    var _a, _b, _c, _d;
-    const candidates = [
-      order == null ? void 0 : order.schedule_date,
-      order == null ? void 0 : order.create_date,
-      order == null ? void 0 : order.created_at,
-      (_b = (_a = order == null ? void 0 : order.bookings) == null ? void 0 : _a[0]) == null ? void 0 : _b.start_date,
-      (_d = (_c = order == null ? void 0 : order.bookings) == null ? void 0 : _c[0]) == null ? void 0 : _d.select_date
-    ];
+    const candidates = [order?.schedule_date, order?.create_date, order?.created_at, order?.bookings?.[0]?.start_date, order?.bookings?.[0]?.select_date];
     for (const v of candidates) {
-      if (!v)
-        continue;
+      if (!v) continue;
       const text = String(v);
-      if (!text)
-        continue;
-      return text.split("T")[0].split(" ")[0];
+      if (!text) continue;
+      return text.split('T')[0].split(' ')[0];
     }
-    return void 0;
+    return undefined;
   }
+
   /**
    * 初始化 OrderDataSource 实例
    */
   initOrderDataSource() {
-    var _a, _b;
-    const OrderDataSourceClass = (_b = (_a = this.core.serverOptions) == null ? void 0 : _a.All_DATA_SOURCES) == null ? void 0 : _b.OrderDataSource;
-    if (!OrderDataSourceClass)
-      return;
+    const OrderDataSourceClass = this.core.serverOptions?.All_DATA_SOURCES?.OrderDataSource;
+    if (!OrderDataSourceClass) return;
     this.orderDataSource = new OrderDataSourceClass();
   }
+
   /**
    * 初始化 pubsub 订阅，监听订单变更（纯订阅，不拉数据；全量 SSE 由 loadOrdersByServer 负责）
    */
   setupOrderSync() {
-    if (!this.orderDataSource)
-      return;
+    if (!this.orderDataSource) return;
     this.orderDataSource.run({
       pubsub: {
-        callback: (res) => {
-          console.log("orderDataSource", res);
+        callback: res => {
           const pubsubReceivedAt = Date.now();
           const message = this.normalizeOrderSyncMessage(res);
-          if (!message)
-            return;
+          if (!message) return;
           message._pubsubReceivedAt = pubsubReceivedAt;
           this.pendingSyncMessages.push(message);
           const throttleMs = this.getOrderSyncThrottleMs();
           const routeInfo = this.resolveSyncMessageRoute(message);
-          this.logInfo("orderSync-收到消息并入队", {
+          this.logInfo('orderSync-收到消息并入队', {
             id: message.id ?? null,
             order_id: message.order_id ?? null,
             type: message.type ?? null,
@@ -1344,8 +1324,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         }
       }
     }).catch(() => {
+      // 忽略同步初始化异常，避免影响主流程
     });
   }
+
   /**
    * 调度订单同步节流窗口（leading-edge throttle）：
    * - 空闲状态下收到的第一条消息立即触发批处理，无需等待；
@@ -1353,29 +1335,27 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * - 若当前批处理执行中，则由批处理结束后决定是否开启下一轮窗口。
    */
   scheduleOrderSyncThrottle() {
-    if (this.isProcessingSyncBatch)
-      return;
+    if (this.isProcessingSyncBatch) return;
     if (this.isIdlePhase) {
       this.isIdlePhase = false;
-      this.logInfo("orderSync-首条消息立即触发处理");
+      this.logInfo('orderSync-首条消息立即触发处理');
       void this.flushOrderSyncMessagesByThrottle();
       return;
     }
-    if (this.syncTimer)
-      return;
+    if (this.syncTimer) return;
     const throttleMs = this.getOrderSyncThrottleMs();
     this.syncTimer = setTimeout(() => {
-      this.syncTimer = void 0;
+      this.syncTimer = undefined;
       void this.flushOrderSyncMessagesByThrottle();
     }, throttleMs);
   }
+
   /**
    * 执行一次节流批处理并在需要时续约下一轮窗口。
    * 批处理完成且无后续消息时恢复空闲状态，下一条消息将立即触发。
    */
   async flushOrderSyncMessagesByThrottle() {
-    if (this.isProcessingSyncBatch)
-      return;
+    if (this.isProcessingSyncBatch) return;
     if (this.pendingSyncMessages.length === 0) {
       this.isIdlePhase = true;
       return;
@@ -1392,6 +1372,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
     }
   }
+
   /**
    * 处理节流窗口内聚合后的同步消息批次
    *
@@ -1406,19 +1387,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   async processOrderSyncMessages() {
     const messages = [...this.pendingSyncMessages];
     this.pendingSyncMessages = [];
-    if (messages.length === 0)
-      return;
+    if (messages.length === 0) return;
     const batchProcessStartAt = Date.now();
-    const earliestReceivedAt = Math.min(
-      ...messages.map((m) => m._pubsubReceivedAt ?? batchProcessStartAt)
-    );
-    this.logInfo("processOrderSyncMessages-开始", {
+    const earliestReceivedAt = Math.min(...messages.map(m => m._pubsubReceivedAt ?? batchProcessStartAt));
+    this.logInfo('processOrderSyncMessages-开始', {
       messageCount: messages.length,
       earliestReceivedAt: new Date(earliestReceivedAt).toISOString(),
       batchProcessStartAt: new Date(batchProcessStartAt).toISOString(),
       waitDurationMs: batchProcessStartAt - earliestReceivedAt
     });
-    const upsertOrders = /* @__PURE__ */ new Map();
+    const upsertOrders = new Map();
     const refreshIds = [];
     messages.forEach((msg, msgIndex) => {
       const routeInfo = this.resolveSyncMessageRoute(msg);
@@ -1426,50 +1404,47 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       const singleId = routeInfo.singleId;
       const hasSingleId = routeInfo.hasSingleId;
       const normalizedBody = this.normalizeOrderSyncPayload(msg.body || msg.data);
-      if (routeInfo.route === "bodyUpsert" && normalizedBody) {
+      if (routeInfo.route === 'bodyUpsert' && normalizedBody) {
         upsertOrders.set(this.getIdKey(normalizedBody.order_id), normalizedBody);
         return;
       }
-      if (hasBatchIds)
-        refreshIds.push(...routeInfo.batchIds);
-      else if (routeInfo.route === "httpRefresh.singleId" && singleId !== null)
-        refreshIds.push(singleId);
-      else if (routeInfo.route === "httpRefresh.relationIds")
-        refreshIds.push(...routeInfo.batchIds);
+      if (hasBatchIds) refreshIds.push(...routeInfo.batchIds);else if (routeInfo.route === 'httpRefresh.singleId' && singleId !== null) refreshIds.push(singleId);else if (routeInfo.route === 'httpRefresh.relationIds') refreshIds.push(...routeInfo.batchIds);
     });
     const uniqueRefreshIds = this.uniqueOrderIds(refreshIds);
     const upsertList = [...upsertOrders.values()];
-    this.logInfo("processOrderSyncMessages-去重完成", {
+    this.logInfo('processOrderSyncMessages-去重完成', {
       upsertCount: upsertList.length,
       refreshIdCount: uniqueRefreshIds.length
     });
     if (upsertList.length > 0) {
-      await this.mergeOrdersToStore(upsertList, "pubsub.bodyUpsert");
+      await this.mergeOrdersToStore(upsertList, 'pubsub.bodyUpsert');
     }
     if (uniqueRefreshIds.length > 0) {
-      const { toFetch, skipped } = this.filterRedundantHttpRefreshIds(uniqueRefreshIds);
-      if (skipped.length > 0) {
-      }
+      const {
+        toFetch,
+        skipped
+      } = this.filterRedundantHttpRefreshIds(uniqueRefreshIds);
+      if (skipped.length > 0) {}
       if (toFetch.length > 0) {
         const freshOrders = await this.fetchOrdersByHttp(toFetch);
         if (freshOrders.length > 0) {
-          await this.mergeOrdersToStore(freshOrders, "pubsub.httpRefresh");
-        } else {
-        }
+          await this.mergeOrdersToStore(freshOrders, 'pubsub.httpRefresh');
+        } else {}
       }
     }
     if (upsertList.length === 0 && uniqueRefreshIds.length === 0) {
       return;
     }
     const batchProcessEndAt = Date.now();
-    this.logInfo("processOrderSyncMessages-结束", {
+    this.logInfo('processOrderSyncMessages-结束', {
       upsertCount: upsertList.length,
       refreshIdCount: uniqueRefreshIds.length,
       batchProcessDurationMs: batchProcessEndAt - batchProcessStartAt,
       totalFromPubsubToProcessedMs: batchProcessEndAt - earliestReceivedAt
     });
-    await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
+    await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
   }
+
   /**
    * 通过 HTTP 按 ids 批量拉取订单详情（走 orderDataSource）。
    *
@@ -1481,16 +1456,17 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * const fresh = await orderModule.fetchOrdersByHttp(['96971', '96972'])
    */
   async fetchOrdersByHttp(ids) {
-    if (!this.orderDataSource || ids.length === 0)
-      return [];
+    if (!this.orderDataSource || ids.length === 0) return [];
     try {
-      if (typeof this.orderDataSource.fetchOrdersByIds === "function") {
-        const orderList2 = await this.orderDataSource.fetchOrdersByIds(ids);
-        return orderList2 || [];
+      if (typeof this.orderDataSource.fetchOrdersByIds === 'function') {
+        const orderList = await this.orderDataSource.fetchOrdersByIds(ids);
+        return orderList || [];
       }
       const orderList = await this.orderDataSource.run({
         http: {
-          query: { ids }
+          query: {
+            ids
+          }
         }
       });
       return orderList || [];
@@ -1498,70 +1474,63 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return [];
     }
   }
+
   /**
    * 将增量订单合并到 store
    */
   async mergeOrdersToStore(freshOrders, source) {
     const storeOrderCountBefore = this.store.list.length;
-    this.logInfo("mergeOrdersToStore-开始", {
+    this.logInfo('mergeOrdersToStore-开始', {
       freshOrderCount: freshOrders.length,
       storeOrderCountBefore,
       source
     });
     this.logDuplicateOrders(`${source}.beforeMerge`, this.store.list);
     const normalizedFreshOrders = [];
-    const incomingProductsHaveStableIdentity = /* @__PURE__ */ new Map();
+    const incomingProductsHaveStableIdentity = new Map();
     for (const order of freshOrders) {
-      const id = order == null ? void 0 : order.order_id;
-      if (id === void 0 || id === null)
-        continue;
+      const id = order?.order_id;
+      if (id === undefined || id === null) continue;
       const rawProducts = order.products;
       if (Array.isArray(rawProducts)) {
         const allProductsHaveStableIdentity = this.doProductsHaveStableMembershipIdentity(rawProducts);
         const orderIdKey = this.getIdKey(id);
-        incomingProductsHaveStableIdentity.set(
-          orderIdKey,
-          (incomingProductsHaveStableIdentity.get(orderIdKey) ?? true) && allProductsHaveStableIdentity
-        );
+        incomingProductsHaveStableIdentity.set(orderIdKey, (incomingProductsHaveStableIdentity.get(orderIdKey) ?? true) && allProductsHaveStableIdentity);
       }
       normalizedFreshOrders.push(this.normalizeRemoteSyncedOrder(order));
     }
-    const uniqueFreshOrders = this.compactOrderListByIdentity(
-      normalizedFreshOrders,
-      `${source}.incoming`
-    ).list;
+    // 先对本批新单做去重（批内规模 m 很小），保证每条 fresh 身份唯一
+    const uniqueFreshOrders = this.compactOrderListByIdentity(normalizedFreshOrders, `${source}.incoming`).list;
     const uniqueFreshCount = uniqueFreshOrders.length;
     const patchedOrders = [];
     const remoteProductMembershipChanges = [];
-    const forceWriteStorageKeys = /* @__PURE__ */ new Set();
+    const forceWriteStorageKeys = new Set();
     const storageKeyMigrations = [];
     const mergeActions = {};
-    const existingProductsHaveStableIdentity = this.store.list.map(
-      (order) => this.doProductsHaveStableMembershipIdentity(
-        order.products
-      )
-    );
-    const updatedList = this.store.list.map(
-      (order) => this.normalizeOrderForMemoryList(order, `${source}.existingMemory`)
-    );
-    const identityKeyToIndex = /* @__PURE__ */ new Map();
+    const existingProductsHaveStableIdentity = this.store.list.map(order => this.doProductsHaveStableMembershipIdentity(order.products));
+    const updatedList = this.store.list.map(order => this.normalizeOrderForMemoryList(order, `${source}.existingMemory`));
+
+    // 基于身份键（field:value）建立索引，把「查找已存在订单」从 O(n) 线性扫描降为 O(1)，
+    // 整体合并复杂度由 O(n^2) 降为 O(n + m)。索引语义与 doOrdersShareIdentity 完全一致：
+    // 任一身份字段（order_id/external_sale_number/order_number/shop_order_number）同值即同一单。
+    const identityKeyToIndex = 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);
+        // 同一 key 命中多张时保留最靠前的下标，与原 findIndex「取首个匹配」一致
+        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 storageKey = this.getOrderStorageKey(fresh);
-      const mergeKey = storageKey || (fresh.order_id !== void 0 && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : "");
+      const mergeKey = storageKey || (fresh.order_id !== undefined && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : '');
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
         const previousStorageKey = this.getPersistedOrderStorageKey(existingOrder);
         if (this.isPendingSyncOrder(existingOrder) && this.isRemoteEchoMergeSource(source)) {
-          this.logInfo("mergeOrdersToStore-跳过 pending 订单远端覆盖", {
+          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,
@@ -1569,39 +1538,34 @@ var OrderModule = class extends import_BaseModule.BaseModule {
             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"
+            reason: 'protect_pending_sync_order_from_remote_echo'
           });
           continue;
         }
         if (this.isDraftOrder(existingOrder) && this.shouldProtectDraftOrderFromIncoming(source)) {
-          this.logInfo("mergeOrdersToStore-跳过 draft 订单远端覆盖", {
+          this.logInfo('mergeOrdersToStore-跳过 draft 订单远端覆盖', {
             source,
             order_id: existingOrder.order_id ?? fresh.order_id ?? null,
             external_sale_number: existingOrder.external_sale_number ?? fresh.external_sale_number ?? null,
             local_is_draft_order: existingOrder.is_draft_order ?? null,
             remote_is_draft_order: fresh.is_draft_order ?? null,
-            reason: "protect_draft_order_from_remote_echo"
+            reason: 'protect_draft_order_from_remote_echo'
           });
           continue;
         }
         let mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
         const freshOrderId = fresh.order_id;
-        const incomingProductsAreStable = freshOrderId !== void 0 && freshOrderId !== null && incomingProductsHaveStableIdentity.get(this.getIdKey(freshOrderId)) !== false;
+        const incomingProductsAreStable = freshOrderId !== undefined && freshOrderId !== null && incomingProductsHaveStableIdentity.get(this.getIdKey(freshOrderId)) !== false;
         let membershipChange = null;
-        if (Array.isArray(fresh.products) && freshOrderId !== void 0 && freshOrderId !== null && existingProductsHaveStableIdentity[matchIndex] !== false && incomingProductsAreStable) {
-          membershipChange = this.getRemoteProductMembershipChange(
-            existingOrder,
-            mergedOrder,
-            source
-          );
+        if (Array.isArray(fresh.products) && freshOrderId !== undefined && freshOrderId !== null && existingProductsHaveStableIdentity[matchIndex] !== false && incomingProductsAreStable) {
+          membershipChange = this.getRemoteProductMembershipChange(existingOrder, mergedOrder, source);
         }
         let mergedProductsHaveStableIdentity = existingProductsHaveStableIdentity[matchIndex] !== false && incomingProductsAreStable;
         let adjustedMatchIndex = matchIndex;
-        const duplicateIndexes = /* @__PURE__ */ new Set();
+        const duplicateIndexes = new Set();
         for (const key of freshIdentityKeys) {
           const duplicateIndex = identityKeyToIndex.get(key);
-          if (duplicateIndex === void 0 || duplicateIndex === matchIndex)
-            continue;
+          if (duplicateIndex === undefined || duplicateIndex === matchIndex) continue;
           duplicateIndexes.add(duplicateIndex);
         }
         if (duplicateIndexes.size > 0) {
@@ -1610,14 +1574,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
             mergedProductsHaveStableIdentity = mergedProductsHaveStableIdentity && existingProductsHaveStableIdentity[duplicateIndex] !== false;
             updatedList.splice(duplicateIndex, 1);
             existingProductsHaveStableIdentity.splice(duplicateIndex, 1);
-            if (duplicateIndex < adjustedMatchIndex)
-              adjustedMatchIndex -= 1;
+            if (duplicateIndex < adjustedMatchIndex) adjustedMatchIndex -= 1;
           }
           identityKeyToIndex.clear();
           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);
+              if (!identityKeyToIndex.has(key)) identityKeyToIndex.set(key, index);
             }
           }
         }
@@ -1634,42 +1596,37 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         if (membershipChange) {
           remoteProductMembershipChanges.push(membershipChange);
           const mergedStorageKey = this.getOrderStorageKey(mergedOrder);
-          if (mergedStorageKey)
-            forceWriteStorageKeys.add(mergedStorageKey);
+          if (mergedStorageKey) forceWriteStorageKeys.add(mergedStorageKey);
         }
+        // 合并后身份字段可能新增（如挂单拿到 order_id），同步登记到索引，
+        // 供同批后续 fresh 命中同一槽位，避免重复插入
         this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, adjustedMatchIndex);
         patchedOrders.push(mergedOrder);
-        if (mergeKey)
-          mergeActions[mergeKey] = "update";
+        if (mergeKey) mergeActions[mergeKey] = 'update';
         continue;
       }
       const insertIndex = updatedList.length;
       updatedList.push(fresh);
-      existingProductsHaveStableIdentity.push(
-        fresh.order_id !== void 0 && fresh.order_id !== null && incomingProductsHaveStableIdentity.get(this.getIdKey(fresh.order_id)) !== false
-      );
+      existingProductsHaveStableIdentity.push(fresh.order_id !== undefined && fresh.order_id !== null && incomingProductsHaveStableIdentity.get(this.getIdKey(fresh.order_id)) !== false);
       this.registerOrderIdentityKeys(identityKeyToIndex, fresh, insertIndex);
       patchedOrders.push(fresh);
-      if (mergeKey)
-        mergeActions[mergeKey] = "insert";
+      if (mergeKey) mergeActions[mergeKey] = 'insert';
     }
-    const insertCount = Object.values(mergeActions).filter((v) => v === "insert").length;
-    const updateCount = Object.values(mergeActions).filter((v) => v === "update").length;
-    this.logInfo("mergeOrdersToStore-合并完成", {
+    const insertCount = Object.values(mergeActions).filter(v => v === 'insert').length;
+    const updateCount = Object.values(mergeActions).filter(v => v === 'update').length;
+    this.logInfo('mergeOrdersToStore-合并完成', {
       insertCount,
       updateCount,
       storeOrderCountAfter: this.store.list.length
     });
+    // 增量索引已保证 store 去重不变量，无需再对全表做 O(n^2) 压缩；
+    // 仅在自检开关开启时做一次兜底校验。
     this.store.list = this.runOrderStoreSelfCheck(updatedList, `${source}.store`);
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(
-      patchedOrders,
-      source,
-      mergeActions,
-      { storageKeyMigrations },
-      forceWriteStorageKeys
-    );
-    this.logInfo("mergeOrdersToStore-结束", {
+    await this.patchOrdersInSQLite(patchedOrders, source, mergeActions, {
+      storageKeyMigrations
+    }, forceWriteStorageKeys);
+    this.logInfo('mergeOrdersToStore-结束', {
       uniqueFreshCount,
       storeOrderCountAfter: this.store.list.length,
       insertCount,
@@ -1678,6 +1635,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     await this.emitRemoteProductMembershipChanges(remoteProductMembershipChanges);
     await this.emitOrdersChanged(patchedOrders, source);
   }
+
   /**
    * 在身份索引中查找与目标订单共享任一身份键的已存在订单下标。
    * 返回所有命中键里最小的下标，等价于原 findOrderIndexByIdentity 的「取首个匹配」语义。
@@ -1689,76 +1647,64 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     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;
+      if (index === undefined) continue;
+      if (matchIndex < 0 || index < matchIndex) matchIndex = index;
     }
     return matchIndex;
   }
   isRemoteEchoMergeSource(source) {
-    return source === "pubsub.bodyUpsert" || source === "pubsub.httpRefresh";
+    return source === 'pubsub.bodyUpsert' || source === 'pubsub.httpRefresh';
   }
   isRemoteProductMembershipChangeSource(source) {
-    return this.isRemoteEchoMergeSource(source) || source === "manual.editOpenRemoteCheck";
+    return this.isRemoteEchoMergeSource(source) || source === 'manual.editOpenRemoteCheck';
   }
   getProductMembershipKey(product) {
-    const persistentId = (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)("product", product);
-    if (persistentId)
-      return `order_detail_id:${persistentId}`;
-    const uid = (0, import_orderCollectionIdentity.getOrderCollectionUid)("product", product);
-    return uid ? `unique_identification_number:${uid}` : "";
+    const persistentId = (0, _orderCollectionIdentity.getOrderCollectionPersistentId)('product', product);
+    if (persistentId) return `order_detail_id:${persistentId}`;
+    const uid = (0, _orderCollectionIdentity.getOrderCollectionUid)('product', product);
+    return uid ? `unique_identification_number:${uid}` : '';
   }
   doProductsHaveStableMembershipIdentity(products) {
-    if (!Array.isArray(products))
-      return true;
-    return products.every(
-      (product) => Boolean(
-        (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)("product", product) || (0, import_orderCollectionIdentity.getOrderCollectionUid)("product", product)
-      )
-    );
+    if (!Array.isArray(products)) return true;
+    return products.every(product => Boolean((0, _orderCollectionIdentity.getOrderCollectionPersistentId)('product', product) || (0, _orderCollectionIdentity.getOrderCollectionUid)('product', product)));
   }
+
   /**
    * 冲突提示关注逻辑商品行，而不是服务端 checkout 过程中可能被重建的 detail 记录。
    * 通用集合合并仍以 order_detail_id 为事实主键；这里只允许相同稳定 UID 跨 detail id 对齐，
    * 避免本机 checkout 回声被误判成“一删一增”。
    */
   isSameProductMembershipItem(left, right) {
-    if ((0, import_orderCollectionIdentity.isSameOrderCollectionItem)("product", left, right))
-      return true;
-    const leftUid = (0, import_orderCollectionIdentity.getOrderCollectionUid)("product", left);
-    const rightUid = (0, import_orderCollectionIdentity.getOrderCollectionUid)("product", right);
+    if ((0, _orderCollectionIdentity.isSameOrderCollectionItem)('product', left, right)) return true;
+    const leftUid = (0, _orderCollectionIdentity.getOrderCollectionUid)('product', left);
+    const rightUid = (0, _orderCollectionIdentity.getOrderCollectionUid)('product', right);
     return Boolean(leftUid && rightUid && leftUid === rightUid);
   }
+
   /**
    * 对比合并前后的商品成员集合。商品字段修改与数组重排不会产生 diff。
    */
   getRemoteProductMembershipChange(existingOrder, mergedOrder, source) {
-    if (!this.isRemoteProductMembershipChangeSource(source))
-      return null;
+    if (!this.isRemoteProductMembershipChangeSource(source)) return null;
     const previousProducts = Array.isArray(existingOrder.products) ? existingOrder.products : [];
     const currentProducts = Array.isArray(mergedOrder.products) ? mergedOrder.products : [];
     const unmatchedCurrentIndexes = new Set(currentProducts.map((_, index) => index));
     const removedProductKeys = [];
     for (const previousProduct of previousProducts) {
-      const matchedIndex = currentProducts.findIndex(
-        (currentProduct, index) => unmatchedCurrentIndexes.has(index) && this.isSameProductMembershipItem(previousProduct, currentProduct)
-      );
+      const matchedIndex = currentProducts.findIndex((currentProduct, index) => unmatchedCurrentIndexes.has(index) && this.isSameProductMembershipItem(previousProduct, currentProduct));
       if (matchedIndex >= 0) {
         unmatchedCurrentIndexes.delete(matchedIndex);
         continue;
       }
       const productKey = this.getProductMembershipKey(previousProduct);
-      if (productKey)
-        removedProductKeys.push(productKey);
+      if (productKey) removedProductKeys.push(productKey);
     }
-    const addedProductKeys = [...unmatchedCurrentIndexes].map((index) => this.getProductMembershipKey(currentProducts[index])).filter(Boolean);
+    const addedProductKeys = [...unmatchedCurrentIndexes].map(index => this.getProductMembershipKey(currentProducts[index])).filter(Boolean);
     if (addedProductKeys.length === 0 && removedProductKeys.length === 0) {
       return null;
     }
     const orderId = mergedOrder.order_id ?? existingOrder.order_id;
-    if (orderId === void 0 || orderId === null)
-      return null;
+    if (orderId === undefined || orderId === null) return null;
     return {
       order_id: orderId,
       source,
@@ -1768,6 +1714,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       current_product_count: currentProducts.length
     };
   }
+
   /**
    * 将订单的全部身份键登记到索引并指向其在列表中的下标。
    * 合并后订单新增的身份字段（如挂单同步后拿到 order_id）也会被登记。
@@ -1781,54 +1728,53 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       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 (!ORDER_MERGE_SELF_CHECK) return orders;
+    const {
+      list,
+      removedCount
+    } = this.compactOrderListByIdentity(orders, source);
     if (removedCount > 0) {
-      this.logWarning("合并自检发现残留重复订单，已压缩", { source, removedCount });
+      this.logWarning('合并自检发现残留重复订单，已压缩', {
+        source,
+        removedCount
+      });
     }
     return list;
   }
   normalizeOrderSyncMessage(res) {
-    const data = (res == null ? void 0 : res.data) || res;
-    if (!data)
-      return null;
-    const payload = (data == null ? void 0 : data.data) && typeof data.data === "object" ? data.data : void 0;
+    const data = res?.data || res;
+    if (!data) return null;
+    const payload = data?.data && typeof data.data === 'object' ? data.data : undefined;
     const normalized = {
       ...data,
-      _channelKey: data.module || "sales_sync"
+      _channelKey: data.module || 'sales_sync'
     };
-    if (!normalized.type && typeof data.event === "string")
-      normalized.type = data.event;
-    if (!normalized.id && data.id !== void 0)
-      normalized.id = data.id;
-    if (!normalized.id && data.order_id !== void 0)
-      normalized.id = data.order_id;
-    if (!normalized.order_id && data.order_id !== void 0)
-      normalized.order_id = data.order_id;
-    if (!normalized.order_id && (payload == null ? void 0 : payload.order_id) !== void 0)
-      normalized.order_id = payload.order_id;
-    if (!normalized.body && (payload == null ? void 0 : payload.order_id) !== void 0)
-      normalized.body = payload;
-    if (!normalized.data && (payload == null ? void 0 : payload.order_id) !== void 0)
-      normalized.data = payload;
+    if (!normalized.type && typeof data.event === 'string') normalized.type = data.event;
+    if (!normalized.id && data.id !== undefined) normalized.id = data.id;
+    if (!normalized.id && data.order_id !== undefined) normalized.id = data.order_id;
+    if (!normalized.order_id && data.order_id !== undefined) normalized.order_id = data.order_id;
+    if (!normalized.order_id && payload?.order_id !== undefined) normalized.order_id = payload.order_id;
+    if (!normalized.body && payload?.order_id !== undefined) normalized.body = payload;
+    if (!normalized.data && payload?.order_id !== undefined) normalized.data = payload;
     return normalized;
   }
   normalizeOrderSyncPayload(payload) {
-    if (!payload)
-      return null;
+    if (!payload) return null;
     const orderId = payload.order_id;
-    if (orderId === void 0 || orderId === null)
-      return null;
-    return { ...payload, order_id: orderId };
+    if (orderId === undefined || orderId === null) return null;
+    return {
+      ...payload,
+      order_id: orderId
+    };
   }
   uniqueOrderIds(ids) {
-    const idMap = /* @__PURE__ */ new Map();
+    const idMap = new Map();
     for (const id of ids) {
       idMap.set(this.getIdKey(id), id);
     }
@@ -1838,21 +1784,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return String(id);
   }
   isOrderLookupMatch(order, lookupKey) {
-    if (!order || !lookupKey)
-      return false;
-    const candidates = [
-      order.order_id,
-      order.external_sale_number,
-      order.order_number,
-      order.shop_order_number,
-      order.shop_full_order_number
-    ];
-    return candidates.some((value) => {
-      if (value === void 0 || value === null || value === "")
-        return false;
+    if (!order || !lookupKey) return false;
+    const candidates = [order.order_id, order.external_sale_number, order.order_number, order.shop_order_number, order.shop_full_order_number];
+    return candidates.some(value => {
+      if (value === undefined || value === null || value === '') return false;
       return this.getIdKey(value) === lookupKey;
     });
   }
+
   /**
    * 解析订单 SQLite 主键，规则与宿主 OrderDataSource.getOrderStorageKey 一致。
    *
@@ -1861,114 +1800,94 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * // => 'S-1001'
    */
   getOrderStorageKey(order) {
-    const externalSaleNumber = order == null ? void 0 : order.external_sale_number;
-    if (externalSaleNumber !== void 0 && externalSaleNumber !== null && externalSaleNumber !== "") {
+    const externalSaleNumber = order?.external_sale_number;
+    if (externalSaleNumber !== undefined && externalSaleNumber !== null && externalSaleNumber !== '') {
       return String(externalSaleNumber);
     }
-    const orderId = order == null ? void 0 : order.order_id;
-    if (orderId !== void 0 && orderId !== null && orderId !== "") {
+    const orderId = order?.order_id;
+    if (orderId !== undefined && orderId !== null && orderId !== '') {
       return String(orderId);
     }
-    return "";
+    return '';
   }
   getPersistedOrderStorageKey(order) {
-    const persistedStorageKey = order == null ? void 0 : order[ORDER_STORAGE_KEY_FIELD];
-    if (persistedStorageKey !== void 0 && persistedStorageKey !== null && persistedStorageKey !== "") {
+    const persistedStorageKey = order?.[ORDER_STORAGE_KEY_FIELD];
+    if (persistedStorageKey !== undefined && persistedStorageKey !== null && persistedStorageKey !== '') {
       return String(persistedStorageKey);
     }
     return this.getOrderStorageKey(order);
   }
   getOrderIdentityMatchKeys(order) {
-    return this.getOrderIdentityEntries(order).map((entry) => `${entry.field}:${entry.key}`);
+    return this.getOrderIdentityEntries(order).map(entry => `${entry.field}:${entry.key}`);
   }
   doOrdersShareIdentity(left, right) {
     const leftKeys = new Set(this.getOrderIdentityMatchKeys(left));
-    if (leftKeys.size === 0)
-      return false;
-    return this.getOrderIdentityMatchKeys(right).some((key) => leftKeys.has(key));
+    if (leftKeys.size === 0) return false;
+    return this.getOrderIdentityMatchKeys(right).some(key => leftKeys.has(key));
   }
   findOrderIndexByIdentity(orders, target) {
-    if (this.getOrderIdentityMatchKeys(target).length === 0)
-      return -1;
-    return orders.findIndex((order) => this.doOrdersShareIdentity(order, target));
+    if (this.getOrderIdentityMatchKeys(target).length === 0) return -1;
+    return orders.findIndex(order => this.doOrdersShareIdentity(order, target));
   }
   getOrderCompletenessScore(order) {
     const record = order;
     let score = this.isPendingSyncOrder(order) ? 0 : 100;
-    if (!this.isBlankIdentityValue(order.order_id) && order.order_id !== record.external_sale_number)
-      score += 30;
+    if (!this.isBlankIdentityValue(order.order_id) && order.order_id !== record.external_sale_number) score += 30;
     score += this.getOrderIdentityMatchKeys(order).length * 5;
-    if (Array.isArray(order.products))
-      score += Math.min(order.products.length, 10);
-    if (Array.isArray(order.bookings))
-      score += Math.min(order.bookings.length, 10);
-    if (Array.isArray(order.payments))
-      score += Math.min(order.payments.length, 10);
-    if (record.updated_at)
-      score += 1;
+    if (Array.isArray(order.products)) score += Math.min(order.products.length, 10);
+    if (Array.isArray(order.bookings)) score += Math.min(order.bookings.length, 10);
+    if (Array.isArray(order.payments)) score += Math.min(order.payments.length, 10);
+    if (record.updated_at) score += 1;
     return score;
   }
   pickPreferredOrder(left, right) {
     const leftScore = this.getOrderCompletenessScore(left);
     const rightScore = this.getOrderCompletenessScore(right);
-    if (rightScore >= leftScore)
-      return right;
+    if (rightScore >= leftScore) return right;
     return left;
   }
   getProductIdentityKeys(product) {
-    var _a;
     const record = product;
-    if (!record)
-      return [];
+    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 metadataUid = record.metadata?.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)}`);
+    if (!this.isBlankIdentityValue(topLevelUid)) keys.push(`uid:${String(topLevelUid)}`);
     const orderDetailId = record.order_detail_id;
-    if (!this.isBlankIdentityValue(orderDetailId))
-      keys.push(`detail:${String(orderDetailId)}`);
+    if (!this.isBlankIdentityValue(orderDetailId)) keys.push(`detail:${String(orderDetailId)}`);
     const bookingUid = record.booking_uid;
-    if (!this.isBlankIdentityValue(bookingUid))
-      keys.push(`booking:${String(bookingUid)}`);
+    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();
+    if (secondaryList.length === 0) return preferredList;
+    if (preferredList.length === 0) return secondaryList;
+    const seenKeys = new Set();
     for (const item of preferredList) {
       const keys = this.getProductIdentityKeys(item);
-      for (const key of keys)
-        seenKeys.add(key);
+      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));
+      if (keys.length === 0 || keys.some(key => seenKeys.has(key))) continue;
+      for (const key of keys) seenKeys.add(key);
+      result.push((0, _lodashEs.cloneDeep)(item));
     }
     return result;
   }
   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);
-    return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(existingList, incomingList);
+    if (incomingList.length === 0) return (0, _lodashEs.cloneDeep)(existingList);
+    return (0, _paymentUtils.mergeOrderPaymentListsByIdentity)(existingList, incomingList);
   }
   getIdentifiedPendingPayments(order) {
-    const payments = Array.isArray(order == null ? void 0 : order.payments) ? order.payments : [];
-    return payments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment));
+    const payments = Array.isArray(order?.payments) ? order.payments : [];
+    return payments.filter(payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment));
   }
   shouldProtectLocalOrderFromRemoteSnapshot(order) {
     return this.isPendingSyncOrder(order) || this.isDraftOrder(order) || this.getIdentifiedPendingPayments(order).length > 0;
@@ -1976,10 +1895,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   getUnmatchedIdentifiedPendingPayments(existing, incoming) {
     const existingPayments = Array.isArray(existing) ? existing : [];
     const incomingPayments = Array.isArray(incoming) ? incoming : [];
-    const incomingIdentityKeys = new Set(
-      incomingPayments.flatMap((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
-    );
-    return existingPayments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment) && !(0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => incomingIdentityKeys.has(key)));
+    const incomingIdentityKeys = new Set(incomingPayments.flatMap(payment => (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment)));
+    return existingPayments.filter(payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment) && !(0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => incomingIdentityKeys.has(key)));
   }
   mergeOrderRecords(existing, incoming) {
     const preferred = this.pickPreferredOrder(existing, incoming);
@@ -1988,31 +1905,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       ...secondary,
       ...preferred
     };
-    const fieldsToPreserve = [
-      "order_id",
-      "external_sale_number",
-      "order_number",
-      "shop_order_number",
-      "shop_full_order_number"
-    ];
-    const incomingPatchFields = [
-      "payment_status",
-      "status",
-      "shipping_status",
-      "updated_at",
-      "shop_discount",
-      "summary",
-      "note",
-      "customer_id",
-      "customer_name",
-      "customer",
-      "holder",
-      "contacts_info",
-      "phone",
-      "email",
-      "relation_forms",
-      "is_draft_order"
-    ];
+    const fieldsToPreserve = ['order_id', 'external_sale_number', 'order_number', 'shop_order_number', 'shop_full_order_number'];
+    const incomingPatchFields = ['payment_status', 'status', 'shipping_status', 'updated_at', 'shop_discount', 'summary', 'note', 'customer_id', 'customer_name', 'customer', 'holder', 'contacts_info', 'phone', 'email', 'relation_forms', 'is_draft_order'];
     const mergedRecord = merged;
     const preferredRecord = preferred;
     const secondaryRecord = secondary;
@@ -2029,41 +1923,34 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
     }
     for (const field of incomingPatchFields) {
-      if (!Object.prototype.hasOwnProperty.call(incomingRecord, field))
-        continue;
-      if (incomingRecord[field] === void 0 || incomingRecord[field] === null)
-        continue;
-      if (typeof incomingRecord[field] === "string" && incomingRecord[field] === "")
-        continue;
-      mergedRecord[field] = (0, import_lodash_es.cloneDeep)(incomingRecord[field]);
+      if (!Object.prototype.hasOwnProperty.call(incomingRecord, field)) continue;
+      if (incomingRecord[field] === undefined || incomingRecord[field] === null) continue;
+      if (typeof incomingRecord[field] === 'string' && incomingRecord[field] === '') continue;
+      mergedRecord[field] = (0, _lodashEs.cloneDeep)(incomingRecord[field]);
     }
+
+    // 子项数组遵循完整快照语义：incoming 自有且为数组（包括 []）时权威替换；
+    // 字段缺席或不是数组时视为稀疏 patch，继续保留 existing。
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
       if (Array.isArray(incomingRecord[field])) {
-        if (field === "payments") {
-          const preservedPending = this.getUnmatchedIdentifiedPendingPayments(
-            existingRecord[field],
-            incomingRecord[field]
-          );
+        if (field === 'payments') {
+          const preservedPending = this.getUnmatchedIdentifiedPendingPayments(existingRecord[field], incomingRecord[field]);
           if (preservedPending.length > 0) {
-            this.logInfo("mergeOrderRecords-保留本地 pending 支付项", {
+            this.logInfo('mergeOrderRecords-保留本地 pending 支付项', {
               order_id: existing.order_id ?? incoming.order_id ?? null,
               external_sale_number: existingRecord.external_sale_number ?? incomingRecord.external_sale_number ?? null,
               preserved_pending_count: preservedPending.length,
-              preserved_payment_identities: preservedPending.map((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
+              preserved_payment_identities: preservedPending.map(payment => (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment))
             });
           }
         }
-        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(
-          field,
-          existingRecord[field],
-          incomingRecord[field],
-          childUidRemaps,
-          { preserveIdentifiedPendingPayments: field === "payments" }
-        );
+        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(field, existingRecord[field], incomingRecord[field], childUidRemaps, {
+          preserveIdentifiedPendingPayments: field === 'payments'
+        });
         continue;
       }
       if (Object.prototype.hasOwnProperty.call(existingRecord, field)) {
-        mergedRecord[field] = (0, import_lodash_es.cloneDeep)(existingRecord[field]);
+        mergedRecord[field] = (0, _lodashEs.cloneDeep)(existingRecord[field]);
       } else {
         delete mergedRecord[field];
       }
@@ -2071,13 +1958,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (!this.isPendingSyncOrder(preferred) || !this.isPendingSyncOrder(secondary)) {
       merged.need_sync = 0;
     }
-    return this.normalizeOrderCollectionsForIngress(
-      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps),
-      "mergeOrderRecords"
-    );
+    return this.normalizeOrderCollectionsForIngress((0, _orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps), 'mergeOrderRecords');
   }
   summarizeDuplicateOrders(orders) {
-    const groups = /* @__PURE__ */ new Map();
+    const groups = new Map();
     for (const order of orders) {
       for (const key of this.getOrderIdentityMatchKeys(order)) {
         const group = groups.get(key) || [];
@@ -2088,7 +1972,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return [...groups.entries()].filter(([, group]) => group.length > 1).slice(0, 20).map(([key, group]) => ({
       key,
       count: group.length,
-      orders: group.map((order) => ({
+      orders: group.map(order => ({
         order_id: order.order_id ?? null,
         external_sale_number: order.external_sale_number ?? null,
         shop_order_number: order.shop_order_number ?? null,
@@ -2100,9 +1984,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   }
   logDuplicateOrders(source, orders) {
     const duplicateGroups = this.summarizeDuplicateOrders(orders);
-    if (duplicateGroups.length === 0)
-      return;
-    this.logWarning("检测到重复订单身份键", {
+    if (duplicateGroups.length === 0) return;
+    this.logWarning('检测到重复订单身份键', {
       source,
       duplicateGroupCount: duplicateGroups.length,
       duplicateGroups
@@ -2112,10 +1995,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const list = [];
     let removedCount = 0;
     for (const order of orders) {
-      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
-        order,
-        `${source}.order`
-      );
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, `${source}.order`);
       const matchIndex = this.findOrderIndexByIdentity(list, normalizedOrder);
       if (matchIndex < 0) {
         list.push(normalizedOrder);
@@ -2125,7 +2005,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       removedCount += 1;
     }
     if (removedCount > 0) {
-      this.logWarning("订单列表重复项已压缩", {
+      this.logWarning('订单列表重复项已压缩', {
         source,
         beforeCount: orders.length,
         afterCount: list.length,
@@ -2134,99 +2014,101 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     } else {
       this.logDuplicateOrders(source, orders);
     }
-    return { list, removedCount };
+    return {
+      list,
+      removedCount
+    };
   }
+
   /**
    * 当前订单拉取窗口：
    * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
    * - 无法解析时退化为自然日窗口
    */
   getCurrentPullWindow() {
-    var _a, _b;
-    const now = (0, import_dayjs.default)();
-    const range = (_b = (_a = this.store) == null ? void 0 : _a.createdAtQuery) == null ? void 0 : _b.sales_time_between;
+    const now = (0, _dayjs.default)();
+    const range = this.store?.createdAtQuery?.sales_time_between;
     if (Array.isArray(range) && range.length >= 2) {
-      const startAt2 = (0, import_dayjs.default)(range[0]);
-      const endExclusiveAt = (0, import_dayjs.default)(range[1]);
-      if (startAt2.isValid() && endExclusiveAt.isValid() && endExclusiveAt.isAfter(startAt2)) {
-        return { startAt: startAt2, endExclusiveAt };
+      const startAt = (0, _dayjs.default)(range[0]);
+      const endExclusiveAt = (0, _dayjs.default)(range[1]);
+      if (startAt.isValid() && endExclusiveAt.isValid() && endExclusiveAt.isAfter(startAt)) {
+        return {
+          startAt,
+          endExclusiveAt
+        };
       }
     }
-    const startAt = now.startOf("day");
-    return { startAt, endExclusiveAt: startAt.add(1, "day") };
+    const startAt = now.startOf('day');
+    return {
+      startAt,
+      endExclusiveAt: startAt.add(1, 'day')
+    };
   }
   hasPulledOrdersToday() {
     const lastFullFetchAt = this.getStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY);
-    if (!lastFullFetchAt)
-      return false;
-    const parsed = (0, import_dayjs.default)(lastFullFetchAt);
-    if (!parsed.isValid())
-      return false;
-    const { startAt, endExclusiveAt } = this.getCurrentPullWindow();
+    if (!lastFullFetchAt) return false;
+    const parsed = (0, _dayjs.default)(lastFullFetchAt);
+    if (!parsed.isValid()) return false;
+
+    // 按当前拉取窗口判断，而不是自然日判断。
+    // 这样在营业日跨日边界（start_time）场景下也能正确判定是否需要重新拉取。
+    const {
+      startAt,
+      endExclusiveAt
+    } = this.getCurrentPullWindow();
     return (parsed.isAfter(startAt) || parsed.isSame(startAt)) && parsed.isBefore(endExclusiveAt);
   }
   markOrderPulledAtNow() {
-    this.setStorageItem(
-      ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY,
-      (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
-    );
+    this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss'));
   }
   getStorageItem(key) {
-    var _a;
     try {
-      if ((_a = this.storage) == null ? void 0 : _a.getStorage)
-        return this.storage.getStorage(key);
-      if (typeof globalThis !== "undefined" && (globalThis == null ? void 0 : globalThis.localStorage)) {
+      if (this.storage?.getStorage) return this.storage.getStorage(key);
+      if (typeof globalThis !== 'undefined' && globalThis?.localStorage) {
         return globalThis.localStorage.getItem(key);
       }
     } catch {
+      // 忽略存储异常，避免影响主流程
     }
     return null;
   }
   setStorageItem(key, value) {
-    var _a;
     try {
-      if ((_a = this.storage) == null ? void 0 : _a.setStorage) {
+      if (this.storage?.setStorage) {
         this.storage.setStorage(key, value);
         return;
       }
-      if (typeof globalThis !== "undefined" && (globalThis == null ? void 0 : globalThis.localStorage)) {
+      if (typeof globalThis !== 'undefined' && globalThis?.localStorage) {
         globalThis.localStorage.setItem(key, value);
       }
     } catch {
+      // 忽略存储异常，避免影响主流程
     }
   }
   async loadOrdersFromSQLite() {
-    if (!this.dbManager)
-      return [];
+    if (!this.dbManager) return [];
     try {
       const orders = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      return (orders || []).map(
-        (order) => this.normalizeOrderCollectionsForIngress(order, "loadOrdersFromSQLite")
-      );
+      return (orders || []).map(order => this.normalizeOrderCollectionsForIngress(order, 'loadOrdersFromSQLite'));
     } catch {
       return [];
     }
   }
   isPendingSyncOrder(order) {
-    return Number(order == null ? void 0 : order.need_sync) === 1;
+    return Number(order?.need_sync) === 1;
   }
   isDraftOrder(order) {
-    return Number(order == null ? void 0 : order.is_draft_order) === 1;
+    return Number(order?.is_draft_order) === 1;
   }
   shouldProtectDraftOrderFromIncoming(source) {
-    return source !== "checkoutSync";
+    return source !== 'checkoutSync';
   }
   normalizeRemoteSyncedOrder(order) {
-    const normalizedOrder = this.normalizeOrderCollectionsForIngress(
-      order,
-      "normalizeRemoteSyncedOrder"
-    );
-    if (this.isPendingSyncOrder(normalizedOrder))
-      return {
-        ...normalizedOrder,
-        is_draft_order: 0
-      };
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, 'normalizeRemoteSyncedOrder');
+    if (this.isPendingSyncOrder(normalizedOrder)) return {
+      ...normalizedOrder,
+      is_draft_order: 0
+    };
     return {
       ...normalizedOrder,
       need_sync: 0,
@@ -2238,48 +2120,33 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       ...this.withoutSyntheticDraftOrderId(draftOrder)
     };
     const remote = remoteOrder;
-    for (const field of [
-      "order_id",
-      "order_number",
-      "shop_order_number",
-      "shop_full_order_number"
-    ]) {
+    for (const field of ['order_id', 'order_number', 'shop_order_number', 'shop_full_order_number']) {
       if (this.isBlankIdentityValue(merged[field]) && !this.isBlankIdentityValue(remote[field])) {
         merged[field] = remote[field];
       }
     }
-    return this.normalizeOrderCollectionsForIngress(
-      merged,
-      "mergeRemoteIdentityIntoDraftOrder"
-    );
+    return this.normalizeOrderCollectionsForIngress(merged, 'mergeRemoteIdentityIntoDraftOrder');
   }
   mergeRemoteSnapshotWithPendingOrders(remoteOrders, existingOrders) {
-    const merged = remoteOrders.map((order) => this.normalizeRemoteSyncedOrder(order));
+    const merged = remoteOrders.map(order => this.normalizeRemoteSyncedOrder(order));
     for (const rawOrder of existingOrders) {
-      const order = this.normalizeOrderCollectionsForIngress(
-        rawOrder,
-        "mergeRemoteSnapshotWithPendingOrders.existingSQLite"
-      );
-      if (!this.shouldProtectLocalOrderFromRemoteSnapshot(order))
-        continue;
+      const order = this.normalizeOrderCollectionsForIngress(rawOrder, 'mergeRemoteSnapshotWithPendingOrders.existingSQLite');
+      if (!this.shouldProtectLocalOrderFromRemoteSnapshot(order)) continue;
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
       if (matchIndex >= 0) {
         if (this.isDraftOrder(order)) {
-          merged[matchIndex] = this.mergeRemoteIdentityIntoDraftOrder(
-            order,
-            merged[matchIndex]
-          );
+          merged[matchIndex] = this.mergeRemoteIdentityIntoDraftOrder(order, merged[matchIndex]);
         } else {
           merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
         }
         continue;
       }
-      if (!this.getOrderStorageKey(order))
-        continue;
+      if (!this.getOrderStorageKey(order)) continue;
       merged.push(order);
     }
-    return this.compactOrderListByIdentity(merged, "mergeRemoteSnapshotWithPendingOrders").list;
+    return this.compactOrderListByIdentity(merged, 'mergeRemoteSnapshotWithPendingOrders').list;
   }
+
   /**
    * 串行执行订单 SQLite 写入任务，避免快照替换与增量 upsert 并发交错。
    *
@@ -2290,45 +2157,40 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   async runInOrderSQLiteSaveQueue(task) {
     const queuedTask = this.orderSQLiteSaveQueue.then(task, task);
-    this.orderSQLiteSaveQueue = queuedTask.then(() => void 0, () => void 0);
+    this.orderSQLiteSaveQueue = queuedTask.then(() => undefined, () => undefined);
     return queuedTask;
   }
+
   /**
    * 批量增量 upsert 订单到 SQLite，不清空表；用于 pubsub / HTTP 增量合并。
    *
    * @example
    * await this.patchOrdersInSQLite(freshOrders)
    */
-  async patchOrdersInSQLite(orders, source, mergeActions = {}, options = {}, forceWriteStorageKeys = /* @__PURE__ */ new Set()) {
+  async patchOrdersInSQLite(orders, source, mergeActions = {}, options = {}, forceWriteStorageKeys = new Set()) {
     if (orders.length === 0) {
       return;
     }
     if (!this.dbManager) {
-      if (options.throwOnError)
-        throw new Error("订单 SQLite 数据库未初始化");
+      if (options.throwOnError) throw new Error('订单 SQLite 数据库未初始化');
       return;
     }
-    const migrationTargetStorageKeys = new Set(
-      (options.storageKeyMigrations || []).map((migration) => migration.to)
-    );
-    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).map((order) => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).map((order) => {
+    const migrationTargetStorageKeys = new Set((options.storageKeyMigrations || []).map(migration => migration.to));
+    const ordersSnapshot = (0, _lodashEs.cloneDeep)(orders).map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).map(order => {
       const storageKey = this.getOrderStorageKey(order);
-      if (!storageKey || !migrationTargetStorageKeys.has(storageKey))
-        return order;
+      if (!storageKey || !migrationTargetStorageKeys.has(storageKey)) return order;
       return {
         ...order,
         [ORDER_STORAGE_KEY_FIELD]: storageKey
       };
-    }).filter((order) => this.getOrderStorageKey(order));
+    }).filter(order => this.getOrderStorageKey(order));
     if (ordersSnapshot.length === 0) {
       return;
     }
-    const { toWrite, skipped } = this.filterRedundantPatchOrders(
-      source,
-      ordersSnapshot,
-      mergeActions,
-      forceWriteStorageKeys
-    );
+    const {
+      toWrite,
+      skipped
+    } = this.filterRedundantPatchOrders(source, ordersSnapshot, mergeActions, forceWriteStorageKeys);
     if (toWrite.length === 0) {
       return;
     }
@@ -2336,55 +2198,49 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (compactedToWrite.length === 0) {
       return;
     }
-    const writtenStorageKeys = new Set(
-      compactedToWrite.map((order) => this.getOrderStorageKey(order)).filter(Boolean)
-    );
-    const storageKeyMigrations = /* @__PURE__ */ new Map();
+    const writtenStorageKeys = new Set(compactedToWrite.map(order => this.getOrderStorageKey(order)).filter(Boolean));
+    const storageKeyMigrations = new Map();
     for (const migration of options.storageKeyMigrations || []) {
-      if (!writtenStorageKeys.has(migration.to))
-        continue;
-      if (writtenStorageKeys.has(migration.from))
-        continue;
+      if (!writtenStorageKeys.has(migration.to)) continue;
+      if (writtenStorageKeys.has(migration.from)) continue;
       storageKeyMigrations.set(migration.from, migration);
     }
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
-        let writeMethod = "none";
-        this.logInfo("patchOrdersInSQLite-开始", {
+        let writeMethod = 'none';
+        this.logInfo('patchOrdersInSQLite-开始', {
           source,
           count: compactedToWrite.length,
           dedupedCount: skipped.length
         });
-        if (typeof this.dbManager.bulkUpdate === "function") {
-          writeMethod = "bulkUpdate";
+        if (typeof this.dbManager.bulkUpdate === 'function') {
+          writeMethod = 'bulkUpdate';
           await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, compactedToWrite);
-        } else if (typeof this.dbManager.bulkAdd === "function") {
-          writeMethod = "bulkAdd";
+        } else if (typeof this.dbManager.bulkAdd === 'function') {
+          writeMethod = 'bulkAdd';
           await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, compactedToWrite);
-        } else if (typeof this.dbManager.update === "function") {
-          writeMethod = "update";
+        } else if (typeof this.dbManager.update === 'function') {
+          writeMethod = 'update';
           for (const order of compactedToWrite) {
             await this.dbManager.update(INDEXDB_STORE_NAME, order);
           }
         } else if (options.throwOnError) {
-          throw new Error("订单 SQLite 数据库不支持写入");
+          throw new Error('订单 SQLite 数据库不支持写入');
         }
         this.recordRecentSqliteWrite(source, compactedToWrite);
-        if (writeMethod !== "none") {
+        if (writeMethod !== 'none') {
           for (const migration of storageKeyMigrations.values()) {
             try {
               await this.dbManager.delete(INDEXDB_STORE_NAME, migration.from);
               this.recentSqliteWriteByStorageKey.delete(migration.from);
               for (const order of orders) {
-                if (this.getOrderStorageKey(order) !== migration.to)
-                  continue;
+                if (this.getOrderStorageKey(order) !== migration.to) continue;
                 const orderRecord = order;
-                if (String(orderRecord[ORDER_STORAGE_KEY_FIELD] ?? "") !== migration.from)
-                  continue;
+                if (String(orderRecord[ORDER_STORAGE_KEY_FIELD] ?? '') !== migration.from) continue;
                 orderRecord[ORDER_STORAGE_KEY_FIELD] = migration.to;
               }
             } catch (error) {
-              this.logError("删除订单旧 SQLite storage key 失败", {
+              this.logError('删除订单旧 SQLite storage key 失败', {
                 source,
                 order_id: migration.orderId,
                 oldStorageKey: migration.from,
@@ -2394,7 +2250,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
             }
           }
         }
-        this.logInfo("patchOrdersInSQLite-完成", {
+        this.logInfo('patchOrdersInSQLite-完成', {
           source,
           count: compactedToWrite.length,
           writeMethod,
@@ -2402,14 +2258,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         });
       });
     } catch (error) {
-      this.logError("增量保存订单到 SQLite 失败", {
+      this.logError('增量保存订单到 SQLite 失败', {
         error: error instanceof Error ? error.message : String(error),
         orderCount: ordersSnapshot.length
       });
-      if (options.throwOnError)
-        throw error;
+      if (options.throwOnError) throw error;
     }
   }
+
   /**
    * 单条 upsert 订单到 SQLite；用于 overwriteExistingOrder 等单条覆盖场景。
    *
@@ -2418,55 +2274,50 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   async updateOrderInSQLite(order, source, options = {}) {
     if (!this.getOrderStorageKey(order)) {
-      if (options.throwOnError)
-        throw new Error("订单缺少可用的 SQLite 存储主键");
+      if (options.throwOnError) throw new Error('订单缺少可用的 SQLite 存储主键');
       return;
     }
     if (!this.dbManager) {
-      if (options.throwOnError)
-        throw new Error("订单 SQLite 数据库未初始化");
+      if (options.throwOnError) throw new Error('订单 SQLite 数据库未初始化');
       return;
     }
-    const orderSnapshot = this.normalizeOrderCollectionsForIngress(
-      (0, import_lodash_es.cloneDeep)(order),
-      `${source}.sqliteIngress`
-    );
+    const orderSnapshot = this.normalizeOrderCollectionsForIngress((0, _lodashEs.cloneDeep)(order), `${source}.sqliteIngress`);
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
-        let writeMethod = "none";
-        this.logInfo("updateOrderInSQLite-开始", {
+        let writeMethod = 'none';
+        this.logInfo('updateOrderInSQLite-开始', {
           source,
           orderId: orderSnapshot.order_id ?? null,
           storageKey: this.getOrderStorageKey(orderSnapshot)
         });
-        if (typeof this.dbManager.update === "function") {
-          writeMethod = "update";
+        if (typeof this.dbManager.update === 'function') {
+          writeMethod = 'update';
           await this.dbManager.update(INDEXDB_STORE_NAME, orderSnapshot);
-        } else if (typeof this.dbManager.bulkUpdate === "function") {
-          writeMethod = "bulkUpdate";
+        } else if (typeof this.dbManager.bulkUpdate === 'function') {
+          writeMethod = 'bulkUpdate';
           await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, [orderSnapshot]);
-        } else if (typeof this.dbManager.bulkAdd === "function") {
-          writeMethod = "bulkAdd";
+        } else if (typeof this.dbManager.bulkAdd === 'function') {
+          writeMethod = 'bulkAdd';
           await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, [orderSnapshot]);
         } else if (options.throwOnError) {
-          throw new Error("订单 SQLite 数据库不支持写入");
+          throw new Error('订单 SQLite 数据库不支持写入');
         }
         this.recordRecentSqliteWrite(source, [orderSnapshot]);
-        this.logInfo("updateOrderInSQLite-完成", {
+        this.logInfo('updateOrderInSQLite-完成', {
           source,
           orderId: orderSnapshot.order_id ?? null,
           writeMethod
         });
       });
     } catch (error) {
-      this.logError("单条保存订单到 SQLite 失败", {
+      this.logError('单条保存订单到 SQLite 失败', {
         error: error instanceof Error ? error.message : String(error),
         orderId: orderSnapshot.order_id ?? null
       });
-      if (options.throwOnError)
-        throw error;
+      if (options.throwOnError) throw error;
     }
   }
+
   /**
    * 全量快照替换 orders 表（clear + bulkAdd），并保留本地 draft / need_sync / pending 支付订单。
    * 用于 SSE 全量拉取与营业日窗口裁剪。
@@ -2476,34 +2327,17 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   async replaceOrdersSnapshotInSQLite(orderList, source, protectedOrdersBeforeRemoteFetch = []) {
     if (!this.dbManager) {
-      return this.compactOrderListByIdentity(
-        orderList.map((order) => this.normalizeRemoteSyncedOrder(order)),
-        `${source}.snapshotNoDb`
-      ).list;
-    }
-    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`
-    ).list;
+      return this.compactOrderListByIdentity(orderList.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.snapshotNoDb`).list;
+    }
+    const remoteSnapshot = (0, _lodashEs.cloneDeep)(orderList).map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.remoteIngress`));
+    let mergedSnapshot = this.compactOrderListByIdentity(remoteSnapshot.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.remoteSnapshot`).list;
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
-        const existingOrders = typeof this.dbManager.getAll === "function" ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
-        const protectedLocalOrders = protectedOrdersBeforeRemoteFetch.map((order) => this.normalizeOrderCollectionsForIngress(
-          order,
-          `${source}.protectedBeforeRemoteFetch`
-        )).filter((order) => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
+        const existingOrders = typeof this.dbManager.getAll === 'function' ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
+        const protectedLocalOrders = protectedOrdersBeforeRemoteFetch.map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.protectedBeforeRemoteFetch`)).filter(order => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
         for (const rawCurrentOrder of existingOrders || []) {
-          const currentOrder = this.normalizeOrderCollectionsForIngress(
-            rawCurrentOrder,
-            `${source}.currentSQLite`
-          );
-          const protectedIndex = this.findOrderIndexByIdentity(
-            protectedLocalOrders,
-            currentOrder
-          );
+          const currentOrder = this.normalizeOrderCollectionsForIngress(rawCurrentOrder, `${source}.currentSQLite`);
+          const protectedIndex = this.findOrderIndexByIdentity(protectedLocalOrders, currentOrder);
           const currentNeedsProtection = this.shouldProtectLocalOrderFromRemoteSnapshot(currentOrder);
           if (protectedIndex >= 0) {
             if (currentNeedsProtection) {
@@ -2513,33 +2347,26 @@ var OrderModule = class extends import_BaseModule.BaseModule {
             }
             continue;
           }
-          if (currentNeedsProtection)
-            protectedLocalOrders.push(currentOrder);
+          if (currentNeedsProtection) protectedLocalOrders.push(currentOrder);
         }
-        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(
-          remoteSnapshot,
-          protectedLocalOrders
-        );
+        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(remoteSnapshot, protectedLocalOrders);
         mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
-        this.logInfo("replaceOrdersSnapshotInSQLite-开始", {
+        this.logInfo('replaceOrdersSnapshotInSQLite-开始', {
           source,
           count: mergedSnapshot.length,
           remoteCount: remoteSnapshot.length,
           protectedBeforeRemoteFetchCount: protectedOrdersBeforeRemoteFetch.length,
           protectedLocalOrderCount: protectedLocalOrders.length,
           preservedLocalUnsyncedCount: mergedSnapshot.length - remoteSnapshot.length,
-          protectedPendingPaymentCount: protectedLocalOrders.reduce(
-            (count, order) => count + this.getIdentifiedPendingPayments(order).length,
-            0
-          ),
-          protectedPendingPaymentIdentities: protectedLocalOrders.flatMap((order) => this.getIdentifiedPendingPayments(order).map((payment) => ({
+          protectedPendingPaymentCount: protectedLocalOrders.reduce((count, order) => count + this.getIdentifiedPendingPayments(order).length, 0),
+          protectedPendingPaymentIdentities: protectedLocalOrders.flatMap(order => this.getIdentifiedPendingPayments(order).map(payment => ({
             order_id: order.order_id ?? null,
             external_sale_number: order.external_sale_number ?? null,
-            payment_identities: (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment)
+            payment_identities: (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment)
           })))
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);
-        this.logInfo("replaceOrdersSnapshotInSQLite-clear完成", {
+        this.logInfo('replaceOrdersSnapshotInSQLite-clear完成', {
           count: mergedSnapshot.length
         });
         if (mergedSnapshot.length === 0) {
@@ -2547,19 +2374,20 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         }
         await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, mergedSnapshot);
         this.recordRecentSqliteWrite(source, mergedSnapshot);
-        this.logInfo("replaceOrdersSnapshotInSQLite-bulkAdd完成", {
+        this.logInfo('replaceOrdersSnapshotInSQLite-bulkAdd完成', {
           source,
           count: mergedSnapshot.length
         });
       });
     } catch (error) {
-      this.logError("全量保存订单到 SQLite 失败", {
+      this.logError('全量保存订单到 SQLite 失败', {
         error: error instanceof Error ? error.message : String(error),
         orderList: remoteSnapshot.length
       });
     }
     return mergedSnapshot;
   }
+
   /**
    * 清空订单模块的内存数据和本地 SQLite 订单表。
    *
@@ -2568,17 +2396,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   async clear() {
     this.store.list = [];
-    this.store.map = /* @__PURE__ */ new Map();
+    this.store.map = new Map();
     if (this.dbManager) {
       await this.runInOrderSQLiteSaveQueue(async () => {
         await this.dbManager.clear(INDEXDB_STORE_NAME);
       });
     }
-    this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, "");
-    this.emitOrdersChanged([], "clear");
+    this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, '');
+    this.emitOrdersChanged([], 'clear');
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  OrderModule
-});
+}
+exports.OrderModule = OrderModule;