daiso 1.0.4 → 1.0.6

package/dist/api/actionsProxy.js

@@ -0,0 +1,82 @@
+/**
+ * OpenAI Actions용 공통 GET 프록시 정의
+ */
+export const ACTION_QUERY_DEFINITIONS = [
+    { action: 'daisoSearchProducts', summary: '다이소 제품 검색', targetPath: '/api/daiso/products' },
+    { action: 'daisoGetProduct', summary: '다이소 제품 상세 조회', targetPath: '/api/daiso/products/:productId', pathParam: 'productId' },
+    { action: 'daisoFindStores', summary: '다이소 매장 검색', targetPath: '/api/daiso/stores' },
+    { action: 'daisoCheckInventory', summary: '다이소 재고 조회', targetPath: '/api/daiso/inventory' },
+    { action: 'daisoGetDisplayLocation', summary: '다이소 진열 위치 조회', targetPath: '/api/daiso/display-location' },
+    { action: 'oliveyoungSearchProducts', summary: '올리브영 상품 검색', targetPath: '/api/oliveyoung/products' },
+    { action: 'oliveyoungFindStores', summary: '올리브영 매장 검색', targetPath: '/api/oliveyoung/stores' },
+    { action: 'oliveyoungCheckInventory', summary: '올리브영 재고 조회', targetPath: '/api/oliveyoung/inventory' },
+    { action: 'cuFindStores', summary: 'CU 매장 검색', targetPath: '/api/cu/stores' },
+    { action: 'cuCheckInventory', summary: 'CU 재고 조회', targetPath: '/api/cu/inventory' },
+    { action: 'emart24FindStores', summary: '이마트24 매장 검색', targetPath: '/api/emart24/stores' },
+    { action: 'emart24SearchProducts', summary: '이마트24 상품 검색', targetPath: '/api/emart24/products' },
+    { action: 'emart24CheckInventory', summary: '이마트24 재고 조회', targetPath: '/api/emart24/inventory' },
+    { action: 'lottemartFindStores', summary: '롯데마트 매장 검색', targetPath: '/api/lottemart/stores' },
+    { action: 'lottemartSearchProducts', summary: '롯데마트 상품 검색', targetPath: '/api/lottemart/products' },
+    { action: 'gs25FindStores', summary: 'GS25 매장 검색', targetPath: '/api/gs25/stores' },
+    { action: 'gs25SearchProducts', summary: 'GS25 상품 검색', targetPath: '/api/gs25/products' },
+    { action: 'gs25CheckInventory', summary: 'GS25 재고 조회', targetPath: '/api/gs25/inventory' },
+    { action: 'sevenelevenSearchProducts', summary: '세븐일레븐 상품 검색', targetPath: '/api/seveneleven/products' },
+    { action: 'sevenelevenSearchStores', summary: '세븐일레븐 매장 검색', targetPath: '/api/seveneleven/stores' },
+    { action: 'sevenelevenCheckInventory', summary: '세븐일레븐 재고 조회', targetPath: '/api/seveneleven/inventory' },
+    { action: 'sevenelevenGetPopwords', summary: '세븐일레븐 인기 검색어 조회', targetPath: '/api/seveneleven/popwords' },
+    { action: 'sevenelevenGetCatalog', summary: '세븐일레븐 카탈로그 조회', targetPath: '/api/seveneleven/catalog' },
+    { action: 'megaboxFindTheaters', summary: '메가박스 지점 검색', targetPath: '/api/megabox/theaters' },
+    { action: 'megaboxListMovies', summary: '메가박스 영화 목록 조회', targetPath: '/api/megabox/movies' },
+    { action: 'megaboxGetSeats', summary: '메가박스 잔여 좌석 조회', targetPath: '/api/megabox/seats' },
+    { action: 'lottecinemaFindTheaters', summary: '롯데시네마 지점 검색', targetPath: '/api/lottecinema/theaters' },
+    { action: 'lottecinemaListMovies', summary: '롯데시네마 영화 목록 조회', targetPath: '/api/lottecinema/movies' },
+    { action: 'lottecinemaGetSeats', summary: '롯데시네마 잔여 좌석 조회', targetPath: '/api/lottecinema/seats' },
+    { action: 'cgvFindTheaters', summary: 'CGV 극장 검색', targetPath: '/api/cgv/theaters' },
+    { action: 'cgvSearchMovies', summary: 'CGV 영화 목록 조회', targetPath: '/api/cgv/movies' },
+    { action: 'cgvGetTimetable', summary: 'CGV 시간표 조회', targetPath: '/api/cgv/timetable' },
+];
+const ACTION_QUERY_MAP = new Map(ACTION_QUERY_DEFINITIONS.map((definition) => [definition.action, definition]));
+export const ACTION_QUERY_ACTIONS = ACTION_QUERY_DEFINITIONS.map((definition) => definition.action);
+function toAbsoluteUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return new URL(value, 'https://actions-proxy.local');
+    }
+}
+export function getActionQueryDefinition(action) {
+    return ACTION_QUERY_MAP.get(action);
+}
+export function buildActionQueryTargetUrl(requestUrl) {
+    const sourceUrl = toAbsoluteUrl(requestUrl);
+    const action = (sourceUrl.searchParams.get('action') || '').trim();
+    if (action.length === 0) {
+        throw new Error('action 파라미터를 입력해주세요.');
+    }
+    const definition = getActionQueryDefinition(action);
+    if (!definition) {
+        throw new Error(`지원하지 않는 action 입니다: ${action}`);
+    }
+    let pathname = definition.targetPath;
+    const consumedParams = new Set(['action']);
+    if (definition.pathParam) {
+        const pathValue = (sourceUrl.searchParams.get(definition.pathParam) || '').trim();
+        if (pathValue.length === 0) {
+            throw new Error(`${definition.pathParam} 파라미터를 입력해주세요.`);
+        }
+        pathname = pathname.replace(`:${definition.pathParam}`, encodeURIComponent(pathValue));
+        consumedParams.add(definition.pathParam);
+    }
+    const targetUrl = new URL(pathname, sourceUrl.origin);
+    for (const [key, value] of sourceUrl.searchParams.entries()) {
+        if (consumedParams.has(key)) {
+            continue;
+        }
+        targetUrl.searchParams.append(key, value);
+    }
+    return targetUrl;
+}
+export function createActionQueryDescriptionList() {
+    return ACTION_QUERY_DEFINITIONS.map((definition) => `- \`${definition.action}\`: ${definition.summary}`).join('\n');
+}

