@pisell/pisellos 2.2.264 → 2.2.265

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

@@ -35,7 +35,9 @@ module.exports = __toCommonJS(order_exports);
 var import_lodash_es = require("lodash-es");
 var import_dayjs = __toESM(require("dayjs"));
 var import_BaseModule = require("../../../modules/BaseModule");
+var import_orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
 var import_types = require("./types");
+var import_payment_utils = require("../../../modules/Order/payment-utils");
 var INDEXDB_STORE_NAME = "orders";
 var ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = "server_order_last_full_fetch_at";
 var ORDER_SYNC_THROTTLE_MS_STORAGE_KEY = "order_sync_throttle_ms";
@@ -45,10 +47,19 @@ var ORDER_SILENT_REFRESH_MIN_INTERVAL_MS = 3e4;
 var ORDER_BUSINESS_WRITE_SOURCES = /* @__PURE__ */ new Set([
   "upsertOrdersFromRemote",
   "upsertPendingSyncOrders",
+  "upsertLocalDraftOrders",
   "overwriteExistingOrder",
-  "markOrderSyncedByExternalSaleNumber"
+  "markOrderSyncedByExternalSaleNumber",
+  "updateLocalPayment"
 ]);
 var ORDER_MERGE_SELF_CHECK = false;
+var PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER = "__pisell_os_pending_payment_without_unique_number__";
+var ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ["products", "bookings", "payments"];
+var ORDER_COLLECTION_KIND_BY_FIELD = {
+  products: "product",
+  bookings: "booking",
+  payments: "payment"
+};
 var OrderModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
@@ -93,7 +104,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       this.updateCreateStore();
     }
     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.store.list = this.normalizeOrdersForMemoryList(
+        options.initialState.list,
+        "initialState"
+      );
       this.syncOrdersMap();
       this.emitOrdersChanged([], "initialState");
     } else {
@@ -154,6 +168,131 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     } catch {
     }
   }
