daiso 1.0.10 → 1.2.0

package/dist/services/oliveyoung/transport.js

@@ -0,0 +1,46 @@
+/** 올리브영 무료 직접 요청 및 운영자가 설정한 브라우저 릴레이 전송. */
+import { fetchJson } from '../../utils/http.js';
+import { OLIVEYOUNG_API } from './api.js';
+export async function requestOliveyoung(path, body, options = {}) {
+    const { timeout = 15000, relayUrl, relayToken } = options;
+    const headers = {
+        'Content-Type': 'application/json', Accept: 'application/json',
+        'X-Requested-With': 'XMLHttpRequest',
+    };
+    let url = `${OLIVEYOUNG_API.BASE_URL}${path}`;
+    if (relayUrl) {
+        let relay;
+        try {
+            relay = new URL(relayUrl);
+        }
+        catch {
+            throw new Error('올리브영 릴레이 URL은 HTTPS 또는 로컬 HTTP 주소여야 합니다.');
+        }
+        if (relay.username || relay.password || relay.search || relay.hash ||
+            (relay.protocol !== 'https:' && !(relay.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(relay.hostname)))) {
+            throw new Error('올리브영 릴레이 URL은 HTTPS 또는 로컬 HTTP 주소여야 합니다.');
+        }
+        if (!relayToken?.trim())
+            throw new Error('OY_RELAY_TOKEN이 필요합니다.');
+        url = `${relayUrl.replace(/\/$/, '')}/v1/oliveyoung/${path.split('/').pop()}`;
+        headers.Authorization = `Bearer ${relayToken}`;
+    }
+    let result;
+    try {
+        result = await fetchJson(url, {
+            method: 'POST', headers, body: JSON.stringify(body), timeout, retries: 0, expectedStatus: 200,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('올리브영 API 요청 시간 초과');
+        }
+        if (relayUrl)
+            throw new Error('올리브영 브라우저 릴레이 요청 실패');
+        throw new Error('올리브영 직접 요청 실패. 운영자는 OY_RELAY_URL과 OY_RELAY_TOKEN으로 브라우저 릴레이를 설정해주세요.', { cause: error });
+    }
+    if (result?.status !== 'SUCCESS') {
+        throw new Error(`올리브영 API 상태 오류: ${result?.status || 'UNKNOWN'}`);
+    }
+    return result;
+}

package/dist/services/seveneleven/client.js

@@ -2,7 +2,8 @@
  * 세븐일레븐 API 클라이언트
  */
 /* c8 ignore start */
-import { fetchJson } from '../../utils/http.js';
+import { withSevenElevenReadCache } from './readCache.js';
+import { fetchJsonWithZyteFallback } from '../../utils/zyteJsonFallback.js';
 import { SEVENELEVEN_API } from './api.js';
 const SEVENELEVEN_DEFAULT_HEADERS = {
     Accept: 'application/json, text/plain, */*',
@@ -109,16 +110,18 @@ function normalizeStores(items) {
         .filter((store) => store.storeCode.length > 0 || store.storeName.length > 0);
 }
 async function requestSevenElevenJson(path, method, body, options = {}) {
-    const { timeout = 15000 } = options;
+    const { timeout = 15000, zyteApiKey } = options;
     const url = `${SEVENELEVEN_API.BASE_URL}${path}`;
-    return fetchJson(url, {
+    return withSevenElevenReadCache(path, body, timeout, () => fetchJsonWithZyteFallback(url, {
         ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
         method,
         retryUnsafeMethods: method === 'POST',
         timeout,
         headers: SEVENELEVEN_DEFAULT_HEADERS,
         body: method === 'POST' ? JSON.stringify(body || {}) : undefined,
-    });
+        zyteApiKey,
+        zyteTags: { service: 'seveneleven' },
+    }));
 }
 export async function searchSevenElevenProducts(params, options = {}) {
     const { query, page = 1, size = 20 } = params;
@@ -216,7 +219,7 @@ export async function fetchSevenElevenStockProductMeta(itemCode, options = {}) {
     const { timeout = 15000 } = options;
     const encodedItemCode = encodeURIComponent(itemCode.trim());
     const url = `${SEVENELEVEN_API.BASE_URL}${SEVENELEVEN_API.PRODUCT_SEARCH_STOCK_PATH}?itemCd=${encodedItemCode}`;
-    const response = await fetchJson(url, {
+    const response = await fetchJsonWithZyteFallback(url, {
         ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
         method: 'GET',
         timeout,
@@ -224,6 +227,8 @@ export async function fetchSevenElevenStockProductMeta(itemCode, options = {}) {
             Accept: SEVENELEVEN_DEFAULT_HEADERS.Accept,
             'User-Agent': SEVENELEVEN_DEFAULT_HEADERS['User-Agent'],
         },
+        zyteApiKey: options.zyteApiKey,
+        zyteTags: { service: 'seveneleven' },
     });
     const productMeta = normalizeStockProductMeta(response);
     if (productMeta.itemCode.length === 0 || productMeta.smCode.length === 0) {
@@ -263,14 +268,20 @@ function extractContentArray(data) {
     return [];
 }
 export async function fetchSevenElevenCatalogSnapshot(options = {}) {
-    const { includeIssues = true, includeExhibition = true, timeout = 15000 } = options;
+    const { includeIssues = true, includeExhibition = true, timeout = 15000, zyteApiKey } = options;
     const tasks = [
-        requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_PAGES_PATH, 'GET', null, { timeout }),
+        requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_PAGES_PATH, 'GET', null, { timeout, zyteApiKey }),
         includeIssues
-            ? requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_ISSUES_PATH, 'GET', null, { timeout })
+            ? requestSevenElevenJson(SEVENELEVEN_API.PRODUCT_ISSUES_PATH, 'GET', null, {
+                timeout,
+                zyteApiKey,
+            })
             : Promise.resolve({ data: { content: [] } }),
         includeExhibition
-            ? requestSevenElevenJson(SEVENELEVEN_API.EXHIBITION_MAIN_PATH, 'GET', null, { timeout })
+            ? requestSevenElevenJson(SEVENELEVEN_API.EXHIBITION_MAIN_PATH, 'GET', null, {
+                timeout,
+                zyteApiKey,
+            })
             : Promise.resolve({ data: [] }),
     ];
     const [pagesResult, issuesResult, exhibitionsResult] = await Promise.allSettled(tasks);

package/dist/services/seveneleven/index.js

@@ -13,18 +13,22 @@ const SEVENELEVEN_METADATA = {
     description: '세븐일레븐 공개 상품/검색/카탈로그 조회 서비스',
 };
 class SevenElevenService {
+    options;
     metadata = SEVENELEVEN_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
     getTools() {
         return [
-            createSearchProductsTool(),
-            createSearchStoresTool(),
-            createCheckInventoryTool(),
-            createGetSearchPopwordsTool(),
-            createGetCatalogSnapshotTool(),
+            createSearchProductsTool(this.options.zyteApiKey),
+            createSearchStoresTool(this.options.zyteApiKey),
+            createCheckInventoryTool(this.options.zyteApiKey),
+            createGetSearchPopwordsTool(this.options.zyteApiKey),
+            createGetCatalogSnapshotTool(this.options.zyteApiKey),
         ];
     }
 }
-export function createSevenElevenService() {
-    return new SevenElevenService();
+export function createSevenElevenService(options = {}) {
+    return new SevenElevenService(options);
 }
 export * from './types.js';

package/dist/services/seveneleven/inventory.js

@@ -5,7 +5,8 @@
  * 재고 API가 암호화로 차단된 경우에도 상품/매장 정보를 graceful하게 반환합니다.
  */
 /* c8 ignore start */
-import { fetchJson, HttpError } from '../../utils/http.js';
+import { HttpError } from '../../utils/http.js';
+import { fetchJsonWithZyteFallback } from '../../utils/zyteJsonFallback.js';
 import { SEVENELEVEN_API } from './api.js';
 import { fetchSevenElevenStockProductMeta, fetchSevenElevenStoresByKeyword, } from './client.js';
 import { pickBestSevenElevenProduct, searchSevenElevenProductsWithVariants } from './productKeyword.js';
@@ -180,11 +181,13 @@ async function tryStockApi(stockProduct, stores, options = {}) {
         return { stores: null, error: null };
     }
     try {
-        const response = await fetchJson(url, {
+        const response = await fetchJsonWithZyteFallback(url, {
             method: 'POST',
             timeout,
             headers: SEVENELEVEN_DEFAULT_HEADERS,
             body: JSON.stringify(payload),
+            zyteApiKey: options.zyteApiKey,
+            zyteTags: { service: 'seveneleven', operation: 'inventory' },
         });
         const responseError = normalizeEnvelopeError(response);
         if (responseError) {

package/dist/services/seveneleven/productKeyword.js

@@ -1,7 +1,7 @@
 /**
  * 세븐일레븐 상품 검색어 보정
  */
-import { searchSevenElevenProducts } from './client.js';
+import { searchSevenElevenProducts, } from './client.js';
 const SANDWICH_SUFFIX_FAMILY = ['샌드위치', '샌드', '산도'];
 function normalizeProductText(value) {
     return value.replace(/[^0-9A-Za-z가-힣]+/g, '').toLowerCase();
@@ -95,7 +95,7 @@ function scoreSevenElevenProduct(product, rawKeyword) {
  * 보정 질의를 순차 적용해 세븐일레븐 상품을 찾습니다.
  */
 export async function searchSevenElevenProductsWithVariants(query, options = {}) {
-    const { page = 1, size = 20, sort = 'recommend', timeout } = options;
+    const { page = 1, size = 20, sort = 'recommend', timeout, zyteApiKey } = options;
     const appliedQueries = buildSevenElevenProductKeywordVariants(query);
     const seenKeys = new Set();
     const collectionIds = new Set();
@@ -108,6 +108,7 @@ export async function searchSevenElevenProductsWithVariants(query, options = {})
             sort,
         }, {
             timeout,
+            zyteApiKey,
         });
         for (const collectionId of result.collectionIds) {
             collectionIds.add(collectionId);

package/dist/services/seveneleven/readCache.js

@@ -0,0 +1,49 @@
+/** 공개 상품·매장 조회를 REST와 MCP에서 함께 재사용합니다. 재고는 저장하지 않습니다. */
+import { SEVENELEVEN_API } from './api.js';
+const MAX_ENTRIES = 128;
+const TTL_BY_PATH = new Map([
+    [SEVENELEVEN_API.SEARCH_GOODS_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.SEARCH_STORE_PATH, 30 * 60_000],
+    [SEVENELEVEN_API.SEARCH_POPWORD_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.PRODUCT_PAGES_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.PRODUCT_ISSUES_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.EXHIBITION_MAIN_PATH, 5 * 60_000],
+]);
+const values = new Map();
+const pending = new Map();
+export function clearSevenElevenReadCache() {
+    values.clear();
+    pending.clear();
+}
+export async function withSevenElevenReadCache(path, body, timeout, request) {
+    const ttl = TTL_BY_PATH.get(path.split('?')[0]);
+    if (!ttl)
+        return request();
+    const key = JSON.stringify([path, body, timeout]);
+    const cached = values.get(key);
+    if (cached && cached.expiresAt > Date.now()) {
+        return structuredClone(cached.value);
+    }
+    values.delete(key);
+    const existing = pending.get(key);
+    if (existing)
+        return structuredClone(await existing);
+    // 부하가 높아져도 진행 중인 조회 키를 무제한으로 보관하지 않습니다.
+    if (pending.size >= MAX_ENTRIES)
+        return request();
+    const promise = request().then((value) => {
+        if (value.success === true && value.data !== undefined) {
+            if (values.size >= MAX_ENTRIES)
+                values.delete(values.keys().next().value);
+            values.set(key, { expiresAt: Date.now() + ttl, value: structuredClone(value) });
+        }
+        return value;
+    });
+    pending.set(key, promise);
+    try {
+        return structuredClone(await promise);
+    }
+    finally {
+        pending.delete(key);
+    }
+}

package/dist/services/seveneleven/tools/checkInventory.js

@@ -16,7 +16,7 @@ function isEncryptedStockFailure(stockError) {
     const messageMatched = /RSA|복호화|암호화|서비스를 사용할 수 없습니다/i.test(messageSource);
     return codeMatched || messageMatched;
 }
-async function checkInventory(args) {
+async function checkInventory(args, zyteApiKey) {
     const { keyword, storeKeyword = '', storeLimit = 20, timeoutMs = 20000, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
@@ -27,6 +27,7 @@ async function checkInventory(args) {
         storeLimit,
     }, {
         timeout: timeoutMs,
+        zyteApiKey,
     });
     const note = !result.product
         ? '상품 검색 결과가 없어 재고를 조회하지 못했습니다. 다른 상품명이나 더 짧은 키워드로 다시 시도해주세요.'
@@ -59,7 +60,7 @@ async function checkInventory(args) {
         ],
     };
 }
-export function createCheckInventoryTool() {
+export function createCheckInventoryTool(zyteApiKey) {
     return {
         name: 'seveneleven_check_inventory',
         metadata: {
@@ -76,7 +77,7 @@ export function createCheckInventoryTool() {
                 timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
             },
         },
-        handler: checkInventory,
+        handler: (args) => checkInventory(args, zyteApiKey),
     };
 }
 /* c8 ignore stop */

package/dist/services/seveneleven/tools/getCatalogSnapshot.js

@@ -3,12 +3,13 @@
  */
 import * as z from 'zod';
 import { fetchSevenElevenCatalogSnapshot } from '../client.js';
-async function getCatalogSnapshot(args) {
+async function getCatalogSnapshot(args, zyteApiKey) {
     const { includeIssues = true, includeExhibition = true, limit = 20, timeoutMs = 15000 } = args;
     const result = await fetchSevenElevenCatalogSnapshot({
         includeIssues,
         includeExhibition,
         timeout: timeoutMs,
+        zyteApiKey,
     });
     return {
         content: [
@@ -37,7 +38,7 @@ async function getCatalogSnapshot(args) {
         ],
     };
 }
-export function createGetCatalogSnapshotTool() {
+export function createGetCatalogSnapshotTool(zyteApiKey) {
     return {
         name: 'seveneleven_get_catalog_snapshot',
         metadata: {
@@ -50,6 +51,6 @@ export function createGetCatalogSnapshotTool() {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: getCatalogSnapshot,
+        handler: (args) => getCatalogSnapshot(args, zyteApiKey),
     };
 }

package/dist/services/seveneleven/tools/getSearchPopwords.js

@@ -3,10 +3,11 @@
  */
 import * as z from 'zod';
 import { fetchSevenElevenSearchPopwords } from '../client.js';
-async function getSearchPopwords(args) {
+async function getSearchPopwords(args, zyteApiKey) {
     const { label = 'home', timeoutMs = 15000 } = args;
     const keywords = await fetchSevenElevenSearchPopwords(label, {
         timeout: timeoutMs,
+        zyteApiKey,
     });
     return {
         content: [
@@ -25,7 +26,7 @@ async function getSearchPopwords(args) {
         ],
     };
 }
-export function createGetSearchPopwordsTool() {
+export function createGetSearchPopwordsTool(zyteApiKey) {
     return {
         name: 'seveneleven_get_search_popwords',
         metadata: {
@@ -36,6 +37,6 @@ export function createGetSearchPopwordsTool() {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: getSearchPopwords,
+        handler: (args) => getSearchPopwords(args, zyteApiKey),
     };
 }

package/dist/services/seveneleven/tools/searchProducts.js

@@ -9,7 +9,7 @@ function buildTextResponse(payload) {
         structuredContent: payload,
     };
 }
-async function searchProducts(args) {
+async function searchProducts(args, zyteApiKey) {
     const { query, page = 1, size = 20, sort = 'recommend', timeoutMs = 15000 } = args;
     if (!query || query.trim().length === 0) {
         throw new Error('상품 검색어(query)를 입력해주세요.');
@@ -20,6 +20,7 @@ async function searchProducts(args) {
             size,
             sort,
             timeout: timeoutMs,
+            zyteApiKey,
         });
         return buildTextResponse({
             query: result.query,
@@ -62,7 +63,7 @@ const searchProductsOutputSchema = {
     status: z.string().optional().describe('외부 API 차단 등으로 결과가 제한된 경우 degraded'),
     message: z.string().optional().describe('degraded 상태의 원인 메시지'),
 };
-export function createSearchProductsTool() {
+export function createSearchProductsTool(zyteApiKey) {
     return {
         name: 'seveneleven_search_products',
         metadata: {
@@ -81,6 +82,6 @@ export function createSearchProductsTool() {
             },
             outputSchema: searchProductsOutputSchema,
         },
-        handler: searchProducts,
+        handler: (args) => searchProducts(args, zyteApiKey),
     };
 }

package/dist/services/seveneleven/tools/searchStores.js

@@ -3,7 +3,7 @@
  */
 import * as z from 'zod';
 import { fetchSevenElevenStoresByKeyword } from '../client.js';
-async function searchStores(args) {
+async function searchStores(args, zyteApiKey) {
     const { keyword, limit = 20, timeoutMs = 15000 } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('매장 검색어(keyword)를 입력해주세요.');
@@ -13,6 +13,7 @@ async function searchStores(args) {
         limit,
     }, {
         timeout: timeoutMs,
+        zyteApiKey,
     });
     return {
         content: [
@@ -28,7 +29,7 @@ async function searchStores(args) {
         ],
     };
 }
-export function createSearchStoresTool() {
+export function createSearchStoresTool(zyteApiKey) {
     return {
         name: 'seveneleven_search_stores',
         metadata: {
@@ -40,6 +41,6 @@ export function createSearchStoresTool() {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: searchStores,
+        handler: (args) => searchStores(args, zyteApiKey),
     };
 }

package/dist/utils/format.js

@@ -24,8 +24,15 @@ export function formatTime(raw) {
     return raw;
 }
 export function toYyyymmdd(value = new Date()) {
-    const year = value.getFullYear();
-    const month = `${value.getMonth() + 1}`.padStart(2, '0');
-    const day = `${value.getDate()}`.padStart(2, '0');
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        timeZone: 'Asia/Seoul',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    }).formatToParts(value);
+    const byType = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    const year = byType.year;
+    const month = byType.month;
+    const day = byType.day;
     return `${year}${month}${day}`;
 }

package/dist/utils/http.js

@@ -15,6 +15,17 @@ export class HttpError extends Error {
         this.bodyText = bodyText;
     }
 }
+/** HTML 원문을 노출하지 않고 예상하지 못한 응답 형식을 구분합니다. */
+export class UnexpectedHtmlResponseError extends Error {
+    status;
+    contentType;
+    constructor(status, contentType) {
+        super(`JSON 대신 HTML 응답을 받았습니다 (HTTP ${status}).`);
+        this.status = status;
+        this.contentType = contentType;
+        this.name = 'UnexpectedHtmlResponseError';
+    }
+}
 export function createTimeoutController(timeout) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
@@ -54,19 +65,22 @@ function parseRetryAfterDelayMs(response) {
     }
     return null;
 }
-export async function fetchWithTimeout(url, options = {}) {
-    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, ...restOptions } = options;
+async function requestWithTimeout(url, options, readResponse) {
+    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, expectedStatus: _expectedStatus, ...restOptions } = options;
     const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
     const method = normalizeMethod(restOptions.method);
     const retryAllowed = canRetryMethod(method, retryMethods, retryUnsafeMethods);
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const { controller, timeoutId } = createTimeoutController(timeout);
+        let readingResponse = false;
         try {
             const response = await fetch(url, {
                 ...restOptions,
                 signal: controller.signal,
             });
-            if (retryAllowed && attempt < maxAttempts && isRetryableStatus(response.status, retryStatusCodes)) {
+            if (retryAllowed &&
+                attempt < maxAttempts &&
+                isRetryableStatus(response.status, retryStatusCodes)) {
                 const delayMs = parseRetryAfterDelayMs(response) ?? retryDelayMs;
                 onRetry?.({
                     attempt,
@@ -81,10 +95,11 @@ export async function fetchWithTimeout(url, options = {}) {
                 await wait(delayMs);
                 continue;
             }
-            return response;
+            readingResponse = true;
+            return await readResponse(response);
         }
         catch (error) {
-            if (!retryAllowed || attempt >= maxAttempts) {
+            if (readingResponse || !retryAllowed || attempt >= maxAttempts) {
                 throw error;
             }
             onRetry?.({
@@ -105,17 +120,30 @@ export async function fetchWithTimeout(url, options = {}) {
     /* v8 ignore next */
     throw new Error('API 요청 재시도 처리 중 알 수 없는 오류가 발생했습니다.');
 }
+export async function fetchWithTimeout(url, options = {}) {
+    return requestWithTimeout(url, options, async (response) => response);
+}
+async function readTextResponse(url, options) {
+    // 헤더 수신뿐 아니라 본문 읽기에도 같은 요청 제한 시간을 적용합니다.
+    return requestWithTimeout(url, options, async (response) => ({
+        response,
+        body: await response.text(),
+    }));
+}
 export async function fetchJson(url, options = {}) {
-    const response = await fetchWithTimeout(url, options);
-    if (!response.ok) {
-        throw new HttpError(response.status, response.statusText, await response.text());
+    const { response, body } = await readTextResponse(url, options);
+    if (!response.ok || (options.expectedStatus !== undefined && response.status !== options.expectedStatus)) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    if (/^\s*(?:<!doctype\s+html\b|<html\b)/i.test(body)) {
+        throw new UnexpectedHtmlResponseError(response.status, response.headers.get('content-type') || '');
     }
-    return response.json();
+    return JSON.parse(body);
 }
 export async function fetchText(url, options = {}) {
-    const response = await fetchWithTimeout(url, options);
+    const { response, body } = await readTextResponse(url, options);
     if (!response.ok) {
-        throw new HttpError(response.status, response.statusText, await response.text());
+        throw new HttpError(response.status, response.statusText, body);
     }
-    return response.text();
+    return body;
 }

package/dist/utils/zyte.js

@@ -1,29 +1,7 @@
 /**
  * Zyte Extract API 공통 유틸리티
  */
-import { createTimeoutController } from './http.js';
-export function resolveZyteApiKey(apiKey) {
-    if (apiKey && apiKey.trim().length > 0) {
-        return apiKey;
-    }
-    /* c8 ignore start */
-    if (typeof process !== 'undefined' && process.env?.ZYTE_API_KEY) {
-        return process.env.ZYTE_API_KEY;
-    }
-    /* c8 ignore end */
-    throw new Error('ZYTE_API_KEY가 설정되지 않았습니다. .env 또는 Cloudflare Worker Secret을 확인해주세요.');
-}
-export function encodeBasicAuth(apiKey) {
-    if (typeof btoa === 'function') {
-        return btoa(`${apiKey}:`);
-    }
-    /* c8 ignore start */
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(`${apiKey}:`).toString('base64');
-    }
-    /* c8 ignore end */
-    throw new Error('Basic 인증 인코딩을 지원하지 않는 런타임입니다.');
-}
+import { ZYTE_COST_POLICY_MESSAGE } from '../core/errors.js';
 export function decodeBase64(value) {
     if (typeof atob === 'function') {
         const binary = atob(value);
@@ -37,84 +15,9 @@ export function decodeBase64(value) {
     /* c8 ignore end */
     throw new Error('Base64 디코딩을 지원하지 않는 런타임입니다.');
 }
-function isAbortError(error) {
-    return error instanceof Error && error.name === 'AbortError';
-}
-class RetryableZyteError extends Error {
-}
-function isRetryableZyteStatus(status) {
-    return status === 408 || status === 429 || status >= 500;
-}
-function isRetryableTargetStatus(statusCode) {
-    return typeof statusCode === 'number' && statusCode >= 500;
-}
-function isRetryableError(error) {
-    return isAbortError(error) || error instanceof RetryableZyteError;
-}
-function wait(ms) {
-    if (ms <= 0) {
-        return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-export async function requestByZyte(options) {
-    const { timeout = 15000, retries = 1, retryDelayMs = 250, url, method = 'GET', headers = [], bodyText, apiKey, } = options;
-    const auth = encodeBasicAuth(resolveZyteApiKey(apiKey));
-    const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const { controller, timeoutId } = createTimeoutController(timeout);
-        try {
-            let response;
-            try {
-                response = await fetch('https://api.zyte.com/v1/extract', {
-                    method: 'POST',
-                    headers: {
-                        Authorization: `Basic ${auth}`,
-                        'Content-Type': 'application/json',
-                        Accept: 'application/json',
-                    },
-                    body: JSON.stringify({
-                        url,
-                        httpRequestMethod: method,
-                        customHttpRequestHeaders: headers,
-                        httpRequestText: bodyText,
-                        httpResponseBody: true,
-                    }),
-                    signal: controller.signal,
-                });
-            }
-            catch (error) {
-                if (error instanceof TypeError) {
-                    throw new RetryableZyteError(error.message);
-                }
-                throw error;
-            }
-            const result = (await response.json());
-            if (!response.ok) {
-                const message = `Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim();
-                if (isRetryableZyteStatus(response.status)) {
-                    throw new RetryableZyteError(message);
-                }
-                throw new Error(message);
-            }
-            if (isRetryableTargetStatus(result.statusCode) && attempt < maxAttempts) {
-                throw new RetryableZyteError(`Zyte target response failed: ${result.statusCode}`);
-            }
-            return result;
-        }
-        catch (error) {
-            if (!isRetryableError(error) || attempt >= maxAttempts) {
-                throw error;
-            }
-            await wait(retryDelayMs);
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    throw new Error('Zyte API 호출 실패');
+/** 키와 재시도 설정에 관계없이 유료 네트워크 경로를 차단합니다. */
+export async function requestByZyte(_options) {
+    throw new Error(ZYTE_COST_POLICY_MESSAGE);
 }
 export function decodeZyteHttpBody(result) {
     if (!result.httpResponseBody) {