package/dist/api/cgvHandlers.js

@@ -2,8 +2,16 @@
  * CGV GET API 핸들러
  */
 import { fetchCgvMovies, fetchCgvTheaters, fetchCgvTimetable, toYyyymmdd } from '../services/cgv/client.js';
+import { fetchCgvNearbyTheaters, resolveCgvNearestTheater } from '../services/cgv/location.js';
 import { filterAndSortTimetable } from '../services/cgv/timetable.js';
 import { errorResponse, successResponse } from './response.js';
+function parseOptionalNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 /**
  * CGV 극장 목록 조회 API 핸들러
  * GET /api/cgv/theaters?playDate={YYYYMMDD}&regionCode={지역코드}
@@ -11,9 +19,28 @@ import { errorResponse, successResponse } from './response.js';
 export async function handleCgvFindTheaters(c) {
     const playDate = c.req.query('playDate') || toYyyymmdd();
     const regionCode = c.req.query('regionCode') || undefined;
+    const keyword = c.req.query('keyword') || undefined;
+    const latitude = parseOptionalNumber(c.req.query('lat'));
+    const longitude = parseOptionalNumber(c.req.query('lng'));
     const limit = parseInt(c.req.query('limit') || '30');
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
+        if (keyword || typeof latitude === 'number' || typeof longitude === 'number') {
+            const result = await fetchCgvNearbyTheaters({
+                playDate,
+                regionCode,
+                keyword,
+                latitude,
+                longitude,
+                limit,
+                timeout: timeoutMs,
+            }, {
+                timeout: timeoutMs,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+                googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+            });
+            return successResponse(c, result, { total: result.count, pageSize: limit });
+        }
         const theaters = await fetchCgvTheaters({
             playDate,
             regionCode,
@@ -25,6 +52,9 @@ export async function handleCgvFindTheaters(c) {
             playDate,
             filters: {
                 regionCode: regionCode || null,
+                keyword: keyword || null,
+                latitude: latitude ?? null,
+                longitude: longitude ?? null,
             },
             theaters: sliced,
         }, { total: sliced.length, pageSize: limit });
@@ -40,20 +70,46 @@ export async function handleCgvFindTheaters(c) {
  */
 export async function handleCgvSearchMovies(c) {
     const playDate = c.req.query('playDate') || toYyyymmdd();
-    const theaterCode = c.req.query('theaterCode') || undefined;
+    let theaterCode = c.req.query('theaterCode') || undefined;
+    const keyword = c.req.query('keyword') || undefined;
+    const latitude = parseOptionalNumber(c.req.query('lat'));
+    const longitude = parseOptionalNumber(c.req.query('lng'));
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
-        const movies = await fetchCgvMovies({
-            playDate,
-            theaterCode,
-            timeout: timeoutMs,
-            zyteApiKey: c.env?.ZYTE_API_KEY,
-        });
+        let resolvedTheater = null;
+        if (!theaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+            const resolved = await resolveCgvNearestTheater({
+                playDate,
+                keyword,
+                latitude,
+                longitude,
+                timeout: timeoutMs,
+            }, {
+                timeout: timeoutMs,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+                googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+            });
+            resolvedTheater = resolved.theater;
+            theaterCode = resolved.theater?.theaterCode;
+        }
+        const shouldReturnEmpty = !theaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+        const movies = shouldReturnEmpty
+            ? []
+            : await fetchCgvMovies({
+                playDate,
+                theaterCode,
+                timeout: timeoutMs,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+            });
         return successResponse(c, {
             playDate,
             filters: {
                 theaterCode: theaterCode || null,
+                keyword: keyword || null,
+                latitude: latitude ?? null,
+                longitude: longitude ?? null,
             },
+            resolvedTheater,
             movies,
         }, { total: movies.length });
     }