+  /**
+   * 在订单进入内存或 SQLite 前统一压缩子项强身份重复并补齐协议 UID。
+   * 仅记录计数与订单标识，不输出商品、预约、支付或客户明细。
+   */
+  normalizeOrderCollectionsForIngress(order, source) {
+    const sourceOrder = (0, import_lodash_es.cloneDeep)(order);
+    const sourceOrderRecord = sourceOrder;
+    if (Array.isArray(sourceOrderRecord.payments)) {
+      sourceOrderRecord.payments = sourceOrderRecord.payments.map((payment) => {
+        if (!(0, import_payment_utils.isPendingOrderPayment)(payment) || (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => key.startsWith("unique_payment_number:"))) {
+          return payment;
+        }
+        return {
+          ...payment,
+          [PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]: true
+        };
+      });
+    }
+    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(sourceOrder);
+    const normalizedOrderRecord = result.order;
+    if (Array.isArray(normalizedOrderRecord.payments)) {
+      normalizedOrderRecord.payments = normalizedOrderRecord.payments.map(
+        (payment) => {
+          if (!(payment == null ? void 0 : payment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]))
+            return payment;
+          const nextPayment = { ...payment };
+          const metadata = { ...nextPayment.metadata || {} };
+          delete metadata.unique_payment_number;
+          delete nextPayment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER];
+          nextPayment.metadata = metadata;
+          return nextPayment;
+        }
+      );
+    }
+    const kinds = ["product", "booking", "payment"];
+    const hasChanges = kinds.some((kind) => {
+      const stats = result.stats[kind];
+      return stats.backfilledUidCount > 0 || stats.collapsedDuplicateCount > 0 || stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
+    });
+    if (hasChanges) {
+      const summarize = (stats) => ({
+        backfilled_uid_count: stats.backfilledUidCount,
+        collapsed_duplicate_count: stats.collapsedDuplicateCount,
+        uid_conflict_count: stats.uidConflictCount,
+        anonymous_row_count: stats.anonymousRowCount
+      });
+      const context = {
+        source,
+        order_id: (order == null ? void 0 : order.order_id) ?? null,
+        external_sale_number: (order == null ? void 0 : order.external_sale_number) ?? null,
+        products: summarize(result.stats.product),
+        bookings: summarize(result.stats.booking),
+        payments: summarize(result.stats.payment)
+      };
+      const hasUnsafeIdentity = kinds.some((kind) => {
+        const stats = result.stats[kind];
+        return stats.uidConflictCount > 0 || stats.anonymousRowCount > 0;
+      });
+      if (hasUnsafeIdentity) {
+        this.logWarning("订单子项身份存在冲突或匿名行", context);
+      } else {
+        this.logInfo("订单子项身份已规范化", context);
+      }
+    }
+    return result.order;
+  }
+  /**
+   * incoming 决定权威成员集合；同一持久化行仍从 existing 补齐 incoming 省略的本地展示字段。
+   */
+  mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = [], options = {}) {
+    const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
+    const existingItems = Array.isArray(existing) ? existing : [];
+    if (field === "payments" && options.preserveIdentifiedPendingPayments) {
+      return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(
+        existingItems,
+        incoming,
+        { preserveUnmatchedExistingWhen: import_payment_utils.isIdentifiedPendingOrderPayment }
+      );
+    }
+    return incoming.map((incomingItem) => {
+      const existingItem = existingItems.find(
+        (item) => (0, import_orderCollectionIdentity.isSameOrderCollectionItem)(kind, item, incomingItem)
+      );
+      if (!existingItem)
+        return (0, import_lodash_es.cloneDeep)(incomingItem);
+      const mergedItem = (0, import_orderCollectionIdentity.mergeOrderCollectionItems)(kind, existingItem, incomingItem);
+      const mergedUid = (0, import_orderCollectionIdentity.getOrderCollectionUid)(kind, mergedItem);
+      if (mergedUid) {
+        for (const from of /* @__PURE__ */ new Set([
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, existingItem),
+          (0, import_orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, incomingItem)
+        ])) {
+          if (!from || from === mergedUid)
+            continue;
+          uidRemaps.push({
+            kind,
+            from,
+            to: mergedUid,
+            persistentId: (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, import_orderCollectionIdentity.getOrderCollectionPersistentId)(kind, existingItem)
+          });
+        }
+      }
+      return mergedItem;
+    });
+  }
+  reconcileOverwriteOrderCollections(existing, incoming) {
+    const reconciled = (0, import_lodash_es.cloneDeep)(incoming);
+    const existingRecord = existing;
+    const incomingRecord = incoming;
+    const uidRemaps = [];
+    for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
+      if (!Array.isArray(incomingRecord[field]))
+        continue;
+      reconciled[field] = this.mergeAuthoritativeOrderCollection(
+        field,
+        existingRecord[field],
+        incomingRecord[field],
+        uidRemaps
+      );
+    }
+    return this.normalizeOrderCollectionsForIngress(
+      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(reconciled, uidRemaps),
+      "overwriteExistingOrder.reconciled"
+    );
+  }
   /**
    * 记录订单最近一次 SQLite 写入，供 pubsub 回声去重使用。
    *
@@ -363,17 +502,11 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return DEFAULT_ORDER_SYNC_THROTTLE_MS;
   }
   async preload() {
-    const getData = async () => {
-      const orders = await this.loadOrdersByServer();
-      if (orders.length === 0) {
-        return;
-      }
-      this.store.list = (0, import_lodash_es.cloneDeep)(orders);
-      this.syncOrdersMap();
-      this.emitOrdersChanged([], "preload");
-      this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
-    };
-    getData();
+    const orders = await this.loadOrdersByServer();
+    this.store.list = (0, import_lodash_es.cloneDeep)(orders);
+    this.syncOrdersMap();
+    await this.emitOrdersChanged([], "preload");
+    await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
   }
   getOrders() {
     return this.store.list;
@@ -385,6 +518,27 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   getOrderByOrderId(orderId) {
     return this.store.map.get(this.getIdKey(orderId));
   }
+  buildLocalPaymentOrderLogContext(order) {
+    if (!order)
+      return {};
+    return {
+      order_id: order.order_id ?? null,
+      external_sale_number: order.external_sale_number ?? null,
+      order_number: order.order_number ?? null,
+      shop_order_number: order.shop_order_number ?? null,
+      shop_full_order_number: order.shop_full_order_number ?? null,
+      order_status: order.status ?? null,
+      payment_status: order.payment_status ?? null,
+      is_draft_order: Number(order.is_draft_order || 0),
+      need_sync: Number(order.need_sync || 0),
+      platform: order.platform ?? null,
+      business_code: order.business_code ?? null,
+      order_sales_channel: order.order_sales_channel ?? null,
+      sales_channel: order.sales_channel ?? null,
+      order_type: order.type ?? null,
+      payments_count: Array.isArray(order.payments) ? order.payments.length : 0
+    };
+  }
   getLocalOrderFromMemoryByLookup(lookup) {
     const key = this.getIdKey(lookup);
     const memoryOrderById = this.store.map.get(key);
@@ -393,28 +547,200 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
     return memoryOrder || null;
   }
-  async getLocalOrderByLookup(lookup) {
+  async getLocalOrderByLookup(lookup, options = {}) {
     const key = this.getIdKey(lookup);
+    const logContext = {
+      operation_id: options.operationId,
+      lookup: key,
+      memory_order_count: this.store.list.length
+    };
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-开始", logContext);
+    }
     const memoryOrderById = this.store.map.get(key);
-    if (memoryOrderById)
+    if (memoryOrderById) {
+      if (options.operationId) {
+        this.logInfo("getLocalOrderByLookup-localPayment-命中内存映射", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(memoryOrderById)
+        });
+      }
       return memoryOrderById;
+    }
     const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
-    if (memoryOrder)
+    if (memoryOrder) {
+      if (options.operationId) {
+        this.logInfo("getLocalOrderByLookup-localPayment-命中内存列表", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(memoryOrder)
+        });
+      }
       return memoryOrder;
+    }
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-开始读取SQLite", logContext);
+    }
     const orders = await this.loadOrdersFromSQLite();
     const localOrder = orders.find((order) => this.isOrderLookupMatch(order, key));
-    if (!localOrder)
+    if (!localOrder) {
+      if (options.operationId) {
+        this.logWarning("getLocalOrderByLookup-localPayment-SQLite未命中", {
+          ...logContext,
+          sqlite_order_count: orders.length
+        });
+      }
       return null;
-    this.store.list = orders.map((order) => this.normalizeOrderForMemoryList(order));
+    }
+    this.store.list = this.normalizeOrdersForMemoryList(
+      orders,
+      "getLocalOrderByLookup.sqliteMemory"
+    );
     this.syncOrdersMap();
-    return this.normalizeOrderForMemoryList(localOrder);
+    const normalizedOrder = this.normalizeOrderForMemoryList(localOrder);
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-SQLite命中", {
+        ...logContext,
+        sqlite_order_count: orders.length,
+        ...this.buildLocalPaymentOrderLogContext(normalizedOrder)
+      });
+    }
+    return normalizedOrder;
+  }
+  async getLocalPayment(params) {
+    const logContext = {
+      operation_id: params.operationId,
+      sale_id: params.saleId,
+      payment_number: params.paymentNumber
+    };
+    this.logInfo("getLocalPayment-开始", logContext);
+    try {
+      const order = await this.getLocalOrderByLookup(params.saleId, {
+        operationId: params.operationId
+      });
+      if (!order) {
+        this.logWarning("getLocalPayment-订单未命中", logContext);
+        return null;
+      }
+      const payments = order.payments || [];
+      const match = (0, import_payment_utils.resolveOrderPaymentIdentity)(
+        payments,
+        params.paymentNumber,
+        "compat"
+      );
+      if (!match) {
+        this.logWarning("getLocalPayment-支付项未命中", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(order),
+          payments
+        });
+        return null;
+      }
+      this.logInfo("getLocalPayment-支付项命中", {
+        ...logContext,
+        ...this.buildLocalPaymentOrderLogContext(order),
+        matched_by: match.matchedBy,
+        payment_index: match.index,
+        payment: match.payment
+      });
+      return {
+        order,
+        payment: match.payment,
+        paymentIndex: match.index,
+        matchedBy: match.matchedBy
+      };
+    } catch (error) {
+      this.logError("getLocalPayment-查询失败", {
+        ...logContext,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async updateLocalPayment(params) {
+    const logContext = {
+      operation_id: params.operationId,
+      sale_id: params.saleId,
+      payment_number: params.paymentNumber,
+      incoming_payment_update: params.updates
+    };
+    this.logInfo("updateLocalPayment-开始", logContext);
+    const found = await this.getLocalPayment(params);
+    if (!found) {
+      this.logWarning("updateLocalPayment-支付项未命中", logContext);
+      return null;
+    }
+    const previousPayment = (0, import_lodash_es.cloneDeep)(found.payment);
+    const nextPayment = (0, import_payment_utils.mergeOrderPaymentRecord)(found.payment, {
+      ...params.updates,
+      updated_at: params.updates.updated_at || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    });
+    const nextOrder = {
+      ...found.order,
+      payments: (found.order.payments || []).map((payment, index) => index === found.paymentIndex ? nextPayment : payment),
+      updated_at: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    };
+    const paymentContext = {
+      ...logContext,
+      matched_by: found.matchedBy,
+      payment_index: found.paymentIndex,
+      ...this.buildLocalPaymentOrderLogContext(nextOrder),
+      previous_payment: previousPayment,
+      payment: nextPayment
+    };
+    this.logInfo("updateLocalPayment-支付项合并完成", paymentContext);
+    const targetIndex = this.findOrderIndexByIdentity(this.store.list, found.order);
+    const shouldKeepInMemory = this.shouldKeepOrderInMemory(nextOrder);
+    if (targetIndex < 0 && shouldKeepInMemory) {
+      this.logError("updateLocalPayment-订单Store索引未命中", paymentContext);
+      return null;
+    }
+    const previousList = this.store.list;
+    this.store.list = shouldKeepInMemory ? this.store.list.map((order, index) => index === targetIndex ? nextOrder : order) : this.store.list.filter((_, index) => index !== targetIndex);
+    this.syncOrdersMap();
+    const storageOrder = this.withoutSyntheticDraftOrderId(nextOrder);
+    try {
+      this.logInfo("updateLocalPayment-SQLite写入开始", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null
+      });
+      await this.updateOrderInSQLite(storageOrder, "updateLocalPayment", { throwOnError: true });
+      this.logInfo("updateLocalPayment-SQLite写入完成", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null
+      });
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      this.logError("updateLocalPayment-SQLite写入失败并回滚内存", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    if (shouldKeepInMemory || targetIndex >= 0) {
+      await this.emitOrdersChanged(
+        shouldKeepInMemory ? [nextOrder] : [],
+        shouldKeepInMemory ? "updateLocalPayment" : "updateLocalPayment.sqliteOnlyDraft"
+      );
+    }
+    this.logInfo("updateLocalPayment-变更事件完成", paymentContext);
+    return { order: nextOrder, payment: nextPayment, previousPayment };
   }
   async loadOrdersByServer() {
     var _a;
     let orderList = [];
+    const protectedOrdersBeforeRemoteFetch = (await this.loadOrdersFromSQLite()).filter(
+      (order) => this.shouldProtectLocalOrderFromRemoteSnapshot(order)
+    );
     this.logInfo("loadOrdersByServer-开始", {
       hasOrderDataSource: !!this.orderDataSource,
-      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null
+      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null,
+      protectedLocalOrderCount: protectedOrdersBeforeRemoteFetch.length,
+      protectedPendingPaymentCount: protectedOrdersBeforeRemoteFetch.reduce(
+        (count, order) => count + this.getIdentifiedPendingPayments(order).length,
+        0
+      )
     });
     if (this.orderDataSource) {
       try {
@@ -434,10 +760,19 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         return this.store.list;
       }
     }
-    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(orderList, "loadOrdersByServer");
-    const memoryOrders = mergedOrders.map((order) => this.normalizeOrderForMemoryList(order));
+    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(
+      orderList,
+      "loadOrdersByServer",
+      protectedOrdersBeforeRemoteFetch
+    );
+    const memoryOrders = this.normalizeOrdersForMemoryList(
+      mergedOrders,
+      "loadOrdersByServer.memory"
+    );
     this.logInfo("loadOrdersByServer-结束", {
-      count: memoryOrders.length
+      count: memoryOrders.length,
+      persistedCount: mergedOrders.length,
+      sqliteOnlyDraftCount: mergedOrders.length - memoryOrders.length
     });
     await this.core.effects.emit(import_types.OrderHooks.onOrdersLoaded, memoryOrders);
     return memoryOrders;
@@ -457,18 +792,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       this.updateCreateStore();
       const orders = await this.loadOrdersByServer();
-      if (orders.length > 0) {
-        this.store.list = (0, import_lodash_es.cloneDeep)(orders);
-        this.syncOrdersMap();
-        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.store.list = (0, import_lodash_es.cloneDeep)(orders);
+      this.syncOrdersMap();
+      await this.emitOrdersChanged([], "silentRefresh");
+      await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
+      this.logInfo("silentRefresh 完成", {
+        orderCount: orders.length,
+        duration: `${Date.now() - startTime}ms`
+      });
       return this.store.list;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -479,19 +810,44 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return this.store.list;
     }
   }
-  normalizeOrderForMemoryList(order) {
-    const externalSaleNumber = order == null ? void 0 : order.external_sale_number;
-    if ((order == null ? void 0 : order.order_id) !== void 0 && (order == null ? void 0 : order.order_id) !== null && (order == null ? void 0 : order.order_id) !== "") {
-      return order;
+  normalizeOrderForMemoryList(order, source = "normalizeOrderForMemoryList") {
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, source);
+    const externalSaleNumber = normalizedOrder == null ? void 0 : normalizedOrder.external_sale_number;
+    if (this.isDraftOrder(normalizedOrder) && !this.hasRealOrderId(normalizedOrder)) {
+      return normalizedOrder;
+    }
+    if ((normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== void 0 && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== null && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== "") {
+      return normalizedOrder;
     }
     if (externalSaleNumber === void 0 || externalSaleNumber === null || externalSaleNumber === "") {
-      return order;
+      return normalizedOrder;
     }
     return {
-      ...order,
+      ...normalizedOrder,
       order_id: externalSaleNumber
     };
   }
+  normalizeOrdersForMemoryList(orders, source) {
+    return orders.map((order) => this.normalizeOrderForMemoryList(order, source)).filter((order) => this.shouldKeepOrderInMemory(order));
+  }
+  hasRealOrderId(order) {
+    if (!order || this.isBlankIdentityValue(order.order_id))
+      return false;
+    const externalSaleNumber = order.external_sale_number;
+    return !(this.isDraftOrder(order) && !this.isBlankIdentityValue(externalSaleNumber) && String(order.order_id) === String(externalSaleNumber));
+  }
+  shouldKeepOrderInMemory(order) {
+    return !this.isDraftOrder(order) || this.hasRealOrderId(order);
+  }
+  withoutSyntheticDraftOrderId(order) {
+    const externalSaleNumber = order.external_sale_number;
+    if (Number(order.is_draft_order || 0) !== 1 || order.order_id === void 0 || externalSaleNumber === void 0 || String(order.order_id) !== String(externalSaleNumber)) {
+      return order;
+    }
+    const next = { ...order };
+    delete next.order_id;
+    return next;
+  }
   /**
    * 仅覆盖本地已存在的订单；不存在则直接跳过，不落库、不 emit。
    * 适用于"按 order_id 主动刷新本地订单详情"的代理场景。
@@ -511,32 +867,42 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       orderId,
       storeOrderCountBefore: this.store.list.length
     });
+    const normalizedFresh = this.normalizeOrderForMemoryList(
+      fresh,
+      "overwriteExistingOrder.incoming"
+    );
+    const existingOrder = this.store.map.get(key);
+    const reconciledFresh = this.reconcileOverwriteOrderCollections(
+      existingOrder,
+      normalizedFresh
+    );
     this.store.list = this.store.list.map((order) => {
       const id = order == null ? void 0 : order.order_id;
-      if (id === void 0 || id === null)
-        return order;
-      return this.getIdKey(id) === key ? fresh : order;
+      if (id === void 0 || id === null) {
+        return this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
+      }
+      return this.getIdKey(id) === key ? reconciledFresh : this.normalizeOrderForMemoryList(order, "overwriteExistingOrder.existingMemory");
     });
     this.syncOrdersMap();
-    await this.updateOrderInSQLite(fresh, "overwriteExistingOrder");
+    await this.updateOrderInSQLite(reconciledFresh, "overwriteExistingOrder");
     this.logInfo("overwriteExistingOrder-结束", {
       orderId,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged([fresh], "overwriteExistingOrder");
+    await this.emitOrdersChanged([reconciledFresh], "overwriteExistingOrder");
     return { overwritten: true };
   }
   /**
    * 将远端拉取的订单合并进本地 store（已存在则更新，不存在则追加），落库并 emit onOrdersChanged。
    * 供 /update/localOrder 等在「本地尚无该单」时写入新建单。
    */
