daiso 1.0.4 → 1.0.6

package/dist/services/megabox/location.js

@@ -0,0 +1,219 @@
+/**
+ * 메가박스 위치 해석 및 근처 지점 조회 보조 모듈
+ */
+import { fetchJson } from '../../utils/http.js';
+import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo } from './client.js';
+const DEFAULT_LATITUDE = 37.5665;
+const DEFAULT_LONGITUDE = 126.978;
+const DEFAULT_AREA_CODE = '11';
+const DEFAULT_TIMEOUT_MS = 15000;
+const GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
+const megaboxGeocodeCache = new Map();
+const MEGABOX_AREA_CODE_BY_REGION = [
+    ['서울특별시', '11'],
+    ['서울', '11'],
+    ['부산광역시', '26'],
+    ['부산', '26'],
+    ['대구광역시', '27'],
+    ['대구', '27'],
+    ['인천광역시', '28'],
+    ['인천', '28'],
+    ['광주광역시', '29'],
+    ['광주', '29'],
+    ['대전광역시', '30'],
+    ['대전', '30'],
+    ['울산광역시', '31'],
+    ['울산', '31'],
+    ['세종특별자치시', '36'],
+    ['세종', '36'],
+    ['경기도', '41'],
+    ['경기', '41'],
+    ['강원특별자치도', '42'],
+    ['강원도', '42'],
+    ['강원', '42'],
+    ['충청북도', '43'],
+    ['충북', '43'],
+    ['충청남도', '44'],
+    ['충남', '44'],
+    ['전북특별자치도', '45'],
+    ['전라북도', '45'],
+    ['전북', '45'],
+    ['전라남도', '46'],
+    ['전남', '46'],
+    ['경상북도', '47'],
+    ['경북', '47'],
+    ['경상남도', '48'],
+    ['경남', '48'],
+    ['제주특별자치도', '50'],
+    ['제주도', '50'],
+    ['제주', '50'],
+];
+function calculateDistanceKm(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return 6371 * c;
+}
+function isValidCoordinate(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function resolveAreaCodeFromText(text) {
+    const normalized = text.replace(/\s+/g, '');
+    for (const [region, areaCode] of MEGABOX_AREA_CODE_BY_REGION) {
+        if (normalized.includes(region.replace(/\s+/g, ''))) {
+            return areaCode;
+        }
+    }
+    return null;
+}
+function resolveAreaCodeFromGeocodeResult(result) {
+    for (const component of result.address_components || []) {
+        const candidates = [component.long_name || '', component.short_name || ''];
+        for (const candidate of candidates) {
+            const areaCode = resolveAreaCodeFromText(candidate);
+            if (areaCode) {
+                return areaCode;
+            }
+        }
+    }
+    return resolveAreaCodeFromText(result.formatted_address || '');
+}
+async function geocodeMegaboxLocation(params, options = {}) {
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    const keyword = (params.keyword || '').trim();
+    if (!hasCoordinates && keyword.length === 0) {
+        return null;
+    }
+    const cacheKey = hasCoordinates ? `coords:${params.latitude},${params.longitude}` : `keyword:${keyword}`;
+    const cached = megaboxGeocodeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    if (hasCoordinates) {
+        endpoint.searchParams.set('latlng', `${params.latitude},${params.longitude}`);
+    }
+    else {
+        endpoint.searchParams.set('address', keyword);
+    }
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_TIMEOUT_MS,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        megaboxGeocodeCache.set(cacheKey, {
+            expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+            value: null,
+        });
+        return null;
+    }
+    const firstResult = body.results?.[0];
+    const latitude = firstResult?.geometry?.location?.lat;
+    const longitude = firstResult?.geometry?.location?.lng;
+    const areaCode = firstResult ? resolveAreaCodeFromGeocodeResult(firstResult) : null;
+    const value = typeof latitude === 'number' && typeof longitude === 'number'
+        ? { latitude, longitude, areaCode }
+        : null;
+    megaboxGeocodeCache.set(cacheKey, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export async function resolveMegaboxLocation(params, options = {}) {
+    const explicitAreaCode = (params.areaCode || '').trim();
+    const keyword = (params.keyword || '').trim();
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    let latitude = hasCoordinates ? params.latitude : DEFAULT_LATITUDE;
+    let longitude = hasCoordinates ? params.longitude : DEFAULT_LONGITUDE;
+    let areaCode = explicitAreaCode || '';
+    let geocodeUsed = false;
+    if (!explicitAreaCode || !hasCoordinates) {
+        const geocoded = await geocodeMegaboxLocation(params, options);
+        if (geocoded) {
+            if (!hasCoordinates) {
+                latitude = geocoded.latitude;
+                longitude = geocoded.longitude;
+            }
+            if (!explicitAreaCode && geocoded.areaCode) {
+                areaCode = geocoded.areaCode;
+            }
+            geocodeUsed = true;
+        }
+    }
+    return {
+        keyword: keyword.length > 0 ? keyword : null,
+        latitude,
+        longitude,
+        areaCode: areaCode || DEFAULT_AREA_CODE,
+        geocodeUsed,
+    };
+}
+export async function fetchMegaboxNearbyTheaters(params, options = {}) {
+    const timeout = params.timeout || DEFAULT_TIMEOUT_MS;
+    const limit = Math.max(1, params.limit || 10);
+    const resolved = await resolveMegaboxLocation(params, options);
+    const { theaters } = await fetchMegaboxBookingList({
+        playDate: params.playDate,
+        areaCode: resolved.areaCode,
+        timeout,
+    });
+    const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeout)));
+    const merged = theaters
+        .map((theater, index) => {
+        const infoResult = infoResults[index];
+        if (infoResult.status !== 'fulfilled') {
+            return null;
+        }
+        const info = infoResult.value;
+        if (info.latitude === null || info.longitude === null) {
+            return null;
+        }
+        return {
+            theaterId: theater.theaterId,
+            theaterName: theater.theaterName,
+            address: info.address,
+            latitude: info.latitude,
+            longitude: info.longitude,
+            distanceKm: Number(calculateDistanceKm(resolved.latitude, resolved.longitude, info.latitude, info.longitude).toFixed(2)),
+        };
+    })
+        .filter((theater) => theater !== null)
+        .sort((left, right) => left.distanceKm - right.distanceKm)
+        .slice(0, limit);
+    return {
+        ...resolved,
+        playDate: params.playDate,
+        count: merged.length,
+        theaters: merged,
+    };
+}
+export async function resolveMegaboxNearestTheater(params, options = {}) {
+    const location = await resolveMegaboxLocation(params, options);
+    const nearby = await fetchMegaboxNearbyTheaters({
+        ...params,
+        playDate: params.playDate,
+        limit: 1,
+        areaCode: location.areaCode,
+        latitude: location.latitude,
+        longitude: location.longitude,
+    }, options);
+    return {
+        theater: nearby.theaters[0] || null,
+        location,
+    };
+}
+export function __testOnlyClearMegaboxLocationCaches() {
+    megaboxGeocodeCache.clear();
+}