@@ -68,25 +124,56 @@ export async function handleCgvSearchMovies(c) {
  */
 export async function handleCgvGetTimetable(c) {
     const playDate = c.req.query('playDate') || toYyyymmdd();
-    const theaterCode = c.req.query('theaterCode') || undefined;
+    let theaterCode = c.req.query('theaterCode') || undefined;
     const movieCode = c.req.query('movieCode') || undefined;
+    const keyword = c.req.query('keyword') || undefined;
+    const latitude = parseOptionalNumber(c.req.query('lat'));
+    const longitude = parseOptionalNumber(c.req.query('lng'));
     const limit = parseInt(c.req.query('limit') || '50');
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
-        const timetable = await fetchCgvTimetable({
-            playDate,
-            theaterCode,
-            movieCode,
-            timeout: timeoutMs,
-            zyteApiKey: c.env?.ZYTE_API_KEY,
-        });
-        const filtered = filterAndSortTimetable(timetable, { theaterCode, movieCode, limit });
+        let resolvedTheater = null;
+        if (!theaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+            const resolved = await resolveCgvNearestTheater({
+                playDate,
+                keyword,
+                latitude,
+                longitude,
+                timeout: timeoutMs,
+            }, {
+                timeout: timeoutMs,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+                googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+            });
+            resolvedTheater = resolved.theater;
+            theaterCode = resolved.theater?.theaterCode;
+        }
+        const shouldReturnEmpty = !theaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+        const timetable = shouldReturnEmpty
+            ? []
+            : await fetchCgvTimetable({
+                playDate,
+                theaterCode,
+                movieCode,
+                timeout: timeoutMs,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+            });
+        const exactFiltered = filterAndSortTimetable(timetable, { theaterCode, movieCode, limit });
+        const filterRelaxed = Boolean(movieCode && exactFiltered.length === 0 && timetable.length > 0);
+        const filtered = filterRelaxed
+            ? filterAndSortTimetable(timetable, { theaterCode, limit })
+            : exactFiltered;
         return successResponse(c, {
             playDate,
             filters: {
                 theaterCode: theaterCode || null,
                 movieCode: movieCode || null,
+                keyword: keyword || null,
+                latitude: latitude ?? null,
+                longitude: longitude ?? null,
             },
+            resolvedTheater,
+            filterRelaxed,
             timetable: filtered,
         }, { total: filtered.length, pageSize: limit });
     }

package/dist/api/configStatus.js

@@ -0,0 +1,19 @@
+function isConfigured(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function buildConfigStatus(bindings) {
+    return {
+        googleMapsApiKey: {
+            configured: isConfigured(bindings?.GOOGLE_MAPS_API_KEY),
+            usedBy: ['gs25', 'cu', 'lottemart', 'megabox', 'lottecinema', 'cgv'],
+        },
+        zyteApiKey: {
+            configured: isConfigured(bindings?.ZYTE_API_KEY),
+            usedBy: ['oliveyoung', 'lottemart', 'cgv'],
+        },
+        healthCheckSecret: {
+            configured: isConfigured(bindings?.HEALTH_CHECK_SECRET),
+            usedBy: ['health-checks'],
+        },
+    };
+}

package/dist/api/daisoHandlers.js

@@ -0,0 +1,127 @@
+/**
+ * 다이소 GET API 핸들러
+ */
+import { getImageUrl } from '../services/daiso/api.js';
+import { toProductSummary } from '../services/daiso/product.js';
+import { fetchOnlineStock, fetchStoreInventory } from '../services/daiso/tools/checkInventory.js';
+import { fetchDisplayLocation } from '../services/daiso/tools/getDisplayLocation.js';
+import { fetchProductById } from '../services/daiso/tools/getPriceInfo.js';
+import { fetchStores } from '../services/daiso/tools/findStores.js';
+import { fetchProducts } from '../services/daiso/tools/searchProducts.js';
+import { errorResponse, successResponse } from './response.js';
+export async function handleSearchProducts(c) {
+    const query = c.req.query('q');
+    const page = parseInt(c.req.query('page') || '1');
+    const pageSize = parseInt(c.req.query('pageSize') || '30');
+    if (!query || query.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '검색어(q)를 입력해주세요.');
+    }
+    try {
+        const { products, totalCount } = await fetchProducts(query, page, pageSize);
+        return successResponse(c, { products }, { total: totalCount, page, pageSize });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'SEARCH_FAILED', message, 500);
+    }
+}
+export async function handleGetProduct(c) {
+    const productId = c.req.param('id');
+    if (!productId) {
+        return errorResponse(c, 'MISSING_ID', '제품 ID가 필요합니다.');
+    }
+    try {
+        const product = await fetchProductById(productId);
+        if (!product) {
+            return errorResponse(c, 'NOT_FOUND', '제품을 찾을 수 없습니다.', 404);
+        }
+        const result = {
+            id: product.PD_NO,
+            name: product.PDNM || product.EXH_PD_NM,
+            price: parseInt(product.PD_PRC) || 0,
+            currency: 'KRW',
+            imageUrl: getImageUrl(product.ATCH_FILE_URL),
+            brand: product.BRND_NM || undefined,
+            soldOut: product.SOLD_OUT_YN === 'Y',
+            isNew: product.NEW_PD_YN === 'Y',
+        };
+        return successResponse(c, result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'FETCH_FAILED', message, 500);
+    }
+}
+export async function handleFindStores(c) {
+    const keyword = c.req.query('keyword');
+    const sido = c.req.query('sido');
+    const gugun = c.req.query('gugun');
+    const dong = c.req.query('dong');
+    const limit = parseInt(c.req.query('limit') || '50');
+    if (!keyword && !sido) {
+        return errorResponse(c, 'MISSING_PARAMS', '검색어(keyword) 또는 지역(sido)을 입력해주세요.');
+    }
+    try {
+        const stores = await fetchStores(keyword, sido, gugun, dong);
+        const limitedStores = stores.slice(0, limit);
+        return successResponse(c, { stores: limitedStores }, { total: stores.length });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'SEARCH_FAILED', message, 500);
+    }
+}
+export async function handleCheckInventory(c) {
+    const productId = c.req.query('productId');
+    const lat = parseFloat(c.req.query('lat') || '37.5665');
+    const lng = parseFloat(c.req.query('lng') || '126.978');
+    const keyword = c.req.query('keyword') || '';
+    const page = parseInt(c.req.query('page') || '1');
+    const pageSize = parseInt(c.req.query('pageSize') || '30');
+    if (!productId) {
+        return errorResponse(c, 'MISSING_PRODUCT_ID', '제품 ID(productId)를 입력해주세요.');
+    }
+    try {
+        const [onlineStock, storeResult, productDoc] = await Promise.all([
+            fetchOnlineStock(productId),
+            fetchStoreInventory(productId, lat, lng, page, pageSize, keyword),
+            fetchProductById(productId).catch(() => null),
+        ]);
+        const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
+        const product = productDoc ? toProductSummary(productDoc) : undefined;
+        const result = {
+            productId,
+            product,
+            location: { latitude: lat, longitude: lng },
+            onlineStock,
+            storeInventory: {
+                totalStores: storeResult.totalCount,
+                inStockCount: inStockStores.length,
+                stores: storeResult.stores,
+            },
+        };
+        return successResponse(c, result, { total: storeResult.totalCount, page, pageSize });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'INVENTORY_CHECK_FAILED', message, 500);
+    }
+}
+export async function handleGetDisplayLocation(c) {
+    const productId = c.req.query('productId')?.trim();
+    const storeCode = c.req.query('storeCode')?.trim();
+    if (!productId || productId.length === 0) {
+        return errorResponse(c, 'MISSING_PRODUCT_ID', '상품 ID(productId)를 입력해주세요.');
+    }
+    if (!storeCode || storeCode.length === 0) {
+        return errorResponse(c, 'MISSING_STORE_CODE', '매장 코드(storeCode)를 입력해주세요.');
+    }
+    try {
+        const result = await fetchDisplayLocation(productId, storeCode);
+        return successResponse(c, result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'DISPLAY_LOCATION_FAILED', message, 500);
+    }
+}