-  async upsertOrdersFromRemote(freshOrders) {
+  async upsertOrdersFromRemote(freshOrders, source = "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, source });
+    await this.mergeOrdersToStore(freshOrders, source);
   }
   async markOrderSyncedByExternalSaleNumber(params) {
     const externalSaleNumber = params.externalSaleNumber;
@@ -562,7 +928,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       ...existing,
       ...params.patch || {},
       external_sale_number: existing.external_sale_number ?? externalSaleNumber,
-      need_sync: 0
+      need_sync: 0,
+      is_draft_order: 0
     });
     const storageKey = this.getOrderStorageKey(nextOrder) || key;
     this.store.list = this.store.list.map((order, index) => {
@@ -587,7 +954,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * 将本地待同步订单按 SQLite storage key 合并进 store 并落库。
    * checkout 离线兜底可能没有 order_id，但通常会有 external_sale_number。
    */
-  async upsertPendingSyncOrders(pendingOrders) {
+  async upsertPendingSyncOrders(pendingOrders, options = {}) {
     if (!(pendingOrders == null ? void 0 : pendingOrders.length)) {
       this.logInfo("upsertPendingSyncOrders-订单列表为空", {});
       return;
@@ -595,11 +962,26 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const pendingMap = /* @__PURE__ */ new Map();
     const memoryPendingMap = /* @__PURE__ */ new Map();
     for (const order of pendingOrders) {
-      const storageKey = this.getOrderStorageKey(order);
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+        order,
+        "upsertPendingSyncOrders.incoming"
+      );
+      const pendingOrder = {
+        ...normalizedOrder,
+        need_sync: 1,
+        is_draft_order: 0
+      };
+      const storageKey = this.getOrderStorageKey(pendingOrder);
       if (!storageKey)
         continue;
-      pendingMap.set(storageKey, order);
-      memoryPendingMap.set(storageKey, this.normalizeOrderForMemoryList(order));
+      pendingMap.set(storageKey, pendingOrder);
+      memoryPendingMap.set(
+        storageKey,
+        this.normalizeOrderForMemoryList(
+          pendingOrder,
+          "upsertPendingSyncOrders.memory"
+        )
+      );
     }
     if (pendingMap.size === 0) {
       this.logError("upsertPendingSyncOrders-订单缺少可落库标识", {
@@ -608,9 +990,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return;
     }
     this.logInfo("upsertPendingSyncOrders-开始", { count: pendingMap.size });
-    const patchedOrders = [...pendingMap.values()];
     const mergeActions = {};
-    const updatedList = [...this.store.list];
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, "upsertPendingSyncOrders.existingMemory")
+    );
     const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
@@ -624,11 +1007,22 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         this.getOrderIdentityMatchKeys(pendingOrder)
       );
       if (matchIndex >= 0) {
-        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], pendingOrder, {
-          preferIncomingProducts: true
-        });
-        updatedList[matchIndex] = mergedOrder;
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
+        const existingOrder = updatedList[matchIndex];
+        const mergedOrder = this.mergeOrderRecords(existingOrder, pendingOrder);
+        const nextOrder = {
+          ...mergedOrder,
+          need_sync: 1,
+          is_draft_order: 0
+        };
+        updatedList[matchIndex] = nextOrder;
+        const pendingSnapshot = pendingMap.get(storageKey);
+        if (pendingSnapshot) {
+          pendingMap.set(
+            storageKey,
+            this.reconcileOverwriteOrderCollections(existingOrder, pendingSnapshot)
+          );
+        }
+        this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
         mergeActions[storageKey] = "update";
         continue;
       }
@@ -637,15 +1031,126 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       this.registerOrderIdentityKeys(identityKeyToIndex, pendingOrder, insertIndex);
       mergeActions[storageKey] = "insert";
     }
