@pisell/pisellos 0.0.569 → 0.10.2

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

@@ -1,65 +1,75 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/server/modules/order/index.ts
+var order_exports = {};
+__export(order_exports, {
+  OrderModule: () => OrderModule
 });
-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");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * SQLite 存储名称
- */
-const INDEXDB_STORE_NAME = 'orders';
-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', 'overwriteExistingOrder', 'markOrderSyncedByExternalSaleNumber']);
-
-/**
- * 合并热路径全表去重自检开关：默认关闭。
- * 开启后每次合并会额外对整张 store 做一次 O(n^2) 重复检测并告警，
- * 仅用于排查增量身份索引是否遗漏了重复订单，不应在生产常开。
- */
-const ORDER_MERGE_SELF_CHECK = false;
-const ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ['products', 'bookings', 'payments'];
-const ORDER_COLLECTION_KIND_BY_FIELD = {
-  products: 'product',
-  bookings: 'booking',
-  payments: 'payment'
+module.exports = __toCommonJS(order_exports);
+var import_lodash_es = require("lodash-es");
+var import_dayjs = __toESM(require("dayjs"));
+var import_BaseModule = require("../../../modules/BaseModule");
+var import_orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
+var import_types = require("./types");
+var INDEXDB_STORE_NAME = "orders";
+var ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = "server_order_last_full_fetch_at";
+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",
+  "overwriteExistingOrder",
+  "markOrderSyncedByExternalSaleNumber"
+]);
+var ORDER_MERGE_SELF_CHECK = false;
+var ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ["products", "bookings", "payments"];
+var ORDER_COLLECTION_KIND_BY_FIELD = {
+  products: "product",
+  bookings: "booking",
+  payments: "payment"
 };
-
-/**
- * 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();
-  /** 最近一次 SSE 全量拉取完成时间 */
-  lastServerFullFetchAtMs = 0;
+var OrderModule = class extends import_BaseModule.BaseModule {
   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;
   }