package/dist/api/emart24Handlers.js

@@ -0,0 +1,176 @@
+/**
+ * 이마트24 GET API 핸들러
+ */
+import { errorResponse, successResponse } from './response.js';
+import { calculateDistanceM, fetchEmart24Stores, searchEmart24Products } from '../services/emart24/client.js';
+import { lookupEmart24Inventory } from '../services/emart24/inventoryLookup.js';
+/**
+ * 이마트24 매장 검색 API 핸들러
+ * GET /api/emart24/stores?keyword={키워드}&lat={위도}&lng={경도}
+ */
+export async function handleEmart24FindStores(c) {
+    const keyword = c.req.query('keyword') || '';
+    const area1 = c.req.query('area1') || '';
+    const area2 = c.req.query('area2') || '';
+    const service24h = c.req.query('service24h') === 'true';
+    const page = parseInt(c.req.query('page') || '1', 10);
+    const limit = parseInt(c.req.query('limit') || '20', 10);
+    const rawLat = c.req.query('lat');
+    const rawLng = c.req.query('lng');
+    const parsedLat = rawLat ? parseFloat(rawLat) : undefined;
+    const parsedLng = rawLng ? parseFloat(rawLng) : undefined;
+    const lat = typeof parsedLat === 'number' && Number.isFinite(parsedLat) ? parsedLat : undefined;
+    const lng = typeof parsedLng === 'number' && Number.isFinite(parsedLng) ? parsedLng : undefined;
+    try {
+        const result = await fetchEmart24Stores({
+            keyword,
+            area1,
+            area2,
+            page,
+            service24h,
+        }, {
+            timeout: 15000,
+        });
+        const stores = result.stores
+            .map((store) => {
+            if (typeof lat !== 'number' || typeof lng !== 'number' || store.latitude === 0 || store.longitude === 0) {
+                return store;
+            }
+            return {
+                ...store,
+                distanceM: calculateDistanceM(lat, lng, store.latitude, store.longitude),
+            };
+        })
+            .sort((a, b) => (a.distanceM ?? Number.MAX_SAFE_INTEGER) - (b.distanceM ?? Number.MAX_SAFE_INTEGER))
+            .slice(0, limit);
+        return successResponse(c, {
+            location: typeof lat === 'number' && typeof lng === 'number' ? { latitude: lat, longitude: lng } : null,
+            keyword,
+            appliedKeyword: result.appliedKeyword,
+            area1,
+            area2,
+            service24h,
+            stores,
+        }, {
+            total: result.totalCount,
+            page,
+            pageSize: limit,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'EMART24_STORE_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 이마트24 상품 검색 API 핸들러
+ * GET /api/emart24/products?keyword={검색어}
+ */
+export async function handleEmart24SearchProducts(c) {
+    const keyword = c.req.query('keyword') || '';
+    const page = parseInt(c.req.query('page') || '1', 10);
+    const pageSize = parseInt(c.req.query('pageSize') || '10', 10);
+    const sortType = c.req.query('sortType') || 'SALE';
+    const saleProductYn = c.req.query('saleProductYn') || 'N';
+    if (keyword.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '검색어(keyword)를 입력해주세요.');
+    }
+    try {
+        const result = await searchEmart24Products({
+            keyword,
+            page,
+            pageSize,
+            sortType,
+            saleProductYn,
+        }, {
+            timeout: 15000,
+        });
+        return successResponse(c, {
+            keyword,
+            sortType,
+            saleProductYn,
+            products: result.products,
+        }, {
+            total: result.totalCount,
+            page,
+            pageSize,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'EMART24_PRODUCT_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 이마트24 재고 조회 API 핸들러
+ * GET /api/emart24/inventory?pluCd={PLU코드}&bizNoArr={매장코드들}
+ */
+export async function handleEmart24CheckInventory(c) {
+    const pluCd = c.req.query('pluCd') || '';
+    const keyword = c.req.query('keyword') || '';
+    const bizNoArr = c.req.query('bizNoArr') || c.req.query('storeCodeArr') || '';
+    const storeCode = c.req.query('storeCode') || '';
+    const storeKeyword = c.req.query('storeKeyword') || '';
+    const area1 = c.req.query('area1') || '';
+    const area2 = c.req.query('area2') || '';
+    const service24h = c.req.query('service24h') === 'true';
+    const productPage = parseInt(c.req.query('page') || '1', 10);
+    const productPageSize = parseInt(c.req.query('pageSize') || '10', 10);
+    const storeLimit = parseInt(c.req.query('storeLimit') || '10', 10);
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000', 10);
+    const rawLat = c.req.query('lat');
+    const rawLng = c.req.query('lng');
+    const parsedLat = rawLat ? parseFloat(rawLat) : undefined;
+    const parsedLng = rawLng ? parseFloat(rawLng) : undefined;
+    const lat = typeof parsedLat === 'number' && Number.isFinite(parsedLat) ? parsedLat : undefined;
+    const lng = typeof parsedLng === 'number' && Number.isFinite(parsedLng) ? parsedLng : undefined;
+    if (pluCd.trim().length === 0 && keyword.trim().length === 0) {
+        return errorResponse(c, 'MISSING_PLU_CD', '상품 PLU 코드(pluCd) 또는 검색어(keyword)를 입력해주세요.');
+    }
+    const bizNos = bizNoArr
+        .split(',')
+        .map((value) => value.trim())
+        .concat(storeCode.trim().length > 0 ? [storeCode.trim()] : [])
+        .filter((value, index, array) => value.length > 0 && array.indexOf(value) === index);
+    const hasStoreFilters = storeKeyword.trim().length > 0 ||
+        area1.trim().length > 0 ||
+        area2.trim().length > 0 ||
+        typeof lat === 'number' ||
+        typeof lng === 'number';
+    if (bizNos.length === 0 && !hasStoreFilters) {
+        return errorResponse(c, 'MISSING_BIZ_NO_ARR', '매장 코드 목록(bizNoArr) 또는 매장 검색 조건(storeKeyword/area1/area2/lat/lng)을 입력해주세요.');
+    }
+    try {
+        const result = await lookupEmart24Inventory({
+            pluCd,
+            keyword,
+            latitude: lat,
+            longitude: lng,
+            storeKeyword,
+            area1,
+            area2,
+            service24h,
+            productPage,
+            productPageSize,
+            storeLimit,
+            timeoutMs,
+            bizNos,
+            includeRequestedStoresWithoutQty: bizNos.length > 0,
+        });
+        return successResponse(c, {
+            keyword: result.keyword,
+            pluCd: result.pluCd,
+            productCandidates: result.productCandidates,
+            location: result.location,
+            storeFilters: result.storeFilters,
+            nearbyStores: result.nearbyStores,
+            goodsInfo: result.inventory.goodsInfo,
+            count: result.inventory.count,
+            stores: result.inventory.stores,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'EMART24_INVENTORY_CHECK_FAILED', message, 500);
+    }
+}