+    const patchedOrders = [...pendingMap.values()];
+    const previousList = this.store.list;
     this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
+    try {
+      await this.patchOrdersInSQLite(
+        patchedOrders,
+        "upsertPendingSyncOrders",
+        mergeActions,
+        options
+      );
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      throw error;
+    }
     this.logInfo("upsertPendingSyncOrders-结束", {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
     await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
   }
+  /**
+   * 将 POS 草稿订单按 SQLite storage key 落库。
+   * 只有具备真实 order_id 的草稿进入 store；其余草稿仅供本地恢复查询。
+   */
+  async upsertLocalDraftOrders(draftOrders) {
+    if (!(draftOrders == null ? void 0 : draftOrders.length)) {
+      this.logInfo("upsertLocalDraftOrders-订单列表为空", {});
+      return;
+    }
+    const draftMap = /* @__PURE__ */ new Map();
+    const memoryDraftMap = /* @__PURE__ */ new Map();
+    for (const order of draftOrders) {
+      const draftOrder = {
+        ...order,
+        need_sync: 0,
+        is_draft_order: 1
+      };
+      const storageKey = this.getOrderStorageKey(draftOrder);
+      if (!storageKey)
+        continue;
+      draftMap.set(storageKey, draftOrder);
+      const memoryDraftOrder = this.normalizeOrderForMemoryList(draftOrder);
+      if (this.shouldKeepOrderInMemory(memoryDraftOrder)) {
+        memoryDraftMap.set(storageKey, memoryDraftOrder);
+      }
+    }
+    if (draftMap.size === 0) {
+      this.logError("upsertLocalDraftOrders-订单缺少可落库标识", {
+        count: draftOrders.length
+      });
+      return;
+    }
+    this.logInfo("upsertLocalDraftOrders-开始", {
+      count: draftMap.size,
+      memoryDraftCount: memoryDraftMap.size,
+      sqliteOnlyDraftCount: draftMap.size - memoryDraftMap.size
+    });
+    const patchedOrders = [...draftMap.values()];
+    const mergeActions = {};
+    const updatedList = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
+    const identityKeyToIndex = /* @__PURE__ */ new Map();
+    for (let index = 0; index < updatedList.length; index += 1) {
+      for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
+        if (!identityKeyToIndex.has(key))
+          identityKeyToIndex.set(key, index);
+      }
+    }
+    for (const [storageKey, draftOrder] of memoryDraftMap.entries()) {
+      const matchIndex = this.lookupOrderIndexByIdentityKeys(
+        identityKeyToIndex,
+        this.getOrderIdentityMatchKeys(draftOrder)
+      );
+      if (matchIndex >= 0) {
+        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], draftOrder);
+        const nextOrder = {
+          ...mergedOrder,
+          need_sync: 0,
+          is_draft_order: 1
+        };
+        updatedList[matchIndex] = nextOrder;
+        this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
+        mergeActions[storageKey] = "update";
+        continue;
+      }
+      const insertIndex = updatedList.length;
+      updatedList.push(draftOrder);
+      this.registerOrderIdentityKeys(identityKeyToIndex, draftOrder, insertIndex);
+      mergeActions[storageKey] = "insert";
+    }
+    const previousList = this.store.list;
+    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertLocalDraftOrders.store");
+    this.syncOrdersMap();
+    try {
+      await this.patchOrdersInSQLite(
+        patchedOrders,
+        "upsertLocalDraftOrders",
+        mergeActions,
+        { throwOnError: true }
+      );
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      throw error;
+    }
+    this.logInfo("upsertLocalDraftOrders-结束", {
+      count: patchedOrders.length,
+      storeOrderCountAfter: this.store.list.length
+    });
+    const removedLegacyMemoryDraft = previousList.some(
+      (order) => !this.shouldKeepOrderInMemory(order)
+    );
+    if (memoryDraftMap.size > 0 || removedLegacyMemoryDraft) {
+      await this.emitOrdersChanged(
+        patchedOrders.filter((order) => this.shouldKeepOrderInMemory(order)),
+        "upsertLocalDraftOrders"
+      );
+    }
+  }
   /**
    * 通过 SSE 按自定义 query 拉取订单（支持 select/with 精简字段）
    */
