daiso 1.0.3 → 1.0.5

package/dist/services/lottecinema/location.js

@@ -0,0 +1,191 @@
+/**
+ * 롯데시네마 위치 해석 및 근처 극장 조회 보조 모듈
+ */
+import { fetchJson } from '../../utils/http.js';
+import { fetchLotteCinemaTicketingPage } from './client.js';
+const DEFAULT_TIMEOUT_MS = 15000;
+const GEOCODE_CACHE_TTL_MS = 60 * 60 * 1000;
+const LOCATION_STOPWORDS = new Set([
+    '롯데시네마',
+    '영화',
+    '극장',
+    '주변',
+    '근처',
+    '오늘',
+    '상영',
+    '영화목록',
+    '시간표',
+    '좌석',
+    '잔여',
+    '찾아',
+    '주세요',
+]);
+const geocodeCache = new Map();
+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 normalizeText(text) {
+    return text.replace(/\s+/g, '').toLowerCase();
+}
+function extractLocationTokens(...values) {
+    const tokens = new Set();
+    for (const value of values) {
+        const matches = (value || '').match(/[0-9A-Za-z가-힣]+/g) || [];
+        for (const match of matches) {
+            const normalized = normalizeText(match);
+            if (normalized.length < 2 || LOCATION_STOPWORDS.has(normalized)) {
+                continue;
+            }
+            tokens.add(normalized);
+            if (normalized.endsWith('역') && normalized.length > 2) {
+                tokens.add(normalized.slice(0, -1));
+            }
+        }
+    }
+    return [...tokens];
+}
+function scoreTheater(theater, tokens) {
+    const normalizedName = normalizeText(theater.theaterName);
+    const normalizedAddress = normalizeText(theater.address || '');
+    return tokens.reduce((score, token) => {
+        if (normalizedName.includes(token)) {
+            return score + 2;
+        }
+        if (normalizedAddress.includes(token)) {
+            return score + 1;
+        }
+        return score;
+    }, 0);
+}
+async function geocodeAddress(query, options) {
+    const apiKey = (options.googleMapsApiKey || '').trim();
+    const trimmedQuery = query.trim();
+    if (apiKey.length === 0 || trimmedQuery.length === 0) {
+        return null;
+    }
+    const cacheKey = `keyword:${trimmedQuery}`;
+    const cached = geocodeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', trimmedQuery);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout: options.timeout || DEFAULT_TIMEOUT_MS,
+        headers: { Accept: 'application/json' },
+    });
+    const firstResult = body.status === 'OK' ? body.results?.[0] : null;
+    const latitude = firstResult?.geometry?.location?.lat;
+    const longitude = firstResult?.geometry?.location?.lng;
+    const value = typeof latitude === 'number' && typeof longitude === 'number'
+        ? {
+            latitude,
+            longitude,
+            formattedAddress: firstResult?.formatted_address || null,
+        }
+        : null;
+    geocodeCache.set(cacheKey, {
+        expiresAt: Date.now() + GEOCODE_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+export async function resolveLotteCinemaLocation(params, options = {}) {
+    const keyword = (params.keyword || '').trim();
+    const hasCoordinates = isValidCoordinate(params.latitude) && isValidCoordinate(params.longitude);
+    if (hasCoordinates) {
+        return {
+            keyword: keyword.length > 0 ? keyword : null,
+            latitude: params.latitude,
+            longitude: params.longitude,
+            geocodeUsed: false,
+            formattedAddress: null,
+        };
+    }
+    if (keyword.length === 0) {
+        return {
+            keyword: null,
+            latitude: null,
+            longitude: null,
+            geocodeUsed: false,
+            formattedAddress: null,
+        };
+    }
+    const geocoded = await geocodeAddress(keyword, options);
+    return {
+        keyword,
+        latitude: geocoded?.latitude ?? null,
+        longitude: geocoded?.longitude ?? null,
+        geocodeUsed: Boolean(geocoded),
+        formattedAddress: geocoded?.formattedAddress ?? null,
+    };
+}
+export async function fetchLotteCinemaNearbyTheaters(params, options = {}) {
+    const timeout = typeof params.timeout === 'number' ? params.timeout : DEFAULT_TIMEOUT_MS;
+    const limit = typeof params.limit === 'number' ? Math.max(1, params.limit) : 10;
+    const location = await resolveLotteCinemaLocation(params, options);
+    const { theaters } = await fetchLotteCinemaTicketingPage(timeout);
+    let nearby;
+    if (location.latitude !== null && location.longitude !== null) {
+        nearby = theaters
+            .filter((theater) => theater.latitude !== null && theater.longitude !== null)
+            .map((theater) => ({
+            ...theater,
+            distanceKm: Number(calculateDistanceKm(location.latitude, location.longitude, theater.latitude, theater.longitude).toFixed(2)),
+        }))
+            .sort((left, right) => left.distanceKm - right.distanceKm || left.theaterName.localeCompare(right.theaterName))
+            .slice(0, limit);
+    }
+    else {
+        const tokens = extractLocationTokens(location.keyword, location.formattedAddress);
+        nearby = theaters
+            .map((theater) => ({
+            theater,
+            score: scoreTheater(theater, tokens),
+        }))
+            .filter((item) => item.score > 0)
+            .sort((left, right) => right.score - left.score || left.theater.theaterName.localeCompare(right.theater.theaterName))
+            .slice(0, limit)
+            .map((item) => ({
+            ...item.theater,
+            distanceKm: null,
+        }));
+    }
+    return {
+        ...location,
+        playDate: params.playDate,
+        count: nearby.length,
+        theaters: nearby,
+    };
+}
+export async function resolveLotteCinemaNearestTheater(params, options = {}) {
+    const nearby = await fetchLotteCinemaNearbyTheaters({
+        ...params,
+        limit: 1,
+        timeout: params.timeout,
+    }, options);
+    return {
+        location: {
+            keyword: nearby.keyword,
+            latitude: nearby.latitude,
+            longitude: nearby.longitude,
+            geocodeUsed: nearby.geocodeUsed,
+            formattedAddress: nearby.formattedAddress,
+        },
+        theater: nearby.theaters[0] || null,
+    };
+}
+export function __testOnlyClearLotteCinemaLocationCaches() {
+    geocodeCache.clear();
+}

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

@@ -0,0 +1,47 @@
+/**
+ * 롯데시네마 주변 지점 탐색 도구
+ */
+import * as z from 'zod';
+import { toYyyymmdd } from '../client.js';
+import { fetchLotteCinemaNearbyTheaters } from '../location.js';
+async function findNearbyTheaters(args, googleMapsApiKey) {
+    const { keyword, latitude, longitude, playDate = toYyyymmdd(), limit = 10, timeoutMs = 15000 } = args;
+    const hasCoordinates = typeof latitude === 'number' && typeof longitude === 'number';
+    const nearby = await fetchLotteCinemaNearbyTheaters({
+        keyword,
+        latitude: hasCoordinates ? latitude : keyword ? undefined : 37.5665,
+        longitude: hasCoordinates ? longitude : keyword ? undefined : 126.978,
+        playDate,
+        limit,
+        timeout: timeoutMs,
+    }, {
+        timeout: timeoutMs,
+        googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(nearby, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyTheatersTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_find_nearby_theaters',
+        metadata: {
+            title: '롯데시네마 주변 지점 탐색',
+            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, 기본값: 오늘)'),
+                limit: z.number().optional().default(10).describe('반환할 최대 지점 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => findNearbyTheaters(args, googleMapsApiKey)),
+    };
+}

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

@@ -0,0 +1,85 @@
+/**
+ * 롯데시네마 잔여 좌석 조회 도구
+ */
+import * as z from 'zod';
+import { fetchLotteCinemaNowShowing, toYyyymmdd } from '../client.js';
+import { resolveLotteCinemaNearestTheater } from '../location.js';
+async function getRemainingSeats(args, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, keyword, latitude, longitude, limit = 50, timeoutMs = 15000, } = args;
+    let resolvedTheater = null;
+    let targetTheaterId = theaterId;
+    if (!targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveLotteCinemaNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterId = resolved.theater?.theaterId;
+    }
+    const shouldReturnEmpty = !targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const { showtimes } = shouldReturnEmpty
+        ? { showtimes: [] }
+        : await fetchLotteCinemaNowShowing({
+            playDate,
+            theaterId: targetTheaterId,
+            movieId,
+            timeout: timeoutMs,
+        });
+    const seats = showtimes
+        .filter((item) => (targetTheaterId ? item.theaterId === targetTheaterId : true))
+        .filter((item) => (movieId ? item.movieId === movieId : true))
+        .sort((a, b) => {
+        if (a.startTime === b.startTime) {
+            return a.theaterName.localeCompare(b.theaterName);
+        }
+        return a.startTime.localeCompare(b.startTime);
+    })
+        .slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    playDate,
+                    filters: {
+                        theaterId: targetTheaterId || null,
+                        movieId: movieId || null,
+                        keyword: keyword || null,
+                        latitude: latitude ?? null,
+                        longitude: longitude ?? null,
+                        limit,
+                    },
+                    resolvedTheater,
+                    count: seats.length,
+                    seats,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetRemainingSeatsTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_get_remaining_seats',
+        metadata: {
+            title: '롯데시네마 잔여 좌석 조회',
+            description: '영화/지점/날짜 조건으로 롯데시네마 상영 회차별 남은 좌석 수를 조회합니다. 지점 ID가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('롯데시네마 지점 ID (예: 1016)'),
+                movieId: z.string().optional().describe('롯데시네마 대표 영화 코드 (예: 23816)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 잠실역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
+                limit: z.number().optional().default(50).describe('반환할 최대 회차 수 (기본값: 50)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => getRemainingSeats(args, googleMapsApiKey)),
+    };
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 롯데시네마 영화 목록 조회 도구
+ */
+import * as z from 'zod';
+import { fetchLotteCinemaNowShowing, toYyyymmdd } from '../client.js';
+import { resolveLotteCinemaNearestTheater } from '../location.js';
+async function listNowShowing(args, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, keyword, latitude, longitude, timeoutMs = 15000 } = args;
+    let resolvedTheater = null;
+    let targetTheaterId = theaterId;
+    if (!targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveLotteCinemaNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterId = resolved.theater?.theaterId;
+    }
+    const shouldReturnEmpty = !targetTheaterId && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const { theaters, movies, showtimes } = shouldReturnEmpty
+        ? { theaters: [], movies: [], showtimes: [] }
+        : await fetchLotteCinemaNowShowing({
+            playDate,
+            theaterId: targetTheaterId,
+            movieId,
+            timeout: timeoutMs,
+        });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    playDate,
+                    filters: {
+                        theaterId: targetTheaterId || null,
+                        movieId: movieId || null,
+                        keyword: keyword || null,
+                        latitude: latitude ?? null,
+                        longitude: longitude ?? null,
+                    },
+                    resolvedTheater,
+                    counts: {
+                        theaters: theaters.length,
+                        movies: movies.length,
+                        showtimes: showtimes.length,
+                    },
+                    theaters,
+                    movies,
+                    showtimes,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createListNowShowingTool(googleMapsApiKey) {
+    return {
+        name: 'lottecinema_list_now_showing',
+        metadata: {
+            title: '롯데시네마 영화 목록 조회',
+            description: '날짜/지점/영화 조건으로 롯데시네마 영화 및 상영 회차 목록을 조회합니다. 지점 ID가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('롯데시네마 지점 ID (예: 1016)'),
+                movieId: z.string().optional().describe('롯데시네마 대표 영화 코드 (예: 23816)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 잠실역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => listNowShowing(args, googleMapsApiKey)),
+    };
+}

package/dist/services/lottecinema/types.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데시네마 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/lottemart/api.js

@@ -0,0 +1,31 @@
+/**
+ * 롯데마트 모바일 도와센터 엔드포인트
+ */
+export const LOTTEMART_API = {
+    BASE_URL: 'https://company.lottemart.com',
+    ORIGIN_HOST: 'company.lottemart.com',
+    SOCKET_HOST: '210.93.146.57',
+    ORIGIN_REFERER: 'https://company.lottemart.com/mobiledowa/',
+    MARKET_OPTIONS_PATH: '/mobiledowa/inc/asp/search_market_list.asp',
+    STORE_SEARCH_PATH: '/mobiledowa/market/search_shop.asp',
+    PRODUCT_SEARCH_PATH: '/mobiledowa/product/search_product.asp',
+    PRODUCT_PAGE_PATH: '/mobiledowa/inc/asp/search_product_list.asp',
+};
+export const LOTTEMART_AREAS = [
+    '서울',
+    '경기',
+    '인천',
+    '강원',
+    '충북',
+    '충남',
+    '대전',
+    '경북',
+    '경남',
+    '대구',
+    '부산',
+    '울산',
+    '전북',
+    '전남',
+    '광주',
+    '기타',
+];

package/dist/services/lottemart/client.js

@@ -0,0 +1,245 @@
+/**
+ * 롯데마트 모바일 도와센터 클라이언트
+ */
+import { LOTTEMART_API } from './api.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from './config.js';
+import { __testOnlyClearLotteMartGeocodeCache, geocodeLotteMartAddress } from './geocode.js';
+import { __testOnlyClearLotteMartSessionCache, fetchLotteMartHtml, fetchLotteMartPageWithSession, getCachedLotteMartSessionCookie, } from './session.js';
+import { attachDistance, fetchAllStoresForAreaList, fetchKeywordMatchedStores, getTargetAreas, normalizeArea, toDisplayArea, } from './storeSearch.js';
+import { calculateDistanceM, dedupeProducts, matchesBrandVariant, matchesKeyword, parseMarketOptions, parseProductSummary, parseProducts, parseStores, sortStores, } from './parser.js';
+import { createZettaFallbackStore, fetchZettaLotteMartProductsWithPrimaryError } from './zetta.js';
+const STORE_CACHE_TTL_MS = 30 * 60 * 1000;
+const LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS = 7000;
+const storeCache = new Map();
+async function getLotteMartSessionCookie(options) {
+    if (options.sessionCookie) {
+        return options.sessionCookie;
+    }
+    return getCachedLotteMartSessionCookie(options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS);
+}
+export async function fetchLotteMartMarketOptions(area, type, options = {}) {
+    const normalizedArea = normalizeArea(area);
+    if (!normalizedArea) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    const endpoint = new URL(LOTTEMART_API.MARKET_OPTIONS_PATH, LOTTEMART_API.BASE_URL);
+    endpoint.searchParams.set('p_area', normalizedArea);
+    endpoint.searchParams.set('p_type', type);
+    const html = await fetchLotteMartHtml(endpoint.toString(), {
+        method: 'GET',
+        headers: {
+            Accept: 'text/html, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+        },
+    }, options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    return parseMarketOptions(toDisplayArea(normalizedArea), html);
+}
+export async function fetchLotteMartStoresByArea(area, options = {}) {
+    const normalizedArea = normalizeArea(area);
+    if (!normalizedArea) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    const cacheKey = normalizedArea;
+    const cached = storeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.stores;
+    }
+    const body = new URLSearchParams();
+    body.set('m_area', normalizedArea);
+    const html = await fetchLotteMartPageWithSession(LOTTEMART_API.STORE_SEARCH_PATH, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: body.toString(),
+    }, options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    const stores = parseStores(toDisplayArea(normalizedArea), html);
+    storeCache.set(cacheKey, {
+        expiresAt: Date.now() + STORE_CACHE_TTL_MS,
+        stores,
+    });
+    return stores;
+}
+async function fetchLotteMartStoresByAreaKeyword(area, keyword, options) {
+    const normalizedArea = normalizeArea(area);
+    const normalizedKeyword = keyword.trim();
+    const cacheKey = `${normalizedArea}:${normalizedKeyword}`;
+    const cached = storeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.stores;
+    }
+    const body = new URLSearchParams();
+    body.set('m_area', normalizedArea);
+    body.set('m_schWord', normalizedKeyword);
+    const html = await fetchLotteMartPageWithSession(LOTTEMART_API.STORE_SEARCH_PATH, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: body.toString(),
+    }, options.timeout, await getLotteMartSessionCookie(options), options.zyteApiKey);
+    const stores = parseStores(toDisplayArea(normalizedArea), html);
+    storeCache.set(cacheKey, {
+        expiresAt: Date.now() + STORE_CACHE_TTL_MS,
+        stores,
+    });
+    return stores;
+}
+export async function fetchLotteMartStores(params = {}, options = {}) {
+    const { area, keyword = '', brandVariant = '', latitude, longitude, limit = 20 } = params;
+    const { timeout = DEFAULT_LOTTEMART_TIMEOUT_MS, googleMapsApiKey } = options;
+    if (area && !normalizeArea(area)) {
+        throw new Error(`지원하지 않는 지역입니다: ${area}`);
+    }
+    let resolvedLatitude = latitude;
+    let resolvedLongitude = longitude;
+    let geocodeUsed = false;
+    if ((typeof resolvedLatitude !== 'number' || typeof resolvedLongitude !== 'number') &&
+        keyword.trim().length > 0) {
+        const geocoded = await geocodeLotteMartAddress(keyword, { timeout, googleMapsApiKey });
+        if (geocoded) {
+            resolvedLatitude = geocoded.latitude;
+            resolvedLongitude = geocoded.longitude;
+            geocodeUsed = true;
+        }
+    }
+    const sessionCookie = await getLotteMartSessionCookie({ timeout });
+    const targetAreas = getTargetAreas(area);
+    const hasKeyword = keyword.trim().length > 0;
+    const fetchAreaStores = (currentArea) => hasKeyword
+        ? fetchLotteMartStoresByAreaKeyword(currentArea, keyword, {
+            timeout,
+            sessionCookie,
+            zyteApiKey: options.zyteApiKey,
+        })
+        : fetchLotteMartStoresByArea(currentArea, { timeout, sessionCookie, zyteApiKey: options.zyteApiKey });
+    const keywordMatchedStores = hasKeyword
+        ? await fetchKeywordMatchedStores(targetAreas, keyword, brandVariant, limit, fetchAreaStores)
+        : [];
+    const useKeywordMatchedStores = keywordMatchedStores.length > 0 || hasKeyword;
+    const stores = useKeywordMatchedStores
+        ? keywordMatchedStores
+        : await fetchAllStoresForAreaList(targetAreas, fetchAreaStores);
+    const filtered = attachDistance(useKeywordMatchedStores
+        ? stores
+        : stores
+            .filter((store) => matchesKeyword(store, keyword))
+            .filter((store) => matchesBrandVariant(store, brandVariant)), resolvedLatitude, resolvedLongitude);
+    const enriched = await Promise.all(filtered.map(async (store) => {
+        if (typeof resolvedLatitude !== 'number' ||
+            typeof resolvedLongitude !== 'number' ||
+            store.latitude !== 0 ||
+            store.longitude !== 0) {
+            return store;
+        }
+        const geocoded = await geocodeLotteMartAddress(store.address, { timeout, googleMapsApiKey });
+        if (!geocoded) {
+            return store;
+        }
+        return {
+            ...store,
+            latitude: geocoded.latitude,
+            longitude: geocoded.longitude,
+            distanceM: calculateDistanceM(resolvedLatitude, resolvedLongitude, geocoded.latitude, geocoded.longitude),
+        };
+    }));
+    return {
+        stores: sortStores(enriched).slice(0, limit),
+        location: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number'
+            ? { latitude: resolvedLatitude, longitude: resolvedLongitude }
+            : null,
+        geocodeUsed,
+    };
+}
+export async function resolveLotteMartStore(area, storeCode, storeName, options = {}) {
+    const normalizedStoreCode = (storeCode || '').trim();
+    if (normalizedStoreCode.length > 0) {
+        for (const currentArea of getTargetAreas(area)) {
+            const matched = (await fetchLotteMartMarketOptions(currentArea, '1', options)).find((item) => item.storeCode === normalizedStoreCode);
+            if (matched) {
+                return matched;
+            }
+        }
+        return null;
+    }
+    const normalizedStoreName = (storeName || '').trim().toLowerCase();
+    if (normalizedStoreName.length === 0) {
+        return null;
+    }
+    const allOptions = (await Promise.all(getTargetAreas(area).map((currentArea) => fetchLotteMartMarketOptions(currentArea, '1', options)))).flat();
+    return (allOptions.find((item) => item.storeName.toLowerCase() === normalizedStoreName) ||
+        allOptions.find((item) => item.storeName.toLowerCase().includes(normalizedStoreName)) ||
+        null);
+}
+export async function searchLotteMartProducts(params, options = {}) {
+    const normalizedKeyword = params.keyword.trim();
+    if (normalizedKeyword.length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const timeout = options.timeout || DEFAULT_LOTTEMART_TIMEOUT_MS;
+    const sessionCookie = await getLotteMartSessionCookie({ timeout: LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS });
+    let resolvedStore;
+    try {
+        resolvedStore = await resolveLotteMartStore(params.area, params.storeCode, params.storeName, {
+            timeout: LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS,
+            sessionCookie,
+            zyteApiKey: options.zyteApiKey,
+        });
+    }
+    catch (error) {
+        const fallbackStore = createZettaFallbackStore(params);
+        return fetchZettaLotteMartProductsWithPrimaryError(fallbackStore, normalizedKeyword, params.pageLimit || 3, timeout, error);
+    }
+    if (!resolvedStore) {
+        throw new Error('검색할 롯데마트 매장을 찾지 못했습니다. area와 storeCode/storeName을 확인해주세요.');
+    }
+    const initialBody = new URLSearchParams();
+    initialBody.set('p_area', normalizeArea(resolvedStore.area));
+    initialBody.set('p_market', resolvedStore.storeCode);
+    initialBody.set('p_schWord', normalizedKeyword);
+    let initialHtml;
+    try {
+        initialHtml = await fetchLotteMartPageWithSession(LOTTEMART_API.PRODUCT_SEARCH_PATH, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: initialBody.toString(),
+        }, LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS, sessionCookie, options.zyteApiKey);
+    }
+    catch (error) {
+        return fetchZettaLotteMartProductsWithPrimaryError(resolvedStore, normalizedKeyword, params.pageLimit || 3, timeout, error);
+    }
+    const pagedSessionCookie = await getCachedLotteMartSessionCookie(LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS);
+    const summary = parseProductSummary(initialHtml);
+    const firstPageProducts = parseProducts(resolvedStore.area, resolvedStore.storeCode, resolvedStore.storeName, normalizedKeyword, initialHtml);
+    const maxPage = Math.min(Math.max(params.pageLimit || 3, 1), Math.max(summary.totalPages, 1));
+    const pageHtmlList = await Promise.all(Array.from({ length: Math.max(maxPage - 1, 0) }, (_, index) => index + 2).map((page) => {
+        const endpoint = new URL(LOTTEMART_API.PRODUCT_PAGE_PATH, LOTTEMART_API.BASE_URL);
+        endpoint.searchParams.set('p_market', resolvedStore.storeCode);
+        endpoint.searchParams.set('p_schWord', normalizedKeyword);
+        endpoint.searchParams.set('page', String(page));
+        return fetchLotteMartHtml(endpoint.toString(), {
+            method: 'GET',
+            headers: {
+                Accept: 'text/html, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+        }, LOTTEMART_PRODUCT_LEGACY_TIMEOUT_MS, pagedSessionCookie, options.zyteApiKey);
+    }));
+    const pagedProducts = pageHtmlList.flatMap((html) => parseProducts(resolvedStore.area, resolvedStore.storeCode, resolvedStore.storeName, normalizedKeyword, html));
+    return {
+        area: resolvedStore.area,
+        storeCode: resolvedStore.storeCode,
+        storeName: resolvedStore.storeName,
+        totalCount: summary.totalCount,
+        totalPages: summary.totalPages,
+        products: dedupeProducts([...firstPageProducts, ...pagedProducts]),
+    };
+}
+export { calculateDistanceM, geocodeLotteMartAddress };
+export function __testOnlyClearLotteMartCaches() {
+    storeCache.clear();
+    __testOnlyClearLotteMartGeocodeCache();
+    __testOnlyClearLotteMartSessionCache();
+}