@pisell/pisellos 0.10.28 → 0.10.30

package/lib/modules/ResourcePlanner/planner.js

@@ -213,7 +213,11 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   if (policy.type === 'before_start') {
-    if (now < candidateRange.start) return null;
+    // Flexible-duration candidates start at minute precision. Keep the current
+    // minute selectable instead of treating the freshly generated candidate as
+    // already started because the query clock still contains seconds.
+    const hasNotReachedStart = product.isFlexibleDuration ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start;
+    if (hasNotReachedStart) return null;
     return {
       status: 'unavailable',
       reasonCodes: ['booking_cutoff_before_start'],
@@ -946,6 +950,7 @@ function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
     }
     const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false);
     const operatingRanges = buildOperatingRanges(projection, dateRange);
+    const operatingEndAt = dateRange.startDate === dateRange.endDate && operatingRanges.length > 0 ? formatDateTime(Math.max(...operatingRanges.map(range => range.end)), projection.meta.timezone, fixedOffsetMinutes) : undefined;
     const resourceRanges = requiredGroups.length ? requiredGroups.map(group => buildGroupWorkingRanges({
       projection,
       product,
@@ -1012,6 +1017,9 @@ function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
       title: product.title,
       kind: product.kind,
       slotStepMinutes,
+      ...(operatingEndAt ? {
+        operatingEndAt
+      } : {}),
       ranges: dedupeProductRanges(ranges)
     };
   });

package/lib/modules/ResourcePlanner/types.d.ts