@@ -678,6 +1183,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     super.destroy();
   }
   syncOrdersMap() {
+    this.store.list = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
     this.store.map.clear();
     for (const order of this.store.list) {
       const primaryIdentity = this.getOrderMapKey(order);
@@ -969,7 +1475,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const uniqueFreshCount = uniqueFreshOrders.length;
     const patchedOrders = [];
     const mergeActions = {};
-    const updatedList = [...this.store.list];
+    const updatedList = this.store.list.map(
+      (order) => this.normalizeOrderForMemoryList(order, `${source}.existingMemory`)
+    );
     const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       const identityKeys = this.getOrderIdentityMatchKeys(updatedList[index]);
@@ -998,9 +1506,43 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           });
           continue;
         }
-        const mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
-        updatedList[matchIndex] = mergedOrder;
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
+        if (this.isDraftOrder(existingOrder) && this.shouldProtectDraftOrderFromIncoming(source)) {
+          this.logInfo("mergeOrdersToStore-跳过 draft 订单远端覆盖", {
+            source,
+            order_id: existingOrder.order_id ?? fresh.order_id ?? null,
+            external_sale_number: existingOrder.external_sale_number ?? fresh.external_sale_number ?? null,
+            local_is_draft_order: existingOrder.is_draft_order ?? null,
+            remote_is_draft_order: fresh.is_draft_order ?? null,
+            reason: "protect_draft_order_from_remote_echo"
+          });
+          continue;
+        }
+        let mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
+        let adjustedMatchIndex = matchIndex;
+        const duplicateIndexes = /* @__PURE__ */ new Set();
+        for (const key of freshIdentityKeys) {
+          const duplicateIndex = identityKeyToIndex.get(key);
+          if (duplicateIndex === void 0 || duplicateIndex === matchIndex)
+            continue;
+          duplicateIndexes.add(duplicateIndex);
+        }
+        if (duplicateIndexes.size > 0) {
+          for (const duplicateIndex of [...duplicateIndexes].sort((left, right) => right - left)) {
+            mergedOrder = this.mergeOrderRecords(mergedOrder, updatedList[duplicateIndex]);
+            updatedList.splice(duplicateIndex, 1);
+            if (duplicateIndex < adjustedMatchIndex)
+              adjustedMatchIndex -= 1;
+          }
+          identityKeyToIndex.clear();
+          for (let index = 0; index < updatedList.length; index += 1) {
+            for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
+              if (!identityKeyToIndex.has(key))
+                identityKeyToIndex.set(key, index);
+            }
+          }
+        }
+        updatedList[adjustedMatchIndex] = mergedOrder;
+        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, adjustedMatchIndex);
         patchedOrders.push(mergedOrder);
         if (mergeKey)
           mergeActions[mergeKey] = "update";