-
   /**
    * 广播订单变更事件，兼容全量列表订阅并额外携带本次变更订单。
    *
@@ -67,42 +77,44 @@ class OrderModule extends _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(_types.OrderHooks.onOrdersChanged, payload);
+    await this.core.effects.emit(import_types.OrderHooks.onOrdersChanged, payload);
   }
   async initialize(core, options) {
+    var _a;
     this.core = core;
-    this.store = options?.store;
-    if (!this.store.map) this.store.map = new Map();
-    const appPlugin = core.getPlugin('app');
-    const app = appPlugin?.getApp();
+    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();
     if (app) {
       this.dbManager = app.sqlite;
       this.logger = app.logger;
       this.storage = app.storage;
       this.updateCreateStore();
     }
-    if (Array.isArray(options?.initialState?.list)) {
-      this.store.list = options.initialState.list.map(order => this.normalizeOrderForMemoryList(order));
+    if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.list)) {
+      this.store.list = options.initialState.list.map((order) => this.normalizeOrderForMemoryList(order));
       this.syncOrdersMap();
-      this.emitOrdersChanged([], 'initialState');
+      this.emitOrdersChanged([], "initialState");
     } else {
       this.store.list = [];
-      this.store.map = new Map();
+      this.store.map = /* @__PURE__ */ 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 日志标题
@@ -112,16 +124,14 @@ class OrderModule extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'info',
+          type: "info",
           title: `[OrderServerModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -131,42 +141,39 @@ class OrderModule extends _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 result = (0, _orderCollectionIdentity.normalizeOrderCollections)(order);
-    const kinds = ['product', 'booking', 'payment'];
-    const hasChanges = kinds.some(kind => {
+    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(order);
+    const kinds = ["product", "booking", "payment"];
+    const hasChanges = kinds.some((kind) => {
       const stats = result.stats[kind];
       return stats.backfilledUidCount > 0 || stats.collapsedDuplicateCount > 0 || stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
     });
     if (hasChanges) {
-      const summarize = stats => ({
+      const summarize = (stats) => ({
         backfilled_uid_count: stats.backfilledUidCount,
         collapsed_duplicate_count: stats.collapsedDuplicateCount,
         uid_conflict_count: stats.uidConflictCount,
@@ -174,44 +181,50 @@ class OrderModule extends _BaseModule.BaseModule {
       });
       const context = {
         source,
-        order_id: order?.order_id ?? null,
-        external_sale_number: order?.external_sale_number ?? null,
+        order_id: (order == null ? void 0 : order.order_id) ?? null,
+        external_sale_number: (order == null ? void 0 : order.external_sale_number) ?? null,
         products: summarize(result.stats.product),
         bookings: summarize(result.stats.booking),
         payments: summarize(result.stats.payment)
       };
-      const hasUnsafeIdentity = kinds.some(kind => {
+      const 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 = []) {
     const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
     const existingItems = Array.isArray(existing) ? existing : [];
-    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);
+    return incoming.map((incomingItem) => {
+      const existingItem = existingItems.find(
+        (item) => (0, import_orderCollectionIdentity.isSameOrderCollectionItem)(kind, item, incomingItem)
+      );
+      if (!existingItem)
+        return (0, import_lodash_es.cloneDeep)(incomingItem);
+      const mergedItem = (0, import_orderCollectionIdentity.mergeOrderCollectionItems)(kind, existingItem, incomingItem);
+      const mergedUid = (0, import_orderCollectionIdentity.getOrderCollectionUid)(kind, mergedItem);
       if (mergedUid) {
-        for (const from of new Set([(0, _orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, existingItem), (0, _orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, incomingItem)])) {
-          if (!from || from === mergedUid) continue;
+        for (const from of /* @__PURE__ */ new Set([
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, existingItem),
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, incomingItem)
+        ])) {
+          if (!from || from === mergedUid)
+            continue;
           uidRemaps.push({
             kind,
             from,
             to: mergedUid,
-            persistentId: (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, existingItem)
+            persistentId: (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, existingItem)
           });
         }
       }
@@ -219,17 +232,25 @@ class OrderModule extends _BaseModule.BaseModule {
     });
   }
   reconcileOverwriteOrderCollections(existing, incoming) {
-    const reconciled = (0, _lodashEs.cloneDeep)(incoming);
+    const reconciled = (0, import_lodash_es.cloneDeep)(incoming);
     const existingRecord = existing;
     const incomingRecord = incoming;
     const uidRemaps = [];
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
-      if (!Array.isArray(incomingRecord[field])) continue;
-      reconciled[field] = this.mergeAuthoritativeOrderCollection(field, existingRecord[field], incomingRecord[field], uidRemaps);
-    }
-    return this.normalizeOrderCollectionsForIngress((0, _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, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(reconciled, uidRemaps),
+      "overwriteExistingOrder.reconciled"
+    );
   }
-
   /**
    * 记录订单最近一次 SQLite 写入，供 pubsub 回声去重使用。
    *
@@ -240,14 +261,11 @@ class OrderModule extends _BaseModule.BaseModule {
     const now = Date.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 回声）。
    *
@@ -255,12 +273,9 @@ class OrderModule extends _BaseModule.BaseModule {
    * const { toWrite, skipped } = this.filterRedundantPatchOrders('pubsub.bodyUpsert', orders, mergeActions)
    */
   filterRedundantPatchOrders(source, orders, mergeActions) {
-    const eligibleSkipSources = new Set(['pubsub.bodyUpsert', 'pubsub.httpRefresh']);
+    const eligibleSkipSources = /* @__PURE__ */ new Set(["pubsub.bodyUpsert", "pubsub.httpRefresh"]);
     if (!eligibleSkipSources.has(source)) {
-      return {
-        toWrite: orders,
-        skipped: []
-      };
+      return { toWrite: orders, skipped: [] };
     }
     const now = Date.now();
     const toWrite = [];
@@ -271,11 +286,9 @@ class OrderModule extends _BaseModule.BaseModule {
         toWrite.push(order);
         continue;
       }
-      const orderKey = order.order_id !== undefined && order.order_id !== null ? this.getIdKey(order.order_id) : '';
-      const mergeAction = orderKey ? mergeActions[orderKey] : undefined;
-
-      // 新增单必须落库，不参与去重
-      if (mergeAction === 'insert') {
+      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") {
         toWrite.push(order);
         continue;
       }
@@ -284,7 +297,7 @@ class OrderModule extends _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
         });
@@ -292,12 +305,8 @@ class OrderModule extends _BaseModule.BaseModule {
       }
       toWrite.push(order);
     }
-    return {
-      toWrite,
-      skipped
-    };
+    return { toWrite, skipped };
   }
-
   /**
    * 过滤 pubsub HTTP 增量拉取 ids：本地刚由业务 API 写入的单可跳过 HTTP。
    *
@@ -315,8 +324,8 @@ class OrderModule extends _BaseModule.BaseModule {
         continue;
       }
       const storageKey = this.getOrderStorageKey(existing);
-      const recent = storageKey ? this.recentSqliteWriteByStorageKey.get(storageKey) : undefined;
-      if (recent && recent.source === 'upsertOrdersFromRemote' && now - recent.ts < ORDER_SQLITE_DEDUPE_MS) {
+      const recent = storageKey ? this.recentSqliteWriteByStorageKey.get(storageKey) : void 0;
+      if (recent && recent.source === "upsertOrdersFromRemote" && now - recent.ts < ORDER_SQLITE_DEDUPE_MS) {
         skipped.push({
           orderId: id,
           lastSource: recent.source,
@@ -326,12 +335,8 @@ class OrderModule extends _BaseModule.BaseModule {
       }
       toFetch.push(id);
     }
-    return {
-      toFetch,
-      skipped
-    };
+    return { toFetch, skipped };
   }
-
   /**
    * 解析 pubsub 消息会走哪条同步分支，便于对照为何触发 HTTP 重拉或 body 直写。
    *
@@ -340,24 +345,25 @@ class OrderModule extends _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 !== undefined && singleIdRaw !== null;
+    const hasSingleId = !hasBatchIds && singleIdRaw !== void 0 && 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?.order_id ?? null
+        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
       };
     }
     if (hasSingleId && normalizedBody) {
       return {
-        route: 'bodyUpsert',
+        route: "bodyUpsert",
         hasBatchIds: false,
         hasSingleId: true,
         hasNormalizedBody: true,
@@ -368,70 +374,77 @@ class OrderModule extends _BaseModule.BaseModule {
     }
     if (hasSingleId) {
       return {
-        route: 'httpRefresh.singleId',
+        route: "httpRefresh.singleId",
         hasBatchIds: false,
         hasSingleId: true,
         hasNormalizedBody: !!normalizedBody,
         singleId: singleIdRaw,
         batchIds: [],
-        bodyOrderId: normalizedBody?.order_id ?? null
+        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
       };
     }
-    if (msg.relation_order_ids?.length) {
+    if ((_a = msg.relation_order_ids) == null ? void 0 : _a.length) {
       return {
-        route: 'httpRefresh.relationIds',
+        route: "httpRefresh.relationIds",
         hasBatchIds: false,
         hasSingleId: false,
         hasNormalizedBody: !!normalizedBody,
         singleId: null,
         batchIds: msg.relation_order_ids,
-        bodyOrderId: normalizedBody?.order_id ?? null
+        bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
       };
     }
     return {
-      route: 'noop',
+      route: "noop",
       hasBatchIds: false,
       hasSingleId: false,
       hasNormalizedBody: !!normalizedBody,
       singleId: null,
       batchIds: [],
-      bodyOrderId: normalizedBody?.order_id ?? null
+      bodyOrderId: (normalizedBody == null ? void 0 : normalizedBody.order_id) ?? null
     };
   }
   updateCreateStore() {
-    const appPlugin = this.core.getPlugin('app');
-    const app = appPlugin?.getApp();
+    const appPlugin = this.core.getPlugin("app");
+    const app = appPlugin == null ? void 0 : appPlugin.getApp();
     if (app) {
-      const coreData = app.data.store.getStore().getDataByModel('core');
-      if (coreData?.core) {
-        const today = (0, _dayjs.default)();
-        if (coreData?.core.operating_day_boundary) {
+      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 operatingDayBoundary = coreData.core.operating_day_boundary;
-          if (operatingDayBoundary.type === 'start_time') {
-            const boundaryTime = String(operatingDayBoundary.time || '').trim();
-            const boundaryStart = (0, _dayjs.default)(`${today.format('YYYY-MM-DD')} ${boundaryTime}`);
+          if (operatingDayBoundary.type === "start_time") {
+            const boundaryTime = String(operatingDayBoundary.time || "").trim();
+            const boundaryStart = (0, import_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")]
           };
         }
       }
@@ -441,36 +454,21 @@ class OrderModule extends _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 getData = async () => {
       const orders = await this.loadOrdersByServer();
       if (orders.length === 0) {
         return;
       }
-      this.store.list = (0, _lodashEs.cloneDeep)(orders);
+      this.store.list = (0, import_lodash_es.cloneDeep)(orders);
       this.syncOrdersMap();
-      this.emitOrdersChanged([], 'preload');
-      this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
+      this.emitOrdersChanged([], "preload");
+      this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
     };
     getData();
   }
@@ -480,7 +478,6 @@ class OrderModule extends _BaseModule.BaseModule {
   getOrderById(id) {
     return this.store.map.get(this.getIdKey(id));
   }
-
   /** 按 order_id 查询内存订单。 */
   getOrderByOrderId(orderId) {
     return this.store.map.get(this.getIdKey(orderId));
@@ -488,28 +485,33 @@ class OrderModule extends _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) {
     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 (memoryOrder) return memoryOrder;
+    if (memoryOrderById)
+      return memoryOrderById;
+    const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
+    if (memoryOrder)
+      return memoryOrder;
     const orders = await this.loadOrdersFromSQLite();
-    const localOrder = orders.find(order => this.isOrderLookupMatch(order, key));
-    if (!localOrder) return null;
-    this.store.list = orders.map(order => this.normalizeOrderForMemoryList(order));
+    const localOrder = orders.find((order) => this.isOrderLookupMatch(order, key));
+    if (!localOrder)
+      return null;
+    this.store.list = orders.map((order) => this.normalizeOrderForMemoryList(order));
     this.syncOrdersMap();
     return this.normalizeOrderForMemoryList(localOrder);
   }
   async loadOrdersByServer() {
+    var _a;
     let orderList = [];
-    this.logInfo('loadOrdersByServer-开始', {
+    this.logInfo("loadOrdersByServer-开始", {
       hasOrderDataSource: !!this.orderDataSource,
-      query: this.store?.createdAtQuery || null
+      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null
     });
     if (this.orderDataSource) {
       try {
@@ -519,25 +521,24 @@ class OrderModule extends _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');
-    const memoryOrders = mergedOrders.map(order => this.normalizeOrderForMemoryList(order));
-    this.logInfo('loadOrdersByServer-结束', {
+    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(orderList, "loadOrdersByServer");
+    const memoryOrders = mergedOrders.map((order) => this.normalizeOrderForMemoryList(order));
+    this.logInfo("loadOrdersByServer-结束", {
       count: memoryOrders.length
     });
-    await this.core.effects.emit(_types.OrderHooks.onOrdersLoaded, memoryOrders);
+    await this.core.effects.emit(import_types.OrderHooks.onOrdersLoaded, memoryOrders);
     return memoryOrders;
   }
-
   /**
    * 静默全量刷新：后台重新拉取全量 SSE 订单数据并更新本地
    * 拿到完整数据后一次性替换 store，触发订单变更与同步完成事件
@@ -549,40 +550,39 @@ class OrderModule extends _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();
       if (orders.length > 0) {
-        this.store.list = (0, _lodashEs.cloneDeep)(orders);
+        this.store.list = (0, import_lodash_es.cloneDeep)(orders);
         this.syncOrdersMap();
-        this.emitOrdersChanged([], 'silentRefresh');
-        await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
-        this.logInfo('silentRefresh 完成', {
+        this.emitOrdersChanged([], "silentRefresh");
+        await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
+        this.logInfo("silentRefresh 完成", {
           orderCount: orders.length,
           duration: `${Date.now() - startTime}ms`
         });
       } else {
-        this.logInfo('silentRefresh: 服务器未返回数据');
+        this.logInfo("silentRefresh: 服务器未返回数据");
       }
       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?.external_sale_number;
-    if (normalizedOrder?.order_id !== undefined && normalizedOrder?.order_id !== null && normalizedOrder?.order_id !== '') {
+    const externalSaleNumber = normalizedOrder == null ? void 0 : normalizedOrder.external_sale_number;
+    if ((normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== void 0 && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== null && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== "") {
       return normalizedOrder;
     }
-    if (externalSaleNumber === undefined || externalSaleNumber === null || externalSaleNumber === '') {
+    if (externalSaleNumber === void 0 || externalSaleNumber === null || externalSaleNumber === "") {
       return normalizedOrder;
     }
     return {
@@ -590,202 +590,199 @@ class OrderModule extends _BaseModule.BaseModule {
       order_id: externalSaleNumber
     };
   }
-
   /**
    * 仅覆盖本地已存在的订单；不存在则直接跳过，不落库、不 emit。
    * 适用于"按 order_id 主动刷新本地订单详情"的代理场景。
    */
   async overwriteExistingOrder(fresh) {
-    const orderId = fresh?.order_id;
-    if (orderId === undefined || orderId === null) {
-      this.logError('overwriteExistingOrder-入参缺少 order_id');
-      return {
-        overwritten: false
-      };
+    const orderId = fresh == null ? void 0 : fresh.order_id;
+    if (orderId === void 0 || 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?.order_id;
-      if (id === undefined || 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 == null ? void 0 : order.order_id;
+      if (id === void 0 || 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) {
-    if (!freshOrders?.length) {
-      this.logInfo('upsertOrdersFromRemote-订单列表为空', {});
+    if (!(freshOrders == null ? void 0 : freshOrders.length)) {
+      this.logInfo("upsertOrdersFromRemote-订单列表为空", {});
       return;
     }
-    this.logInfo('upsertOrdersFromRemote-开始', {
-      count: freshOrders.length
-    });
-    await this.mergeOrdersToStore(freshOrders, 'upsertOrdersFromRemote');
+    this.logInfo("upsertOrdersFromRemote-开始", { count: freshOrders.length });
+    await this.mergeOrdersToStore(freshOrders, "upsertOrdersFromRemote");
   }
   async markOrderSyncedByExternalSaleNumber(params) {
     const externalSaleNumber = params.externalSaleNumber;
-    if (externalSaleNumber === undefined || externalSaleNumber === null || externalSaleNumber === '') {
-      this.logError('markOrderSyncedByExternalSaleNumber-缺少 external_sale_number');
-      return {
-        updated: false
-      };
+    if (externalSaleNumber === void 0 || 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?.external_sale_number;
-      if (value === undefined || value === null || value === '') return false;
+    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;
       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
     });
     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) {
-    if (!pendingOrders?.length) {
-      this.logInfo('upsertPendingSyncOrders-订单列表为空', {});
+    if (!(pendingOrders == null ? void 0 : pendingOrders.length)) {
+      this.logInfo("upsertPendingSyncOrders-订单列表为空", {});
       return;
     }
-    const pendingMap = new Map();
-    const memoryPendingMap = new Map();
+    const pendingMap = /* @__PURE__ */ new Map();
+    const memoryPendingMap = /* @__PURE__ */ new Map();
     for (const order of pendingOrders) {
-      const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, 'upsertPendingSyncOrders.incoming');
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+        order,
+        "upsertPendingSyncOrders.incoming"
+      );
       const storageKey = this.getOrderStorageKey(normalizedOrder);
-      if (!storageKey) continue;
+      if (!storageKey)
+        continue;
       pendingMap.set(storageKey, normalizedOrder);
-      memoryPendingMap.set(storageKey, this.normalizeOrderForMemoryList(normalizedOrder, 'upsertPendingSyncOrders.memory'));
+      memoryPendingMap.set(
+        storageKey,
+        this.normalizeOrderForMemoryList(
+          normalizedOrder,
+          "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'));
-
-    // 与 mergeOrdersToStore 一致：基于身份键（field:value）建立索引，把「查找已存在订单」
-    // 从 O(n) 线性扫描降为 O(1)，整体复杂度由 O(n^2) 降为 O(n + m)。
-    const identityKeyToIndex = new Map();
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, "upsertPendingSyncOrders.existingMemory")
+    );
+    const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
-        // 同一 key 命中多张时保留最靠前的下标，与原 findIndex「取首个匹配」一致
-        if (!identityKeyToIndex.has(key)) identityKeyToIndex.set(key, index);
+        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);
         updatedList[matchIndex] = mergedOrder;
         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, mergedOrder, 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) 压缩；仅自检开关开启时兜底。
-    this.store.list = this.runOrderStoreSelfCheck(updatedList, 'upsertPendingSyncOrders.store');
+    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(patchedOrders, 'upsertPendingSyncOrders', mergeActions);
-    this.logInfo('upsertPendingSyncOrders-结束', {
+    await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
+    this.logInfo("upsertPendingSyncOrders-结束", {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged(patchedOrders, 'upsertPendingSyncOrders');
+    await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
   }
-
   /**
    * 通过 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 [];
@@ -795,25 +792,29 @@ class OrderModule extends _BaseModule.BaseModule {
     return [];
   }
   destroy() {
+    var _a;
     if (this.syncTimer) {
       clearTimeout(this.syncTimer);
-      this.syncTimer = undefined;
+      this.syncTimer = void 0;
     }
     this.isProcessingSyncBatch = false;
     this.pendingSyncMessages = [];
-    if (this.orderDataSource?.destroy) this.orderDataSource.destroy();
+    if ((_a = this.orderDataSource) == null ? void 0 : _a.destroy)
+      this.orderDataSource.destroy();
     super.destroy();
   }
   syncOrdersMap() {
     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);
     }
@@ -821,82 +822,88 @@ class OrderModule extends _BaseModule.BaseModule {
     if (!this.isBlankIdentityValue(externalSaleNumber)) {
       return this.getIdKey(externalSaleNumber);
     }
-    return '';
+    return "";
   }
   isBlankIdentityValue(value) {
-    return value === undefined || value === null || value === '';
+    return value === void 0 || value === null || value === "";
   }
   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) {
-    const candidates = [order?.schedule_date, order?.create_date, order?.created_at, order?.bookings?.[0]?.start_date, order?.bookings?.[0]?.select_date];
+    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
+    ];
     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 undefined;
+    return void 0;
   }
-
   /**
    * 初始化 OrderDataSource 实例
    */
   initOrderDataSource() {
-    const OrderDataSourceClass = this.core.serverOptions?.All_DATA_SOURCES?.OrderDataSource;
-    if (!OrderDataSourceClass) return;
+    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;
     this.orderDataSource = new OrderDataSourceClass();
   }
-
   /**
    * 初始化 pubsub 订阅，监听订单变更（纯订阅，不拉数据；全量 SSE 由 loadOrdersByServer 负责）
    */
   setupOrderSync() {
-    if (!this.orderDataSource) return;
+    if (!this.orderDataSource)
+      return;
     this.orderDataSource.run({
       pubsub: {
-        callback: res => {
+        callback: (res) => {
+          console.log("orderDataSource", 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,
@@ -909,10 +916,8 @@ class OrderModule extends _BaseModule.BaseModule {
         }
       }
     }).catch(() => {
-      // 忽略同步初始化异常，避免影响主流程
     });
   }
-
   /**
    * 调度订单同步节流窗口（leading-edge throttle）：
    * - 空闲状态下收到的第一条消息立即触发批处理，无需等待；
@@ -920,27 +925,29 @@ class OrderModule extends _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 = undefined;
+      this.syncTimer = void 0;
       void this.flushOrderSyncMessagesByThrottle();
     }, throttleMs);
   }
-
   /**
    * 执行一次节流批处理并在需要时续约下一轮窗口。
    * 批处理完成且无后续消息时恢复空闲状态，下一条消息将立即触发。
    */
   async flushOrderSyncMessagesByThrottle() {
-    if (this.isProcessingSyncBatch) return;
+    if (this.isProcessingSyncBatch)
+      return;
     if (this.pendingSyncMessages.length === 0) {
       this.isIdlePhase = true;
       return;
@@ -957,7 +964,6 @@ class OrderModule extends _BaseModule.BaseModule {
       }
     }
   }
-
   /**
    * 处理节流窗口内聚合后的同步消息批次
    *
@@ -972,16 +978,19 @@ class OrderModule extends _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 = new Map();
+    const upsertOrders = /* @__PURE__ */ new Map();
     const refreshIds = [];
     messages.forEach((msg, msgIndex) => {
       const routeInfo = this.resolveSyncMessageRoute(msg);
@@ -989,47 +998,50 @@ class OrderModule extends _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(_types.OrderHooks.onOrdersSyncCompleted, null);
+    await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
   }
-
   /**
    * 通过 HTTP 按 ids 批量拉取订单详情（走 orderDataSource）。
    *
@@ -1041,17 +1053,16 @@ class OrderModule extends _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 orderList = await this.orderDataSource.fetchOrdersByIds(ids);
-        return orderList || [];
+      if (typeof this.orderDataSource.fetchOrdersByIds === "function") {
+        const orderList2 = await this.orderDataSource.fetchOrdersByIds(ids);
+        return orderList2 || [];
       }
       const orderList = await this.orderDataSource.run({
         http: {
-          query: {
-            ids
-          }
+          query: { ids }
         }
       });
       return orderList || [];
@@ -1059,13 +1070,12 @@ class OrderModule extends _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
@@ -1073,37 +1083,38 @@ class OrderModule extends _BaseModule.BaseModule {
     this.logDuplicateOrders(`${source}.beforeMerge`, this.store.list);
     const normalizedFreshOrders = [];
     for (const order of freshOrders) {
-      const id = order?.order_id;
-      if (id === undefined || id === null) continue;
+      const id = order == null ? void 0 : order.order_id;
+      if (id === void 0 || id === null)
+        continue;
       normalizedFreshOrders.push(this.normalizeRemoteSyncedOrder(order));
     }
-    // 先对本批新单做去重（批内规模 m 很小），保证每条 fresh 身份唯一
-    const uniqueFreshOrders = this.compactOrderListByIdentity(normalizedFreshOrders, `${source}.incoming`).list;
+    const uniqueFreshOrders = this.compactOrderListByIdentity(
+      normalizedFreshOrders,
+      `${source}.incoming`
+    ).list;
     const uniqueFreshCount = uniqueFreshOrders.length;
     const patchedOrders = [];
     const mergeActions = {};
-    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();
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, `${source}.existingMemory`)
+    );
+    const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       const identityKeys = this.getOrderIdentityMatchKeys(updatedList[index]);
       for (const key of identityKeys) {
-        // 同一 key 命中多张时保留最靠前的下标，与原 findIndex「取首个匹配」一致
-        if (!identityKeyToIndex.has(key)) identityKeyToIndex.set(key, index);
+        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 !== undefined && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : '');
+      const mergeKey = storageKey || (fresh.order_id !== void 0 && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : "");
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
         if (this.isPendingSyncOrder(existingOrder) && this.isRemoteEchoMergeSource(source)) {
-          this.logInfo('mergeOrdersToStore-跳过 pending 订单远端覆盖', {
+          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,
@@ -1111,38 +1122,36 @@ class OrderModule extends _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;
         }
         const mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
         updatedList[matchIndex] = mergedOrder;
-        // 合并后身份字段可能新增（如挂单拿到 order_id），同步登记到索引，
-        // 供同批后续 fresh 命中同一槽位，避免重复插入
         this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
         patchedOrders.push(mergedOrder);
-        if (mergeKey) mergeActions[mergeKey] = 'update';
+        if (mergeKey)
+          mergeActions[mergeKey] = "update";
         continue;
       }
       const insertIndex = updatedList.length;
       updatedList.push(fresh);
       this.registerOrderIdentityKeys(identityKeyToIndex, fresh, insertIndex);
       patchedOrders.push(fresh);
-      if (mergeKey) mergeActions[mergeKey] = 'insert';
+      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);
-    this.logInfo('mergeOrdersToStore-结束', {
+    this.logInfo("mergeOrdersToStore-结束", {
       uniqueFreshCount,
       storeOrderCountAfter: this.store.list.length,
       insertCount,
@@ -1150,7 +1159,6 @@ class OrderModule extends _BaseModule.BaseModule {
     });
     await this.emitOrdersChanged(patchedOrders, source);
   }
-
   /**
    * 在身份索引中查找与目标订单共享任一身份键的已存在订单下标。
    * 返回所有命中键里最小的下标，等价于原 findOrderIndexByIdentity 的「取首个匹配」语义。
@@ -1162,15 +1170,16 @@ class OrderModule extends _BaseModule.BaseModule {
     let matchIndex = -1;
     for (const key of identityKeys) {
       const index = identityKeyToIndex.get(key);
-      if (index === undefined) continue;
-      if (matchIndex < 0 || index < matchIndex) matchIndex = index;
+      if (index === void 0)
+        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";
   }
-
   /**
    * 将订单的全部身份键登记到索引并指向其在列表中的下标。
    * 合并后订单新增的身份字段（如挂单同步后拿到 order_id）也会被登记。
@@ -1184,53 +1193,54 @@ class OrderModule extends _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?.data || res;
-    if (!data) return null;
-    const payload = data?.data && typeof data.data === 'object' ? data.data : undefined;
+    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 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 !== 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;
+    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;
     return normalized;
   }
   normalizeOrderSyncPayload(payload) {
-    if (!payload) return null;
+    if (!payload)
+      return null;
     const orderId = payload.order_id;
-    if (orderId === undefined || orderId === null) return null;
-    return {
-      ...payload,
-      order_id: orderId
-    };
+    if (orderId === void 0 || orderId === null)
+      return null;
+    return { ...payload, order_id: orderId };
   }
   uniqueOrderIds(ids) {
-    const idMap = new Map();
+    const idMap = /* @__PURE__ */ new Map();
     for (const id of ids) {
       idMap.set(this.getIdKey(id), id);
     }
@@ -1240,14 +1250,21 @@ class OrderModule extends _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 === undefined || 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 === void 0 || value === null || value === "")
+        return false;
       return this.getIdKey(value) === lookupKey;
     });
   }
-
   /**
    * 解析订单 SQLite 主键，规则与宿主 OrderDataSource.getOrderStorageKey 一致。
    *
@@ -1256,43 +1273,51 @@ class OrderModule extends _BaseModule.BaseModule {
    * // => 'S-1001'
    */
   getOrderStorageKey(order) {
-    const externalSaleNumber = order?.external_sale_number;
-    if (externalSaleNumber !== undefined && externalSaleNumber !== null && externalSaleNumber !== '') {
+    const externalSaleNumber = order == null ? void 0 : order.external_sale_number;
+    if (externalSaleNumber !== void 0 && externalSaleNumber !== null && externalSaleNumber !== "") {
       return String(externalSaleNumber);
     }
-    const orderId = order?.order_id;
-    if (orderId !== undefined && orderId !== null && orderId !== '') {
+    const orderId = order == null ? void 0 : order.order_id;
+    if (orderId !== void 0 && orderId !== null && orderId !== "") {
       return String(orderId);
     }
-    return '';
+    return "";
   }
   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;
   }
   mergeOrderRecords(existing, incoming) {
@@ -1302,8 +1327,30 @@ class OrderModule extends _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'];
+    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"
+    ];
     const mergedRecord = merged;
     const preferredRecord = preferred;
     const secondaryRecord = secondary;
@@ -1320,21 +1367,26 @@ class OrderModule extends _BaseModule.BaseModule {
       }
     }
     for (const field of incomingPatchFields) {
-      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]);
+      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]);
     }
-
-    // 子项数组遵循完整快照语义：incoming 自有且为数组（包括 []）时权威替换；
-    // 字段缺席或不是数组时视为稀疏 patch，继续保留 existing。
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
       if (Array.isArray(incomingRecord[field])) {
-        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(field, existingRecord[field], incomingRecord[field], childUidRemaps);
+        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(
+          field,
+          existingRecord[field],
+          incomingRecord[field],
+          childUidRemaps
+        );
         continue;
       }
       if (Object.prototype.hasOwnProperty.call(existingRecord, field)) {
-        mergedRecord[field] = (0, _lodashEs.cloneDeep)(existingRecord[field]);
+        mergedRecord[field] = (0, import_lodash_es.cloneDeep)(existingRecord[field]);
       } else {
         delete mergedRecord[field];
       }
@@ -1342,10 +1394,13 @@ class OrderModule extends _BaseModule.BaseModule {
     if (!this.isPendingSyncOrder(preferred) || !this.isPendingSyncOrder(secondary)) {
       merged.need_sync = 0;
     }
-    return this.normalizeOrderCollectionsForIngress((0, _orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps), 'mergeOrderRecords');
+    return this.normalizeOrderCollectionsForIngress(
+      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps),
+      "mergeOrderRecords"
+    );
   }
   summarizeDuplicateOrders(orders) {
-    const groups = new Map();
+    const groups = /* @__PURE__ */ new Map();
     for (const order of orders) {
       for (const key of this.getOrderIdentityMatchKeys(order)) {
         const group = groups.get(key) || [];
@@ -1356,7 +1411,7 @@ class OrderModule extends _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,
@@ -1367,8 +1422,9 @@ class OrderModule extends _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
@@ -1378,7 +1434,10 @@ class OrderModule extends _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);
@@ -1388,7 +1447,7 @@ class OrderModule extends _BaseModule.BaseModule {
       removedCount += 1;
     }
     if (removedCount > 0) {
-      this.logWarning('订单列表重复项已压缩', {
+      this.logWarning("订单列表重复项已压缩", {
         source,
         beforeCount: orders.length,
         afterCount: list.length,
@@ -1397,113 +1456,115 @@ class OrderModule extends _BaseModule.BaseModule {
     } else {
       this.logDuplicateOrders(source, orders);
     }
-    return {
-      list,
-      removedCount
-    };
+    return { list, removedCount };
   }
-
   /**
    * 当前订单拉取窗口：
    * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
    * - 无法解析时退化为自然日窗口
    */
   getCurrentPullWindow() {
-    const now = (0, _dayjs.default)();
-    const range = this.store?.createdAtQuery?.sales_time_between;
+    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;
     if (Array.isArray(range) && range.length >= 2) {
-      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 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 = 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, _dayjs.default)(lastFullFetchAt);
-    if (!parsed.isValid()) return false;
-
-    // 按当前拉取窗口判断，而不是自然日判断。
-    // 这样在营业日跨日边界（start_time）场景下也能正确判定是否需要重新拉取。
-    const {
-      startAt,
-      endExclusiveAt
-    } = this.getCurrentPullWindow();
+    if (!lastFullFetchAt)
+      return false;
+    const parsed = (0, import_dayjs.default)(lastFullFetchAt);
+    if (!parsed.isValid())
+      return false;
+    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, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss'));
+    this.setStorageItem(
+      ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY,
+      (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    );
   }
   getStorageItem(key) {
+    var _a;
     try {
-      if (this.storage?.getStorage) return this.storage.getStorage(key);
-      if (typeof globalThis !== 'undefined' && globalThis?.localStorage) {
+      if ((_a = this.storage) == null ? void 0 : _a.getStorage)
+        return this.storage.getStorage(key);
+      if (typeof globalThis !== "undefined" && (globalThis == null ? void 0 : globalThis.localStorage)) {
         return globalThis.localStorage.getItem(key);
       }
     } catch {
-      // 忽略存储异常，避免影响主流程
     }
     return null;
   }
   setStorageItem(key, value) {
+    var _a;
     try {
-      if (this.storage?.setStorage) {
+      if ((_a = this.storage) == null ? void 0 : _a.setStorage) {
         this.storage.setStorage(key, value);
         return;
       }
-      if (typeof globalThis !== 'undefined' && globalThis?.localStorage) {
+      if (typeof globalThis !== "undefined" && (globalThis == null ? void 0 : 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?.need_sync) === 1;
+    return Number(order == null ? void 0 : order.need_sync) === 1;
   }
   normalizeRemoteSyncedOrder(order) {
-    const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, 'normalizeRemoteSyncedOrder');
-    if (this.isPendingSyncOrder(normalizedOrder)) return normalizedOrder;
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+      order,
+      "normalizeRemoteSyncedOrder"
+    );
+    if (this.isPendingSyncOrder(normalizedOrder))
+      return normalizedOrder;
     return {
       ...normalizedOrder,
       need_sync: 0
     };
   }
   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.isPendingSyncOrder(order)) continue;
+      const order = this.normalizeOrderCollectionsForIngress(
+        rawOrder,
+        "mergeRemoteSnapshotWithPendingOrders.existingSQLite"
+      );
+      if (!this.isPendingSyncOrder(order))
+        continue;
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
       if (matchIndex >= 0) {
         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 并发交错。
    *
@@ -1514,10 +1575,9 @@ class OrderModule extends _BaseModule.BaseModule {
    */
   async runInOrderSQLiteSaveQueue(task) {
     const queuedTask = this.orderSQLiteSaveQueue.then(task, task);
-    this.orderSQLiteSaveQueue = queuedTask.then(() => undefined, () => undefined);
+    this.orderSQLiteSaveQueue = queuedTask.then(() => void 0, () => void 0);
     return queuedTask;
   }
-
   /**
    * 批量增量 upsert 订单到 SQLite，不清空表；用于 pubsub / HTTP 增量合并。
    *
@@ -1528,14 +1588,15 @@ class OrderModule extends _BaseModule.BaseModule {
     if (!this.dbManager || orders.length === 0) {
       return;
     }
-    const ordersSnapshot = (0, _lodashEs.cloneDeep)(orders).map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).filter(order => this.getOrderStorageKey(order));
+    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).map((order) => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).filter((order) => this.getOrderStorageKey(order));
     if (ordersSnapshot.length === 0) {
       return;
     }
-    const {
-      toWrite,
-      skipped
-    } = this.filterRedundantPatchOrders(source, ordersSnapshot, mergeActions);
+    const { toWrite, skipped } = this.filterRedundantPatchOrders(
+      source,
+      ordersSnapshot,
+      mergeActions
+    );
     if (toWrite.length === 0) {
       return;
     }
@@ -1545,26 +1606,26 @@ class OrderModule extends _BaseModule.BaseModule {
     }
     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);
           }
         }
         this.recordRecentSqliteWrite(source, compactedToWrite);
-        this.logInfo('patchOrdersInSQLite-完成', {
+        this.logInfo("patchOrdersInSQLite-完成", {
           source,
           count: compactedToWrite.length,
           writeMethod,
@@ -1572,13 +1633,12 @@ class OrderModule extends _BaseModule.BaseModule {
         });
       });
     } catch (error) {
-      this.logError('增量保存订单到 SQLite 失败', {
+      this.logError("增量保存订单到 SQLite 失败", {
         error: error instanceof Error ? error.message : String(error),
         orderCount: ordersSnapshot.length
       });
     }
   }
-
   /**
    * 单条 upsert 订单到 SQLite；用于 overwriteExistingOrder 等单条覆盖场景。
    *
@@ -1589,40 +1649,42 @@ class OrderModule extends _BaseModule.BaseModule {
     if (!this.dbManager || !this.getOrderStorageKey(order)) {
       return;
     }
-    const orderSnapshot = this.normalizeOrderCollectionsForIngress((0, _lodashEs.cloneDeep)(order), `${source}.sqliteIngress`);
+    const orderSnapshot = this.normalizeOrderCollectionsForIngress(
+      (0, import_lodash_es.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]);
         }
         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
       });
     }
   }
-
   /**
    * 全量快照替换 orders 表（clear + bulkAdd），用于 SSE 全量拉取与营业日窗口裁剪。
    *
@@ -1631,23 +1693,34 @@ class OrderModule extends _BaseModule.BaseModule {
    */
   async replaceOrdersSnapshotInSQLite(orderList, source) {
     if (!this.dbManager) {
-      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;
+      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;
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
-        const existingOrders = typeof this.dbManager.getAll === 'function' ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
-        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(remoteSnapshot, existingOrders || []);
+        const existingOrders = typeof this.dbManager.getAll === "function" ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
+        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(
+          remoteSnapshot,
+          existingOrders || []
+        );
         mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
-        this.logInfo('replaceOrdersSnapshotInSQLite-开始', {
+        this.logInfo("replaceOrdersSnapshotInSQLite-开始", {
           source,
           count: mergedSnapshot.length,
           remoteCount: remoteSnapshot.length,
           preservedPendingCount: mergedSnapshot.length - remoteSnapshot.length
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);
-        this.logInfo('replaceOrdersSnapshotInSQLite-clear完成', {
+        this.logInfo("replaceOrdersSnapshotInSQLite-clear完成", {
           count: mergedSnapshot.length
         });
         if (mergedSnapshot.length === 0) {
@@ -1655,20 +1728,19 @@ class OrderModule extends _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 订单表。
    *
@@ -1677,14 +1749,17 @@ class OrderModule extends _BaseModule.BaseModule {
    */
   async clear() {
     this.store.list = [];
-    this.store.map = new Map();
+    this.store.map = /* @__PURE__ */ 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");
   }
-}
-exports.OrderModule = OrderModule;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrderModule
+});