package/dist/services/megabox/tools/findNearbyTheaters.js

@@ -2,54 +2,22 @@
  * 메가박스 주변 지점 탐색 도구
  */
 import * as z from 'zod';
-import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo, toYyyymmdd } from '../client.js';
-function calculateDistanceKm(lat1, lng1, lat2, lng2) {
-    const toRad = (deg) => (deg * Math.PI) / 180;
-    const dLat = toRad(lat2 - lat1);
-    const dLng = toRad(lng2 - lng1);
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    return 6371 * c;
-}
+import { toYyyymmdd } from '../client.js';
+import { fetchMegaboxNearbyTheaters } from '../location.js';
 async function findNearbyTheaters(args) {
-    const { latitude = 37.5665, longitude = 126.978, playDate = toYyyymmdd(), areaCode = '11', limit = 10, timeoutMs = 15000, } = args;
-    const { theaters } = await fetchMegaboxBookingList({
+    const { keyword, latitude, longitude, playDate = toYyyymmdd(), areaCode, limit = 10, timeoutMs = 15000, } = args;
+    const result = await fetchMegaboxNearbyTheaters({
+        keyword,
+        latitude,
+        longitude,
         playDate,
         areaCode,
+        limit,
+        timeout: timeoutMs,
+    }, {
+        googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
         timeout: timeoutMs,
     });
-    const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeoutMs)));
-    const merged = theaters
-        .map((theater, index) => {
-        const infoResult = infoResults[index];
-        if (infoResult.status !== 'fulfilled') {
-            return null;
-        }
-        const info = infoResult.value;
-        if (info.latitude === null || info.longitude === null) {
-            return null;
-        }
-        const distanceKm = calculateDistanceKm(latitude, longitude, info.latitude, info.longitude);
-        return {
-            theaterId: theater.theaterId,
-            theaterName: theater.theaterName,
-            address: info.address,
-            latitude: info.latitude,
-            longitude: info.longitude,
-            distanceKm: Number(distanceKm.toFixed(2)),
-        };
-    })
-        .filter((theater) => theater !== null)
-        .sort((a, b) => a.distanceKm - b.distanceKm)
-        .slice(0, limit);
-    const result = {
-        location: { latitude, longitude },
-        playDate,
-        areaCode,
-        count: merged.length,
-        theaters: merged,
-    };
     return {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
@@ -59,8 +27,9 @@ export function createFindNearbyTheatersTool() {
         name: 'megabox_find_nearby_theaters',
         metadata: {
             title: '메가박스 주변 지점 탐색',
-            description: '사용자 좌표 기준으로 메가박스 지점을 거리순으로 조회합니다.',
+            description: '사용자 좌표 또는 위치 키워드 기준으로 메가박스 지점을 거리순으로 조회합니다.',
             inputSchema: {
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
                 latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
                 longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),

package/dist/services/megabox/tools/getRemainingSeats.js

@@ -3,13 +3,34 @@
  */
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+import { resolveMegaboxNearestTheater } from '../location.js';
 async function getRemainingSeats(args) {
-    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', limit = 50, timeoutMs = 15000, } = args;
+    const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, limit = 50, timeoutMs = 15000, } = args;
+    let theaterId = inputTheaterId;
+    let resolvedTheater = null;
+    let resolvedLocation = null;
+    if (!theaterId && (typeof latitude === 'number' || typeof longitude === 'number' || (keyword || '').trim().length > 0)) {
+        const resolved = await resolveMegaboxNearestTheater({
+            keyword,
+            latitude,
+            longitude,
+            areaCode,
+            playDate,
+            timeout: timeoutMs,
+        }, {
+            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            timeout: timeoutMs,
+        });
+        theaterId = resolved.theater?.theaterId;
+        resolvedTheater = resolved.theater;
+        resolvedLocation = resolved.location;
+    }
+    const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
     const { showtimes } = await fetchMegaboxBookingList({
         playDate,
         theaterId,
         movieId,
-        areaCode,
+        areaCode: resolvedAreaCode,
         timeout: timeoutMs,
     });
     const filteredShowtimes = showtimes
@@ -27,9 +48,13 @@ async function getRemainingSeats(args) {
         filters: {
             theaterId: theaterId || null,
             movieId: movieId || null,
-            areaCode,
+            keyword: keyword || null,
+            latitude: typeof latitude === 'number' ? latitude : null,
+            longitude: typeof longitude === 'number' ? longitude : null,
+            areaCode: resolvedAreaCode,
             limit,
         },
+        resolvedTheater,
         count: filteredShowtimes.length,
         seats: filteredShowtimes,
     };
@@ -47,6 +72,9 @@ export function createGetRemainingSeatsTool() {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
                 movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
                 limit: z.number().optional().default(50).describe('반환할 최대 회차 수 (기본값: 50)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),

package/dist/services/megabox/tools/listNowShowing.js

@@ -3,13 +3,34 @@
  */
 import * as z from 'zod';
 import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+import { resolveMegaboxNearestTheater } from '../location.js';
 async function listNowShowing(args) {
-    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', timeoutMs = 15000, } = args;
+    const { playDate = toYyyymmdd(), theaterId: inputTheaterId, movieId, keyword, latitude, longitude, areaCode, timeoutMs = 15000, } = args;
+    let theaterId = inputTheaterId;
+    let resolvedTheater = null;
+    let resolvedLocation = null;
+    if (!theaterId && (typeof latitude === 'number' || typeof longitude === 'number' || (keyword || '').trim().length > 0)) {
+        const resolved = await resolveMegaboxNearestTheater({
+            keyword,
+            latitude,
+            longitude,
+            areaCode,
+            playDate,
+            timeout: timeoutMs,
+        }, {
+            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            timeout: timeoutMs,
+        });
+        theaterId = resolved.theater?.theaterId;
+        resolvedTheater = resolved.theater;
+        resolvedLocation = resolved.location;
+    }
+    const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
     const { theaters, movies, showtimes } = await fetchMegaboxBookingList({
         playDate,
         theaterId,
         movieId,
-        areaCode,
+        areaCode: resolvedAreaCode,
         timeout: timeoutMs,
     });
     const result = {
@@ -17,8 +38,12 @@ async function listNowShowing(args) {
         filters: {
             theaterId: theaterId || null,
             movieId: movieId || null,
-            areaCode,
+            keyword: keyword || null,
+            latitude: typeof latitude === 'number' ? latitude : null,
+            longitude: typeof longitude === 'number' ? longitude : null,
+            areaCode: resolvedAreaCode,
         },
+        resolvedTheater,
         counts: {
             theaters: theaters.length,
             movies: movies.length,
@@ -42,6 +67,9 @@ export function createListNowShowingTool() {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
                 movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },

package/dist/services/oliveyoung/api.js

@@ -5,4 +5,6 @@ export const OLIVEYOUNG_API = {
     BASE_URL: 'https://www.oliveyoung.co.kr',
     STORE_FINDER_PATH: '/oystore/api/storeFinder/find-store',
     PRODUCT_SEARCH_PATH: '/oystore/api/stock/product-search-v3',
+    STOCK_GOODS_INFO_PATH: '/oystore/api/stock/stock-goods-info-v3',
+    STOCK_STORES_PATH: '/oystore/api/stock/stock-stores',
 };

package/dist/services/oliveyoung/client.js

@@ -5,6 +5,88 @@
  */
 import { OLIVEYOUNG_API } from './api.js';
 import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+const OLIVEYOUNG_IMAGE_HOST = 'https://image.oliveyoung.co.kr';
+const OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS = 10 * 60 * 1000;
+const OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS = 30 * 60 * 1000;
+const oliveyoungProductIdCache = new Map();
+const oliveyoungProductSearchCache = new Map();
+const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
+function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
+    return o2oStockFlag || o2oRemainQuantity > 0;
+}
+function resolveOliveyoungImageUrl(imagePath) {
+    if (!imagePath) {
+        return undefined;
+    }
+    if (/^https?:\/\//i.test(imagePath)) {
+        return imagePath;
+    }
+    if (imagePath.startsWith('//')) {
+        return `https:${imagePath}`;
+    }
+    const normalizedPath = imagePath.startsWith('/') ? imagePath : `/${imagePath}`;
+    if (normalizedPath.startsWith(`${OLIVEYOUNG_IMAGE_PATH_PREFIX}/`)) {
+        return `${OLIVEYOUNG_IMAGE_HOST}${normalizedPath}`;
+    }
+    return `${OLIVEYOUNG_IMAGE_HOST}${OLIVEYOUNG_IMAGE_PATH_PREFIX}${normalizedPath}`;
+}
+function resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity) {
+    return Math.max(remainQuantity, o2oRemainQuantity);
+}
+function resolveOliveyoungStoreStock(rawStore) {
+    const remainQuantity = rawStore?.remainQuantity || 0;
+    const o2oRemainQuantity = rawStore?.o2oRemainQuantity || 0;
+    const quantity = resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity);
+    const salesStoreYn = Boolean(rawStore?.salesStoreYn);
+    let stockStatus = 'out_of_stock';
+    let stockLabel = '품절';
+    if (!salesStoreYn) {
+        stockStatus = 'not_sold';
+        stockLabel = '미판매';
+    }
+    else if (quantity > 0) {
+        stockStatus = 'in_stock';
+        stockLabel = quantity >= 9 ? '재고 9개 이상' : `재고 ${quantity}개`;
+    }
+    return {
+        storeCode: rawStore?.storeCode || '',
+        storeName: rawStore?.storeName || '',
+        address: rawStore?.address || '',
+        latitude: rawStore?.latitude || 0,
+        longitude: rawStore?.longitude || 0,
+        distance: rawStore?.distance || 0,
+        pickupYn: Boolean(rawStore?.pickupYn),
+        salesStoreYn,
+        remainQuantity,
+        o2oRemainQuantity,
+        stockStatus,
+        stockLabel,
+        openYn: Boolean(rawStore?.openYn),
+    };
+}
+function createOliveyoungProductSearchCacheKey(params) {
+    return JSON.stringify([params.keyword, params.page, params.size, params.sort, params.includeSoldOut]);
+}
+function cloneOliveyoungProductSearchResult(result) {
+    return {
+        totalCount: result.totalCount,
+        nextPage: result.nextPage,
+        products: result.products.map((product) => ({ ...product })),
+    };
+}
+function readStaleOliveyoungProductSearchResult(cacheKey) {
+    const cached = oliveyoungProductSearchCache.get(cacheKey);
+    if (!cached || cached.expiresAt <= Date.now()) {
+        return null;
+    }
+    return cloneOliveyoungProductSearchResult(cached.result);
+}
+function writeStaleOliveyoungProductSearchResult(cacheKey, result) {
+    oliveyoungProductSearchCache.set(cacheKey, {
+        expiresAt: Date.now() + OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS,
+        result: cloneOliveyoungProductSearchResult(result),
+    });
+}
 async function zyteExtract(targetPath, requestBody, options = {}) {
     const { timeout = 15000, apiKey } = options;
     try {
@@ -71,20 +153,150 @@ export async function fetchOliveyoungProducts(params, options = {}) {
         sort: params.sort,
         size: params.size,
     };
-    const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
-    const list = body.data?.serachList || body.data?.searchList || [];
-    const products = list.map((product) => ({
-        goodsNumber: product.goodsNumber || '',
-        goodsName: product.goodsName || '',
-        priceToPay: product.priceToPay || 0,
-        originalPrice: product.originalPrice || 0,
-        discountRate: product.discountRate || 0,
-        o2oStockFlag: Boolean(product.o2oStockFlag),
-        o2oRemainQuantity: product.o2oRemainQuantity || 0,
-    }));
+    const cacheKey = createOliveyoungProductSearchCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
+        const list = body.data?.serachList || body.data?.searchList || [];
+        const products = list.map((product) => {
+            const o2oStockFlag = Boolean(product.o2oStockFlag);
+            const o2oRemainQuantity = product.o2oRemainQuantity || 0;
+            const inStock = resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity);
+            const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
+            const stockSource = 'global_search';
+            return {
+                goodsNumber: product.goodsNumber || '',
+                goodsName: product.goodsName || '',
+                imageUrl: resolveOliveyoungImageUrl(product.imagePath),
+                priceToPay: product.priceToPay || 0,
+                originalPrice: product.originalPrice || 0,
+                discountRate: product.discountRate || 0,
+                o2oStockFlag,
+                o2oRemainQuantity,
+                inStock,
+                stockStatus,
+                stockSource,
+            };
+        });
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            nextPage: Boolean(body.data?.nextPage),
+            products,
+        };
+        writeStaleOliveyoungProductSearchResult(cacheKey, result);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleOliveyoungProductSearchResult(cacheKey);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
+}
+async function fetchOliveyoungProductId(goodsNumber, options = {}) {
+    const normalizedGoodsNumber = goodsNumber.trim();
+    if (!normalizedGoodsNumber) {
+        return '';
+    }
+    const cached = oliveyoungProductIdCache.get(normalizedGoodsNumber);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+        return cached.productId;
+    }
+    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: normalizedGoodsNumber }, options);
+    const productId = body.data?.goodsInfo?.masterGoodsNumber || '';
+    if (productId) {
+        oliveyoungProductIdCache.set(normalizedGoodsNumber, {
+            expiresAt: now + OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS,
+            productId,
+        });
+    }
+    return productId;
+}
+async function fetchOliveyoungStockStores(params, options = {}) {
+    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+        productId: params.productId,
+        lat: params.latitude,
+        lon: params.longitude,
+        pageIdx: params.pageIdx,
+        searchWords: params.searchWords,
+        mapLat: params.latitude,
+        mapLon: params.longitude,
+    }, options);
+    const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
+    const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
+    const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
     return {
         totalCount: body.data?.totalCount || 0,
-        nextPage: Boolean(body.data?.nextPage),
-        products,
+        inStockCount,
+        outOfStockCount: stores.length - inStockCount - notSoldCount,
+        notSoldCount,
+        stores,
     };
 }