@@ -1236,56 +1778,29 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
     return result;
   }
-  getPaymentMergeKey(payment) {
-    var _a;
-    const record = payment;
-    if (!record)
-      return "";
-    const uniquePaymentNumber = (_a = record.metadata) == null ? void 0 : _a.unique_payment_number;
-    if (!this.isBlankIdentityValue(uniquePaymentNumber)) {
-      return `unique:${String(uniquePaymentNumber)}`;
-    }
-    const orderPaymentId = record.order_payment_id;
-    if (!this.isBlankIdentityValue(orderPaymentId))
-      return `order_payment:${String(orderPaymentId)}`;
-    const code = record.code;
-    const customPaymentId = record.custom_payment_id;
-    if (!this.isBlankIdentityValue(code) && !this.isBlankIdentityValue(customPaymentId)) {
-      return `custom:${String(code)}#${String(customPaymentId)}`;
-    }
-    return "";
-  }
   mergeOrderPaymentLists(existing, incoming) {
     const existingList = Array.isArray(existing) ? existing : [];
     const incomingList = Array.isArray(incoming) ? incoming : [];
     if (incomingList.length === 0)
       return (0, import_lodash_es.cloneDeep)(existingList);
-    if (existingList.length === 0)
-      return (0, import_lodash_es.cloneDeep)(incomingList);
-    const existingByKey = /* @__PURE__ */ new Map();
-    for (const payment of existingList) {
-      const key = this.getPaymentMergeKey(payment);
-      if (!key)
-        continue;
-      existingByKey.set(key, payment);
-    }
-    return incomingList.map((payment) => {
-      const incomingPayment = payment;
-      const key = this.getPaymentMergeKey(incomingPayment);
-      const existingPayment = key ? existingByKey.get(key) : void 0;
-      if (!existingPayment)
-        return (0, import_lodash_es.cloneDeep)(incomingPayment);
-      return {
-        ...(0, import_lodash_es.cloneDeep)(existingPayment),
-        ...(0, import_lodash_es.cloneDeep)(incomingPayment),
-        metadata: {
-          ...(0, import_lodash_es.cloneDeep)(existingPayment.metadata || {}),
-          ...(0, import_lodash_es.cloneDeep)(incomingPayment.metadata || {})
-        }
-      };
-    });
+    return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(existingList, incomingList);
+  }
+  getIdentifiedPendingPayments(order) {
+    const payments = Array.isArray(order == null ? void 0 : order.payments) ? order.payments : [];
+    return payments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment));
   }
-  mergeOrderRecords(existing, incoming, options) {
+  shouldProtectLocalOrderFromRemoteSnapshot(order) {
+    return this.isPendingSyncOrder(order) || this.isDraftOrder(order) || this.getIdentifiedPendingPayments(order).length > 0;
+  }
+  getUnmatchedIdentifiedPendingPayments(existing, incoming) {
+    const existingPayments = Array.isArray(existing) ? existing : [];
+    const incomingPayments = Array.isArray(incoming) ? incoming : [];
+    const incomingIdentityKeys = new Set(
+      incomingPayments.flatMap((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
+    );
+    return existingPayments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment) && !(0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => incomingIdentityKeys.has(key)));
+  }
+  mergeOrderRecords(existing, incoming) {
     const preferred = this.pickPreferredOrder(existing, incoming);
     const secondary = preferred === existing ? incoming : existing;
     const merged = {
@@ -1306,8 +1821,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       "updated_at",
       "shop_discount",
       "summary",
-      "products",
-      "bookings",
       "note",
       "customer_id",
       "customer_name",
@@ -1316,13 +1829,15 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       "contacts_info",
       "phone",
       "email",
-      "relation_forms"
+      "relation_forms",
+      "is_draft_order"
     ];
     const mergedRecord = merged;
     const preferredRecord = preferred;
     const secondaryRecord = secondary;
+    const existingRecord = existing;
     const incomingRecord = incoming;
-    const previousRecord = preferred === incoming ? secondaryRecord : preferredRecord;
+    const childUidRemaps = [];
     for (const field of fieldsToPreserve) {
       if (!this.isBlankIdentityValue(preferredRecord[field])) {
         mergedRecord[field] = preferredRecord[field];
@@ -1332,8 +1847,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         mergedRecord[field] = secondaryRecord[field];
       }
     }
-    const hasIncomingProducts = Object.prototype.hasOwnProperty.call(incomingRecord, "products");
-    const shouldUseIncomingProductsSnapshot = (options == null ? void 0 : options.preferIncomingProducts) === true && hasIncomingProducts && incomingRecord.products !== void 0 && incomingRecord.products !== null;
     for (const field of incomingPatchFields) {
       if (!Object.prototype.hasOwnProperty.call(incomingRecord, field))
         continue;
@@ -1343,21 +1856,44 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         continue;
       mergedRecord[field] = (0, import_lodash_es.cloneDeep)(incomingRecord[field]);
     }
-    mergedRecord.products = shouldUseIncomingProductsSnapshot ? (0, import_lodash_es.cloneDeep)(incomingRecord.products) : this.mergeOrderProductLists(preferredRecord.products, secondaryRecord.products);
-    if (Object.prototype.hasOwnProperty.call(incomingRecord, "payments")) {
-      if (Array.isArray(incomingRecord.payments)) {
-        mergedRecord.payments = this.mergeOrderPaymentLists(
-          previousRecord.payments,
-          incomingRecord.payments
+    for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
+      if (Array.isArray(incomingRecord[field])) {
+        if (field === "payments") {
+          const preservedPending = this.getUnmatchedIdentifiedPendingPayments(
+            existingRecord[field],
+            incomingRecord[field]
+          );
+          if (preservedPending.length > 0) {
+            this.logInfo("mergeOrderRecords-保留本地 pending 支付项", {
+              order_id: existing.order_id ?? incoming.order_id ?? null,
+              external_sale_number: existingRecord.external_sale_number ?? incomingRecord.external_sale_number ?? null,
+              preserved_pending_count: preservedPending.length,
+              preserved_payment_identities: preservedPending.map((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
+            });
+          }
+        }
+        mergedRecord[field] = this.mergeAuthoritativeOrderCollection(
+          field,
+          existingRecord[field],
+          incomingRecord[field],
+          childUidRemaps,
+          { preserveIdentifiedPendingPayments: field === "payments" }
         );
-      } else if (incomingRecord.payments !== void 0 && incomingRecord.payments !== null) {
-        mergedRecord.payments = (0, import_lodash_es.cloneDeep)(incomingRecord.payments);
+        continue;
+      }
+      if (Object.prototype.hasOwnProperty.call(existingRecord, field)) {
+        mergedRecord[field] = (0, import_lodash_es.cloneDeep)(existingRecord[field]);
+      } else {
+        delete mergedRecord[field];
       }
     }
     if (!this.isPendingSyncOrder(preferred) || !this.isPendingSyncOrder(secondary)) {
       merged.need_sync = 0;
     }
-    return merged;
+    return this.normalizeOrderCollectionsForIngress(
+      (0, import_orderCollectionIdentity.applyOrderCollectionUidRemaps)(merged, childUidRemaps),
+      "mergeOrderRecords"
+    );
   }
   summarizeDuplicateOrders(orders) {
     const groups = /* @__PURE__ */ new Map();
@@ -1376,7 +1912,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         external_sale_number: order.external_sale_number ?? null,
         shop_order_number: order.shop_order_number ?? null,
         shop_full_order_number: order.shop_full_order_number ?? null,
-        need_sync: order.need_sync ?? null
+        need_sync: order.need_sync ?? null,
+        is_draft_order: order.is_draft_order ?? null
       }))
     }));
   }