@@ -213,6 +213,8 @@ export interface ProductTimeRangeGroup {
     title?: string;
     kind: AvailabilityProductKind;
     slotStepMinutes?: number;
+    /** 单日查询对应营业窗口的最终结束时刻，不受资源排班是否为空影响。 */
+    operatingEndAt?: string;
     ranges: ProductTimeRange[];
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {

package/lib/plugins/request.d.ts

@@ -68,6 +68,7 @@ export interface RequestOptions {
     useCache?: boolean;
     customToast?: () => void;
     cache?: CacheProps;
+    cacheUpdateChange?: (data: any) => void;
     osServer?: boolean;
     isNocobase?: boolean;
     prefix?: boolean;

package/lib/server/index.d.ts

@@ -51,6 +51,8 @@ declare class Server {
     private productQueryScheduleTimers;
     /** 餐牌筛选为空时才触发的菜单/日程缓存自愈，避免每次商品查询都请求远端。 */
     private menuScheduleRefreshInFlight;
+    /** 启动阶段模块预加载任务；预渲染商品查询复用该任务，避免缓存尚未 ready 时误触发远端自愈。 */
+    private startupModulePreloadInFlight;
     private lastMenuScheduleRefreshAt;
     private readonly MENU_SCHEDULE_REFRESH_COOLDOWN_MS;
     private orderQuerySubscribers;
@@ -126,6 +128,9 @@ declare class Server {
     private runCheckoutSync;
     private omitCheckoutSyncMode;
     private buildRemoteCheckoutData;
+    private buildCheckoutDeviceHeaders;
+    private applyKioskCheckoutOperator;
+    private resolveKioskCheckoutOperatorId;
     private mergeCheckoutSyncPayments;
     private persistSyncedCheckoutOrder;
     /**
@@ -157,13 +162,17 @@ declare class Server {
      * 重新拉取全量 SSE 接口，更新本地数据后触发 onProductsSyncCompleted
      * 不影响当前界面展示，适用于切回前台、定时刷新等场景
      */
-    refreshProductsInBackground(): Promise<void>;
+    refreshProductsInBackground(options?: {
+        trigger?: string;
+    }): Promise<void>;
     /**
      * 后台静默刷新订单数据
      * 重新拉取全量 SSE 接口，更新本地数据后触发 onOrdersSyncCompleted
      * 不影响当前界面展示，适用于切回前台、定时刷新等场景
      */
-    refreshOrdersInBackground(): Promise<void>;
+    refreshOrdersInBackground(options?: {
+        trigger?: string;
+    }): Promise<void>;
     /**
      * 编辑正式订单时强制查询 Server 最新快照并覆盖本地缓存。
      * 商品成员增删由 OrderModule 在 SQLite/Store 更新完成后广播，
@@ -524,6 +533,8 @@ declare class Server {
     private getLocalPrintOrderLookup;
     private mergeLocalPrintOrderInput;
     private handleLocalPrintOrder;
+    private normalizeRequestedReceiptLocales;
+    private handleLocalOrderReceiptSnapshot;
     private handleMachinecodeBatchMeta;
     private resolveMachinecodeBatchMetadataLookup;
     private syncMachinecodeRedeemStatusToLocalOrder;

package/lib/server/index.js

@@ -103,6 +103,8 @@ class Server {
   productQueryScheduleTimers = new Map();
   /** 餐牌筛选为空时才触发的菜单/日程缓存自愈，避免每次商品查询都请求远端。 */
   menuScheduleRefreshInFlight = null;
+  /** 启动阶段模块预加载任务；预渲染商品查询复用该任务，避免缓存尚未 ready 时误触发远端自愈。 */
+  startupModulePreloadInFlight = null;
   lastMenuScheduleRefreshAt = 0;
   MENU_SCHEDULE_REFRESH_COOLDOWN_MS = 30 * 1000;
 
@@ -505,7 +507,15 @@ class Server {
 
     // 自动预加载数据
     if (autoPreload) {
-      await this.preloadModulesData(registeredModules, options);
+      const preloadTask = this.preloadModulesData(registeredModules, options);
+      this.startupModulePreloadInFlight = preloadTask;
+      try {
+        await preloadTask;
+      } finally {
+        if (this.startupModulePreloadInFlight === preloadTask) {
+          this.startupModulePreloadInFlight = null;
+        }
+      }
     } else {
       this.logInfo('跳过自动预加载', {
         autoPreload
@@ -634,12 +644,16 @@ class Server {
     const numberedData = await this.ensureCheckoutOrderNumbers(normalizedData, title);
     const checkoutData = this.normalizeCheckoutCollections(this.applyCheckoutFulfillmentBuzzer(numberedData, title));
     const remoteCheckoutData = this.buildRemoteCheckoutData(checkoutData, title);
+    const deviceHeaders = await this.buildCheckoutDeviceHeaders(title);
     if (!this.app?.request?.post) {
       throw new Error('app.request 不可用');
     }
     const response = await this.app.request.post(backendPath, remoteCheckoutData, {
       isShopApi: true,
-      customToast: () => {}
+      customToast: () => {},
+      ...(Object.keys(deviceHeaders).length > 0 ? {
+        headers: deviceHeaders
+      } : {})
     });
     if (this.isCheckoutResponseRejected(response)) {
       return {
@@ -705,6 +719,7 @@ class Server {
     const record = next;
     delete record[OS_FULFILLMENT_REF_MODE_FIELD];
     delete record[OS_INVOICE_LAYOUT_CONFIG_FIELD];
+    this.applyKioskCheckoutOperator(record);
     if (!Array.isArray(record.payments)) return next;
     const originalPayments = record.payments;
     const filteredPayments = originalPayments.filter(payment => !(0, _paymentUtils.isPendingOrderPayment)(payment));
@@ -719,6 +734,44 @@ class Server {
     });
     return next;
   }
+  async buildCheckoutDeviceHeaders(title) {
+    const getAsyncIotDeviceInfo = this.getAppData('async_iot_device_info');
+    if (!getAsyncIotDeviceInfo) return {};
+    let deviceInfo;
+    try {
+      deviceInfo = typeof getAsyncIotDeviceInfo === 'function' ? await getAsyncIotDeviceInfo() : getAsyncIotDeviceInfo;
+    } catch (error) {
+      this.logWarning(`${title}: 读取 async_iot_device_info 失败，跳过 checkout 设备请求头`, {
+        error: this.getUnknownErrorMessage(error)
+      });
+      return {};
+    }
+    if (!deviceInfo || typeof deviceInfo !== 'object') return {};
+    const headers = {};
+    const assignHeader = (key, value) => {
+      if (this.isBlankCheckoutValue(value)) return;
+      headers[key] = String(value);
+    };
+    assignHeader('Device-ID', deviceInfo.id);
+    assignHeader('Device-Type-Code', deviceInfo.type_code);
+    assignHeader('Device-Model-Code', deviceInfo.model_code);
+    return headers;
+  }
+  applyKioskCheckoutOperator(record) {
+    if (record.platform !== 'kiosk') return;
+    record.operator_type = 'customer';
+    record.operator_id = this.resolveKioskCheckoutOperatorId(record.customer_id);
+  }
+  resolveKioskCheckoutOperatorId(customerId) {
+    if (customerId === undefined || customerId === null) return 1;
+    if (typeof customerId === 'string') {
+      const trimmed = customerId.trim();
+      if (trimmed === '' || trimmed === '0' || trimmed === '1') return 1;
+      return customerId;
+    }
+    if (customerId === 0 || customerId === 1) return 1;
+    return customerId;
+  }
   mergeCheckoutSyncPayments(checkoutData, fresh, title) {
     const localPayments = Array.isArray(checkoutData?.payments) ? checkoutData.payments : [];
     const freshRecord = fresh;
@@ -820,11 +873,24 @@ class Server {
       return;
     }
     try {
-      await this.schedule.loadAllSchedule();
       this.products.clearPriceCache();
       await this.products.setupQuotationPriceBridge({
         scheduleModule: this.schedule,
-        channel: this.core.context?.channel
+        channel: this.core.context?.channel,
+        onQuotationUpdated: () => {
+          void this.recomputeAndNotifyProductQuery();
+        }
+      });
+
+      // Schedule 已在模块 preload 阶段加载完成。价格桥接先使用本地数据，
+      // 远端刷新转为后台校准，避免二次启动重复阻塞请求。
+      void this.schedule.loadAllSchedule().then(() => {
+        this.products?.clearPriceCache();
+        void this.recomputeAndNotifyProductQuery();
+      }).catch(error => {
+        this.logWarning('Products 报价单价格桥接后台刷新 Schedule 失败，继续使用本地数据', {
+          error: error instanceof Error ? error.message : String(error)
+        });
       });
       this.logInfo('Products 报价单价格桥接初始化完成');
     } catch (error) {
@@ -883,17 +949,23 @@ class Server {
    * 重新拉取全量 SSE 接口，更新本地数据后触发 onProductsSyncCompleted
    * 不影响当前界面展示，适用于切回前台、定时刷新等场景
    */
-  async refreshProductsInBackground() {
+  async refreshProductsInBackground(options = {}) {
     if (!this.products) {
       this.logWarning('refreshProductsInBackground: Products 模块未注册');
       return;
     }
-    this.logInfo('refreshProductsInBackground 开始');
+    const trigger = options.trigger || 'background';
+    this.logInfo('refreshProductsInBackground 开始', {
+      trigger
+    });
     const startTime = Date.now();
     try {
-      await this.products.silentRefresh();
+      await this.products.silentRefresh({
+        trigger
+      });
       const duration = Date.now() - startTime;
       this.logInfo('refreshProductsInBackground 完成', {
+        trigger,
         duration: `${duration}ms`
       });
     } catch (error) {
@@ -901,6 +973,7 @@ class Server {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Server] refreshProductsInBackground 失败:', error);
       this.logError('refreshProductsInBackground 失败', {
+        trigger,
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -912,17 +985,23 @@ class Server {
    * 重新拉取全量 SSE 接口，更新本地数据后触发 onOrdersSyncCompleted
    * 不影响当前界面展示，适用于切回前台、定时刷新等场景
    */
-  async refreshOrdersInBackground() {
+  async refreshOrdersInBackground(options = {}) {
     if (!this.order) {
       this.logWarning('refreshOrdersInBackground: Order 模块未注册');
       return;
     }
-    this.logInfo('refreshOrdersInBackground 开始');
+    const trigger = options.trigger || 'background';
+    this.logInfo('refreshOrdersInBackground 开始', {
+      trigger
+    });
     const startTime = Date.now();
     try {
-      await this.order.silentRefresh();
+      await this.order.silentRefresh({
+        trigger
+      });
       const duration = Date.now() - startTime;
       this.logInfo('refreshOrdersInBackground 完成', {
+        trigger,
         duration: `${duration}ms`
       });
     } catch (error) {
@@ -930,6 +1009,7 @@ class Server {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Server] refreshOrdersInBackground 失败:', error);
       this.logError('refreshOrdersInBackground 失败', {
+        trigger,
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -1240,6 +1320,10 @@ class Server {
       method: 'post',
       path: '/shop/local/print-order',
       handler: this.handleLocalPrintOrder.bind(this)
+    }, {
+      method: 'post',
+      path: '/shop/local/order-receipt-snapshot',
+      handler: this.handleLocalOrderReceiptSnapshot.bind(this)
     }, {
       method: 'post',
       path: '/shop/local/getLocalPayment',
@@ -1466,7 +1550,7 @@ class Server {
     //   timerIds.push(timerId);
     // }
     setInterval(() => {
-      const currentTime = (0, _dayjs.default)().format('hh:mm');
+      const currentTime = (0, _dayjs.default)().format('HH:mm');
       if (timePoints.includes(currentTime)) {
         this.onScheduleTimePointTimerFire(subscriberId);
       }
@@ -3688,7 +3772,8 @@ class Server {
             order_id: printIdentity,
             small_ticket_data: params.syncedOrder?.payment_info?.small_ticket_data,
             skip_wristband: true,
-            skip_voucher: true
+            skip_voucher: true,
+            skip_discount: true
           } : {
             order_id: printIdentity,
             machine_code_print_info: params.syncedOrder?.payment_info?.machine_code_print_info,
@@ -3904,6 +3989,99 @@ class Server {
       };
     }
   };
+  normalizeRequestedReceiptLocales(value) {
+    if (!Array.isArray(value)) return [];
+    return Array.from(new Set(value.filter(locale => typeof locale === 'string').map(locale => locale.trim()).filter(Boolean)));
+  }
+  handleLocalOrderReceiptSnapshot = async ({
+    data
+  }) => {
+    const input = data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+    const lookup = this.getLocalPrintOrderLookup(input);
+    if (lookup === undefined) {
+      return {
+        code: 400,
+        status: false,
+        message: '订单 lookup 缺失',
+        data: {
+          small_ticket_data: null
+        }
+      };
+    }
+    if (!this.order?.getLocalOrderByLookup) {
+      return {
+        code: 500,
+        status: false,
+        message: 'Order 模块未注册',
+        data: {
+          small_ticket_data: null
+        }
+      };
+    }
+    try {
+      let sourceOrder = await this.order.getLocalOrderByLookup(lookup);
+      if (!sourceOrder) {
+        const remoteResult = await this.fetchAndPersistSalesOrderByLookup(lookup, {
+          with: ['all']
+        }, 'handleLocalOrderReceiptSnapshot');
+        if (!remoteResult.order) {
+          return {
+            code: remoteResult.code,
+            status: false,
+            message: remoteResult.message,
+            data: {
+              small_ticket_data: null
+            }
+          };
+        }
+        sourceOrder = remoteResult.order;
+      }
+      const paymentInfo = {
+        ...(sourceOrder.payment_info || {})
+      };
+      delete paymentInfo.small_ticket_data;
+      const rebuiltOrder = await this.withLocalSmallTicketData({
+        ...sourceOrder,
+        small_ticket_data_flag: 1,
+        payment_info: paymentInfo
+      }, {
+        locales: this.normalizeRequestedReceiptLocales(input.locales)
+      });
+      const smallTicketData = rebuiltOrder.payment_info?.small_ticket_data;
+      if (!(0, _smallTicket.hasSmallTicketData)(smallTicketData)) {
+        return {
+          code: 500,
+          status: false,
+          message: '本地小票 Snapshot 生成失败',
+          data: {
+            small_ticket_data: null
+          }
+        };
+      }
+      return {
+        code: 200,
+        status: true,
+        message: '',
+        data: {
+          small_ticket_data: smallTicketData
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logError('handleLocalOrderReceiptSnapshot: 生成失败', {
+        lookup,
+        error: message
+      });
+      return {
+        code: 500,
+        status: false,
+        message,
+        data: {
+          small_ticket_data: null
+        }
+      };
+    }
+  };
   handleMachinecodeBatchMeta = async ({
     data
   }) => {
@@ -4740,7 +4918,7 @@ class Server {
       const smallTicketData = (0, _smallTicket.buildSmallTicketData)({
         order: enrichedOrder,
         shopInfo: this.getSmallTicketShopInfo(),
-        locales: (0, _OpenData.resolveInvoiceReceiptLocales)(options?.invoiceTemplateSettings),
+        locales: [...(0, _OpenData.resolveInvoiceReceiptLocales)(options?.invoiceTemplateSettings), ...(options?.locales || [])],
         productMap
       });
       return {
@@ -5638,12 +5816,6 @@ class Server {
       strategy_context
     } = context;
     const queryIds = Array.isArray(ids) ? ids.map(id => Number(id)).filter(id => Number.isFinite(id)) : [];
-    const formatterContext = this.buildProductFormatterContext({
-      schedule_date,
-      schedule_datetime,
-      customer_id,
-      strategy_context
-    });
     this.logInfo('computeProductQueryResult 开始', {
       menuListIdsCount: menu_list_ids?.length ?? 0,
       ids: queryIds,
@@ -5655,6 +5827,23 @@ class Server {
       strategyContextKeys: strategy_context ? Object.keys(strategy_context) : [],
       changedIds: options?.changedIds
     });
+
+    // 预渲染可能在 PisellOS 顺序 preload 尚未完成时发起商品查询。此时 Menu/Schedule
+    // 暂时为空不代表缓存失效；等待当前 preload 后再按原逻辑查询，避免并发远端刷新先 clear
+    // SQLite/IndexDB，造成 preload 读到空数据并重复请求。正常运行期该字段为 null，不增加等待。
+    const startupPreloadTask = this.startupModulePreloadInFlight;
+    if (startupPreloadTask) {
+      await startupPreloadTask;
+    }
+
+    // Menu/Schedule preload 会替换 store 中的数组；必须在等待完成后再读取，
+    // 避免 formatterContext 持有预加载前的空数组快照。
+    const formatterContext = this.buildProductFormatterContext({
+      schedule_date,
+      schedule_datetime,
+      customer_id,
+      strategy_context
+    });
     if (!this.products) {
       this.logError('computeProductQueryResult: Products 模块未注册');
       return {
@@ -5867,6 +6056,8 @@ class Server {
       schedule_datetime: context.schedule_datetime,
       customer_id: context.customer_id,
       strategy_context: context.strategy_context,
+      // 固定本次商品查询使用的语言，确保格式化与缓存使用同一份 locale 快照。
+      locale: this.core.context?.locale,
       menuList: this.menu?.getMenuList?.() || [],
       scheduleList: scheduleModule?.getScheduleList?.() || [],
       dataVariantEvaluator: this.core.context?.dataVariantEvaluator

package/lib/server/modules/floor-plan/index.d.ts

@@ -10,6 +10,7 @@ export declare class FloorPlanModule extends BaseModule implements Module {
     private store;
     private request;
     private logger;
+    private dbManager;
     private floorPlanDataSource;
     private pendingSyncMessages;
     private syncTimer?;
@@ -28,6 +29,9 @@ export declare class FloorPlanModule extends BaseModule implements Module {
     private mergeItems;
     private removeByIds;
     private loadListFromServer;
+    private loadListFromSQLite;
+    private saveListToSQLite;
+    private refreshListFromServer;
     fetchByIdFromServer(id: number | string): Promise<FloorPlanItem | null>;
     fetchByCodeFromServer(code: string): Promise<FloorPlanItem | null>;
     preload(): Promise<void>;

package/lib/server/modules/floor-plan/index.js

@@ -7,6 +7,7 @@ exports.FloorPlanModule = void 0;
 var _BaseModule = require("../../../modules/BaseModule");
 var _types = require("./types");
 const FLOOR_PLAN_SYNC_DEBOUNCE_MS = 3000;
+const FLOOR_PLAN_STORE_NAME = 'floor_plans';
 
 /**
  * 平面图模块：预加载列表、pubsub 同步、供 OS Server 路由读本地 store
@@ -17,6 +18,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
   store;
   request;
   logger;
+  dbManager;
   floorPlanDataSource;
   pendingSyncMessages = [];
   syncTimer;
@@ -40,6 +42,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
     if (appPlugin) {
       const app = appPlugin.getApp();
       this.logger = app.logger;
+      this.dbManager = app.sqlite || app.dbManager;
     }
     this.initFloorPlanDataSource();
     this.setupFloorPlanSync();
@@ -147,6 +150,45 @@ class FloorPlanModule extends _BaseModule.BaseModule {
       return [];
     }
   }
+  async loadListFromSQLite() {
+    if (!this.dbManager) return [];
+    try {
+      const list = await this.dbManager.getAll(FLOOR_PLAN_STORE_NAME);
+      return Array.isArray(list) ? list : [];
+    } catch (error) {
+      this.logWarning('从 SQLite 读取平面图失败', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async saveListToSQLite(list) {
+    if (!this.dbManager) return;
+    try {
+      await this.dbManager.clear(FLOOR_PLAN_STORE_NAME);
+      if (list.length > 0) {
+        await this.dbManager.bulkAdd(FLOOR_PLAN_STORE_NAME, list);
+      }
+    } catch (error) {
+      this.logWarning('保存平面图到 SQLite 失败', {
+        count: list.length,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async refreshListFromServer() {
+    const list = await this.loadListFromServer();
+    if (list.length === 0) {
+      this.logWarning('远端平面图刷新完成但列表为空');
+      return;
+    }
+    this.replaceStore(list);
+    await this.saveListToSQLite(list);
+    this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
+    this.logInfo('远端平面图刷新完成', {
+      count: list.length
+    });
+  }
   async fetchByIdFromServer(id) {
     try {
       const res = await this.request.get(`/schedule/floor-plan/${id}`, {}, {
@@ -174,16 +216,25 @@ class FloorPlanModule extends _BaseModule.BaseModule {
   }
   async preload() {
     this.logInfo('开始预加载平面图列表');
-    const list = await this.loadListFromServer();
-    if (list.length > 0) {
-      this.replaceStore(list);
+    const cachedList = await this.loadListFromSQLite();
+    if (cachedList.length > 0) {
+      this.replaceStore(cachedList);
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
-      this.logInfo('预加载完成', {
-        count: list.length
+      this.logInfo('预加载完成（SQLite）', {
+        count: cachedList.length
       });
-    } else {
-      this.logWarning('预加载完成但列表为空');
+
+      // 二次启动立即使用本地平面图，远端刷新完成后自动更新 store 与订阅者。
+      void this.refreshListFromServer().catch(error => {
+        this.logWarning('后台刷新平面图失败，继续使用本地数据', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+      return;
     }
+
+    // 首次启动没有缓存时仍等待一次远端请求，并为后续启动建立缓存。
+    await this.refreshListFromServer();
   }
   initFloorPlanDataSource() {
     const Ctor = this.core.serverOptions?.All_DATA_SOURCES?.FloorPlanDataSource;
@@ -282,6 +333,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
       }
     }
     if (changed) {
+      await this.saveListToSQLite(this.store.list);
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlanSyncCompleted, null);
     }
@@ -290,6 +342,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
     this.store.list = [];
     this.store.map.clear();
     this.store.codeMap.clear();
+    await this.saveListToSQLite([]);
   }
   destroy() {
     if (this.syncTimer) {

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

@@ -190,17 +190,20 @@ class MenuModule extends _BaseModule.BaseModule {
       this.logWarning('loadMenuFromIndexDB: dbManager 不可用');
       return [];
     }
+    const startedAt = performance.now();
     try {
       // 直接获取所有餐牌记录
       const menuList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
       this.logInfo('从 IndexDB 加载餐牌数据', {
-        menuCount: menuList?.length ?? 0
+        menuCount: menuList?.length ?? 0,
+        durationMs: +(performance.now() - startedAt).toFixed(2)
       });
       return menuList || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Menu] 从 IndexDB 读取数据失败:', error);
       this.logError('从 IndexDB 读取数据失败', {
+        durationMs: +(performance.now() - startedAt).toFixed(2),
         error: errorMessage
       });
       return [];
@@ -216,24 +219,43 @@ class MenuModule extends _BaseModule.BaseModule {
       this.logWarning('saveMenuToIndexDB: dbManager 不可用');
       return;
     }
+    const startedAt = performance.now();
+    let clearDurationMs = 0;
+    let writeDurationMs = 0;
     this.logInfo('开始保存餐牌数据到 IndexDB', {
       menuCount: menuList.length
     });
     try {
       // 先清空现有的餐牌数据
-      await this.dbManager.clear(INDEXDB_STORE_NAME);
+      const clearStartedAt = performance.now();
+      try {
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+      } finally {
+        clearDurationMs = +(performance.now() - clearStartedAt).toFixed(2);
+      }
 
       // 逐个保存餐牌（每个餐牌是独立的记录）
+      const writeStartedAt = performance.now();
       const savePromises = menuList.map(menu => this.dbManager.add(INDEXDB_STORE_NAME, menu));
-      await Promise.all(savePromises);
+      try {
+        await Promise.all(savePromises);
+      } finally {
+        writeDurationMs = +(performance.now() - writeStartedAt).toFixed(2);
+      }
       this.logInfo('餐牌数据已保存到 IndexDB', {
-        menuCount: menuList.length
+        menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2)
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Menu] 保存数据到 IndexDB 失败:', error);
       this.logError('保存数据到 IndexDB 失败', {
         menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2),
         error: errorMessage
       });
     }