@maixio/pstore 0.1.0

package/dist/index.js

@@ -0,0 +1,2107 @@
+// src/api/category-names.ts
+var CATEGORY_DISPLAY_NAMES = {
+  "cat.gma.AllDeals": {
+    "zh-hans-HK": "所有优惠",
+    "zh-hant-HK": "所有優惠",
+    "zh-hant-TW": "所有優惠",
+    "en-US": "All Deals",
+    "en-HK": "All Deals",
+    "en-TW": "All Deals",
+    "ja-JP": "すべてのセール",
+    default: "All Deals"
+  },
+  "cat.gma.x_All_games": {
+    "zh-hans-HK": "所有游戏",
+    "zh-hant-HK": "所有遊戲",
+    "zh-hant-TW": "所有遊戲",
+    "en-US": "All Games",
+    "en-HK": "All Games",
+    "en-TW": "All Games",
+    "ja-JP": "すべてのゲーム",
+    default: "All Games"
+  },
+  "cat.gma.NewGames": {
+    "zh-hans-HK": "新的游戏",
+    "zh-hant-HK": "新遊戲",
+    "zh-hant-TW": "新遊戲",
+    "en-US": "New Games",
+    "en-HK": "New Games",
+    "en-TW": "New Games",
+    "ja-JP": "新着ゲーム",
+    default: "New Games"
+  },
+  "cat.gma.Pre-Orders": {
+    "zh-hans-HK": "预购",
+    "zh-hant-HK": "預購",
+    "zh-hant-TW": "預購",
+    "en-US": "Pre-Orders",
+    "en-HK": "Pre-Orders",
+    "en-TW": "Pre-Orders",
+    "ja-JP": "予約注文",
+    default: "Pre-Orders"
+  },
+  "cat.gma.x_All_PS4_games": {
+    "zh-hans-HK": "所有 PS4 游戏",
+    "zh-hant-HK": "所有 PS4 遊戲",
+    "zh-hant-TW": "所有 PS4 遊戲",
+    "en-US": "All PS4 Games",
+    "en-HK": "All PS4 Games",
+    "en-TW": "All PS4 Games",
+    "ja-JP": "すべてのPS4ゲーム",
+    default: "All PS4 Games"
+  },
+  "cat.gma.x_All_PS5_games": {
+    "zh-hans-HK": "所有 PS5 游戏",
+    "zh-hant-HK": "所有 PS5 遊戲",
+    "zh-hant-TW": "所有 PS5 遊戲",
+    "en-US": "All PS5 Games",
+    "en-HK": "All PS5 Games",
+    "en-TW": "All PS5 Games",
+    "ja-JP": "すべてのPS5ゲーム",
+    default: "All PS5 Games"
+  },
+  "cat.gma.x_Top_10_games_in_your_country": {
+    "zh-hans-HK": "本地十大热门游戏",
+    "zh-hant-HK": "本地十大熱門遊戲",
+    "zh-hant-TW": "本地十大熱門遊戲",
+    "en-US": "Top 10 Games in Your Country",
+    "en-HK": "Top 10 Games in Your Country",
+    "en-TW": "Top 10 Games in Your Country",
+    "ja-JP": "あなたの国のトップ10ゲーム",
+    default: "Top 10 Games in Your Country"
+  }
+};
+function resolveCategoryDisplayName(localizedName, locale) {
+  if (!localizedName)
+    return;
+  const names = CATEGORY_DISPLAY_NAMES[localizedName];
+  if (names) {
+    return (locale ? names[locale] : undefined) ?? names.default;
+  }
+  return formatCategoryKey(localizedName);
+}
+function formatCategoryKey(localizedName) {
+  const key = localizedName.replace(/^cat\.gma\./, "");
+  if (!key || key === localizedName)
+    return;
+  return key.replace(/^x_/, "").replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").trim();
+}
+
+// src/api/catalog-registry.ts
+function catalog(alias, id, localizedName, zhHansHkName, source = "built-in", visibility = "visible", notes) {
+  return {
+    alias,
+    id,
+    localizedName,
+    displayName: zhHansHkName ? { "zh-hans-HK": zhHansHkName, default: zhHansHkName } : undefined,
+    visibility: { default: visibility },
+    source,
+    notes
+  };
+}
+var BUILTIN_CATALOGS = [
+  catalog("all-deals", "3f772501-f6f8-49b7-abac-874a88ca4897", "cat.gma.AllDeals", "所有优惠", "manual", "hidden", "Globally valid catalog; not exposed from current storefront navigation."),
+  catalog("best-sellers", "132bb05e-89dc-4e66-966d-1297b045e21d", "cat.gma.Best_Sellers", "最畅销"),
+  catalog("ps5-pro-enhanced-games", "1d443305-2dcf-4543-8f7e-8c6ec409ecbf", "cat.gma.PS5_Pro_Enhanced_Games", "PS5 Pro Enhanced Games"),
+  catalog("all-ps4-games", "30e3fe35-8f2d-4496-95bc-844f56952e3c", "cat.gma.x_All_PS4_games", "所有 PS4 游戏"),
+  catalog("pre-orders", "3bf499d7-7acf-4931-97dd-2667494ee2c9", "cat.gma.Pre-Orders", "预购"),
+  catalog("free-to-play", "4dfd67ab-4ed7-40b0-a937-a549aece13d0", "cat.gma.FreeToPlay", "基本免费游戏"),
+  catalog("add-ons", "51c9aa7a-c0c7-4b68-90b4-328ad11bf42e", "cat.gma.add-onsbygame", "所有追加内容"),
+  catalog("play-station-vr2-games", "7b0ad209-dadd-4575-9e51-09ccc803deeb", "cat.gma.PlayStation_VR2_Games", "PlayStation VR2游戏"),
+  catalog("all-ps5-games", "d0446d4b-dc9a-4f1e-86ec-651f099c9b29", "cat.gma.x_All_PS5_games", "所有 PS5 游戏"),
+  catalog("new-games", "e1699f77-77e1-43ca-a296-26d08abacb0f", "cat.gma.NewGames", "新的游戏"),
+  catalog("top-10-games-in-your-country", "fbb563aa-c602-476d-bb92-fe7f35080205", "cat.gma.x_Top_10_games_in_your_country", "本地十大热门游戏"),
+  catalog("beginner-friendly", "0a1e21f5-2bf6-45aa-8105-82e0a18940f6", "cat.gma.EDITBeginnerFriendly", "适合新手"),
+  catalog("fighting", "0f6fc626-a05d-4378-8537-83f515a6d64e", "cat.gma.Fighting", "战斗"),
+  catalog("monthly-picks", "1dfb1512-2d95-4288-aebb-c5355a5083be", "cat.gma.DiscoverMonthlyPicks", "每月精选游戏"),
+  catalog("accessibility", "26790261-5100-4c8e-93f2-2f38b189ed20", "cat.gma.EditAccessibility", "协助工具"),
+  catalog("all-games", "28c9c2b2-cecc-415c-9a08-482a605cb104", "cat.gma.x_All_games", "所有游戏"),
+  catalog("action", "298b428c-0c39-4ec8-abd5-237484e5a2ea", "cat.gma.Action", "动作"),
+  catalog("great-games-2026", "2afbc717-a46f-4527-885b-0287dabf9786", "cat.gma.EDIT_26_Great_Games", "2026年绝佳游戏"),
+  catalog("robot-games", "2c53964f-8525-4ecc-ad9f-7dd9e87080e4", "cat.gma.RobotGames", "机器人游戏"),
+  catalog("open-world", "30cbd819-fe39-4a71-b26b-7bd5e585e81a", "cat.gma.x_Open_World", "开放世界"),
+  catalog("family-friendly", "38848c2a-a417-4e79-8fda-b499d1c7621b", "cat.gma.forallages", "合家欢游戏"),
+  catalog("story-driven", "3f61c5cb-2a7c-4870-a7ed-73d0eca710c1", "cat.gma.StoryDriven", "剧情导向"),
+  catalog("party-music-dance", "53563c94-a8bc-44b5-829e-6b2faa22e858", "cat.gma.PartyMusicandDance", "物品"),
+  catalog("play-list", "5d607247-7a7f-49d9-a39f-004183d6ec1c", "cat.gma.x_Explore_The_Play_List", "探索 The Play List"),
+  catalog("ea-play", "607787d5-1e83-4183-b028-e2ba3b873e57", "cat.gma.x_EA_Play_", "查看最新 EA Play 游戏试玩版"),
+  catalog("shooter", "64ee024b-7644-468a-92c6-370269075d5c", "cat.gma.Shooter", "射击"),
+  catalog("horror", "6ec578f6-d6b7-423c-8b93-14e14a5a43f2", "cat.gma.Horror", "体验恐怖"),
+  catalog("arcade", "7754f7e7-0f77-4cc6-9329-327f99558f63", "cat.gma.k.PlayStation_Plus_Game_Cata", "街机游戏"),
+  catalog("gta-plus-games", "83449c85-2cb2-419e-9f5f-640a925fa213", "cat.gma.GAMES_AVAILABLE_WITH_GTA_PLUS", "GTA+内含的游戏"),
+  catalog("heroine", "86d14731-40cd-40ec-b4f5-cdee3ff2b38a", "cat.gma.Heroine2020", "物品"),
+  catalog("demos", "95601a70-7564-4771-b305-0283fe3593e4", "cat.gma.Demos", "试玩版游戏"),
+  catalog("ps5-essentials", "97d3ba9f-58cb-4b68-b77c-c67744a52df3", "cat.gma.EditPS5Essentials", "PS5必玩游戏"),
+  catalog("brain-teasers", "a1bcd7d4-2bcb-44cb-934c-cc1f4ef33ffa", "cat.gma.Edit_BrainTeasers", "脑力大考验"),
+  catalog("platformer", "a6c1a446-52a9-4372-89ad-1662708d437c", "cat.gma.Platform", "物品"),
+  catalog("most-anticipated", "a7c97306-69bd-45cb-a44f-c9ffd9eaa7d3", "cat.gma.MostAnticipated", "万众期待"),
+  catalog("ps-plus-exclusive-discounts", "b3915b25-f581-43dd-95dd-a4ec50dbabe6", "cat.gma..x_PS_Plus_exclusive_discounts", "PS Plus专属折扣"),
+  catalog("superheroes", "b5823083-b523-44cf-9b47-5bb14235f256", "cat.gma.Superheroes", "超级英雄"),
+  catalog("racing", "b78c6346-2a31-4cf7-978b-134d61ce584d", "cat.gma.i.PlayStation_Plus_Game_Cata", "驾驶与赛车游戏"),
+  catalog("sports", "b86f0f65-cf49-4f96-8cdd-3991ca17eadc", "cat.gma.f.PlayStation_Plus_Game_Cata", "体育游戏"),
+  catalog("simulation", "bb42a4e0-2d0e-40e5-9714-ae4e10320f24", "cat.gma.Simulation", "模拟"),
+  catalog("cozy-games", "bf015f98-c056-442e-ace3-d37794adb358", "cat.gma.EditCozyGames", "享受闲适"),
+  catalog("best-companions", "c2ce2847-6c6f-41f5-9a57-e50fff2a9055", "cat.gma.BestCompanions", "最佳伙伴"),
+  catalog("play-together", "c6a44ef3-fb6e-4a5d-88b8-1235d77a3d34", "cat.gma.PlayTogether", "结伴同游"),
+  catalog("games-to-wishlist", "ca30992e-0de1-4092-b514-e00438fbc0d9", "cat.gma.Games_to_wishlist", "值得收藏的游戏"),
+  catalog("jrpgs", "d6fa0b3e-8da9-4990-a215-77be705b3555", "cat.gma.JRPGs", "日系RPG"),
+  catalog("kids-family", "d7095c22-4e0b-458c-bb50-fc79c0d4b5a8", "cat.gma.l.PlayStation_Plus_Game_Cata", "儿童和家庭游戏"),
+  catalog("ubisoft-plus", "db65f8d8-e606-49af-9a9a-23a05f55bd9a", "cat.gma.UbisoftPlus", "Ubisoft+ Classics"),
+  catalog("long-haul-legends", "dbe740ab-97a8-4809-97b0-73c89836f78b", "cat.gma.EDIT_LongHaulLegends_Category", "长篇传奇杰作"),
+  catalog("ps5-pro-enhanced-games-alt", "defeaa4c-377c-418e-8642-a0fc39fbdbe4", "cat.gma.PS5_Pro_Enhanced_Games", "PS5 Pro Enhanced Games"),
+  catalog("rpg", "e0b1cde3-a7ea-4d7a-960a-fa5edbafae8f", "cat.gma.j.PlayStation_Plus_Game_Cata", "角色扮演游戏"),
+  catalog("play-station-studios", "e6562951-eee2-4964-a5e0-176b28bb4603", "cat.gma.EDIT_PlayStationStudios", "Discover PlayStation Studios™"),
+  catalog("gta-online-add-ons", "e7132a49-c17f-42e6-968e-0bc4e9e834e0", "cat.am.GTA_Online_Add_Ons", "Grand Theft Auto在线模式（PlayStation®5）追加内容"),
+  catalog("online-multiplayer", "edaeb3f9-aeaf-45d4-81ab-67a1f18d5c36", "cat.gma.EditOnline_Multiplayer", "在线多人游玩"),
+  catalog("play-station-indies", "f073e967-8952-4b28-908f-35476499178a", "cat.gma.PlayStationIndies", "独立游戏"),
+  catalog("yakuza-games", "f0c9b0e6-a9ac-4556-84cc-f449f7cb6994", "cat.gma.EDIT_YakuzaGames_Franchise_Collection_Category", "人中之龙"),
+  catalog("editors-choice", "f0e0aa50-998f-4fc7-881b-064f10f0c2cc", "cat.gma.EditorsChoice", "编辑精选"),
+  catalog("roguelikes", "f5cebe8a-c63f-4b51-bf00-e786307d6373", "cat.gma.Roguelikes", "Roguelike游戏"),
+  catalog("anime-games", "f744ea6a-5367-45d9-ba28-39c0ae624018", "cat.gma.ANIMEgames", "动漫游戏")
+];
+var CATALOG_ALIASES = Object.fromEntries(BUILTIN_CATALOGS.map((entry) => [entry.alias, entry.id]));
+function resolveCatalogAlias(input) {
+  const normalized = input.toLowerCase();
+  return BUILTIN_CATALOGS.find((entry) => entry.alias === normalized || entry.id === input);
+}
+function resolveCatalogDisplayName(entry, locale) {
+  return (locale ? entry.displayName?.[locale] : undefined) ?? (entry.localizedName ? resolveCategoryDisplayName(entry.localizedName, locale) : undefined) ?? entry.displayName?.default;
+}
+function resolveCatalogVisibility(entry, locale) {
+  return (locale ? entry.visibility?.[locale] : undefined) ?? entry.visibility?.default ?? "unknown";
+}
+
+// src/types.ts
+var LOCALE_MAP = {
+  "zh-hans-HK": { locale: "zh-hans-HK", language: "zh", country: "HK", region: "SIE-ASIA", currency: "HKD" },
+  "zh-hant-HK": { locale: "zh-hant-HK", language: "zh", country: "HK", region: "SIE-ASIA", currency: "HKD" },
+  "en-HK": { locale: "en-HK", language: "en", country: "HK", region: "SIE-ASIA", currency: "HKD" },
+  "zh-hant-TW": { locale: "zh-hant-TW", language: "zh", country: "TW", region: "SIE-ASIA", currency: "TWD" },
+  "en-TW": { locale: "en-TW", language: "en", country: "TW", region: "SIE-ASIA", currency: "TWD" },
+  "ja-JP": { locale: "ja-JP", language: "ja", country: "JP", region: "SIEJ", currency: "JPY" },
+  "en-US": { locale: "en-US", language: "en", country: "US", region: "SIEA", currency: "USD" },
+  "en-GB": { locale: "en-GB", language: "en", country: "GB", region: "SIEE", currency: "GBP" },
+  "zh-hans-CN": { locale: "zh-hans-CN", language: "zh", country: "CN", region: "SIEC", currency: "CNY" }
+};
+
+class PsnApiError extends Error {
+  statusCode;
+  operationName;
+  retryAfterMs;
+  constructor(message, statusCode, operationName, retryAfterMs) {
+    super(message);
+    this.statusCode = statusCode;
+    this.operationName = operationName;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "PsnApiError";
+  }
+}
+
+// src/locale.ts
+var DEFAULT_LOCALE = "zh-hans-HK";
+var TITLE_LOCALE_PRESETS = {
+  "cjk-en": ["zh-hans-HK", "zh-hant-HK", "ja-JP", "en-US"],
+  "zh-ja-en": ["zh-hans-HK", "zh-hant-HK", "ja-JP", "en-US"],
+  all: ["zh-hans-HK", "zh-hant-HK", "en-HK", "zh-hant-TW", "en-TW", "ja-JP", "en-US", "en-GB", "zh-hans-CN"]
+};
+function isPsnLocale(value) {
+  return typeof value === "string" && value in LOCALE_MAP;
+}
+function normalizeLocale(value) {
+  if (!value)
+    return DEFAULT_LOCALE;
+  if (isPsnLocale(value))
+    return value;
+  const lower = value.toLowerCase();
+  const match = Object.keys(LOCALE_MAP).find((locale) => locale.toLowerCase() === lower);
+  return match ?? DEFAULT_LOCALE;
+}
+function getLocaleInfo(locale) {
+  return LOCALE_MAP[normalizeLocale(locale)];
+}
+function localeToSearchParams(locale) {
+  const info = getLocaleInfo(locale);
+  return {
+    countryCode: info.country,
+    languageCode: info.language
+  };
+}
+function localeToStorePath(locale) {
+  return normalizeLocale(locale).toLowerCase();
+}
+function parseLocaleList(input) {
+  if (!input)
+    return [];
+  const preset = TITLE_LOCALE_PRESETS[input.trim().toLowerCase()];
+  if (preset)
+    return [...preset];
+  const seen = new Set;
+  const locales = [];
+  for (const item of input.split(",")) {
+    const raw = item.trim();
+    if (!raw)
+      continue;
+    if (!isPsnLocale(raw) && !Object.keys(LOCALE_MAP).some((locale2) => locale2.toLowerCase() === raw.toLowerCase())) {
+      continue;
+    }
+    const locale = normalizeLocale(raw);
+    if (!seen.has(locale)) {
+      seen.add(locale);
+      locales.push(locale);
+    }
+  }
+  return locales;
+}
+
+// src/fetch.ts
+var API_BASE = "https://web.np.playstation.com/api/graphql/v1/op";
+var TIMEOUT_MS = 1e4;
+var MAX_RETRIES = 2;
+async function fetchPsnApi(operationName, sha256Hash, variables, locale) {
+  const url = new URL(API_BASE);
+  url.searchParams.set("operationName", operationName);
+  url.searchParams.set("variables", JSON.stringify(variables));
+  url.searchParams.set("extensions", JSON.stringify({
+    persistedQuery: { version: 1, sha256Hash }
+  }));
+  const headers = {
+    "apollo-require-preflight": "true",
+    "Accept-Encoding": "gzip, deflate",
+    Accept: "application/json"
+  };
+  if (locale) {
+    headers["x-psn-store-locale-override"] = normalizeLocale(locale);
+  }
+  let lastError = null;
+  for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
+      const response = await fetch(url.toString(), {
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+        throw new PsnApiError(`HTTP ${response.status}: ${body.slice(0, 200)}`, response.status, operationName, retryAfterMs);
+      }
+      const data = await response.json();
+      if (data.errors && data.errors.length > 0) {
+        throw new PsnApiError(`GraphQL error: ${data.errors[0]?.message ?? "Unknown error"}`, undefined, operationName);
+      }
+      return data.data;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (err instanceof PsnApiError && err.statusCode) {
+        if (err.statusCode !== 429 && err.statusCode < 500) {
+          throw err;
+        }
+      }
+      if (attempt === MAX_RETRIES) {
+        throw lastError;
+      }
+      const retryAfterMs = err instanceof PsnApiError ? err.retryAfterMs : undefined;
+      const delayMs = retryAfterMs ?? 1000 * (attempt + 1);
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  throw lastError ?? new Error("Unexpected error");
+}
+async function fetchHtml(url) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS * 2);
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; PsnStoreCLI/1.0)",
+        "Accept-Encoding": "gzip"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new PsnApiError(`HTML fetch failed: HTTP ${response.status}`, response.status);
+    }
+    return await response.text();
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (err instanceof PsnApiError)
+      throw err;
+    throw new PsnApiError(`HTML fetch error: ${err.message}`);
+  }
+}
+function parseRetryAfter(value) {
+  if (!value)
+    return;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.min(seconds * 1000, 30000);
+  }
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    return Math.min(Math.max(dateMs - Date.now(), 0), 30000);
+  }
+  return;
+}
+
+// src/cache.ts
+class Cache {
+  store = new Map;
+  defaultTtl;
+  constructor(defaultTtlMs = 5 * 60 * 1000) {
+    this.defaultTtl = defaultTtlMs;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return;
+    if (Date.now() > entry.expires) {
+      this.store.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.store.set(key, {
+      value,
+      expires: Date.now() + (ttlMs ?? this.defaultTtl)
+    });
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return false;
+    if (Date.now() > entry.expires) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+}
+var TTL = {
+  GAME_LOOKUP: 5 * 60 * 1000,
+  PRODUCT_TO_CONCEPT: 30 * 60 * 1000,
+  SEARCH: 2 * 60 * 1000,
+  CATEGORY: 2 * 60 * 1000,
+  BATARANG: 10 * 60 * 1000
+};
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_CONFIG = {
+  locale: "zh-hans-HK",
+  format: "text",
+  pageSize: 24,
+  verbose: false,
+  color: true
+};
+var cachedConfig = null;
+function loadConfigFile() {
+  const searchPaths = [
+    join(process.cwd(), "pstore.config.json"),
+    join(process.cwd(), "psn-config.json"),
+    join(homedir(), ".config", "pstore", "config.json"),
+    join(homedir(), ".config", "psn-cli", "config.json")
+  ];
+  for (const filePath of searchPaths) {
+    try {
+      if (existsSync(filePath)) {
+        const raw = readFileSync(filePath, "utf-8");
+        return JSON.parse(raw);
+      }
+    } catch {}
+  }
+  return {};
+}
+function getConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  const fileConfig = loadConfigFile();
+  cachedConfig = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    locale: normalizeLocale(fileConfig.locale ?? DEFAULT_CONFIG.locale),
+    pageSize: clampNumber(fileConfig.pageSize, 1, 100, DEFAULT_CONFIG.pageSize ?? 24)
+  };
+  return cachedConfig;
+}
+function clampNumber(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return fallback;
+  return Math.min(Math.max(Math.floor(value), min), max);
+}
+
+// src/utils.ts
+function detectIdType(id) {
+  return /^\d+$/.test(id) ? "concept" : "product";
+}
+function calcDiscountPercent(listPrice, salePrice) {
+  if (listPrice <= 0 || salePrice >= listPrice || salePrice < 0)
+    return null;
+  return Math.round((1 - salePrice / listPrice) * 100);
+}
+function isFreePrice(basePriceValue, discountedValue) {
+  return basePriceValue === 0 && discountedValue === 0;
+}
+function isIncludedPrice(basePriceValue, discountedValue, discountText, discountedPrice) {
+  if (basePriceValue === null || basePriceValue === undefined || basePriceValue <= 0)
+    return false;
+  if (discountedValue !== 0)
+    return false;
+  const text = `${discountText ?? ""} ${discountedPrice ?? ""}`;
+  return /included|包含/i.test(text);
+}
+function htmlEntityDecode(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&nbsp;/g, " ").replace(/<br\s*\/?>/gi, `
+`);
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]+>/g, "").trim();
+}
+
+// src/api/graphql.ts
+var HASH = {
+  TELEMETRY_CONCEPT: "906eef4a71644e7c6c9c7b300b68754e385f01149240c1767bbca493c5d92485",
+  TELEMETRY_PRODUCT: "71375f8f3dba0de83520ecd474069e037f8ea23b4efcb6778aef58894cd4452d",
+  PRICE_CONCEPT: "4ec6effdcdb6e041936c79acecd44aeea347ae3055d2b23ee2c794084b6e9c60",
+  PRICE_PRODUCT: "737838e0e3fe50986b4087b51327970a71c80497576bea07904e9ecf4a2dab02",
+  RATING_CONCEPT: "6c476325b232d51aca55ce143d6f946860e22174a263967fbb9e1da4f78489fa",
+  RATING_PRODUCT: "799fa113378f699281e0eda3154c54e03d763f6a98ad9a1378d58b1c2cb76cec",
+  UPSELL_CONCEPT: "20883918a853e2b01a1b73d5ee0bc23f337f00e4d1e07d5cbc8efde9223c460e",
+  UPSELL_PRODUCT: "a110672db9e20dc4f4d655fffd2f3a09730914ec3458cfb53de70cb2b526af53",
+  SEARCH: "6ef5e809c35a056a1150fdcf513d9c505484dd1a946b6208888435c3182f105a",
+  CATEGORY_GRID: "4e41660b6732f35c99fc5541926b7502a09557924e8c2cfebd1beb1a5c8c8f81"
+};
+async function fetchTelemetry(conceptId, locale) {
+  const data = await fetchPsnApi("queryRetrieveTelemetryDataPDPConcept", HASH.TELEMETRY_CONCEPT, { conceptId }, locale);
+  if (!data?.conceptRetrieve)
+    return null;
+  const cr = data.conceptRetrieve;
+  const dp = cr.defaultProduct;
+  return {
+    idType: "concept",
+    conceptId: cr.id,
+    productId: dp?.id,
+    name: cr.name,
+    productName: dp?.name,
+    edition: dp?.edition?.name ?? undefined,
+    genres: dp?.localizedGenres?.map((g) => g.value) ?? [],
+    skus: dp?.skus,
+    starRating: dp?.starRating ? { averageRating: dp.starRating.averageRating } : undefined,
+    price: extractBestPrice(dp?.webctas),
+    npTitleId: dp?.npTitleId,
+    classification: dp?.storeDisplayClassification,
+    topCategory: dp?.topCategory,
+    platforms: dp?.platforms,
+    releaseDate: cr.releaseDate?.value ?? undefined,
+    contentRating: dp?.contentRating ?? undefined
+  };
+}
+async function fetchTelemetryByProduct(productId, locale) {
+  const data = await fetchPsnApi("queryRetrieveTelemetryDataPDPProduct", HASH.TELEMETRY_PRODUCT, { productId }, locale);
+  const pr = data?.productRetrieve;
+  if (!pr)
+    return null;
+  return {
+    idType: "product",
+    conceptId: "",
+    productId,
+    productName: pr.name,
+    edition: pr.edition?.name ?? undefined,
+    genres: pr.localizedGenres?.map((g) => g.value) ?? [],
+    skus: pr.skus,
+    starRating: pr.starRating ? { averageRating: pr.starRating.averageRating } : undefined,
+    npTitleId: pr.npTitleId,
+    classification: pr.storeDisplayClassification,
+    topCategory: pr.topCategory,
+    platforms: pr.platforms,
+    releaseDate: pr.releaseDate?.value ?? undefined,
+    contentRating: pr.contentRating ?? undefined
+  };
+}
+function extractBestPrice(webctas) {
+  if (!webctas || webctas.length === 0)
+    return;
+  const numericPrice = webctas.find((w) => {
+    const val = w?.price?.basePriceValue ?? 0;
+    return val > 0;
+  });
+  if (numericPrice?.price)
+    return numericPrice.price;
+  const currencyMatch = webctas.find((w) => {
+    const bp = w?.price?.basePrice ?? "";
+    return bp.includes("HK$") || bp.includes("¥") || bp.startsWith("$") || bp.includes("€") || bp.includes("£");
+  });
+  if (currencyMatch?.price)
+    return currencyMatch.price;
+  const nonTrial = webctas.find((w) => {
+    const svc = w?.price?.serviceBranding;
+    if (svc?.includes("PS_PLUS"))
+      return false;
+    const bp = w?.price?.basePrice ?? "";
+    return !bp.includes("试玩") && !bp.includes("Free") && !bp.includes("Trial");
+  });
+  if (nonTrial?.price)
+    return nonTrial.price;
+  const fallback = webctas[0]?.price;
+  if (fallback)
+    return fallback;
+  return;
+}
+function toPrice(priceInfo) {
+  if (!priceInfo)
+    return;
+  return {
+    basePrice: priceInfo.basePrice ?? null,
+    basePriceValue: priceInfo.basePriceValue ?? null,
+    discountedPrice: priceInfo.discountedPrice ?? null,
+    discountedValue: priceInfo.discountedValue ?? null,
+    discountText: priceInfo.discountText ?? null,
+    currencyCode: priceInfo.currencyCode ?? null,
+    endTime: priceInfo.endTime ?? null,
+    isFree: isFreePrice(priceInfo.basePriceValue, priceInfo.discountedValue),
+    isIncluded: isIncludedPrice(priceInfo.basePriceValue, priceInfo.discountedValue, priceInfo.discountText, priceInfo.discountedPrice)
+  };
+}
+async function fetchPrice(conceptId, locale) {
+  const data = await fetchPsnApi("conceptRetrieveForCtasWithPrice", HASH.PRICE_CONCEPT, { conceptId }, locale);
+  if (!data?.conceptRetrieve)
+    return null;
+  const priceInfo = extractBestPrice(data.conceptRetrieve.defaultProduct?.webctas);
+  return {
+    price: toPrice(priceInfo),
+    conceptId: data.conceptRetrieve.id,
+    productId: data.conceptRetrieve.defaultProduct?.id,
+    products: data.conceptRetrieve.products?.map((p) => ({
+      id: p.id,
+      name: p.name,
+      edition: p.edition?.name
+    }))
+  };
+}
+async function fetchPriceByProduct(productId, locale) {
+  const data = await fetchPsnApi("productRetrieveForCtasWithPrice", HASH.PRICE_PRODUCT, { productId }, locale);
+  const priceInfo = extractBestPrice(data?.productRetrieve?.webctas);
+  if (!priceInfo)
+    return null;
+  return {
+    price: toPrice(priceInfo),
+    conceptId: data?.productRetrieve?.concept?.id,
+    productId: data?.productRetrieve?.id ?? productId
+  };
+}
+async function fetchRating(conceptId, locale) {
+  const data = await fetchPsnApi("wcaConceptStarRatingRetrive", HASH.RATING_CONCEPT, { conceptId }, locale);
+  if (!data?.conceptRetrieve)
+    return null;
+  return {
+    conceptId: data.conceptRetrieve.id,
+    name: data.conceptRetrieve.defaultProduct?.name ?? data.conceptRetrieve.defaultProduct?.name,
+    starRating: data.conceptRetrieve.defaultProduct?.starRating,
+    classification: data.conceptRetrieve.defaultProduct?.storeDisplayClassification,
+    topCategory: data.conceptRetrieve.defaultProduct?.topCategory,
+    releaseDate: data.conceptRetrieve.releaseDate?.value ?? undefined
+  };
+}
+async function fetchRatingByProduct(productId, locale) {
+  const data = await fetchPsnApi("wcaProductStarRatingRetrive", HASH.RATING_PRODUCT, { productId }, locale);
+  return {
+    conceptId: data?.productRetrieve?.concept?.id,
+    productId: data?.productRetrieve?.id ?? productId,
+    name: data?.productRetrieve?.name,
+    starRating: data?.productRetrieve?.starRating,
+    classification: data?.productRetrieve?.storeDisplayClassification,
+    topCategory: data?.productRetrieve?.topCategory,
+    releaseDate: data?.productRetrieve?.releaseDate?.value ?? undefined
+  };
+}
+async function fetchUpsell(conceptId, locale) {
+  const data = await fetchPsnApi("conceptRetrieveForUpsellWithCtas", HASH.UPSELL_CONCEPT, { conceptId }, locale);
+  if (!data?.conceptRetrieve)
+    return null;
+  return {
+    conceptId: data.conceptRetrieve.id,
+    media: data.conceptRetrieve.media?.filter((m) => m.type === "IMAGE").map((m) => ({
+      role: m.role,
+      type: m.type,
+      url: m.url
+    })),
+    products: data.conceptRetrieve.products?.map((p) => ({
+      id: p.id,
+      name: p.name,
+      edition: p.edition?.name,
+      editionType: p.edition?.type,
+      platforms: p.platforms,
+      classification: p.storeDisplayClassification,
+      price: toPrice(extractBestPrice(p.webctas)),
+      media: p.media?.filter((m) => m.type === "IMAGE").map((m) => ({
+        role: m.role,
+        type: m.type,
+        url: m.url
+      }))
+    }))
+  };
+}
+async function fetchUpsellByProduct(productId, locale) {
+  const data = await fetchPsnApi("productRetrieveForUpsellWithCtas", HASH.UPSELL_PRODUCT, { productId }, locale);
+  const concept = data?.productRetrieve?.concept;
+  if (!concept)
+    return null;
+  return {
+    conceptId: concept.id,
+    productId: data.productRetrieve?.id ?? productId,
+    media: concept.media?.filter((m) => m.type === "IMAGE").map((m) => ({
+      role: m.role,
+      type: m.type,
+      url: m.url
+    })),
+    products: concept.products?.map((p) => ({
+      id: p.id,
+      name: p.name,
+      edition: p.edition?.name,
+      editionType: p.edition?.type,
+      platforms: p.platforms,
+      classification: p.storeDisplayClassification,
+      price: toPrice(extractBestPrice(p.webctas))
+    }))
+  };
+}
+function parseSearchResults(data) {
+  if (!data)
+    return [];
+  const universalSearch = data.universalSearch;
+  if (Array.isArray(universalSearch?.results)) {
+    return universalSearch.results.map((item) => extractSearchHit(item)).filter((hit) => hit !== null);
+  }
+  for (const path of ["conceptRetrieve", "searchResults", "results"]) {
+    const section = data[path];
+    if (section && typeof section === "object") {
+      const items = extractItemsFromSection(section);
+      if (items.length > 0)
+        return items;
+    }
+  }
+  return [];
+}
+function extractItemsFromSection(section) {
+  const hits = [];
+  for (const value of Object.values(section)) {
+    if (!Array.isArray(value))
+      continue;
+    for (const item of value) {
+      if (typeof item !== "object" || item === null)
+        continue;
+      const hit = extractSearchHit(item);
+      if (hit)
+        hits.push(hit);
+    }
+  }
+  return hits;
+}
+function extractSearchHit(item) {
+  const id = item.id ?? item.productId ?? item.conceptId ?? "";
+  const name = item.name ?? item.title ?? "";
+  if (!id || !name)
+    return null;
+  const type = item.__typename?.includes("Product") ? "product" : "concept";
+  let price;
+  const priceObj = item.price;
+  if (priceObj?.displayPrice) {
+    price = priceObj.displayPrice;
+  } else if (priceObj?.basePrice) {
+    price = priceObj.basePrice;
+  }
+  return {
+    id: String(id),
+    name: String(name),
+    type,
+    price,
+    platforms: item.platforms,
+    classification: item.localizedStoreDisplayClassification ?? item.storeDisplayClassification
+  };
+}
+var cfg = getConfig();
+var categoryCache = new Cache(cfg.cacheTtl?.category ?? TTL.CATEGORY);
+async function fetchCategoryGrid(params) {
+  const result = await fetchCategoryGridResult(params);
+  return result?.items ?? null;
+}
+async function fetchCategoryGridResult(params) {
+  const sortBy = typeof params.sortBy === "string" && params.sortBy.length > 2 ? JSON.parse(params.sortBy) : params.sortBy ?? null;
+  const variables = {
+    id: params.id,
+    pageArgs: {
+      offset: params.offset ?? 0,
+      size: params.size ?? 24
+    },
+    sortBy,
+    filterBy: params.filterBy ?? [],
+    maxResults: params.maxResults ?? null,
+    facetOptions: [
+      "ageRating",
+      "conceptCompatibilityNotices",
+      "conceptGenres",
+      "conceptReleaseDate",
+      "conceptVrCompatibility",
+      "webBasePrice",
+      "productCompatibilityNotices",
+      "productGenres",
+      "productReleaseDate",
+      "productVrCompatibility",
+      "storeDisplayClassification",
+      "targetPlatforms"
+    ]
+  };
+  const cacheKey = JSON.stringify({ locale: params.locale, variables });
+  const cached = categoryCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const data = await fetchPsnApi("categoryGridRetrieve", HASH.CATEGORY_GRID, variables, params.locale);
+  const grid = data?.categoryGridRetrieve;
+  if (!grid)
+    return null;
+  const result = parseCategoryGridResult(params.id, grid, params.locale);
+  categoryCache.set(cacheKey, result);
+  return result;
+}
+function parseCategoryGridResult(id, grid, locale) {
+  return {
+    id,
+    localizedName: grid.localizedName,
+    displayName: resolveCategoryDisplayName(grid.localizedName, locale),
+    reportingName: grid.reportingName,
+    pageInfo: grid.pageInfo ? {
+      totalCount: grid.pageInfo.totalCount,
+      offset: grid.pageInfo.offset,
+      size: grid.pageInfo.size,
+      isLast: grid.pageInfo.isLast
+    } : undefined,
+    sortedBy: grid.sortedBy ? parseSortingOption(grid.sortedBy) : undefined,
+    sortingOptions: grid.sortingOptions?.map(parseSortingOption),
+    facets: grid.facetOptions?.map((facet) => ({
+      name: facet.name,
+      displayName: facet.displayName,
+      values: (facet.values ?? []).map((value) => ({
+        key: value.key,
+        displayName: value.displayName,
+        count: value.count
+      }))
+    })),
+    items: parseCategoryGridItems(grid)
+  };
+}
+function parseSortingOption(option) {
+  return {
+    name: option.name,
+    displayName: option.displayName,
+    isAscending: option.isAscending
+  };
+}
+function parseCategoryGridItems(grid) {
+  const nodes = grid.products?.length ? grid.products : grid.concepts ?? [];
+  return nodes.map((node) => ({
+    id: node.id,
+    name: node.name ?? "Unknown",
+    type: node.__typename?.includes("Product") ? "product" : "concept",
+    price: node.displayPrice ?? node.price?.discountedPrice ?? node.price?.basePrice,
+    platforms: node.platforms,
+    classification: node.localizedStoreDisplayClassification ?? node.storeDisplayClassification
+  }));
+}
+function clearCategoryCache() {
+  categoryCache.clear();
+}
+
+// src/api/browse.ts
+var HASH2 = {
+  EXPERIENCE: "ca9089d2e37af4044e054283ba4a84a6099a35b30d56d4c6bd00fa44eca2f07a",
+  DEFAULT_VIEW: "b359cfcf086857a5828ac75ac43cb863934f540df1b92cceb65f4b62bc61dd48"
+};
+var BROWSE_ALIAS = "browse";
+var BROWSE_CLIENT_ID = "b6de8d4d-bf9b-11ee-ad2a-aea73dc1ea43";
+var BROWSE_EXPERIENCE_ID = "7bbceafe-bfa8-11ee-b375-5e45f4e139ac";
+var BROWSE_CATEGORY_ID = "28c9c2b2-cecc-415c-9a08-482a605cb104";
+var BROWSE_LOCALIZED_KEY_ID = "cat.gma.x_All_games";
+function normalizeBrowseWindow(input) {
+  const value = (input ?? "all").toLowerCase().replace(/_/g, "-");
+  if (value === "next" || value === "next-thirty-days" || value === "next-30-days") {
+    return "next-thirty-days";
+  }
+  if (value === "last" || value === "last-thirty-days" || value === "last-30-days" || value === "latest") {
+    return "last-thirty-days";
+  }
+  return "all";
+}
+function resolveBrowseSortDefaults(window) {
+  switch (window) {
+    case "next-thirty-days":
+      return { sortBy: "conceptReleaseDate", order: "asc" };
+    case "last-thirty-days":
+      return { sortBy: "conceptReleaseDate", order: "desc" };
+    default:
+      return { sortBy: "sales30", order: "desc" };
+  }
+}
+function resolveBrowseQuery(query) {
+  const window = normalizeBrowseWindow(query.window);
+  const defaults = resolveBrowseSortDefaults(window);
+  const sortInput = query.sortBy?.toLowerCase();
+  let sortBy = normalizeBrowseSort(query.sortBy) ?? defaults.sortBy;
+  let order = normalizeBrowseOrder(query.order) ?? defaults.order;
+  if (sortInput === "price-asc") {
+    sortBy = "webBasePrice";
+    order = "asc";
+  } else if (sortInput === "price-desc") {
+    sortBy = "webBasePrice";
+    order = "desc";
+  } else if (sortInput === "name-desc") {
+    sortBy = "conceptName";
+    order = "desc";
+  } else if (sortInput === "release-new") {
+    sortBy = "conceptReleaseDate";
+    order = "desc";
+  } else if (sortInput === "release-old") {
+    sortBy = "conceptReleaseDate";
+    order = "asc";
+  }
+  const filters = resolveBrowseFilters(query);
+  return {
+    window,
+    sortBy,
+    order,
+    page: Math.max(1, query.page ?? 1),
+    size: Math.min(Math.max(1, query.size ?? 24), 100),
+    sample: query.sample && query.sample > 0 ? query.sample : undefined,
+    filters
+  };
+}
+function sampleItems(items, count, rng = Math.random) {
+  if (count <= 0)
+    return [];
+  if (count >= items.length)
+    return [...items];
+  const pool = [...items];
+  for (let i = pool.length - 1;i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const current = pool[i];
+    const target = pool[j];
+    if (current !== undefined && target !== undefined) {
+      pool[i] = target;
+      pool[j] = current;
+    }
+  }
+  return pool.slice(0, count);
+}
+async function fetchBrowseGrid(query) {
+  const resolved = resolveBrowseQuery(query);
+  const categoryId = await resolveBrowseCategoryId(query.locale);
+  const filterBy = resolved.filters;
+  const items = await fetchCategoryGrid({
+    id: categoryId,
+    offset: (resolved.page - 1) * resolved.size,
+    size: resolved.size,
+    sortBy: { name: resolved.sortBy, isAscending: resolved.order === "asc" },
+    filterBy,
+    maxResults: null,
+    locale: query.locale
+  });
+  if (!items)
+    return null;
+  return {
+    categoryId,
+    items,
+    query: resolved
+  };
+}
+async function resolveBrowseCategoryId(locale) {
+  try {
+    await fetchPsnApi("getExperience", HASH2.EXPERIENCE, { clientId: BROWSE_CLIENT_ID, alias: BROWSE_ALIAS }, locale);
+    const defaultView = await fetchPsnApi("getDefaultView", HASH2.DEFAULT_VIEW, {
+      experienceId: BROWSE_EXPERIENCE_ID,
+      categoryId: BROWSE_CATEGORY_ID,
+      localizedKeyId: BROWSE_LOCALIZED_KEY_ID
+    }, locale);
+    const candidate = pickString([
+      defaultView?.categoryId,
+      defaultView?.gridCategoryId,
+      defaultView?.defaultView?.categoryId,
+      defaultView?.getDefaultView?.categoryId,
+      defaultView?.data?.categoryId,
+      defaultView?.data?.gridCategoryId
+    ]);
+    return candidate ?? BROWSE_CATEGORY_ID;
+  } catch {
+    return BROWSE_CATEGORY_ID;
+  }
+}
+function normalizeBrowseSort(input) {
+  if (!input)
+    return null;
+  const value = input.toLowerCase();
+  if (value === "conceptreleasedate" || value === "release-date" || value === "releasedate") {
+    return "conceptReleaseDate";
+  }
+  if (value === "conceptname" || value === "name") {
+    return "conceptName";
+  }
+  if (value === "sales30" || value === "best-selling" || value === "bestselling") {
+    return "sales30";
+  }
+  if (value === "downloads30" || value === "best-downloaded" || value === "bestdownloaded") {
+    return "downloads30";
+  }
+  if (value === "webbaseprice") {
+    return "webBasePrice";
+  }
+  if (value === "contentcollections.contentcollectionstartdate" || value === "content-collection-start-date") {
+    return "contentCollections.contentCollectionStartDate";
+  }
+  return input;
+}
+function normalizeBrowseOrder(input) {
+  if (!input)
+    return null;
+  const value = input.toLowerCase();
+  if (value === "asc" || value === "ascending")
+    return "asc";
+  if (value === "desc" || value === "descending")
+    return "desc";
+  return null;
+}
+function resolveBrowseFilters(query) {
+  const filters = [];
+  const window = normalizeBrowseWindow(query.window);
+  if (query.filters) {
+    for (const filter of query.filters) {
+      const normalized = filter.trim();
+      if (normalized) {
+        filters.push(normalized);
+      }
+    }
+  }
+  const pushFacet = (facet, values) => {
+    for (const value of values ?? []) {
+      const normalized = value.trim();
+      if (normalized) {
+        filters.push(`${facet}:${normalized}`);
+      }
+    }
+  };
+  pushFacet("targetPlatforms", query.platforms);
+  pushFacet("conceptGenres", query.genres);
+  pushFacet("webBasePrice", query.prices);
+  pushFacet("storeDisplayClassification", query.classifications);
+  pushFacet("ageRating", query.ageRatings);
+  pushFacet("productVrCompatibility", query.vrCompatibilities);
+  pushFacet("conceptCompatibilityNotices", query.notices);
+  if (window === "next-thirty-days") {
+    filters.unshift("conceptReleaseDate:next_thirty_days");
+  } else if (window === "last-thirty-days") {
+    filters.unshift("conceptReleaseDate:last_thirty_days");
+  }
+  return filters;
+}
+function pickString(values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+
+// src/api/search.ts
+var SEARCH_HASH = "6ef5e809c35a056a1150fdcf513d9c505484dd1a946b6208888435c3182f105a";
+var cfg2 = getConfig();
+var searchCache = new Cache(cfg2.cacheTtl?.search ?? TTL.SEARCH);
+async function searchGames(options) {
+  const localeInfo = localeToSearchParams(options.locale);
+  const page = options.page ?? 1;
+  const size = options.size ?? 24;
+  const variables = {
+    searchTerm: options.term,
+    countryCode: localeInfo.countryCode,
+    languageCode: localeInfo.languageCode,
+    pageSize: size,
+    pageOffset: (page - 1) * size
+  };
+  if (options.nextCursor) {
+    variables.nextCursor = options.nextCursor;
+  }
+  const cacheKey = JSON.stringify({ locale: options.locale, variables });
+  const cached = searchCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const rawData = await fetchPsnApi("getSearchResults", SEARCH_HASH, variables, options.locale);
+  const response = parseSearchResponse(rawData, page, size);
+  searchCache.set(cacheKey, response);
+  return response;
+}
+function parseSearchResponse(rawData, page, size) {
+  const hits = parseSearchResults(rawData);
+  const nextCursor = extractNextCursor(rawData);
+  const pageInfo = extractPageInfo(rawData);
+  return {
+    hits,
+    page,
+    size,
+    nextCursor,
+    isLast: pageInfo?.isLast,
+    total: pageInfo?.totalCount
+  };
+}
+function extractNextCursor(data) {
+  if (!data)
+    return;
+  const universalSearch = data.universalSearch;
+  return universalSearch?.next;
+}
+function extractPageInfo(data) {
+  if (!data)
+    return;
+  const universalSearch = data.universalSearch;
+  const pageInfo = universalSearch?.pageInfo;
+  if (!pageInfo)
+    return;
+  return {
+    isLast: typeof pageInfo.isLast === "boolean" ? pageInfo.isLast : undefined,
+    totalCount: typeof pageInfo.totalCount === "number" ? pageInfo.totalCount : undefined
+  };
+}
+function clearSearchCache() {
+  searchCache.clear();
+}
+
+// src/api/status.ts
+var STATUS_CONFIG_URL = "https://status.playstation.com/config/app.json";
+var DEFAULT_STATUS_BASE_URL = "https://status.playstation.com/data/";
+var DEFAULT_STATUS_SUFFIX = ".json";
+async function fetchPsnStatus(options = {}) {
+  const locale = normalizeLocale(options.locale);
+  const country = (options.country ?? getLocaleInfo(locale).country).toUpperCase();
+  const region = options.region ?? regionForCountry(country);
+  const config = await fetchStatusConfig().catch(() => null);
+  const baseUrl = config?.status_base_url ?? DEFAULT_STATUS_BASE_URL;
+  const suffix = config?.status_base_url_suffix ?? DEFAULT_STATUS_SUFFIX;
+  const url = `${baseUrl}statuses/region/${region}${suffix}`;
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": "pstore/0.0 status-check"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`PlayStation status request failed: HTTP ${response.status}`);
+  }
+  const raw = await response.json();
+  return parsePsnStatus(raw, {
+    locale,
+    country,
+    region,
+    refreshIntervalMs: config?.status_refresh_interval
+  });
+}
+function parsePsnStatus(raw, context) {
+  const country = raw.countries?.find((item) => item.countryCode?.toUpperCase() === context.country);
+  if (!country) {
+    throw new Error(`Country ${context.country} not found in PlayStation status region ${context.region}`);
+  }
+  const incidents = normalizeIncidents(country.status ?? raw.status ?? [], context.locale);
+  const services = (country.services ?? []).map((service) => {
+    const serviceIncidents = normalizeIncidents(service.status ?? [], context.locale);
+    const resources = (service.resources ?? []).map((resource) => {
+      const resourceIncidents = normalizeIncidents(resource.status ?? [], context.locale);
+      return {
+        name: pickLocalizedText(resource.i18n, context.locale) ?? resource.resourceName ?? "Unknown",
+        status: statusFromIncidents(resourceIncidents),
+        incidents: resourceIncidents
+      };
+    });
+    return {
+      id: service.serviceId ?? service.serviceName ?? "unknown",
+      name: pickLocalizedText(service.i18n, context.locale) ?? service.serviceName ?? "Unknown",
+      status: statusFromIncidents(serviceIncidents),
+      incidents: serviceIncidents,
+      resources
+    };
+  });
+  return {
+    region: context.region,
+    country: context.country,
+    locale: context.locale,
+    overallStatus: statusFromStatuses([
+      statusFromIncidents(incidents),
+      ...services.map((service) => service.status)
+    ]),
+    generatedAt: raw.generatedAt,
+    updatedAt: latestModifiedDate([...incidents, ...services.flatMap((service) => service.incidents)]),
+    refreshIntervalMs: context.refreshIntervalMs,
+    services,
+    incidents
+  };
+}
+function regionForCountry(country) {
+  const code = country.toUpperCase();
+  if (["US", "CA", "MX", "BR", "AR", "CL", "CO", "PE"].includes(code))
+    return "SCEA";
+  if (["HK", "TW", "JP", "CN", "KR", "SG", "TH", "MY", "ID"].includes(code))
+    return "SCEJA";
+  return "SCEE";
+}
+async function fetchStatusConfig() {
+  const response = await fetch(STATUS_CONFIG_URL, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": "pstore/0.0 status-check"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`PlayStation status config request failed: HTTP ${response.status}`);
+  }
+  return response.json();
+}
+function normalizeIncidents(statuses, locale) {
+  return statuses.filter((status) => normalizeStatusType(status.statusType) !== "ok").map((status) => ({
+    id: status.statusId,
+    statusType: status.statusType ?? "Unknown",
+    message: pickLocalizedText(status.message?.messages, locale) ?? status.message?.messageKey,
+    startDate: status.startDate,
+    modifiedDate: status.modifiedDate
+  }));
+}
+function statusFromIncidents(incidents) {
+  return statusFromStatuses(incidents.map((incident) => normalizeStatusType(incident.statusType)));
+}
+function statusFromStatuses(statuses) {
+  if (statuses.includes("outage"))
+    return "outage";
+  if (statuses.includes("degraded"))
+    return "degraded";
+  if (statuses.includes("maintenance"))
+    return "maintenance";
+  return "ok";
+}
+function normalizeStatusType(statusType) {
+  const value = statusType?.toLowerCase();
+  if (value === "outage")
+    return "outage";
+  if (value === "degraded")
+    return "degraded";
+  if (value === "maintenance")
+    return "maintenance";
+  return "ok";
+}
+function pickLocalizedText(values, locale) {
+  if (!values)
+    return;
+  if (values[locale])
+    return values[locale];
+  const language = locale.split("-")[0]?.toLowerCase();
+  const sameLanguage = Object.entries(values).find(([key]) => key.toLowerCase().startsWith(`${language}-`));
+  if (sameLanguage)
+    return sameLanguage[1];
+  return values["en-US"] ?? values["en-GB"] ?? Object.values(values)[0];
+}
+function latestModifiedDate(incidents) {
+  return incidents.map((incident) => incident.modifiedDate ?? incident.startDate).filter((value) => Boolean(value)).sort().at(-1);
+}
+
+// src/api/batarang.ts
+var ENV_SCRIPT_RE = /<script\s+id="env:[^"]*"\s+type="application\/json">([\s\S]*?)<\/script>/gi;
+async function fetchBatarang(conceptId, locale) {
+  const localePath = localeToStorePath(locale);
+  const url = `https://store.playstation.com/${localePath}/concept/${conceptId}`;
+  try {
+    const html = await fetchHtml(url);
+    return parseBatarangAll(html);
+  } catch {
+    return null;
+  }
+}
+async function fetchBatarangByProduct(productId, locale) {
+  const localePath = localeToStorePath(locale);
+  const url = `https://store.playstation.com/${localePath}/product/${productId}`;
+  try {
+    const html = await fetchHtml(url);
+    return parseBatarangAll(html);
+  } catch {
+    return null;
+  }
+}
+function extractEnvScripts(html) {
+  const scripts = [];
+  let match;
+  while ((match = ENV_SCRIPT_RE.exec(html)) !== null) {
+    const script = match[1];
+    if (script)
+      scripts.push(script);
+  }
+  return scripts;
+}
+function parseBatarangAll(html) {
+  const scripts = extractEnvScripts(html);
+  const merged = {};
+  const conceptEntries = {};
+  for (const script of scripts) {
+    try {
+      const data = JSON.parse(script);
+      const cache = data.cache ?? {};
+      for (const [key, value] of Object.entries(cache)) {
+        if (typeof value !== "object" || value === null)
+          continue;
+        const record = value;
+        if (key.startsWith("Product:")) {
+          const id = key.split(":").slice(1).join(":");
+          merged[id] = smartMerge(merged[id], record);
+        } else if (key.startsWith("Concept:")) {
+          const id = key.split(":").slice(1).join(":");
+          conceptEntries[id] = smartMerge(conceptEntries[id], record);
+        }
+      }
+    } catch {}
+  }
+  const result = {};
+  for (const product of Object.values(merged)) {
+    if (!result.name && typeof product.name === "string") {
+      result.name = product.name;
+    }
+    if (!result.edition && product.edition && typeof product.edition === "object") {
+      const edition = product.edition;
+      if (typeof edition.name === "string") {
+        result.edition = edition.name;
+      }
+    }
+    if (!result.genres && Array.isArray(product.localizedGenres)) {
+      result.genres = product.localizedGenres.map((g) => g.value).filter((value) => typeof value === "string" && value.length > 0);
+    }
+    if (!result.platforms && Array.isArray(product.platforms)) {
+      result.platforms = product.platforms.filter((platform) => typeof platform === "string" && platform.length > 0);
+    }
+    if (!result.classification && typeof product.storeDisplayClassification === "string") {
+      result.classification = product.storeDisplayClassification;
+    }
+    if (!result.topCategory && typeof product.topCategory === "string") {
+      result.topCategory = product.topCategory;
+    }
+    if (!result.npTitleId && typeof product.npTitleId === "string") {
+      result.npTitleId = product.npTitleId;
+    }
+    if (!result.starRating && product.starRating && typeof product.starRating === "object") {
+      const sr = product.starRating;
+      const averageRating = typeof sr.averageRating === "number" ? sr.averageRating : undefined;
+      if (typeof averageRating === "number") {
+        result.starRating = {
+          averageRating,
+          averageRatingForDisplay: typeof sr.averageRatingForDisplay === "string" ? sr.averageRatingForDisplay : undefined,
+          totalRatingsCount: typeof sr.totalRatingsCount === "number" ? sr.totalRatingsCount : undefined,
+          ratingsDistribution: Array.isArray(sr.ratingsDistribution) ? sr.ratingsDistribution : undefined
+        };
+      }
+    }
+    if (product.descriptions) {
+      result.descriptions = product.descriptions;
+    }
+    if (product.publisherName) {
+      result.publisherName = product.publisherName;
+    }
+    if (result.descriptions && result.publisherName) {
+      break;
+    }
+  }
+  for (const concept of Object.values(conceptEntries)) {
+    if (!result.name && typeof concept.name === "string") {
+      result.name = concept.name;
+    }
+    if (!result.genres && Array.isArray(concept.localizedGenres)) {
+      result.genres = concept.localizedGenres.map((g) => g.value).filter((value) => typeof value === "string" && value.length > 0);
+    }
+    if (!result.platforms && Array.isArray(concept.platforms)) {
+      result.platforms = concept.platforms.filter((platform) => typeof platform === "string" && platform.length > 0);
+    }
+    if (!result.classification && typeof concept.storeDisplayClassification === "string") {
+      result.classification = concept.storeDisplayClassification;
+    }
+    if (!result.topCategory && typeof concept.topCategory === "string") {
+      result.topCategory = concept.topCategory;
+    }
+    if (!result.npTitleId && typeof concept.npTitleId === "string") {
+      result.npTitleId = concept.npTitleId;
+    }
+    if (!result.starRating && concept.starRating && typeof concept.starRating === "object") {
+      const sr = concept.starRating;
+      const averageRating = typeof sr.averageRating === "number" ? sr.averageRating : undefined;
+      if (typeof averageRating === "number") {
+        result.starRating = {
+          averageRating,
+          averageRatingForDisplay: typeof sr.averageRatingForDisplay === "string" ? sr.averageRatingForDisplay : undefined,
+          totalRatingsCount: typeof sr.totalRatingsCount === "number" ? sr.totalRatingsCount : undefined,
+          ratingsDistribution: Array.isArray(sr.ratingsDistribution) ? sr.ratingsDistribution : undefined
+        };
+      }
+    }
+    if (!result.descriptions && concept.descriptions) {
+      result.descriptions = concept.descriptions;
+    }
+    if (!result.publisherName && concept.publisherName) {
+      result.publisherName = concept.publisherName;
+    }
+  }
+  for (const product of Object.values(merged)) {
+    if (!result.releaseDate) {
+      const releaseDate = extractReleaseDate(product.releaseDate);
+      if (releaseDate) {
+        result.releaseDate = releaseDate;
+      }
+    }
+  }
+  for (const concept of Object.values(conceptEntries)) {
+    if (!result.releaseDate) {
+      const releaseDate = extractReleaseDate(concept.releaseDate);
+      if (releaseDate) {
+        result.releaseDate = releaseDate;
+      }
+    }
+  }
+  for (const product of Object.values(merged)) {
+    if (product.compatibilityNoticesByPlatform && !result.compatibilityNoticesByPlatform) {
+      result.compatibilityNoticesByPlatform = product.compatibilityNoticesByPlatform;
+    }
+    if (product.screenLanguages && !result.screenLanguages) {
+      result.screenLanguages = product.screenLanguages;
+    }
+    if (product.spokenLanguages && !result.spokenLanguages) {
+      result.spokenLanguages = product.spokenLanguages;
+    }
+    if (product.contentRating && !result.contentRating) {
+      result.contentRating = product.contentRating;
+    }
+  }
+  for (const concept of Object.values(conceptEntries)) {
+    if (!result.contentRating && concept.contentRating) {
+      result.contentRating = concept.contentRating;
+    }
+  }
+  return result;
+}
+function extractReleaseDate(value) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.value === "string" && record.value.length > 0) {
+      return record.value;
+    }
+  }
+  return;
+}
+function smartMerge(existing, incoming) {
+  if (!existing)
+    return { ...incoming };
+  const result = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    if (value === null || value === undefined)
+      continue;
+    const current = result[key];
+    if (current === undefined || current === null) {
+      result[key] = value;
+    } else if (Array.isArray(value) && Array.isArray(current)) {
+      if (value.length > current.length) {
+        result[key] = value;
+      }
+    } else if (typeof value === "object" && typeof current === "object" && !Array.isArray(value) && !Array.isArray(current)) {
+      if (Object.keys(value).length > Object.keys(current).length) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/build-record.ts
+function buildLookupRecord(data) {
+  const { inputId, telemetry, price, rating, upsell, batarang, concept, locale, timing, includeProducts, warnings } = data;
+  const idType = data.idType ?? telemetry?.idType;
+  const conceptId = telemetry?.conceptId || price?.conceptId || rating?.conceptId || upsell?.conceptId || undefined;
+  const productId = telemetry?.productId ?? price?.productId ?? rating?.productId ?? upsell?.productId;
+  const resolvedPrice = resolvePrice(price, telemetry);
+  const resolvedName = telemetry?.name ?? telemetry?.productName ?? rating?.name ?? batarang?.name ?? "";
+  const resolvedRating = rating?.starRating ?? telemetry?.starRating ?? batarang?.starRating ?? undefined;
+  const resolvedReleaseDate = batarang?.releaseDate ?? telemetry?.releaseDate ?? rating?.releaseDate ?? undefined;
+  const resolvedMedia = upsell?.media;
+  const resolvedProducts = includeProducts ? upsell?.products?.map((p) => ({
+    id: p.id,
+    name: p.name ?? "",
+    edition: p.edition ? { name: p.edition } : undefined,
+    price: p.price,
+    platforms: p.platforms,
+    storeDisplayClassification: p.classification
+  })) : undefined;
+  const result = {
+    id: idType === "product" ? productId ?? inputId ?? "" : conceptId ?? inputId ?? "",
+    idType,
+    conceptId,
+    productId,
+    name: resolvedName,
+    locale: locale ?? "zh-hans-HK",
+    productName: telemetry?.productName,
+    edition: telemetry?.edition ?? batarang?.edition,
+    genres: telemetry?.genres ?? batarang?.genres,
+    publisher: batarang?.publisherName ?? undefined,
+    releaseDate: resolvedReleaseDate,
+    price: resolvedPrice,
+    starRating: resolvedRating,
+    classification: telemetry?.classification ?? rating?.classification ?? batarang?.classification,
+    topCategory: telemetry?.topCategory ?? rating?.topCategory ?? batarang?.topCategory,
+    platforms: telemetry?.platforms ?? batarang?.platforms,
+    skus: telemetry?.skus,
+    descriptions: batarang?.descriptions,
+    media: resolvedMedia,
+    products: resolvedProducts,
+    npTitleId: telemetry?.npTitleId ?? batarang?.npTitleId,
+    contentRating: batarang?.contentRating ?? telemetry?.contentRating ?? undefined,
+    sources: {
+      name: telemetry?.name ? "telemetry" : telemetry?.productName ? "telemetry" : rating?.name ? "rating" : batarang?.name ? "batarang" : "none",
+      edition: telemetry?.edition ? "telemetry" : batarang?.edition ? "batarang" : "none",
+      genres: telemetry?.genres?.length ? "telemetry" : batarang?.genres?.length ? "batarang" : "none",
+      publisher: batarang?.publisherName ? "batarang" : "none",
+      releaseDate: batarang?.releaseDate ? "batarang" : telemetry?.releaseDate ? "telemetry" : rating?.releaseDate ? "rating" : "none",
+      price: price?.price ? "price" : telemetry?.price ? "telemetry" : "none",
+      starRating: rating?.starRating ? "rating" : telemetry?.starRating ? "telemetry" : batarang?.starRating ? "batarang" : "none",
+      classification: telemetry?.classification ? "telemetry" : rating?.classification ? "rating" : batarang?.classification ? "batarang" : "none",
+      topCategory: telemetry?.topCategory ? "telemetry" : rating?.topCategory ? "rating" : batarang?.topCategory ? "batarang" : "none",
+      platforms: telemetry?.platforms?.length ? "telemetry" : batarang?.platforms?.length ? "batarang" : "none",
+      skus: telemetry?.skus?.length ? "telemetry" : "none",
+      descriptions: batarang?.descriptions?.length ? "batarang" : "none",
+      media: resolvedMedia?.length ? "upsell" : "none",
+      products: resolvedProducts?.length ? "upsell" : "none",
+      npTitleId: telemetry?.npTitleId ? "telemetry" : batarang?.npTitleId ? "batarang" : "none",
+      contentRating: batarang?.contentRating ? "batarang" : telemetry?.contentRating ? "telemetry" : "none"
+    },
+    timing,
+    warnings: warnings && warnings.length > 0 ? warnings : undefined,
+    concept: concept ?? undefined
+  };
+  return result;
+}
+function resolvePrice(priceResult, telemetry) {
+  if (priceResult?.price) {
+    const p = priceResult.price;
+    const discountPercent = p.basePriceValue && p.discountedValue && p.basePriceValue > 0 ? calcDiscountPercent(p.basePriceValue, p.discountedValue) : null;
+    return {
+      ...p,
+      discountPercent,
+      isFree: isFreePrice(p.basePriceValue, p.discountedValue),
+      isIncluded: p.isIncluded ?? isIncludedPrice(p.basePriceValue, p.discountedValue, p.discountText, p.discountedPrice)
+    };
+  }
+  if (telemetry?.price) {
+    const p = telemetry.price;
+    const discountPercent = p.basePriceValue && p.discountedValue && p.basePriceValue > 0 ? calcDiscountPercent(p.basePriceValue, p.discountedValue) : null;
+    return {
+      basePrice: p.basePrice ?? null,
+      basePriceValue: p.basePriceValue ?? null,
+      discountedPrice: p.discountedPrice ?? null,
+      discountedValue: p.discountedValue ?? null,
+      discountText: null,
+      currencyCode: null,
+      endTime: null,
+      discountPercent,
+      isFree: isFreePrice(p.basePriceValue, p.discountedValue),
+      isIncluded: isIncludedPrice(p.basePriceValue, p.discountedValue, p.discountText, p.discountedPrice)
+    };
+  }
+  return;
+}
+
+// src/perf.ts
+class PerfTracer {
+  startTime;
+  spans = new Map;
+  label;
+  constructor(label) {
+    this.startTime = performance.now();
+    this.label = label ?? "trace";
+  }
+  async span(name, fn) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      this.spans.set(name, performance.now() - start);
+    }
+  }
+  spanSync(name, fn) {
+    const start = performance.now();
+    try {
+      return fn();
+    } finally {
+      this.spans.set(name, performance.now() - start);
+    }
+  }
+  elapsed() {
+    return performance.now() - this.startTime;
+  }
+  getTiming() {
+    const result = {};
+    for (const [name, duration] of this.spans) {
+      result[name] = Math.round(duration);
+    }
+    result.total = Math.round(this.elapsed());
+    return result;
+  }
+  report() {
+    const total = this.elapsed();
+    console.log(`
+${this.label}:`);
+    console.log("Phase".padEnd(30), "Time".padEnd(10), "%");
+    console.log("-".repeat(50));
+    for (const [name, duration] of this.spans) {
+      const pct = total > 0 ? (duration / total * 100).toFixed(1) : "0.0";
+      console.log(name.padEnd(30), `${Math.round(duration)}ms`.padEnd(10), `${pct}%`);
+    }
+    console.log("-".repeat(50));
+    console.log("total".padEnd(30), `${Math.round(total)}ms`);
+  }
+}
+
+// src/provider.ts
+var cfg3 = getConfig();
+var lookupCache = new Cache(cfg3.cacheTtl?.lookup ?? TTL.GAME_LOOKUP);
+var conceptCache = new Cache(TTL.PRODUCT_TO_CONCEPT);
+async function lookupGame(id, options = {}) {
+  const perf = new PerfTracer("lookup");
+  const locale = normalizeLocale(options.locale);
+  const idType = detectIdType(id);
+  const warnings = [];
+  const warn = (source, err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    warnings.push({ source, message: message.slice(0, 200) });
+    return null;
+  };
+  const titleLocales = normalizeTitleLocales(options.titleLocales);
+  const requestPlan = resolveLookupRequestPlan(options);
+  const cacheKey = [
+    id,
+    locale,
+    requestPlan.profile,
+    requestPlan.includeTelemetry,
+    requestPlan.includePrice,
+    requestPlan.includeRating,
+    requestPlan.includeUpsell,
+    requestPlan.includeProducts,
+    requestPlan.includeConcept,
+    requestPlan.includeBatarang,
+    titleLocales.join(",")
+  ].join(":");
+  const cached = lookupCache.get(cacheKey);
+  if (cached) {
+    return { result: cached, fromCache: true };
+  }
+  const useProductApi = idType === "product";
+  const queryId = id;
+  const [telemetry, price, rating, upsell, batarang] = await Promise.all([
+    requestPlan.includeTelemetry ? perf.span("telemetry", () => useProductApi ? fetchTelemetryByProduct(queryId, locale) : fetchTelemetry(queryId, locale)).catch((err) => warn("telemetry", err)) : Promise.resolve(null),
+    requestPlan.includePrice ? perf.span("price", () => useProductApi ? fetchPriceByProduct(queryId, locale) : fetchPrice(queryId, locale)).catch((err) => warn("price", err)) : Promise.resolve(null),
+    requestPlan.includeRating ? perf.span("rating", () => useProductApi ? fetchRatingByProduct(queryId, locale) : fetchRating(queryId, locale)).catch((err) => warn("rating", err)) : Promise.resolve(null),
+    requestPlan.includeUpsell || requestPlan.includeProducts ? perf.span("upsell", () => useProductApi ? fetchUpsellByProduct(queryId, locale) : fetchUpsell(queryId, locale)).catch((err) => warn("upsell", err)) : Promise.resolve(null),
+    requestPlan.includeBatarang ? perf.span("batarang", async () => {
+      return useProductApi ? fetchBatarangByProduct(queryId, locale) : fetchBatarang(queryId, locale);
+    }).catch((err) => warn("batarang", err)) : Promise.resolve(null)
+  ]);
+  const conceptId = telemetry?.conceptId || price?.conceptId || rating?.conceptId || upsell?.conceptId || (useProductApi ? conceptCache.get(id) : id);
+  if (useProductApi && conceptId) {
+    conceptCache.set(id, conceptId);
+  }
+  const concept = useProductApi && requestPlan.includeConcept && conceptId ? await buildConceptSupplement(conceptId, locale, warn) : null;
+  const result = buildLookupRecord({
+    inputId: id,
+    idType,
+    telemetry,
+    price,
+    rating,
+    upsell,
+    batarang,
+    concept,
+    locale,
+    timing: perf.getTiming(),
+    includeProducts: requestPlan.includeProducts,
+    warnings
+  });
+  if (titleLocales.length > 0) {
+    result.localizedTitles = await fetchLocalizedTitles(queryId, useProductApi, titleLocales, warn);
+  }
+  lookupCache.set(cacheKey, result);
+  return { result, fromCache: false };
+}
+function resolveLookupRequestPlan(options) {
+  const profile = options.profile ?? "default";
+  const profileDefaults = profile === "title-maintenance" ? {
+    includeTelemetry: true,
+    includePrice: false,
+    includeRating: false,
+    includeUpsell: false,
+    includeProducts: false,
+    includeConcept: false,
+    includeBatarang: true
+  } : {
+    includeTelemetry: true,
+    includePrice: true,
+    includeRating: true,
+    includeUpsell: true,
+    includeProducts: options.includeProducts ?? false,
+    includeConcept: options.includeConcept ?? false,
+    includeBatarang: options.includeBatarang ?? false
+  };
+  return {
+    profile,
+    includeTelemetry: options.includeTelemetry ?? profileDefaults.includeTelemetry,
+    includePrice: options.includePrice ?? profileDefaults.includePrice,
+    includeRating: options.includeRating ?? profileDefaults.includeRating,
+    includeUpsell: options.includeUpsell ?? profileDefaults.includeUpsell,
+    includeProducts: options.includeProducts ?? profileDefaults.includeProducts,
+    includeConcept: options.includeConcept ?? profileDefaults.includeConcept,
+    includeBatarang: options.includeBatarang ?? profileDefaults.includeBatarang
+  };
+}
+function normalizeTitleLocales(locales) {
+  const seen = new Set;
+  const result = [];
+  for (const locale of locales ?? []) {
+    const normalized = normalizeLocale(locale);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      result.push(normalized);
+    }
+  }
+  return result;
+}
+async function fetchLocalizedTitles(id, useProductApi, locales, warn) {
+  const entries = await Promise.all(locales.map(async (locale) => {
+    const telemetry = await (useProductApi ? fetchTelemetryByProduct(id, locale) : fetchTelemetry(id, locale)).catch((err) => warn("telemetry", err));
+    const title = telemetry?.name ?? telemetry?.productName;
+    return [locale, title];
+  }));
+  const titles = {};
+  for (const [locale, title] of entries) {
+    if (title)
+      titles[locale] = title;
+  }
+  return titles;
+}
+async function buildConceptSupplement(conceptId, locale, warn) {
+  const [telemetry, price, rating, upsell] = await Promise.all([
+    fetchTelemetry(conceptId, locale).catch((err) => warn("telemetry", err)),
+    fetchPrice(conceptId, locale).catch((err) => warn("price", err)),
+    fetchRating(conceptId, locale).catch((err) => warn("rating", err)),
+    fetchUpsell(conceptId, locale).catch((err) => warn("upsell", err))
+  ]);
+  return buildLookupRecord({
+    inputId: conceptId,
+    idType: "concept",
+    telemetry,
+    price,
+    rating,
+    upsell,
+    locale,
+    includeProducts: true
+  });
+}
+function clearCaches() {
+  lookupCache.clear();
+  conceptCache.clear();
+  clearSearchCache();
+  clearCategoryCache();
+}
+
+// src/client.ts
+var defaultDeps = {
+  lookupGame,
+  searchGames,
+  fetchBrowseGrid,
+  fetchCategoryGrid,
+  fetchCategoryGridResult,
+  fetchPsnStatus
+};
+function createPstoreClient(options = {}) {
+  return createPstoreClientWithDeps(options, defaultDeps);
+}
+function createPstoreClientWithDeps(options = {}, deps) {
+  const defaultLocale = normalizeLocale(options.locale ?? DEFAULT_LOCALE);
+  return {
+    locale: defaultLocale,
+    lookup: (id, lookupOptions = {}) => deps.lookupGame(id, {
+      ...lookupOptions,
+      locale: normalizeLocale(lookupOptions.locale ?? defaultLocale)
+    }),
+    search: (searchOptions) => deps.searchGames({
+      ...searchOptions,
+      locale: normalizeLocale(searchOptions.locale ?? defaultLocale)
+    }),
+    browse: (query = {}) => deps.fetchBrowseGrid({
+      ...query,
+      locale: normalizeLocale(query.locale ?? defaultLocale)
+    }),
+    category: (params) => deps.fetchCategoryGrid({
+      ...params,
+      id: resolveCatalogAlias(params.id)?.id ?? params.id,
+      locale: normalizeLocale(params.locale ?? defaultLocale)
+    }),
+    categoryGrid: (params) => deps.fetchCategoryGridResult({
+      ...params,
+      id: resolveCatalogAlias(params.id)?.id ?? params.id,
+      locale: normalizeLocale(params.locale ?? defaultLocale)
+    }),
+    status: (statusOptions = {}) => deps.fetchPsnStatus({
+      ...statusOptions,
+      locale: normalizeLocale(statusOptions.locale ?? defaultLocale)
+    })
+  };
+}
+// src/api/catalog-validation.ts
+async function validateCatalog(entry, options = {}) {
+  const locale = normalizeLocale(options.locale);
+  try {
+    const result = await fetchCategoryGridResult({
+      id: entry.id,
+      offset: 0,
+      size: options.size ?? 1,
+      locale
+    });
+    return {
+      alias: entry.alias,
+      id: entry.id,
+      locale,
+      ok: Boolean(result),
+      totalCount: result?.pageInfo?.totalCount,
+      itemCount: result?.items.length,
+      localizedName: result?.localizedName,
+      displayName: result?.displayName,
+      reportingName: result?.reportingName,
+      error: result ? undefined : "empty response"
+    };
+  } catch (error) {
+    return {
+      alias: entry.alias,
+      id: entry.id,
+      locale,
+      ok: false,
+      error: error.message
+    };
+  }
+}
+async function validateCatalogs(options = {}) {
+  const entries = options.entries ?? BUILTIN_CATALOGS;
+  return Promise.all(entries.map((entry) => validateCatalog(entry, options)));
+}
+// src/api/catalog-discovery.ts
+var PAGE_ALIAS_RE = /href="[^"]*\/pages\/([a-z0-9-]+)"/gi;
+var CATEGORY_HREF_RE = /href="[^"]*\/category\/([0-9a-f-]{36})(?:\/[0-9]+)?"/gi;
+var CATEGORY_EMS_RE = /(?:&quot;|")(?:emsCategoryId|interactLink)(?:&quot;|"):(?:&quot;|")?(?:EMS_CATEGORY:)?([0-9a-f-]{36})(?:&quot;|")?/gi;
+var CATEGORY_APOLLO_KEY_RE = /(?:CategoryGrid|CategoryStrand):([0-9a-f-]{36})(?=[:"])/gi;
+var CATEGORY_LINK_TARGET_RE = /(?:&quot;|")target(?:&quot;|"):(?:&quot;|")([0-9a-f-]{36})(?:&quot;|")[\s\S]{0,160}?(?:&quot;|")type(?:&quot;|"):(?:&quot;|")EMS_CATEGORY(?:&quot;|")/gi;
+var CATEGORY_LINK_TYPE_RE = /(?:&quot;|")type(?:&quot;|"):(?:&quot;|")EMS_CATEGORY(?:&quot;|")[\s\S]{0,160}?(?:&quot;|")target(?:&quot;|"):(?:&quot;|")([0-9a-f-]{36})(?:&quot;|")/gi;
+var CATEGORY_TITLE_RE = /id="title-([0-9a-f-]{36})"[^>]*>([\s\S]*?)<\/h2>/gi;
+var PAGE_TITLE_RE = /<title>([\s\S]*?)<\/title>/i;
+var PAGE_H1_RE = /<h1[^>]*class="[^"]*psw-sr-only[^"]*"[^>]*>([\s\S]*?)<\/h1>/i;
+var GRID_TITLE_RE = /data-qa="ems-sdk-grid-title"[^>]*>([\s\S]*?)<\/h2>/i;
+async function discoverCatalogs(opts = {}) {
+  const locale = opts.locale;
+  const localePath = localeToStorePath(locale);
+  const maxDepth = opts.maxDepth ?? 2;
+  const concurrency = Math.max(1, opts.concurrency ?? 4);
+  const maxPages = Math.max(1, opts.maxPages ?? 25);
+  const maxCatalogs = Math.max(1, opts.maxCatalogs ?? 300);
+  const pages = [];
+  const catalogs = [];
+  const catalogsById = new Map;
+  const seenPages = new Set;
+  const seenCatalogs = new Set;
+  const queue = [];
+  const enqueuePage = (alias, url, depth, sourcePageAlias) => {
+    if (seenPages.has(url))
+      return;
+    seenPages.add(url);
+    queue.push({
+      kind: "page",
+      alias,
+      url,
+      depth,
+      sourcePageAlias
+    });
+  };
+  const enqueueCategory = (id, url, depth, sourcePageAlias) => {
+    if (seenCatalogs.has(id))
+      return false;
+    seenCatalogs.add(id);
+    queue.push({
+      kind: "category",
+      id,
+      url,
+      depth,
+      sourcePageAlias
+    });
+    return true;
+  };
+  enqueuePage("latest", `https://store.playstation.com/${localePath}/pages/latest`, 0);
+  while (queue.length > 0 && (pages.length < maxPages || catalogs.length < maxCatalogs)) {
+    const batch = queue.splice(0, concurrency);
+    const results = await Promise.all(batch.map(async (item) => {
+      try {
+        const html = await fetchHtml(item.url);
+        return { item, html };
+      } catch {
+        return { item, html: null };
+      }
+    }));
+    for (const { item, html } of results) {
+      if (!html)
+        continue;
+      if (item.kind === "page") {
+        if (pages.length < maxPages) {
+          pages.push({
+            alias: item.alias ?? item.url,
+            url: item.url,
+            depth: item.depth,
+            title: extractPageTitle(html)
+          });
+        }
+      }
+      const categoryTitles = extractCategoryTitles(html);
+      const categoryMetadata = extractCategoryMetadata(html, locale);
+      if (item.kind === "category" && item.id) {
+        const title = extractPageTitle(html);
+        if (title) {
+          const existing = categoryMetadata.get(item.id) ?? { id: item.id };
+          existing.displayName = title;
+          categoryMetadata.set(item.id, existing);
+        }
+      }
+      for (const metadata of categoryMetadata.values()) {
+        const catalog2 = catalogsById.get(metadata.id);
+        if (!catalog2)
+          continue;
+        catalog2.localizedName ??= metadata.localizedName;
+        catalog2.displayName ??= metadata.displayName;
+        catalog2.reportingName ??= metadata.reportingName;
+      }
+      const pageAliases = extractPageAliases(html);
+      const categoryIds = extractCategoryIds(html);
+      for (const id of categoryIds) {
+        if (catalogs.length >= maxCatalogs)
+          break;
+        const nextUrl = `https://store.playstation.com/${localePath}/category/${id}/1`;
+        const added = enqueueCategory(id, nextUrl, item.depth + 1, item.alias ?? item.sourcePageAlias);
+        if (!added)
+          continue;
+        const label = categoryTitles.get(id);
+        const metadata = categoryMetadata.get(id);
+        const catalog2 = {
+          id,
+          url: nextUrl,
+          depth: item.depth + 1,
+          label,
+          displayName: label ?? metadata?.displayName,
+          localizedName: metadata?.localizedName,
+          reportingName: metadata?.reportingName,
+          sourcePageAlias: item.alias
+        };
+        catalogs.push(catalog2);
+        catalogsById.set(id, catalog2);
+        if (catalogs.length >= maxCatalogs)
+          break;
+      }
+      if (item.depth >= maxDepth)
+        continue;
+      for (const alias of pageAliases) {
+        const nextUrl = `https://store.playstation.com/${localePath}/pages/${alias}`;
+        enqueuePage(alias, nextUrl, item.depth + 1, item.alias);
+      }
+    }
+  }
+  catalogs.sort((a, b) => {
+    const depthDiff = a.depth - b.depth;
+    if (depthDiff !== 0)
+      return depthDiff;
+    return a.id.localeCompare(b.id);
+  });
+  return { pages, catalogs };
+}
+function extractPageAliases(html) {
+  const aliases = new Set;
+  PAGE_ALIAS_RE.lastIndex = 0;
+  let match;
+  while ((match = PAGE_ALIAS_RE.exec(html)) !== null) {
+    const alias = match[1];
+    if (alias)
+      aliases.add(alias);
+  }
+  return [...aliases];
+}
+function extractCategoryIds(html) {
+  const ids = new Set;
+  CATEGORY_HREF_RE.lastIndex = 0;
+  CATEGORY_EMS_RE.lastIndex = 0;
+  CATEGORY_APOLLO_KEY_RE.lastIndex = 0;
+  CATEGORY_LINK_TARGET_RE.lastIndex = 0;
+  CATEGORY_LINK_TYPE_RE.lastIndex = 0;
+  let match;
+  while ((match = CATEGORY_HREF_RE.exec(html)) !== null) {
+    const id = match[1];
+    if (id)
+      ids.add(id);
+  }
+  while ((match = CATEGORY_EMS_RE.exec(html)) !== null) {
+    const id = match[1];
+    if (id)
+      ids.add(id);
+  }
+  while ((match = CATEGORY_APOLLO_KEY_RE.exec(html)) !== null) {
+    const id = match[1];
+    if (id)
+      ids.add(id);
+  }
+  while ((match = CATEGORY_LINK_TARGET_RE.exec(html)) !== null) {
+    const id = match[1];
+    if (id)
+      ids.add(id);
+  }
+  while ((match = CATEGORY_LINK_TYPE_RE.exec(html)) !== null) {
+    const id = match[1];
+    if (id)
+      ids.add(id);
+  }
+  return [...ids];
+}
+function extractCategoryTitles(html) {
+  const titles = new Map;
+  CATEGORY_TITLE_RE.lastIndex = 0;
+  let match;
+  while ((match = CATEGORY_TITLE_RE.exec(html)) !== null) {
+    const id = match[1];
+    const raw = match[2];
+    if (!id || !raw)
+      continue;
+    const title = decodeText(raw);
+    if (title)
+      titles.set(id, title);
+  }
+  return titles;
+}
+function extractCategoryMetadata(html, locale) {
+  const metadata = new Map;
+  const apolloState = extractApolloState(html);
+  if (!apolloState)
+    return metadata;
+  for (const [key, value] of Object.entries(apolloState)) {
+    if (!key.startsWith("CategoryGrid:") || !isRecord(value))
+      continue;
+    const id = key.split(":")[1];
+    if (!id)
+      continue;
+    const localizedName = stringValue(value.localizedName);
+    const reportingName = stringValue(value.reportingName);
+    metadata.set(id, {
+      id,
+      localizedName,
+      reportingName,
+      displayName: resolveCategoryDisplayName(localizedName, locale)
+    });
+  }
+  return metadata;
+}
+function extractPageTitle(html) {
+  PAGE_H1_RE.lastIndex = 0;
+  const h1 = PAGE_H1_RE.exec(html)?.[1];
+  if (h1) {
+    const title = decodeText(h1);
+    if (title)
+      return title;
+  }
+  GRID_TITLE_RE.lastIndex = 0;
+  const gridTitle = GRID_TITLE_RE.exec(html)?.[1];
+  if (gridTitle) {
+    const title = decodeText(gridTitle);
+    if (title)
+      return title;
+  }
+  PAGE_TITLE_RE.lastIndex = 0;
+  const pageTitle = PAGE_TITLE_RE.exec(html)?.[1];
+  if (pageTitle) {
+    const title = decodeText(pageTitle).split("|")[0]?.trim();
+    if (title)
+      return title;
+  }
+  return;
+}
+function decodeText(html) {
+  return stripHtml(htmlEntityDecode(html)).replace(/\s+/g, " ").trim();
+}
+function extractApolloState(html) {
+  const match = /<script id="__NEXT_DATA__" type="application\/json">([\s\S]*?)<\/script>/i.exec(html);
+  if (!match?.[1])
+    return null;
+  try {
+    const data = JSON.parse(match[1]);
+    const props = data.props;
+    if (!isRecord(props))
+      return null;
+    const apolloState = props.apolloState;
+    return isRecord(apolloState) ? apolloState : null;
+  } catch {
+    return null;
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export {
+  validateCatalogs,
+  validateCatalog,
+  searchGames,
+  sampleItems,
+  resolveCategoryDisplayName,
+  resolveCatalogVisibility,
+  resolveCatalogDisplayName,
+  resolveCatalogAlias,
+  resolveBrowseSortDefaults,
+  resolveBrowseQuery,
+  regionForCountry,
+  parsePsnStatus,
+  parseLocaleList,
+  normalizeLocale,
+  normalizeBrowseWindow,
+  lookupGame,
+  localeToStorePath,
+  localeToSearchParams,
+  isPsnLocale,
+  getLocaleInfo,
+  fetchPsnStatus,
+  fetchCategoryGridResult,
+  fetchCategoryGrid,
+  fetchBrowseGrid,
+  discoverCatalogs,
+  createPstoreClient,
+  clearCaches as clearPstoreCaches,
+  TITLE_LOCALE_PRESETS,
+  LOCALE_MAP,
+  DEFAULT_LOCALE,
+  CATALOG_ALIASES,
+  BUILTIN_CATALOGS
+};