@@ -1394,12 +1931,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const list = [];
     let removedCount = 0;
     for (const order of orders) {
-      const matchIndex = this.findOrderIndexByIdentity(list, order);
+      const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+        order,
+        `${source}.order`
+      );
+      const matchIndex = this.findOrderIndexByIdentity(list, normalizedOrder);
       if (matchIndex < 0) {
-        list.push(order);
+        list.push(normalizedOrder);
         continue;
       }
-      list[matchIndex] = this.mergeOrderRecords(list[matchIndex], order);
+      list[matchIndex] = this.mergeOrderRecords(list[matchIndex], normalizedOrder);
       removedCount += 1;
     }
     if (removedCount > 0) {
@@ -1479,7 +2020,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return [];
     try {
       const orders = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      return orders || [];
+      return (orders || []).map(
+        (order) => this.normalizeOrderCollectionsForIngress(order, "loadOrdersFromSQLite")
+      );
     } catch {
       return [];
     }
@@ -1487,22 +2030,67 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   isPendingSyncOrder(order) {
     return Number(order == null ? void 0 : order.need_sync) === 1;
   }
+  isDraftOrder(order) {
+    return Number(order == null ? void 0 : order.is_draft_order) === 1;
+  }
+  shouldProtectDraftOrderFromIncoming(source) {
+    return source !== "checkoutSync";
+  }
   normalizeRemoteSyncedOrder(order) {
-    if (this.isPendingSyncOrder(order))
-      return order;
+    const normalizedOrder = this.normalizeOrderCollectionsForIngress(
+      order,
+      "normalizeRemoteSyncedOrder"
+    );
+    if (this.isPendingSyncOrder(normalizedOrder))
+      return {
+        ...normalizedOrder,
+        is_draft_order: 0
+      };
     return {
-      ...order,
-      need_sync: 0
+      ...normalizedOrder,
+      need_sync: 0,
+      is_draft_order: 0
+    };
+  }
+  mergeRemoteIdentityIntoDraftOrder(draftOrder, remoteOrder) {
+    const merged = {
+      ...this.withoutSyntheticDraftOrderId(draftOrder)
     };
+    const remote = remoteOrder;
+    for (const field of [
+      "order_id",
+      "order_number",
+      "shop_order_number",
+      "shop_full_order_number"
+    ]) {
+      if (this.isBlankIdentityValue(merged[field]) && !this.isBlankIdentityValue(remote[field])) {
+        merged[field] = remote[field];
+      }
+    }
+    return this.normalizeOrderCollectionsForIngress(
+      merged,
+      "mergeRemoteIdentityIntoDraftOrder"
+    );
   }
   mergeRemoteSnapshotWithPendingOrders(remoteOrders, existingOrders) {
     const merged = remoteOrders.map((order) => this.normalizeRemoteSyncedOrder(order));
-    for (const order of existingOrders) {
-      if (!this.isPendingSyncOrder(order))
+    for (const rawOrder of existingOrders) {
+      const order = this.normalizeOrderCollectionsForIngress(
+        rawOrder,
+        "mergeRemoteSnapshotWithPendingOrders.existingSQLite"
+      );
+      if (!this.shouldProtectLocalOrderFromRemoteSnapshot(order))
         continue;
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
       if (matchIndex >= 0) {
-        merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
+        if (this.isDraftOrder(order)) {
+          merged[matchIndex] = this.mergeRemoteIdentityIntoDraftOrder(
+            order,
+            merged[matchIndex]
+          );
+        } else {
+          merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
+        }
         continue;
       }
       if (!this.getOrderStorageKey(order))
@@ -1530,11 +2118,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * @example
    * await this.patchOrdersInSQLite(freshOrders)
    */
-  async patchOrdersInSQLite(orders, source, mergeActions = {}) {
-    if (!this.dbManager || orders.length === 0) {
+  async patchOrdersInSQLite(orders, source, mergeActions = {}, options = {}) {
+    if (orders.length === 0) {
+      return;
+    }
+    if (!this.dbManager) {
+      if (options.throwOnError)
+        throw new Error("订单 SQLite 数据库未初始化");
       return;
     }
-    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).filter((order) => this.getOrderStorageKey(order));
+    const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).map((order) => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).filter((order) => this.getOrderStorageKey(order));
     if (ordersSnapshot.length === 0) {
       return;
     }
@@ -1569,6 +2162,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           for (const order of compactedToWrite) {
             await this.dbManager.update(INDEXDB_STORE_NAME, order);
           }
+        } else if (options.throwOnError) {
+          throw new Error("订单 SQLite 数据库不支持写入");
         }
         this.recordRecentSqliteWrite(source, compactedToWrite);
         this.logInfo("patchOrdersInSQLite-完成", {
@@ -1583,6 +2178,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         error: error instanceof Error ? error.message : String(error),
         orderCount: ordersSnapshot.length
       });
+      if (options.throwOnError)
+        throw error;
     }
   }
   /**
@@ -1591,11 +2188,21 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * @example
    * await this.updateOrderInSQLite(freshOrder)
    */
-  async updateOrderInSQLite(order, source) {
-    if (!this.dbManager || !this.getOrderStorageKey(order)) {
+  async updateOrderInSQLite(order, source, options = {}) {
+    if (!this.getOrderStorageKey(order)) {
+      if (options.throwOnError)
+        throw new Error("订单缺少可用的 SQLite 存储主键");
       return;
     }
-    const orderSnapshot = (0, import_lodash_es.cloneDeep)(order);
+    if (!this.dbManager) {
+      if (options.throwOnError)
+        throw new Error("订单 SQLite 数据库未初始化");
+      return;
+    }
+    const orderSnapshot = this.normalizeOrderCollectionsForIngress(
+      (0, import_lodash_es.cloneDeep)(order),
+      `${source}.sqliteIngress`
+    );
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         let writeMethod = "none";
@@ -1613,6 +2220,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         } else if (typeof this.dbManager.bulkAdd === "function") {
           writeMethod = "bulkAdd";
           await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, [orderSnapshot]);
+        } else if (options.throwOnError) {
+          throw new Error("订单 SQLite 数据库不支持写入");
         }
         this.recordRecentSqliteWrite(source, [orderSnapshot]);
         this.logInfo("updateOrderInSQLite-完成", {
@@ -1626,22 +2235,27 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         error: error instanceof Error ? error.message : String(error),
         orderId: orderSnapshot.order_id ?? null
       });
+      if (options.throwOnError)
+        throw error;
     }
   }
   /**
-   * 全量快照替换 orders 表（clear + bulkAdd），用于 SSE 全量拉取与营业日窗口裁剪。
+   * 全量快照替换 orders 表（clear + bulkAdd），并保留本地 draft / need_sync / pending 支付订单。
+   * 用于 SSE 全量拉取与营业日窗口裁剪。
    *
    * @example
    * await this.replaceOrdersSnapshotInSQLite(orderList)
    */
-  async replaceOrdersSnapshotInSQLite(orderList, source) {
+  async replaceOrdersSnapshotInSQLite(orderList, source, protectedOrdersBeforeRemoteFetch = []) {
     if (!this.dbManager) {
       return this.compactOrderListByIdentity(
         orderList.map((order) => this.normalizeRemoteSyncedOrder(order)),
         `${source}.snapshotNoDb`
       ).list;
     }
-    const remoteSnapshot = (0, import_lodash_es.cloneDeep)(orderList);
+    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`
@@ -1649,16 +2263,52 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         const existingOrders = typeof this.dbManager.getAll === "function" ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
+        const protectedLocalOrders = protectedOrdersBeforeRemoteFetch.map((order) => this.normalizeOrderCollectionsForIngress(
+          order,
+          `${source}.protectedBeforeRemoteFetch`
+        )).filter((order) => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
+        for (const rawCurrentOrder of existingOrders || []) {
+          const currentOrder = this.normalizeOrderCollectionsForIngress(
+            rawCurrentOrder,
+            `${source}.currentSQLite`
+          );
+          const protectedIndex = this.findOrderIndexByIdentity(
+            protectedLocalOrders,
+            currentOrder
+          );
+          const currentNeedsProtection = this.shouldProtectLocalOrderFromRemoteSnapshot(currentOrder);
+          if (protectedIndex >= 0) {
+            if (currentNeedsProtection) {
+              protectedLocalOrders[protectedIndex] = currentOrder;
+            } else {
+              protectedLocalOrders.splice(protectedIndex, 1);
+            }
+            continue;
+          }
+          if (currentNeedsProtection)
+            protectedLocalOrders.push(currentOrder);
+        }
         const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(
           remoteSnapshot,
-          existingOrders || []
+          protectedLocalOrders
         );
         mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
         this.logInfo("replaceOrdersSnapshotInSQLite-开始", {
           source,
           count: mergedSnapshot.length,
           remoteCount: remoteSnapshot.length,
-          preservedPendingCount: mergedSnapshot.length - remoteSnapshot.length
+          protectedBeforeRemoteFetchCount: protectedOrdersBeforeRemoteFetch.length,
+          protectedLocalOrderCount: protectedLocalOrders.length,
+          preservedLocalUnsyncedCount: mergedSnapshot.length - remoteSnapshot.length,
+          protectedPendingPaymentCount: protectedLocalOrders.reduce(
+            (count, order) => count + this.getIdentifiedPendingPayments(order).length,
+            0
+          ),
+          protectedPendingPaymentIdentities: protectedLocalOrders.flatMap((order) => this.getIdentifiedPendingPayments(order).map((payment) => ({
+            order_id: order.order_id ?? null,
+            external_sale_number: order.external_sale_number ?? null,
+            payment_identities: (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment)
+          })))
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);
         this.logInfo("replaceOrdersSnapshotInSQLite-clear完成", {