@chevre/domain 24.1.0-alpha.33 → 24.1.0-alpha.35

package/lib/chevre/repo/acceptedOffer.d.ts

@@ -18,8 +18,8 @@ export declare class AcceptedOfferRepo extends AcceptedOfferInReserveRepo {
     /**
      * オファー展開の注文検索
      */
-    searchWithUnwoundAcceptedOffers(params: factory.order.ISearchConditions, projection: IProjection4searchWithUnwoundAcceptedOffers, _options: {
-        useItemOfferedByReserve?: boolean;
+    searchWithUnwoundAcceptedOffers(params: factory.order.ISearchConditions, projection: IProjection4searchWithUnwoundAcceptedOffers, options: {
+        useItemOfferedByReserve: boolean;
     }): Promise<(factory.order.IOrder & {
         acceptedOffers: [IAcceptedOffer];
         _id?: never;
@@ -67,8 +67,8 @@ export declare class AcceptedOfferRepo extends AcceptedOfferInReserveRepo {
                 };
             };
         };
-    }, _options: {
-        useItemOfferedByReserve?: boolean;
+    }, options: {
+        useItemOfferedByReserve: boolean;
     }): Promise<IAcceptedOffer[]>;
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
@@ -83,8 +83,8 @@ export declare class AcceptedOfferRepo extends AcceptedOfferInReserveRepo {
                 $eq: string;
             };
         };