+function sortOliveyoungProducts(products) {
+    const score = (product) => {
+        if (product.stockSource === 'nearby_store') {
+            return product.inStock ? 4 : 3;
+        }
+        return product.inStock ? 2 : 1;
+    };
+    return [...products].sort((left, right) => score(right) - score(left));
+}
+export async function enrichOliveyoungProductsWithNearbyStoreInventory(products, params, options = {}) {
+    const maxProducts = Math.max(0, Math.min(products.length, params.maxProducts));
+    if (maxProducts === 0) {
+        return { checkedCount: 0, products };
+    }
+    const checkedProducts = await Promise.all(products.slice(0, maxProducts).map(async (product) => {
+        let productId = '';
+        try {
+            productId = await fetchOliveyoungProductId(product.goodsNumber, options);
+        }
+        catch {
+            return { checked: false, product };
+        }
+        if (!productId) {
+            return { checked: false, product };
+        }
+        let storeInventory;
+        try {
+            storeInventory = await fetchOliveyoungStockStores({
+                productId,
+                latitude: params.latitude,
+                longitude: params.longitude,
+                pageIdx: 1,
+                searchWords: params.storeKeyword,
+            }, options);
+        }
+        catch {
+            return { checked: false, product };
+        }
+        const inStock = storeInventory.inStockCount > 0;
+        const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
+        const stockSource = 'nearby_store';
+        return {
+            checked: true,
+            product: {
+                ...product,
+                inStock,
+                stockStatus,
+                stockSource,
+                storeInventory,
+            },
+        };
+    }));
+    const enrichedProducts = [
+        ...checkedProducts.map((result) => result.product),
+        ...products.slice(maxProducts),
+    ];
+    const checkedCount = checkedProducts.filter((result) => result.checked).length;
+    return {
+        checkedCount,
+        products: sortOliveyoungProducts(enrichedProducts),
+    };
+}
+export function __testOnlyClearOliveyoungCaches() {
+    oliveyoungProductIdCache.clear();
+    oliveyoungProductSearchCache.clear();
+}