-    }, _options: {
-        useItemOfferedByReserve?: boolean;
+    }, options: {
+        useItemOfferedByReserve: boolean;
     }): Promise<ISearchSlicedAcceptedOffersResult>;
     countByOrderNumber(filter: {
         orderNumber: {

package/lib/chevre/repo/acceptedOffer.js

@@ -19,7 +19,7 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
     /**
      * オファー展開の注文検索
      */
-    async searchWithUnwoundAcceptedOffers(params, projection, _options) {
+    async searchWithUnwoundAcceptedOffers(params, projection, options) {
         const conditions = order_2.OrderRepo.CREATE_MONGO_CONDITIONS(params);
         const aggregate = this.orderModel.aggregate();
         // unwind->matchでは遅い
@@ -54,6 +54,7 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
         // 予約取引を参照(2026-05-17~)
         const offeredThroughIdentifier = orders.at(0)?.acceptedOffers[0].offeredThrough?.identifier;
         const useReserveTransaction = offeredThroughIdentifier !== factory_1.factory.service.webAPI.Identifier.COA; // COAでは予約取引を参照しない
+        const { useItemOfferedByReserve } = options;
         if (useReserveTransaction) {
             const reservationNumbers = [...new Set(orders.map((order) => String(order.acceptedOffers[0].serialNumber)))];
             let acceptedOffersByReserveTransaction = [];
@@ -72,17 +73,22 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
                 if (priceSpecByReserveTransaction === undefined) {
                     console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: priceSpecByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
                 }
+                const itemOfferedByReserve = acceptedOfferByReserveTransaction?.itemOffered;
+                // itemOfferedByReserveは必ず存在するはず
+                if (itemOfferedByReserve === undefined) {
+                    console.error('repo:acceptedOffer: searchWithUnwoundAcceptedOffers: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+                }
                 const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
-                ...acceptedOfferWithoutPrice } = acceptedOffer;
+                itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
                 return {
                     ...order,
                     acceptedOffers: [
                         {
                             ...acceptedOfferWithoutPrice,
-                            ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }) // 予約取引参照の値で上書き
-                            // ...(priceSpecByReserveTransaction !== undefined)
-                            //     ? { priceSpecification: priceSpecByReserveTransaction } // 予約取引参照の値で上書き
-                            //     : { priceSpecification } // 万が一予約取引に存在しなければ注文ドキュメントの値を採用
+                            ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
+                            ...(useItemOfferedByReserve && itemOfferedByReserve !== undefined)
+                                ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き(2026-05-25~)
+                                : { itemOffered }
                         }
                     ]
                 };
@@ -124,7 +130,7 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
      */
     async searchAcceptedOffersByOrderNumber(filter, 
     // inclusion?: (keyof IAcceptedOffer)[], // 分かりにくいので廃止(2026-05-17~)
-    _options) {
+    options) {
         /**
          * unwind前に1ドキュメントを特定するためのstage
          */
@@ -219,12 +225,12 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
             .option({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
             .exec();
         // 予約取引を参照(2026-05-18~)
-        return this.addAcceptedOffersDetails(acceptedOffers);
+        return this.addAcceptedOffersDetails(acceptedOffers, options);
     }
     /**
      * 注文オファーをsliceして検索する(2024-01-10~)
      */
-    async searchSlicedAcceptedOffersByOrderNumber(filter, _options) {
+    async searchSlicedAcceptedOffersByOrderNumber(filter, options) {
         const aggregate = this.orderModel.aggregate([
             { $match: { orderNumber: { $eq: filter.orderNumber.$eq } } },
             { $match: { 'project.id': { $eq: filter.project.id.$eq } } },
@@ -246,7 +252,7 @@ class AcceptedOfferRepo extends acceptedOfferInReserve_1.AcceptedOfferInReserveR
         const { acceptedOffers, numAcceptedOffers } = result;
         // 予約取引を参照(2026-05-18~)
         return {
-            acceptedOffers: await this.addAcceptedOffersDetails(acceptedOffers),
+            acceptedOffers: await this.addAcceptedOffersDetails(acceptedOffers, options),
             numAcceptedOffers
         };
     }

package/lib/chevre/repo/acceptedOfferInReserve.d.ts

@@ -26,5 +26,7 @@ export declare class AcceptedOfferInReserveRepo {
     /**
      * 予約取引からオファー詳細情報を付加する
      */
-    protected addAcceptedOffersDetails(acceptedOffers: IAcceptedOffer[]): Promise<IAcceptedOffer[]>;
+    protected addAcceptedOffersDetails(acceptedOffers: IAcceptedOffer[], options: {
+        useItemOfferedByReserve: boolean;
+    }): Promise<IAcceptedOffer[]>;
 }

package/lib/chevre/repo/acceptedOfferInReserve.js

@@ -41,7 +41,7 @@ class AcceptedOfferInReserveRepo {
     /**
      * 予約取引からオファー詳細情報を付加する
      */
-    async addAcceptedOffersDetails(acceptedOffers) {
+    async addAcceptedOffersDetails(acceptedOffers, options) {
         const offeredThroughIdentifier = acceptedOffers.at(0)?.offeredThrough?.identifier;
         if (offeredThroughIdentifier === factory_1.factory.service.webAPI.Identifier.COA) {
             // COAでは予約取引を参照しない
@@ -52,6 +52,7 @@ class AcceptedOfferInReserveRepo {
         if (reservationNumbers.length > 0) {
             acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers });
         }
+        const { useItemOfferedByReserve } = options;
         return acceptedOffers.map((acceptedOffer) => {
             const acceptedOfferByReserveTransaction = acceptedOffersByReserveTransaction.find(((offer) => offer.itemOffered.id === acceptedOffer.itemOffered.id));
             // 予約は必ず存在するはず
@@ -63,14 +64,19 @@ class AcceptedOfferInReserveRepo {
             if (priceSpecByReserveTransaction === undefined) {
                 console.error('repo:acceptedOffer: addAcceptedOffersDetails: priceSpecByReserveTransaction: undefined!!!', acceptedOffer.itemOffered.id);
             }
+            const itemOfferedByReserve = acceptedOfferByReserveTransaction?.itemOffered;
+            // itemOfferedByReserveは必ず存在するはず
+            if (itemOfferedByReserve === undefined) {
+                console.error('repo:acceptedOffer: addAcceptedOffersDetails: itemOfferedByReserve: undefined!!!', acceptedOffer.itemOffered.id);
+            }
             const { priceSpecification: _originalPriceSpec, // 注文ドキュメントのpriceSpecificationはもう採用しない(2026-05-21~)
-            ...acceptedOfferWithoutPrice } = acceptedOffer;
+            itemOffered, ...acceptedOfferWithoutPrice } = acceptedOffer;
             return {
                 ...acceptedOfferWithoutPrice,
-                ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }) // 予約取引参照の値で上書き
-                // ...(priceSpecByReserveTransaction !== undefined)
-                //     ? { priceSpecification: priceSpecByReserveTransaction } // 予約取引参照の値で上書き
-                //     : { priceSpecification } // 万が一予約取引に存在しなければ注文ドキュメントの値を採用
+                ...((priceSpecByReserveTransaction !== undefined) && { priceSpecification: priceSpecByReserveTransaction }), // 予約取引参照の値で上書き
+                ...(useItemOfferedByReserve && itemOfferedByReserve !== undefined)
+                    ? { itemOffered: itemOfferedByReserve } // 予約取引参照の値で上書き
+                    : { itemOffered }
             };
         });
     }

package/lib/chevre/repo/orderInTransaction.d.ts

@@ -26,6 +26,20 @@ export type IPlacingOrder = Pick<factory.order.IOrder, 'broker' | 'confirmationN
      */
     customer?: never;
 };
+export type IMinimizedReservationFor = Pick<factory.order.IEventAsReservationFor, 'endDate' | 'id' | 'startDate' | 'typeOf'> & {
+    location: Pick<factory.order.IEventAsReservationFor['location'], 'branchCode' | 'typeOf'>;
+    superEvent: Pick<factory.order.ISuperEvent, 'id' | 'typeOf'> & {
+        location: Pick<factory.order.ISuperEvent['location'], 'branchCode' | 'typeOf'>;
+        workPerformed: Pick<factory.order.ISuperEvent['workPerformed'], 'identifier' | 'typeOf'>;
+    };
+};
+export type IMinimizedItemOffered = Pick<factory.order.IEventReservation, 'id' | 'reservationNumber' | 'typeOf'> & {
+    reservedTicket: Pick<factory.order.IReservedTicket, 'identifier' | 'ticketedSeat' | 'typeOf'>;
+    reservationFor: IMinimizedReservationFor;
+};
+export type IMinimizedAcceptedOffer = Pick<factory.order.IOptimizedAcceptedOffer, 'id' | 'name' | 'offeredThrough' | 'priceSpecification' | 'serialNumber' | 'typeOf'> & {
+    itemOffered: IMinimizedItemOffered;
+};
 /**
  * 取引中注文リポジトリ
  */
@@ -44,14 +58,6 @@ export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
     }): Promise<(Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
         priceSpecification?: factory.order.ITicketPriceSpecification;
     })[]>;
-    /**
-     * 取引進行中の注文からacceptedOffersを検索する
-     */
-    findAcceptedOffersByOrderNumber(params: {
-        orderNumber: {
-            $eq: string;
-        };
-    }): Promise<Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'serialNumber'>[]>;
     /**
      * 注文を受注する
      * typeOf: PlaceOrder -> typeOf: Order
@@ -62,7 +68,7 @@ export declare class OrderInTransactionRepo extends AcceptedOfferInReserveRepo {
      * このメソッドでdocumentが初めて生成される(typeOf:PlaceOrderとして)
      */
     acceptOffer(params: Pick<IOrderInTransaction, 'orderNumber' | 'project'> & {
-        acceptedOffers: (Omit<IAcceptedOffer, 'priceSpecification'> & {
+        acceptedOffers: IMinimizedAcceptedOffer[] | (Omit<IAcceptedOffer, 'priceSpecification'> & {
             /**
              * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
              */

package/lib/chevre/repo/orderInTransaction.js

@@ -41,32 +41,44 @@ class OrderInTransactionRepo extends acceptedOfferInReserve_1.AcceptedOfferInRes
             acceptedOffersByReserveTransaction = await this.findAcceptedOffersByReservationNumbers({ reservationNumbers });
         }
         return doc.acceptedOffers.map((acceptedOffer) => {
-            const priceSpecification = acceptedOffersByReserveTransaction.find((acceptedOfferByReserveTransaction) => acceptedOfferByReserveTransaction.itemOffered.id === acceptedOffer.itemOffered.id)?.priceSpecification;
+            const acceptedOfferByReserve = acceptedOffersByReserveTransaction.find((acceptedOfferByReserveTransaction) => acceptedOfferByReserveTransaction.itemOffered.id === acceptedOffer.itemOffered.id);
+            const priceSpecification = acceptedOfferByReserve?.priceSpecification;
             // COA予約でなければ、予約取引の価格は必ず存在するはず(2026-05-20~)
             if (priceSpecification === undefined) {
                 throw new factory_1.factory.errors.Internal(`findAcceptedOffersWithPriceByOrderNumber: priceSpecification undefined. ${acceptedOffer.itemOffered.id}`);
             }
+            const itemOffered = acceptedOfferByReserve?.itemOffered;
+            // COA予約でなければ、予約取引のitemOfferedは必ず存在するはず(2026-05-25~)
+            if (itemOffered === undefined) {
+                throw new factory_1.factory.errors.Internal(`findAcceptedOffersWithPriceByOrderNumber: itemOffered undefined. ${acceptedOffer.itemOffered.id}`);
+            }
             return {
                 ...acceptedOffer,
+                itemOffered,
                 priceSpecification
             };
         });
     }
-    /**
-     * 取引進行中の注文からacceptedOffersを検索する
-     */
-    async findAcceptedOffersByOrderNumber(params) {
-        const doc = await this.orderModel.findOne({
-            orderNumber: { $eq: params.orderNumber.$eq },
-            typeOf: { $eq: factory_1.factory.transactionType.PlaceOrder }
-        }, { acceptedOffers: 1 })
-            .lean()
-            .exec();
-        if (doc === null) {
-            throw new factory_1.factory.errors.NotFound('orderInTransaction');
-        }
-        return doc.acceptedOffers;
-    }
+    // /**
+    //  * 取引進行中の注文からacceptedOffersを検索する
+    //  */
+    // public async findAcceptedOffersByOrderNumber(
+    //     params: { orderNumber: { $eq: string } }
+    // ): Promise<Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'serialNumber'>[]> {
+    //     const doc = await this.orderModel.findOne<HydratedDocument<Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'serialNumber'>>>(
+    //         {
+    //             orderNumber: { $eq: params.orderNumber.$eq },
+    //             typeOf: { $eq: factory.transactionType.PlaceOrder }
+    //         },
+    //         { acceptedOffers: 1 }
+    //     )
+    //         .lean<Pick<IOrderInTransaction, 'acceptedOffers'>>()
+    //         .exec();
+    //     if (doc === null) {
+    //         throw new factory.errors.NotFound('orderInTransaction');
+    //     }
+    //     return doc.acceptedOffers;
+    // }
     /**
      * 注文を受注する
      * typeOf: PlaceOrder -> typeOf: Order

package/lib/chevre/service/offer/any.d.ts

@@ -1,5 +1,5 @@
 import { factory } from '../../factory';
-import type { OrderInTransactionRepo } from '../../repo/orderInTransaction';
+import type { IMinimizedAcceptedOffer, OrderInTransactionRepo } from '../../repo/orderInTransaction';
 interface IAcceptOfferOperationRepos {
     orderInTransaction: OrderInTransactionRepo;
 }
@@ -10,7 +10,7 @@ export declare function acceptOffer(params: {
     project: {
         id: string;
     };
-    acceptedOffers: (Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
+    acceptedOffers: IMinimizedAcceptedOffer[] | (Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
         /**
          * COA以外では注文ドキュメントにpriceSpecificationが存在しないのでIFを補完
          */

package/lib/chevre/service/offer/event/authorize/factory.d.ts

@@ -32,7 +32,7 @@ declare function acceptedOffers2authorizeResult(params: {
     ticketOffers: factory.product.ITicketOffer[];
 }): factory.action.authorize.offer.eventService.IResult;
 type IObjectSubReservation = factory.assetTransaction.reserve.IObjectSubReservation;
-export type IResultAcceptedOffer = Omit<factory.order.IAcceptedOffer, 'priceSpecification'> & {
+export type IResultAcceptedOffer = Omit<factory.order.IOptimizedAcceptedOffer, 'priceSpecification'> & {
     itemOffered: factory.order.IEventReservation;
     offeredThrough: factory.offer.IOfferedThrough;
     serialNumber: string;

package/lib/chevre/service/offer/event/authorize/factory.js

@@ -305,16 +305,17 @@ function createReservation(params) {
     const { itemOffered } = params;
     const event = params.reservationFor;
     let reservationItem;
+    const ticketType = {
+        typeOf: itemOffered.reservedTicket.ticketType.typeOf,
+        id: itemOffered.reservedTicket.ticketType.id,
+        identifier: itemOffered.reservedTicket.ticketType.identifier,
+        name: itemOffered.reservedTicket.ticketType.name,
+        description: itemOffered.reservedTicket.ticketType.description,
+        ...((Array.isArray(itemOffered.reservedTicket.ticketType.additionalProperty)) && { additionalProperty: itemOffered.reservedTicket.ticketType.additionalProperty })
+    };
     const reservedTicket = {
         typeOf: itemOffered.reservedTicket.typeOf,
-        ticketType: {
-            typeOf: itemOffered.reservedTicket.ticketType.typeOf,
-            id: itemOffered.reservedTicket.ticketType.id,
-            identifier: itemOffered.reservedTicket.ticketType.identifier,
-            name: itemOffered.reservedTicket.ticketType.name,
-            description: itemOffered.reservedTicket.ticketType.description,
-            additionalProperty: itemOffered.reservedTicket.ticketType.additionalProperty
-        },
+        ticketType,
         ...(typeof itemOffered.reservedTicket.identifier === 'string')
             ? { identifier: itemOffered.reservedTicket.identifier }
             : undefined, // チケット識別子追加(2024-04-15~)

package/lib/chevre/service/offer/event/authorize.d.ts

@@ -68,11 +68,10 @@ interface IAuthorizeOptions {
      */
     maxReservationGracePeriodInDays: number;
     /**
-     * 価格仕様なしのacceptedOfferを採用するかどうか
-     * 実験的に導入
-     * 2026-005-19~
+     * acceptedOfferのitemOfferedを最小化するかどうか
+     * 2026-05-25~
      */
-    useAcceptedOfferNoPriceSpec?: boolean;
+    useAcceptedOfferItemOfferedMinimized?: boolean;
 }
 /**
  * 興行オファー承認

package/lib/chevre/service/offer/event/authorize.js

@@ -56,21 +56,20 @@ function authorize(params, options) {
                 ...(typeof params.object.broker?.typeOf === 'string') ? { broker: params.object.broker } : undefined
             }, options)(repos, settings);
             acceptedOffers4result = processStartReserveResult.acceptedOffers4result;
-            // add orderInTransaction(2024-01-15~)
             if (!noOfferSpecified) {
-                const useAcceptedOfferNoPriceSpec = options.useAcceptedOfferNoPriceSpec === true;
+                const useAcceptedOfferItemOfferedMinimized = options.useAcceptedOfferItemOfferedMinimized === true;
                 await (0, any_1.acceptOffer)({
                     orderNumber,
                     project: transaction.project,
                     acceptedOffers: acceptedOffers4result.map((acceptOffer4result) => {
                         // support useAcceptedOfferNoPriceSpec(2026-05-19~)
-                        if (useAcceptedOfferNoPriceSpec) {
-                            const { priceSpecification: _priceSpecification, ...acceptOfferNoPriceSpec } = acceptOffer4result;
-                            return acceptOfferNoPriceSpec;
-                        }
-                        else {
-                            return acceptOffer4result;
-                        }
+                        const { priceSpecification: _priceSpecification, itemOffered, ...acceptOfferNoPriceSpec } = acceptOffer4result;
+                        return {
+                            ...acceptOfferNoPriceSpec,
+                            itemOffered: (useAcceptedOfferItemOfferedMinimized) // support useAcceptedOfferItemOfferedMinimized(2026-05-25~)
+                                ? minimizeItemOffered(itemOffered)
+                                : itemOffered
+                        };
                     })
                 })(repos);
             }
@@ -89,6 +88,46 @@ function authorize(params, options) {
         return { id: action.id, result };
     };
 }
+/**
+ * 注文ドキュメントに保管するitemOfferedを最小化する
+ * 2026-05-25~
+ */
+function minimizeItemOffered(itemOffered) {
+    const { id, reservationNumber, typeOf, reservationFor, reservedTicket } = itemOffered;
+    const minimizedReservation = {
+        id: reservationFor.id,
+        typeOf: reservationFor.typeOf,
+        location: {
+            branchCode: reservationFor.location.branchCode,
+            typeOf: reservationFor.location.typeOf
+        },
+        superEvent: {
+            id: reservationFor.superEvent.id,
+            typeOf: reservationFor.superEvent.typeOf,
+            location: {
+                branchCode: reservationFor.superEvent.location.branchCode,
+                typeOf: reservationFor.superEvent.location.typeOf
+            },
+            workPerformed: {
+                identifier: reservationFor.superEvent.workPerformed.identifier,
+                typeOf: reservationFor.superEvent.workPerformed.typeOf
+            }
+        },
+        startDate: reservationFor.startDate,
+        endDate: reservationFor.endDate
+    };
+    return {
+        id,
+        reservationNumber,
+        typeOf,
+        reservationFor: minimizedReservation,
+        reservedTicket: {
+            typeOf: reservedTicket.typeOf,
+            ...((typeof reservedTicket.ticketedSeat?.typeOf === 'string') && { ticketedSeat: reservedTicket.ticketedSeat }),
+            ...((typeof reservedTicket.identifier === 'string') && { identifier: reservedTicket.identifier })
+        }
+    };
+}
 function validateCreateRequest(params) {
     return async (repos) => {
         const transaction = await repos.placeOrder.findPlaceOrderInProgressById({

package/lib/chevre/service/order/deleteOrder.js

@@ -96,7 +96,9 @@ function deleteReservationsByOrder(order) {
             acceptedOffers: {
             // itemOffered: { typeOf: { $in: [factory.reservationType.EventReservation] } }
             }
-        }, {} // 予約取引参照(2026-05-18~)
+        }, {
+            useItemOfferedByReserve: true // 2026-05-25~
+        } // 予約取引参照(2026-05-18~)
         );
         const reservationIds = acceptedOffers.map((o) => String(o.itemOffered.id));
         if (reservationIds.length > 0) {

package/lib/chevre/service/order/placeOrder/createPlacingOrderFromExistingTransaction.js

@@ -80,7 +80,10 @@ function createPlacingOrderFromExistingTransaction(params) {
             .map(({ instrument }) => String(instrument.transactionNumber));
         try {
             // すでにtypeOf: Orderに変更済の場合acceptedOffersは空になるが、そもそもorderedItemはその後上書きされないので、空のまま処理して問題なし
-            acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersByOrderNumber({ orderNumber: { $eq: orderNumber } }))
+            acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByOrderNumber({
+                orderNumber,
+                project: { id: params.project.id }
+            }))
                 .filter(({ serialNumber }) => typeof serialNumber === 'string' && serialNumbers.includes(serialNumber));
         }
         catch (error) {

package/lib/chevre/service/order/sendOrder.js

@@ -101,7 +101,9 @@ function sendOrder(params) {
                     $slice: [offerIndexBase, limit],
                     orderNumber: { $eq: order.orderNumber },
                     project: { id: { $eq: order.project.id } }
-                }, {} // 予約取引参照(2026-05-18~)
+                }, {
+                    useItemOfferedByReserve: true // 2026-05-25~
+                } // 予約取引参照(2026-05-18~)
                 );
                 acceptedOffers = searchSlicedAcceptedOffersResult.acceptedOffers;
                 debug('delivering...', order.orderNumber, acceptedOffers.map((offer) => `${offer.itemOffered.id}`), // eslint-disable-line @typescript-eslint/no-explicit-any

package/lib/chevre/service/reserve/findByCode.js

@@ -39,7 +39,9 @@ function findByCode(params) {
                                 // typeOf?: { $in?: factory.order.IItemOffered['typeOf'][] };
                             }
                         }
-                    }, {} // 予約取引参照(2026-05-18~)
+                    }, {
+                        useItemOfferedByReserve: true // 2026-05-25~
+                    } // 予約取引参照(2026-05-18~)
                     )).shift();
                     if (acceptedOffer === undefined) {
                         throw new factory_1.factory.errors.NotFound('acceptedOffer');

package/lib/chevre/service/reserve/searchByOrder.js

@@ -16,7 +16,9 @@ function searchByOrder(params) {
                 // typeOf: { $in: [reservationType] }
                 }
             }
-        }, {} // 予約取引参照(2026-05-18~)
+        }, {
+            useItemOfferedByReserve: true // 2026-05-25~
+        } // 予約取引参照(2026-05-18~)
         );
         const reservationIds = acceptedOffers.map((offer) => {
             if (offer.itemOffered.typeOf === reservationType) {

package/lib/chevre/service/task/confirmReserveTransaction.js

@@ -137,7 +137,9 @@ function fixOrderAsPurpose(params) {
         const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber({
             orderNumber: { $eq: order.orderNumber },
             project: { id: { $eq: params.project.id } }
-        }, {} // 予約取引参照(2026-05-18~)
+        }, {
+            useItemOfferedByReserve: true // 2026-05-25~
+        } // 予約取引参照(2026-05-18~)
         );
         return {
             ...order,

package/lib/chevre/service/task/payment/payByTask.js

@@ -77,7 +77,9 @@ function fixOrderAsPurpose(params, transaction) {
                         reservedTicket: { ticketedSeat: { seatNumber: { $in: seatNumbers } } }
                     }
                 }
-            }, {} // 予約取引参照(2026-05-18~)
+            }, {
+                useItemOfferedByReserve: true // 2026-05-25~
+            } // 予約取引参照(2026-05-18~)
             );
         }
         return {

package/lib/chevre/service/transaction/returnOrder/preStart.js

@@ -144,7 +144,9 @@ function fixOrders(params) {
         const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber({
             orderNumber: { $eq: params.object.order[0].orderNumber },
             project: { id: { $eq: params.project.id } }
-        }, {} // 予約取引参照(2026-05-18~)
+        }, {
+            useItemOfferedByReserve: true // 2026-05-25~
+        } // 予約取引参照(2026-05-18~)
         );
         return { acceptedOffers, eventIds, offerIds, orders };
     };

package/lib/chevre/service/validation/validateOrder.js

@@ -22,7 +22,9 @@ function validateOrder(params) {
         const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber({
             orderNumber: { $eq: params.orderNumber },
             project: { id: { $eq: params.project.id } }
-        }, {} // 予約取引参照(2026-05-18~)
+        }, {
+            useItemOfferedByReserve: true // 2026-05-25~
+        } // 予約取引参照(2026-05-18~)
         );
         let payTransactions = [];
         if (order.paymentMethods.length > 0) {

package/package.json

@@ -91,5 +91,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "24.1.0-alpha.33"
+  "version": "24.1.0-alpha.35"
 }