shop-client 3.8.2

package/dist/index.js

@@ -0,0 +1,3241 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ShopClient: () => ShopClient,
+  calculateDiscount: () => calculateDiscount,
+  classifyProduct: () => classifyProduct,
+  configureRateLimit: () => configureRateLimit,
+  detectShopifyCountry: () => detectShopifyCountry,
+  extractDomainWithoutSuffix: () => extractDomainWithoutSuffix,
+  genProductSlug: () => genProductSlug,
+  generateSEOContent: () => generateSEOContent,
+  generateStoreSlug: () => generateStoreSlug,
+  safeParseDate: () => safeParseDate,
+  sanitizeDomain: () => sanitizeDomain
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ai/enrich.ts
+var import_turndown = __toESM(require("turndown"));
+var import_turndown_plugin_gfm = require("turndown-plugin-gfm");
+
+// src/utils/rate-limit.ts
+var RateLimiter = class {
+  constructor(options) {
+    this.queue = [];
+    this.inFlight = 0;
+    this.refillTimer = null;
+    this.options = options;
+    this.tokens = options.maxRequestsPerInterval;
+  }
+  startRefill() {
+    if (this.refillTimer) return;
+    this.refillTimer = setInterval(() => {
+      this.tokens = this.options.maxRequestsPerInterval;
+      this.tryRun();
+    }, this.options.intervalMs);
+    if (this.refillTimer && typeof this.refillTimer.unref === "function") {
+      this.refillTimer.unref();
+    }
+  }
+  stopRefill() {
+    if (this.refillTimer) {
+      clearInterval(this.refillTimer);
+      this.refillTimer = null;
+    }
+  }
+  ensureRefillStarted() {
+    if (!this.refillTimer) {
+      this.startRefill();
+    }
+  }
+  configure(next) {
+    this.options = { ...this.options, ...next };
+    this.options.maxRequestsPerInterval = Math.max(
+      1,
+      this.options.maxRequestsPerInterval
+    );
+    this.options.intervalMs = Math.max(10, this.options.intervalMs);
+    this.options.maxConcurrency = Math.max(1, this.options.maxConcurrency);
+  }
+  schedule(fn) {
+    return new Promise((resolve, reject) => {
+      this.ensureRefillStarted();
+      this.queue.push({ fn, resolve, reject });
+      this.tryRun();
+    });
+  }
+  tryRun() {
+    while (this.queue.length > 0 && this.inFlight < this.options.maxConcurrency && this.tokens > 0) {
+      const task = this.queue.shift();
+      this.tokens -= 1;
+      this.inFlight += 1;
+      Promise.resolve().then(task.fn).then((result) => task.resolve(result)).catch((err) => task.reject(err)).finally(() => {
+        this.inFlight -= 1;
+        setTimeout(() => this.tryRun(), 0);
+      });
+    }
+  }
+};
+var enabled = false;
+var defaultOptions = {
+  maxRequestsPerInterval: 5,
+  // 5 requests
+  intervalMs: 1e3,
+  // per second
+  maxConcurrency: 5
+  // up to 5 in parallel
+};
+var limiter = new RateLimiter(defaultOptions);
+var hostLimiters = /* @__PURE__ */ new Map();
+var classLimiters = /* @__PURE__ */ new Map();
+function getHost(input) {
+  try {
+    if (typeof input === "string") {
+      return new URL(input).host;
+    }
+    if (input instanceof URL) {
+      return input.host;
+    }
+    const url = input.url;
+    if (url) {
+      return new URL(url).host;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getHostLimiter(host) {
+  if (!host) return void 0;
+  const exact = hostLimiters.get(host);
+  if (exact) return exact;
+  for (const [key, lim] of hostLimiters.entries()) {
+    if (key.startsWith("*.") && host.endsWith(key.slice(2))) {
+      return lim;
+    }
+  }
+  return void 0;
+}
+function configureRateLimit(options) {
+  var _a, _b, _c, _d, _e, _f;
+  if (typeof options.enabled === "boolean") {
+    enabled = options.enabled;
+  }
+  const { perHost, perClass } = options;
+  const globalOpts = {};
+  if (typeof options.maxRequestsPerInterval === "number") {
+    globalOpts.maxRequestsPerInterval = options.maxRequestsPerInterval;
+  }
+  if (typeof options.intervalMs === "number") {
+    globalOpts.intervalMs = options.intervalMs;
+  }
+  if (typeof options.maxConcurrency === "number") {
+    globalOpts.maxConcurrency = options.maxConcurrency;
+  }
+  if (Object.keys(globalOpts).length) {
+    limiter.configure(globalOpts);
+  }
+  if (perHost) {
+    for (const host of Object.keys(perHost)) {
+      const opts = perHost[host];
+      const existing = hostLimiters.get(host);
+      if (existing) {
+        existing.configure(opts);
+      } else {
+        hostLimiters.set(
+          host,
+          new RateLimiter({
+            maxRequestsPerInterval: (_a = opts.maxRequestsPerInterval) != null ? _a : defaultOptions.maxRequestsPerInterval,
+            intervalMs: (_b = opts.intervalMs) != null ? _b : defaultOptions.intervalMs,
+            maxConcurrency: (_c = opts.maxConcurrency) != null ? _c : defaultOptions.maxConcurrency
+          })
+        );
+      }
+    }
+  }
+  if (perClass) {
+    for (const klass of Object.keys(perClass)) {
+      const opts = perClass[klass];
+      const existing = classLimiters.get(klass);
+      if (existing) {
+        existing.configure(opts);
+      } else {
+        classLimiters.set(
+          klass,
+          new RateLimiter({
+            maxRequestsPerInterval: (_d = opts.maxRequestsPerInterval) != null ? _d : defaultOptions.maxRequestsPerInterval,
+            intervalMs: (_e = opts.intervalMs) != null ? _e : defaultOptions.intervalMs,
+            maxConcurrency: (_f = opts.maxConcurrency) != null ? _f : defaultOptions.maxConcurrency
+          })
+        );
+      }
+    }
+  }
+}
+async function rateLimitedFetch(input, init) {
+  var _a;
+  if (!enabled) {
+    return fetch(input, init);
+  }
+  const klass = init == null ? void 0 : init.rateLimitClass;
+  const byClass = klass ? classLimiters.get(klass) : void 0;
+  const byHost = getHostLimiter(getHost(input));
+  const eff = (_a = byClass != null ? byClass : byHost) != null ? _a : limiter;
+  return eff.schedule(() => fetch(input, init));
+}
+
+// src/ai/enrich.ts
+function ensureOpenRouter(apiKey) {
+  const key = apiKey || process.env.OPENROUTER_API_KEY;
+  if (!key) {
+    throw new Error(
+      "Missing OpenRouter API key. Set OPENROUTER_API_KEY or pass apiKey."
+    );
+  }
+  return key;
+}
+function normalizeDomainToBase(domain) {
+  if (domain.startsWith("http://") || domain.startsWith("https://")) {
+    try {
+      const u = new URL(domain);
+      return `${u.protocol}//${u.hostname}`;
+    } catch {
+      return domain;
+    }
+  }
+  return `https://${domain}`;
+}
+async function fetchAjaxProduct(domain, handle) {
+  const base = normalizeDomainToBase(domain);
+  const url = `${base}/products/${handle}.js`;
+  const res = await rateLimitedFetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch AJAX product: ${url}`);
+  const data = await res.json();
+  return data;
+}
+async function fetchProductPage(domain, handle) {
+  const base = normalizeDomainToBase(domain);
+  const url = `${base}/products/${handle}`;
+  const res = await rateLimitedFetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch product page: ${url}`);
+  return res.text();
+}
+function extractMainSection(html) {
+  const startMatch = html.match(
+    /<section[^>]*id="shopify-section-template--.*?__main"[^>]*>/
+  );
+  if (!startMatch) return null;
+  const startIndex = html.indexOf(startMatch[0]);
+  if (startIndex === -1) return null;
+  const endIndex = html.indexOf("</section>", startIndex);
+  if (endIndex === -1) return null;
+  return html.substring(startIndex, endIndex + "</section>".length);
+}
+function htmlToMarkdown(html, options) {
+  var _a;
+  if (!html) return "";
+  const td = new import_turndown.default({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+    emDelimiter: "*",
+    strongDelimiter: "**",
+    linkStyle: "inlined"
+  });
+  const useGfm = (_a = options == null ? void 0 : options.useGfm) != null ? _a : true;
+  if (useGfm) {
+    td.use(import_turndown_plugin_gfm.gfm);
+  }
+  ["script", "style", "nav", "footer"].forEach((tag) => {
+    td.remove((node) => {
+      var _a2;
+      return ((_a2 = node.nodeName) == null ? void 0 : _a2.toLowerCase()) === tag;
+    });
+  });
+  const removeByClass = (className) => td.remove((node) => {
+    const cls = typeof node.getAttribute === "function" ? node.getAttribute("class") || "" : "";
+    return cls.split(/\s+/).includes(className);
+  });
+  [
+    "product-form",
+    "shopify-payment-button",
+    "shopify-payment-buttons",
+    "product__actions",
+    "product__media-wrapper",
+    "loox-rating",
+    "jdgm-widget",
+    "stamped-reviews"
+  ].forEach(removeByClass);
+  ["button", "input", "select", "label"].forEach((tag) => {
+    td.remove((node) => {
+      var _a2;
+      return ((_a2 = node.nodeName) == null ? void 0 : _a2.toLowerCase()) === tag;
+    });
+  });
+  ["quantity-selector", "product-atc-wrapper"].forEach(removeByClass);
+  return td.turndown(html);
+}
+async function mergeWithLLM(bodyInput, pageInput, options) {
+  var _a, _b;
+  const inputType = (_a = options == null ? void 0 : options.inputType) != null ? _a : "markdown";
+  const bodyLabel = inputType === "html" ? "BODY HTML" : "BODY MARKDOWN";
+  const pageLabel = inputType === "html" ? "PAGE HTML" : "PAGE MARKDOWN";
+  const prompt = (options == null ? void 0 : options.outputFormat) === "json" ? `You are extracting structured buyer-useful information from Shopify product content.
+
+Inputs:
+1) ${bodyLabel}: ${inputType === "html" ? "Raw Shopify product body_html" : "Cleaned version of Shopify product body_html"}
+2) ${pageLabel}: ${inputType === "html" ? "Raw product page HTML (main section)" : "Extracted product page HTML converted to markdown"}
+
+Return ONLY valid JSON (no markdown, no code fences) with this shape:
+{
+  "title": null | string,
+  "description": null | string,
+  "materials": string[] | [],
+  "care": string[] | [],
+  "fit": null | string,
+  "images": null | string[],
+  "returnPolicy": null | string
+}
+
+Rules:
+- Do not invent facts; if a field is unavailable, use null or []
+- Prefer concise, factual statements
+ - Do NOT include product gallery/hero images in "images"; include only documentation images like size charts or measurement guides. If none, set "images": null.
+
+${bodyLabel}:
+${bodyInput}
+
+${pageLabel}:
+${pageInput}
+` : `
+You are enriching a Shopify product for a modern shopping-discovery app.
+
+Inputs:
+1) ${bodyLabel}: ${inputType === "html" ? "Raw Shopify product body_html" : "Cleaned version of Shopify product body_html"}
+2) ${pageLabel}: ${inputType === "html" ? "Raw product page HTML (main section)" : "Extracted product page HTML converted to markdown"}
+
+Your tasks:
+- Merge them into a single clean markdown document
+- Remove duplicate content
+- Remove product images
+- Remove UI text, buttons, menus, review widgets, theme junk
+- Remove product options
+- Keep only available buyer-useful info: features, materials, care, fit, size chart, return policy, size chart, care instructions
+- Include image of size-chart if present
+- Don't include statements like information not available.
+- Maintain structured headings (## Description, ## Materials, etc.)
+- Output ONLY markdown (no commentary)
+
+${bodyLabel}:
+${bodyInput}
+
+${pageLabel}:
+${pageInput}
+`;
+  const apiKey = ensureOpenRouter(options == null ? void 0 : options.apiKey);
+  const defaultModel = process.env.OPENROUTER_MODEL || "openai/gpt-4o-mini";
+  const model = (_b = options == null ? void 0 : options.model) != null ? _b : defaultModel;
+  const result = await callOpenRouter(model, prompt, apiKey);
+  if ((options == null ? void 0 : options.outputFormat) === "json") {
+    const cleaned = result.replace(/```json|```/g, "").trim();
+    const obj = safeParseJson(cleaned);
+    if (!obj.ok) {
+      throw new Error(`LLM returned invalid JSON: ${obj.error}`);
+    }
+    const schema = validateStructuredJson(obj.value);
+    if (!schema.ok) {
+      throw new Error(`LLM JSON schema invalid: ${schema.error}`);
+    }
+    const value = obj.value;
+    if (Array.isArray(value.images)) {
+      const filtered = value.images.filter((url) => {
+        if (typeof url !== "string") return false;
+        const u = url.toLowerCase();
+        const productPatterns = [
+          "cdn.shopify.com",
+          "/products/",
+          "%2Fproducts%2F",
+          "_large",
+          "_grande",
+          "_1024x1024",
+          "_2048x"
+        ];
+        const looksLikeProductImage = productPatterns.some(
+          (p) => u.includes(p)
+        );
+        return !looksLikeProductImage;
+      });
+      value.images = filtered.length > 0 ? filtered : null;
+    }
+    return JSON.stringify(value);
+  }
+  return result;
+}
+function safeParseJson(input) {
+  try {
+    const v = JSON.parse(input);
+    return { ok: true, value: v };
+  } catch (err) {
+    return { ok: false, error: (err == null ? void 0 : err.message) || "Failed to parse JSON" };
+  }
+}
+function validateStructuredJson(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return { ok: false, error: "Top-level must be a JSON object" };
+  }
+  const o = obj;
+  if ("title" in o && !(o.title === null || typeof o.title === "string")) {
+    return { ok: false, error: "title must be null or string" };
+  }
+  if ("description" in o && !(o.description === null || typeof o.description === "string")) {
+    return { ok: false, error: "description must be null or string" };
+  }
+  if ("fit" in o && !(o.fit === null || typeof o.fit === "string")) {
+    return { ok: false, error: "fit must be null or string" };
+  }
+  if ("returnPolicy" in o && !(o.returnPolicy === null || typeof o.returnPolicy === "string")) {
+    return { ok: false, error: "returnPolicy must be null or string" };
+  }
+  const validateStringArray = (arr, field) => {
+    if (!Array.isArray(arr))
+      return { ok: false, error: `${field} must be an array` };
+    for (const item of arr) {
+      if (typeof item !== "string")
+        return { ok: false, error: `${field} items must be strings` };
+    }
+    return { ok: true };
+  };
+  if ("materials" in o) {
+    const res = validateStringArray(o.materials, "materials");
+    if (!res.ok) return res;
+  }
+  if ("care" in o) {
+    const res = validateStringArray(o.care, "care");
+    if (!res.ok) return res;
+  }
+  if ("images" in o) {
+    if (!(o.images === null || Array.isArray(o.images))) {
+      return { ok: false, error: "images must be null or an array" };
+    }
+    if (Array.isArray(o.images)) {
+      const res = validateStringArray(o.images, "images");
+      if (!res.ok) return res;
+    }
+  }
+  return { ok: true };
+}
+async function callOpenRouter(model, prompt, apiKey) {
+  var _a, _b, _c;
+  if (process.env.OPENROUTER_OFFLINE === "1") {
+    return mockOpenRouterResponse(prompt);
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`
+  };
+  const referer = process.env.OPENROUTER_SITE_URL || process.env.SITE_URL;
+  const title = process.env.OPENROUTER_APP_TITLE || "Shop Search";
+  if (referer) headers["HTTP-Referer"] = referer;
+  if (title) headers["X-Title"] = title;
+  const buildPayload = (m) => ({
+    model: m,
+    messages: [{ role: "user", content: prompt }],
+    temperature: 0.2
+  });
+  const base = (process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1").replace(/\/$/, "");
+  const endpoints = [`${base}/chat/completions`];
+  const fallbackEnv = (process.env.OPENROUTER_FALLBACK_MODELS || "").split(",").map((s) => s.trim()).filter(Boolean);
+  const defaultModel = process.env.OPENROUTER_MODEL || "openai/gpt-4o-mini";
+  const modelsToTry = Array.from(
+    /* @__PURE__ */ new Set([model, ...fallbackEnv, defaultModel])
+  ).filter(Boolean);
+  let lastErrorText = "";
+  for (const m of modelsToTry) {
+    for (const url of endpoints) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15e3);
+        const response = await rateLimitedFetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(buildPayload(m)),
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
+          const text = await response.text();
+          lastErrorText = text || `${url}: HTTP ${response.status}`;
+          await new Promise((r) => setTimeout(r, 300));
+          continue;
+        }
+        const data = await response.json();
+        const content = (_c = (_b = (_a = data == null ? void 0 : data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content;
+        if (typeof content === "string") return content;
+        lastErrorText = JSON.stringify(data);
+        await new Promise((r) => setTimeout(r, 200));
+      } catch (err) {
+        lastErrorText = `${url}: ${(err == null ? void 0 : err.message) || String(err)}`;
+        await new Promise((r) => setTimeout(r, 200));
+      }
+    }
+  }
+  throw new Error(`OpenRouter request failed: ${lastErrorText}`);
+}
+function mockOpenRouterResponse(prompt) {
+  const p = prompt.toLowerCase();
+  if (p.includes("return only valid json") && p.includes('"audience":')) {
+    return JSON.stringify({
+      audience: "generic",
+      vertical: "clothing",
+      category: null,
+      subCategory: null
+    });
+  }
+  if (p.includes("return only valid json") && p.includes('"materials":')) {
+    return JSON.stringify({
+      title: null,
+      description: null,
+      materials: [],
+      care: [],
+      fit: null,
+      images: null,
+      returnPolicy: null
+    });
+  }
+  return [
+    "## Description",
+    "Offline merge of product body and page.",
+    "",
+    "## Materials",
+    "- Not available"
+  ].join("\n");
+}
+async function enrichProduct(domain, handle, options) {
+  var _a;
+  const ajaxProduct = await fetchAjaxProduct(domain, handle);
+  const bodyHtml = ajaxProduct.description || "";
+  const pageHtml = await fetchProductPage(domain, handle);
+  const extractedHtml = extractMainSection(pageHtml);
+  const inputType = (_a = options == null ? void 0 : options.inputType) != null ? _a : "markdown";
+  const bodyInput = inputType === "html" ? bodyHtml : htmlToMarkdown(bodyHtml, { useGfm: options == null ? void 0 : options.useGfm });
+  const pageInput = inputType === "html" ? extractedHtml || pageHtml : htmlToMarkdown(extractedHtml, { useGfm: options == null ? void 0 : options.useGfm });
+  const mergedMarkdown = await mergeWithLLM(bodyInput, pageInput, {
+    apiKey: options == null ? void 0 : options.apiKey,
+    inputType,
+    model: options == null ? void 0 : options.model,
+    outputFormat: options == null ? void 0 : options.outputFormat
+  });
+  if ((options == null ? void 0 : options.outputFormat) === "json") {
+    try {
+      const obj = JSON.parse(mergedMarkdown);
+      if (obj && Array.isArray(obj.images)) {
+        const productImageCandidates = [];
+        if (ajaxProduct.featured_image) {
+          productImageCandidates.push(String(ajaxProduct.featured_image));
+        }
+        if (Array.isArray(ajaxProduct.images)) {
+          for (const img of ajaxProduct.images) {
+            if (typeof img === "string" && img.length > 0) {
+              productImageCandidates.push(img);
+            }
+          }
+        }
+        if (Array.isArray(ajaxProduct.media)) {
+          for (const m of ajaxProduct.media) {
+            if (m == null ? void 0 : m.src) productImageCandidates.push(String(m.src));
+          }
+        }
+        if (Array.isArray(ajaxProduct.variants)) {
+          for (const v of ajaxProduct.variants) {
+            const fi = v == null ? void 0 : v.featured_image;
+            if (fi == null ? void 0 : fi.src) productImageCandidates.push(String(fi.src));
+          }
+        }
+        const productSet = new Set(
+          productImageCandidates.map((u) => String(u).toLowerCase())
+        );
+        const filtered = obj.images.filter((url) => {
+          if (typeof url !== "string") return false;
+          const u = url.toLowerCase();
+          if (productSet.has(u)) return false;
+          const productPatterns = [
+            "cdn.shopify.com",
+            "/products/",
+            "%2Fproducts%2F",
+            "_large",
+            "_grande",
+            "_1024x1024",
+            "_2048x"
+          ];
+          const looksLikeProductImage = productPatterns.some(
+            (p) => u.includes(p)
+          );
+          return !looksLikeProductImage;
+        });
+        obj.images = filtered.length > 0 ? filtered : null;
+        const sanitized = JSON.stringify(obj);
+        return {
+          bodyHtml,
+          pageHtml,
+          extractedMainHtml: extractedHtml || "",
+          mergedMarkdown: sanitized
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    bodyHtml,
+    pageHtml,
+    extractedMainHtml: extractedHtml || "",
+    mergedMarkdown
+  };
+}
+async function classifyProduct(productContent, options) {
+  var _a;
+  const apiKey = ensureOpenRouter(options == null ? void 0 : options.apiKey);
+  const defaultModel = process.env.OPENROUTER_MODEL || "openai/gpt-4o-mini";
+  const model = (_a = options == null ? void 0 : options.model) != null ? _a : defaultModel;
+  const prompt = `Classify the following product using a three-tiered hierarchy:
+
+Product Content:
+${productContent}
+
+Classification Rules:
+1. First determine the vertical (main product category)
+2. Then determine the category (specific type within that vertical)
+3. Finally determine the subCategory (sub-type within that category)
+
+Vertical must be one of: clothing, beauty, accessories, home-decor, food-and-beverages
+Audience must be one of: adult_male, adult_female, kid_male, kid_female, generic
+
+Hierarchy Examples:
+- Clothing \u2192 tops \u2192 t-shirts
+- Clothing \u2192 footwear \u2192 sneakers
+- Beauty \u2192 skincare \u2192 moisturizers
+- Accessories \u2192 bags \u2192 backpacks
+- Home-decor \u2192 furniture \u2192 chairs
+- Food-and-beverages \u2192 snacks \u2192 chips
+
+IMPORTANT CONSTRAINTS:
+- Category must be relevant to the chosen vertical
+- subCategory must be relevant to both vertical and category
+- subCategory must be a single word or hyphenated words (no spaces)
+- subCategory should NOT be material (e.g., "cotton", "leather") or color (e.g., "red", "blue")
+- Focus on product type/function, not attributes
+
+If you're not confident about category or sub-category, you can leave them optional.
+
+Return ONLY valid JSON (no markdown, no code fences) with keys:
+{
+  "audience": "adult_male" | "adult_female" | "kid_male" | "kid_female" | "generic",
+  "vertical": "clothing" | "beauty" | "accessories" | "home-decor" | "food-and-beverages",
+  "category": null | string,
+  "subCategory": null | string
+}`;
+  const raw = await callOpenRouter(model, prompt, apiKey);
+  const cleaned = raw.replace(/```json|```/g, "").trim();
+  const parsed = safeParseJson(cleaned);
+  if (!parsed.ok) {
+    throw new Error(`LLM returned invalid JSON: ${parsed.error}`);
+  }
+  const validated = validateClassification(parsed.value);
+  if (!validated.ok) {
+    throw new Error(`LLM JSON schema invalid: ${validated.error}`);
+  }
+  return validated.value;
+}
+function validateClassification(obj) {
+  var _a, _b;
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return { ok: false, error: "Top-level must be a JSON object" };
+  }
+  const o = obj;
+  const audienceValues = [
+    "adult_male",
+    "adult_female",
+    "kid_male",
+    "kid_female",
+    "generic"
+  ];
+  if (typeof o.audience !== "string" || !audienceValues.includes(o.audience)) {
+    return {
+      ok: false,
+      error: "audience must be one of: adult_male, adult_female, kid_male, kid_female, generic"
+    };
+  }
+  const verticalValues = [
+    "clothing",
+    "beauty",
+    "accessories",
+    "home-decor",
+    "food-and-beverages"
+  ];
+  if (typeof o.vertical !== "string" || !verticalValues.includes(o.vertical)) {
+    return {
+      ok: false,
+      error: "vertical must be one of: clothing, beauty, accessories, home-decor, food-and-beverages"
+    };
+  }
+  if ("category" in o && !(o.category === null || typeof o.category === "string")) {
+    return { ok: false, error: "category must be null or string" };
+  }
+  if ("subCategory" in o && !(o.subCategory === null || typeof o.subCategory === "string")) {
+    return { ok: false, error: "subCategory must be null or string" };
+  }
+  if (typeof o.subCategory === "string") {
+    const sc = o.subCategory.trim();
+    if (!/^[A-Za-z0-9-]+$/.test(sc)) {
+      return {
+        ok: false,
+        error: "subCategory must be single word or hyphenated, no spaces"
+      };
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      audience: o.audience,
+      vertical: o.vertical,
+      category: typeof o.category === "string" ? o.category : (_a = o.category) != null ? _a : null,
+      subCategory: typeof o.subCategory === "string" ? o.subCategory : (_b = o.subCategory) != null ? _b : null
+    }
+  };
+}
+async function generateSEOContent(product, options) {
+  var _a;
+  const apiKey = ensureOpenRouter(options == null ? void 0 : options.apiKey);
+  const defaultModel = process.env.OPENROUTER_MODEL || "openai/gpt-4o-mini";
+  const model = (_a = options == null ? void 0 : options.model) != null ? _a : defaultModel;
+  if (process.env.OPENROUTER_OFFLINE === "1") {
+    const baseTags = Array.isArray(product.tags) ? product.tags.slice(0, 6) : [];
+    const titlePart = product.title.trim().slice(0, 50);
+    const vendorPart = (product.vendor || "").trim();
+    const pricePart = typeof product.price === "number" ? `$${product.price}` : "";
+    const metaTitle = vendorPart ? `${titlePart} | ${vendorPart}` : titlePart;
+    const metaDescription = `Discover ${product.title}. ${pricePart ? `Priced at ${pricePart}. ` : ""}Crafted to delight customers with quality and style.`.slice(
+      0,
+      160
+    );
+    const shortDescription = `${product.title} \u2014 ${vendorPart || "Premium"} quality, designed to impress.`;
+    const longDescription = product.description || `Introducing ${product.title}, combining performance and style for everyday use.`;
+    const marketingCopy = `Get ${product.title} today${pricePart ? ` for ${pricePart}` : ""}. Limited availability \u2014 don\u2019t miss out!`;
+    const res = {
+      metaTitle,
+      metaDescription,
+      shortDescription,
+      longDescription,
+      tags: baseTags.length ? baseTags : ["new", "featured", "popular"],
+      marketingCopy
+    };
+    const validated2 = validateSEOContent(res);
+    if (!validated2.ok)
+      throw new Error(`Offline SEO content invalid: ${validated2.error}`);
+    return validated2.value;
+  }
+  const prompt = `Generate SEO-optimized content for this product:
+
+Title: ${product.title}
+Description: ${product.description || "N/A"}
+Vendor: ${product.vendor || "N/A"}
+Price: ${typeof product.price === "number" ? `$${product.price}` : "N/A"}
+Tags: ${Array.isArray(product.tags) && product.tags.length ? product.tags.join(", ") : "N/A"}
+
+Create compelling, SEO-friendly content that will help this product rank well and convert customers.
+
+Return ONLY valid JSON (no markdown, no code fences) with keys: {
+  "metaTitle": string,
+  "metaDescription": string,
+  "shortDescription": string,
+  "longDescription": string,
+  "tags": string[],
+  "marketingCopy": string
+}`;
+  const raw = await callOpenRouter(model, prompt, apiKey);
+  const cleaned = raw.replace(/```json|```/g, "").trim();
+  const parsed = safeParseJson(cleaned);
+  if (!parsed.ok) {
+    throw new Error(`LLM returned invalid JSON: ${parsed.error}`);
+  }
+  const validated = validateSEOContent(parsed.value);
+  if (!validated.ok) {
+    throw new Error(`LLM JSON schema invalid: ${validated.error}`);
+  }
+  return validated.value;
+}
+function validateSEOContent(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return { ok: false, error: "Top-level must be a JSON object" };
+  }
+  const o = obj;
+  const requiredStrings = [
+    "metaTitle",
+    "metaDescription",
+    "shortDescription",
+    "longDescription",
+    "marketingCopy"
+  ];
+  for (const key of requiredStrings) {
+    if (typeof o[key] !== "string" || !o[key].trim()) {
+      return { ok: false, error: `${key} must be a non-empty string` };
+    }
+  }
+  if (!Array.isArray(o.tags)) {
+    return { ok: false, error: "tags must be an array" };
+  }
+  for (const t of o.tags) {
+    if (typeof t !== "string")
+      return { ok: false, error: "tags items must be strings" };
+  }
+  return {
+    ok: true,
+    value: {
+      metaTitle: String(o.metaTitle),
+      metaDescription: String(o.metaDescription),
+      shortDescription: String(o.shortDescription),
+      longDescription: String(o.longDescription),
+      tags: o.tags,
+      marketingCopy: String(o.marketingCopy)
+    }
+  };
+}
+async function determineStoreType(storeInfo, options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const apiKey = ensureOpenRouter(options == null ? void 0 : options.apiKey);
+  const defaultModel = process.env.OPENROUTER_MODEL || "openai/gpt-4o-mini";
+  const model = (_a = options == null ? void 0 : options.model) != null ? _a : defaultModel;
+  const productLines = Array.isArray(storeInfo.showcase.products) ? storeInfo.showcase.products.slice(0, 10).map((p) => {
+    if (typeof p === "string") return `- ${p}`;
+    const pt = typeof (p == null ? void 0 : p.productType) === "string" && p.productType.trim() ? p.productType : "N/A";
+    return `- ${String((p == null ? void 0 : p.title) || "N/A")}: ${pt}`;
+  }) : [];
+  const collectionLines = Array.isArray(storeInfo.showcase.collections) ? storeInfo.showcase.collections.slice(0, 5).map((c) => {
+    if (typeof c === "string") return `- ${c}`;
+    return `- ${String((c == null ? void 0 : c.title) || "N/A")}`;
+  }) : [];
+  const storeContent = `Store Title: ${storeInfo.title}
+Store Description: ${(_b = storeInfo.description) != null ? _b : "N/A"}
+
+Sample Products:
+${productLines.join("\n") || "- N/A"}
+
+Sample Collections:
+${collectionLines.join("\n") || "- N/A"}`;
+  const textNormalized = `${storeInfo.title} ${(_c = storeInfo.description) != null ? _c : ""} ${productLines.join(" ")} ${collectionLines.join(" ")}`.toLowerCase();
+  if (process.env.OPENROUTER_OFFLINE === "1") {
+    const text = `${storeInfo.title} ${(_d = storeInfo.description) != null ? _d : ""} ${productLines.join(" ")} ${collectionLines.join(" ")}`.toLowerCase();
+    const verticalKeywords = {
+      clothing: /(dress|shirt|pant|jean|hoodie|tee|t[- ]?shirt|sneaker|apparel|clothing)/,
+      beauty: /(skincare|moisturizer|serum|beauty|cosmetic|makeup)/,
+      accessories: /(bag|belt|watch|wallet|accessor(y|ies)|sunglasses|jewell?ery)/,
+      "home-decor": /(sofa|chair|table|decor|home|candle|lamp|rug)/,
+      "food-and-beverages": /(snack|food|beverage|coffee|tea|chocolate|gourmet)/
+    };
+    const audienceKeywords = {
+      kid: /(\bkid\b|\bchild\b|\bchildren\b|\btoddler\b|\bboy\b|\bgirl\b)/,
+      kid_male: /\bboys\b|\bboy\b/,
+      kid_female: /\bgirls\b|\bgirl\b/,
+      adult_male: /\bmen\b|\bmale\b|\bman\b|\bmens\b/,
+      adult_female: /\bwomen\b|\bfemale\b|\bwoman\b|\bwomens\b/
+    };
+    const audiences = [];
+    if ((_e = audienceKeywords.kid) == null ? void 0 : _e.test(text)) {
+      if ((_f = audienceKeywords.kid_male) == null ? void 0 : _f.test(text)) audiences.push("kid_male");
+      if ((_g = audienceKeywords.kid_female) == null ? void 0 : _g.test(text)) audiences.push("kid_female");
+      if (!((_h = audienceKeywords.kid_male) == null ? void 0 : _h.test(text)) && !((_i = audienceKeywords.kid_female) == null ? void 0 : _i.test(text)))
+        audiences.push("generic");
+    } else {
+      if ((_j = audienceKeywords.adult_male) == null ? void 0 : _j.test(text)) audiences.push("adult_male");
+      if ((_k = audienceKeywords.adult_female) == null ? void 0 : _k.test(text))
+        audiences.push("adult_female");
+      if (audiences.length === 0) audiences.push("generic");
+    }
+    const verticals = Object.entries(verticalKeywords).filter(([, rx]) => rx.test(text)).map(([k]) => k);
+    if (verticals.length === 0) verticals.push("accessories");
+    const allTitles = productLines.join(" ").toLowerCase();
+    const categoryMap = {
+      shirts: /(shirt|t[- ]?shirt|tee)/,
+      pants: /(pant|trouser|chino)/,
+      shorts: /shorts?/,
+      jeans: /jeans?/,
+      dresses: /dress/,
+      skincare: /(serum|moisturizer|skincare|cream)/,
+      accessories: /(belt|watch|wallet|bag)/,
+      footwear: /(sneaker|shoe|boot)/,
+      decor: /(candle|lamp|rug|sofa|chair|table)/,
+      beverages: /(coffee|tea|chocolate)/
+    };
+    const categories = Object.entries(categoryMap).filter(([, rx]) => rx.test(allTitles)).map(([name]) => name);
+    const defaultCategories = categories.length ? categories : ["general"];
+    const breakdown = {};
+    for (const aud of audiences) {
+      breakdown[aud] = breakdown[aud] || {};
+      for (const v of verticals) {
+        breakdown[aud][v] = Array.from(new Set(defaultCategories));
+      }
+    }
+    return pruneBreakdownForSignals(breakdown, textNormalized);
+  }
+  const prompt = `Analyze this store and build a multi-audience breakdown of verticals and categories.
+Store Information:
+${storeContent}
+
+Return ONLY valid JSON (no markdown, no code fences) using this shape:
+{
+  "adult_male": { "clothing": ["shirts", "pants"], "accessories": ["belts"] },
+  "adult_female": { "beauty": ["skincare"], "clothing": ["dresses"] },
+  "generic": { "clothing": ["t-shirts"] }
+}
+
+Rules:
+- Keys MUST be audience: "adult_male" | "adult_female" | "kid_male" | "kid_female" | "generic".
+- Nested keys MUST be vertical: "clothing" | "beauty" | "accessories" | "home-decor" | "food-and-beverages".
+- Values MUST be non-empty arrays of category strings.
+`;
+  const raw = await callOpenRouter(model, prompt, apiKey);
+  const cleaned = raw.replace(/```json|```/g, "").trim();
+  const parsed = safeParseJson(cleaned);
+  if (!parsed.ok) {
+    throw new Error(`LLM returned invalid JSON: ${parsed.error}`);
+  }
+  const validated = validateStoreTypeBreakdown(parsed.value);
+  if (!validated.ok) {
+    throw new Error(`LLM JSON schema invalid: ${validated.error}`);
+  }
+  return pruneBreakdownForSignals(validated.value, textNormalized);
+}
+function validateStoreTypeBreakdown(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return {
+      ok: false,
+      error: "Top-level must be an object keyed by audience"
+    };
+  }
+  const audienceKeys = [
+    "adult_male",
+    "adult_female",
+    "kid_male",
+    "kid_female",
+    "generic"
+  ];
+  const verticalKeys = [
+    "clothing",
+    "beauty",
+    "accessories",
+    "home-decor",
+    "food-and-beverages"
+  ];
+  const o = obj;
+  const out = {};
+  const keys = Object.keys(o);
+  if (keys.length === 0) {
+    return { ok: false, error: "At least one audience key is required" };
+  }
+  for (const aKey of keys) {
+    if (!audienceKeys.includes(aKey)) {
+      return { ok: false, error: `Invalid audience key: ${aKey}` };
+    }
+    const vObj = o[aKey];
+    if (!vObj || typeof vObj !== "object" || Array.isArray(vObj)) {
+      return {
+        ok: false,
+        error: `Audience ${aKey} must map to an object of verticals`
+      };
+    }
+    const vOut = {};
+    for (const vKey of Object.keys(vObj)) {
+      if (!verticalKeys.includes(vKey)) {
+        return {
+          ok: false,
+          error: `Invalid vertical key ${vKey} for audience ${aKey}`
+        };
+      }
+      const cats = vObj[vKey];
+      if (!Array.isArray(cats) || cats.length === 0 || !cats.every((c) => typeof c === "string" && c.trim())) {
+        return {
+          ok: false,
+          error: `Vertical ${vKey} for audience ${aKey} must be a non-empty array of strings`
+        };
+      }
+      vOut[vKey] = cats.map(
+        (c) => c.trim()
+      );
+    }
+    out[aKey] = vOut;
+  }
+  return { ok: true, value: out };
+}
+function pruneBreakdownForSignals(breakdown, text) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const audienceKeywords = {
+    kid: /(\bkid\b|\bchild\b|\bchildren\b|\btoddler\b|\bboy\b|\bgirl\b)/,
+    kid_male: /\bboys\b|\bboy\b/,
+    kid_female: /\bgirls\b|\bgirl\b/,
+    adult_male: /\bmen\b|\bmale\b|\bman\b|\bmens\b/,
+    adult_female: /\bwomen\b|\bfemale\b|\bwoman\b|\bwomens\b/
+  };
+  const verticalKeywords = {
+    clothing: /(dress|shirt|pant|jean|hoodie|tee|t[- ]?shirt|sneaker|apparel|clothing)/,
+    beauty: /(skincare|moisturizer|serum|beauty|cosmetic|makeup)/,
+    accessories: /(bag|belt|watch|wallet|accessor(y|ies)|sunglasses|jewell?ery)/,
+    // Tighten home-decor detection to avoid matching generic "Home" nav labels
+    // and other unrelated uses. Require specific furniture/decor terms or phrases.
+    "home-decor": /(sofa|chair|table|candle|lamp|rug|furniture|home[- ]?decor|homeware|housewares|living\s?room|dining\s?table|bed(?:room)?|wall\s?(art|mirror|clock))/,
+    "food-and-beverages": /(snack|food|beverage|coffee|tea|chocolate|gourmet)/
+  };
+  const signaledAudiences = /* @__PURE__ */ new Set();
+  if ((_a = audienceKeywords.kid) == null ? void 0 : _a.test(text)) {
+    if ((_b = audienceKeywords.kid_male) == null ? void 0 : _b.test(text))
+      signaledAudiences.add("kid_male");
+    if ((_c = audienceKeywords.kid_female) == null ? void 0 : _c.test(text))
+      signaledAudiences.add("kid_female");
+    if (!((_d = audienceKeywords.kid_male) == null ? void 0 : _d.test(text)) && !((_e = audienceKeywords.kid_female) == null ? void 0 : _e.test(text)))
+      signaledAudiences.add("generic");
+  } else {
+    if ((_f = audienceKeywords.adult_male) == null ? void 0 : _f.test(text))
+      signaledAudiences.add("adult_male");
+    if ((_g = audienceKeywords.adult_female) == null ? void 0 : _g.test(text))
+      signaledAudiences.add("adult_female");
+    if (signaledAudiences.size === 0) signaledAudiences.add("generic");
+  }
+  const signaledVerticals = new Set(
+    Object.entries(verticalKeywords).filter(([, rx]) => rx.test(text)).map(([k]) => k) || []
+  );
+  if (signaledVerticals.size === 0) signaledVerticals.add("accessories");
+  const pruned = {};
+  for (const [audience, verticals] of Object.entries(breakdown)) {
+    const a = audience;
+    if (!signaledAudiences.has(a)) continue;
+    const vOut = {};
+    for (const [vertical, categories] of Object.entries(verticals || {})) {
+      const v = vertical;
+      if (!signaledVerticals.has(v)) continue;
+      vOut[v] = categories;
+    }
+    if (Object.keys(vOut).length > 0) {
+      pruned[a] = vOut;
+    }
+  }
+  if (Object.keys(pruned).length === 0) {
+    const vOut = {};
+    for (const v of Array.from(signaledVerticals)) {
+      vOut[v] = ["general"];
+    }
+    pruned.generic = vOut;
+  }
+  const adultHasData = pruned.adult_male && Object.keys(pruned.adult_male).length > 0 || pruned.adult_female && Object.keys(pruned.adult_female).length > 0;
+  if (adultHasData) {
+    delete pruned.generic;
+  }
+  return pruned;
+}
+
+// src/ai/determine-store-type.ts
+async function determineStoreTypeForStore(args) {
+  var _a, _b, _c;
+  const info = await args.getInfo();
+  const maxProducts = Math.max(0, Math.min(50, (_a = args.maxShowcaseProducts) != null ? _a : 10));
+  const maxCollections = Math.max(
+    0,
+    Math.min(50, (_b = args.maxShowcaseCollections) != null ? _b : 10)
+  );
+  const take = (arr, n) => arr.slice(0, Math.max(0, n));
+  const productsSample = Array.isArray(info.showcase.products) ? take(info.showcase.products, maxProducts) : [];
+  const collectionsSample = Array.isArray(info.showcase.collections) ? take(info.showcase.collections, maxCollections) : [];
+  const breakdown = await determineStoreType(
+    {
+      title: info.title || info.name,
+      description: (_c = info.description) != null ? _c : null,
+      showcase: {
+        products: productsSample,
+        collections: collectionsSample
+      }
+    },
+    { apiKey: args.apiKey, model: args.model }
+  );
+  return breakdown;
+}
+
+// src/checkout.ts
+function createCheckoutOperations(baseUrl) {
+  return {
+    /**
+     * Creates a Shopify checkout URL with pre-filled customer information and cart items.
+     *
+     * @param params - Checkout parameters
+     * @param params.email - Customer's email address (must be valid email format)
+     * @param params.items - Array of products to add to cart
+     * @param params.items[].productVariantId - Shopify product variant ID
+     * @param params.items[].quantity - Quantity as string (must be positive number)
+     * @param params.address - Customer's shipping address
+     * @param params.address.firstName - Customer's first name
+     * @param params.address.lastName - Customer's last name
+     * @param params.address.address1 - Street address
+     * @param params.address.city - City name
+     * @param params.address.zip - Postal/ZIP code
+     * @param params.address.country - Country name
+     * @param params.address.province - State/Province name
+     * @param params.address.phone - Phone number
+     *
+     * @returns {string} Complete Shopify checkout URL with pre-filled information
+     *
+     * @throws {Error} When email is invalid, items array is empty, or required address fields are missing
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const checkoutUrl = await shop.checkout.create([
+     *   { variantId: '123', quantity: 2 },
+     *   { variantId: '456', quantity: 1 }
+     * ]);
+     * console.log(checkoutUrl);
+     * ```
+     */
+    createUrl: ({
+      email,
+      items,
+      address
+    }) => {
+      if (!email || !email.includes("@")) {
+        throw new Error("Invalid email address");
+      }
+      if (!items || items.length === 0) {
+        throw new Error("Items array cannot be empty");
+      }
+      for (const item of items) {
+        if (!item.productVariantId || !item.quantity) {
+          throw new Error("Each item must have productVariantId and quantity");
+        }
+        const qty = Number.parseInt(item.quantity, 10);
+        if (Number.isNaN(qty) || qty <= 0) {
+          throw new Error("Quantity must be a positive number");
+        }
+      }
+      const requiredFields = [
+        "firstName",
+        "lastName",
+        "address1",
+        "city",
+        "zip",
+        "country"
+      ];
+      for (const field of requiredFields) {
+        if (!address[field]) {
+          throw new Error(`Address field '${field}' is required`);
+        }
+      }
+      const cartPath = items.map(
+        (item) => `${encodeURIComponent(item.productVariantId)}:${encodeURIComponent(item.quantity)}`
+      ).join(",");
+      const params = new URLSearchParams({
+        "checkout[email]": email,
+        "checkout[shipping_address][first_name]": address.firstName,
+        "checkout[shipping_address][last_name]": address.lastName,
+        "checkout[shipping_address][address1]": address.address1,
+        "checkout[shipping_address][city]": address.city,
+        "checkout[shipping_address][zip]": address.zip,
+        "checkout[shipping_address][country]": address.country,
+        "checkout[shipping_address][province]": address.province,
+        "checkout[shipping_address][phone]": address.phone
+      });
+      return `${baseUrl}cart/${cartPath}?${params.toString()}`;
+    }
+  };
+}
+
+// src/client/get-info.ts
+var import_remeda = require("remeda");
+
+// src/utils/detect-country.ts
+var COUNTRY_CODES = {
+  "+1": "US",
+  // United States (primary) / Canada also uses +1
+  "+44": "GB",
+  // United Kingdom
+  "+61": "AU",
+  // Australia
+  "+65": "SG",
+  // Singapore
+  "+91": "IN",
+  // India
+  "+81": "JP",
+  // Japan
+  "+49": "DE",
+  // Germany
+  "+33": "FR",
+  // France
+  "+971": "AE",
+  // United Arab Emirates
+  "+39": "IT",
+  // Italy
+  "+34": "ES",
+  // Spain
+  "+82": "KR",
+  // South Korea
+  "+55": "BR",
+  // Brazil
+  "+62": "ID",
+  // Indonesia
+  "+92": "PK",
+  // Pakistan
+  "+7": "RU"
+  // Russia
+};
+var CURRENCY_SYMBOLS = {
+  Rs: "IN",
+  // India
+  "\u20B9": "IN",
+  // India
+  $: "US",
+  // United States (primary, though many countries use $)
+  CA$: "CA",
+  // Canada
+  A$: "AU",
+  // Australia
+  "\xA3": "GB",
+  // United Kingdom
+  "\u20AC": "EU",
+  // European Union (not a country code, but commonly used)
+  AED: "AE",
+  // United Arab Emirates
+  "\u20A9": "KR",
+  // South Korea
+  "\xA5": "JP"
+  // Japan (primary, though China also uses ¥)
+};
+var CURRENCY_SYMBOL_TO_CODE = {
+  Rs: "INR",
+  "\u20B9": "INR",
+  $: "USD",
+  CA$: "CAD",
+  A$: "AUD",
+  "\xA3": "GBP",
+  "\u20AC": "EUR",
+  AED: "AED",
+  "\u20A9": "KRW",
+  "\xA5": "JPY"
+};
+var CURRENCY_CODE_TO_COUNTRY = {
+  INR: "IN",
+  USD: "US",
+  CAD: "CA",
+  AUD: "AU",
+  GBP: "GB",
+  EUR: "EU",
+  AED: "AE",
+  KRW: "KR",
+  JPY: "JP"
+};
+function scoreCountry(countryScores, country, weight, reason) {
+  if (!country) return;
+  if (!countryScores[country])
+    countryScores[country] = { score: 0, reasons: [] };
+  countryScores[country].score += weight;
+  countryScores[country].reasons.push(reason);
+}
+async function detectShopifyCountry(html) {
+  var _a, _b;
+  const countryScores = {};
+  let detectedCurrencyCode;
+  const shopifyFeaturesMatch = html.match(
+    /<script[^>]+id=["']shopify-features["'][^>]*>([\s\S]*?)<\/script>/
+  );
+  if (shopifyFeaturesMatch) {
+    try {
+      const json = shopifyFeaturesMatch[1];
+      if (!json) {
+      } else {
+        const data = JSON.parse(json);
+        if (data.country)
+          scoreCountry(
+            countryScores,
+            data.country,
+            1,
+            "shopify-features.country"
+          );
+        if ((_a = data.locale) == null ? void 0 : _a.includes("-")) {
+          const [, localeCountry] = data.locale.split("-");
+          if (localeCountry) {
+            scoreCountry(
+              countryScores,
+              localeCountry.toUpperCase(),
+              0.7,
+              "shopify-features.locale"
+            );
+          }
+        }
+        if (data.moneyFormat) {
+          for (const symbol in CURRENCY_SYMBOLS) {
+            if (data.moneyFormat.includes(symbol)) {
+              const iso = CURRENCY_SYMBOLS[symbol];
+              if (typeof iso === "string") {
+                scoreCountry(countryScores, iso, 0.6, "moneyFormat symbol");
+              }
+              const code = CURRENCY_SYMBOL_TO_CODE[symbol];
+              if (!detectedCurrencyCode && typeof code === "string") {
+                detectedCurrencyCode = code;
+              }
+            }
+          }
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  const currencyJsonMatch = html.match(/Shopify\.currency\s*=\s*(\{[^}]*\})/);
+  if (currencyJsonMatch) {
+    try {
+      const raw = currencyJsonMatch[1];
+      const obj = JSON.parse(raw || "{}");
+      const activeCode = typeof (obj == null ? void 0 : obj.active) === "string" ? obj.active.toUpperCase() : void 0;
+      const iso = activeCode ? CURRENCY_CODE_TO_COUNTRY[activeCode] : void 0;
+      if (activeCode) {
+        detectedCurrencyCode = activeCode;
+      }
+      if (typeof iso === "string") {
+        scoreCountry(countryScores, iso, 0.8, "Shopify.currency.active");
+      }
+    } catch (_error) {
+    }
+  } else {
+    const currencyActiveAssignMatch = html.match(
+      /Shopify\.currency\.active\s*=\s*['"]([A-Za-z]{3})['"]/i
+    );
+    if (currencyActiveAssignMatch) {
+      const captured = currencyActiveAssignMatch[1];
+      const code = typeof captured === "string" ? captured.toUpperCase() : void 0;
+      const iso = code ? CURRENCY_CODE_TO_COUNTRY[code] : void 0;
+      if (code) {
+        detectedCurrencyCode = code;
+      }
+      if (typeof iso === "string") {
+        scoreCountry(countryScores, iso, 0.8, "Shopify.currency.active");
+      }
+    }
+  }
+  const shopifyCountryMatch = html.match(
+    /Shopify\.country\s*=\s*['"]([A-Za-z]{2})['"]/i
+  );
+  if (shopifyCountryMatch) {
+    const captured = shopifyCountryMatch[1];
+    const iso = typeof captured === "string" ? captured.toUpperCase() : void 0;
+    if (typeof iso === "string") {
+      scoreCountry(countryScores, iso, 1, "Shopify.country");
+    }
+  }
+  const phones = html.match(/\+\d{1,3}[\s\-()0-9]{5,}/g);
+  if (phones) {
+    for (const phone of phones) {
+      const prefix = (_b = phone.match(/^\+\d{1,3}/)) == null ? void 0 : _b[0];
+      if (prefix && COUNTRY_CODES[prefix])
+        scoreCountry(
+          countryScores,
+          COUNTRY_CODES[prefix],
+          0.8,
+          `phone prefix ${prefix}`
+        );
+    }
+  }
+  const jsonLdRegex = /<script[^>]+application\/ld\+json[^>]*>(.*?)<\/script>/g;
+  let jsonLdMatch = jsonLdRegex.exec(html);
+  while (jsonLdMatch !== null) {
+    try {
+      const json = jsonLdMatch[1];
+      if (!json) {
+      } else {
+        const raw = JSON.parse(json);
+        const collectAddressCountries = (node, results = []) => {
+          if (Array.isArray(node)) {
+            for (const item of node) collectAddressCountries(item, results);
+            return results;
+          }
+          if (node && typeof node === "object") {
+            const obj = node;
+            const address = obj.address;
+            if (address && typeof address === "object") {
+              const country = address.addressCountry;
+              if (typeof country === "string") results.push(country);
+            }
+            const graph = obj["@graph"];
+            if (graph) collectAddressCountries(graph, results);
+          }
+          return results;
+        };
+        const countries = collectAddressCountries(raw);
+        for (const country of countries) {
+          scoreCountry(countryScores, country, 1, "JSON-LD addressCountry");
+        }
+      }
+    } catch (_error) {
+    }
+    jsonLdMatch = jsonLdRegex.exec(html);
+  }
+  const footerMatch = html.match(/<footer[^>]*>(.*?)<\/footer>/i);
+  if (footerMatch) {
+    const footerTextGroup = footerMatch[1];
+    const footerText = footerTextGroup ? footerTextGroup.toLowerCase() : "";
+    const countryNameToISO = {
+      india: "IN",
+      "united states": "US",
+      canada: "CA",
+      australia: "AU",
+      "united kingdom": "GB",
+      britain: "GB",
+      uk: "GB",
+      japan: "JP",
+      "south korea": "KR",
+      korea: "KR",
+      germany: "DE",
+      france: "FR",
+      italy: "IT",
+      spain: "ES",
+      brazil: "BR",
+      russia: "RU",
+      singapore: "SG",
+      indonesia: "ID",
+      pakistan: "PK"
+    };
+    for (const [countryName, isoCode] of Object.entries(countryNameToISO)) {
+      if (footerText.includes(countryName))
+        scoreCountry(countryScores, isoCode, 0.4, "footer mention");
+    }
+  }
+  const sorted = Object.entries(countryScores).sort(
+    (a, b) => b[1].score - a[1].score
+  );
+  const best = sorted[0];
+  return best ? {
+    country: best[0],
+    confidence: Math.min(1, best[1].score / 2),
+    signals: best[1].reasons,
+    currencyCode: detectedCurrencyCode
+  } : {
+    country: "Unknown",
+    confidence: 0,
+    signals: [],
+    currencyCode: detectedCurrencyCode
+  };
+}
+
+// src/utils/func.ts
+var import_tldts = require("tldts");
+function extractDomainWithoutSuffix(domain) {
+  const parsedDomain = (0, import_tldts.parse)(domain);
+  return parsedDomain.domainWithoutSuffix;
+}
+function generateStoreSlug(domain) {
+  var _a;
+  const input = new URL(domain);
+  const parsedDomain = (0, import_tldts.parse)(input.href);
+  const domainName = (_a = parsedDomain.domainWithoutSuffix) != null ? _a : input.hostname.split(".")[0];
+  return (domainName || "").toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+var genProductSlug = ({
+  handle,
+  storeDomain
+}) => {
+  const storeSlug = generateStoreSlug(storeDomain);
+  return `${handle}-by-${storeSlug}`;
+};
+var calculateDiscount = (price, compareAtPrice) => !compareAtPrice || compareAtPrice === 0 ? 0 : Math.max(
+  0,
+  Math.round(100 - price / compareAtPrice * 100)
+  // Removed the decimal precision
+);
+function sanitizeDomain(input, opts) {
+  var _a;
+  if (typeof input !== "string") {
+    throw new Error("sanitizeDomain: input must be a string");
+  }
+  let raw = input.trim();
+  if (!raw) {
+    throw new Error("sanitizeDomain: input cannot be empty");
+  }
+  const hasProtocol = /^[a-z]+:\/\//i.test(raw);
+  if (!hasProtocol && !raw.startsWith("//")) {
+    raw = `https://${raw}`;
+  }
+  const stripWWW = (_a = opts == null ? void 0 : opts.stripWWW) != null ? _a : true;
+  try {
+    let url;
+    if (raw.startsWith("//")) {
+      url = new URL(`https:${raw}`);
+    } else if (raw.includes("://")) {
+      url = new URL(raw);
+    } else {
+      url = new URL(`https://${raw}`);
+    }
+    let hostname = url.hostname.toLowerCase();
+    const hadWWW = /^www\./i.test(url.hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = (0, import_tldts.parse)(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  } catch {
+    let hostname = raw.toLowerCase();
+    hostname = hostname.replace(/^[a-z]+:\/\//, "");
+    hostname = hostname.replace(/^\/\//, "");
+    hostname = hostname.replace(/[/:#?].*$/, "");
+    const hadWWW = /^www\./i.test(hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = (0, import_tldts.parse)(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  }
+}
+function safeParseDate(input) {
+  if (!input || typeof input !== "string") return void 0;
+  const d = new Date(input);
+  return Number.isNaN(d.getTime()) ? void 0 : d;
+}
+function normalizeKey(input) {
+  return input.toLowerCase().replace(/\s+/g, "_");
+}
+function buildVariantOptionsMap(optionNames, variants) {
+  const keys = optionNames.map(normalizeKey);
+  const map = {};
+  for (const v of variants) {
+    const parts = [];
+    if (keys[0] && v.option1)
+      parts.push(`${keys[0]}#${normalizeKey(v.option1)}`);
+    if (keys[1] && v.option2)
+      parts.push(`${keys[1]}#${normalizeKey(v.option2)}`);
+    if (keys[2] && v.option3)
+      parts.push(`${keys[2]}#${normalizeKey(v.option3)}`);
+    if (parts.length > 0) {
+      if (parts.length > 1) parts.sort();
+      const key = parts.join("##");
+      const id = v.id.toString();
+      if (map[key] === void 0) {
+        map[key] = id;
+      }
+    }
+  }
+  return map;
+}
+function formatPrice(amountInCents, currency) {
+  try {
+    return new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency
+    }).format((amountInCents || 0) / 100);
+  } catch {
+    const val = (amountInCents || 0) / 100;
+    return `${val} ${currency}`;
+  }
+}
+
+// src/client/get-info.ts
+async function getInfoForStore(args) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const {
+    baseUrl,
+    storeDomain,
+    validateProductExists,
+    validateCollectionExists,
+    validateLinksInBatches
+  } = args;
+  const response = await rateLimitedFetch(baseUrl);
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const html = await response.text();
+  const getMetaTag = (name2) => {
+    const regex = new RegExp(
+      `<meta[^>]*name=["']${name2}["'][^>]*content=["'](.*?)["']`
+    );
+    const match = html.match(regex);
+    return match ? match[1] : null;
+  };
+  const getPropertyMetaTag = (property) => {
+    const regex = new RegExp(
+      `<meta[^>]*property=["']${property}["'][^>]*content=["'](.*?)["']`
+    );
+    const match = html.match(regex);
+    return match ? match[1] : null;
+  };
+  const name = (_a = getMetaTag("og:site_name")) != null ? _a : extractDomainWithoutSuffix(baseUrl);
+  const title = (_b = getMetaTag("og:title")) != null ? _b : getMetaTag("twitter:title");
+  const description = getMetaTag("description") || getPropertyMetaTag("og:description");
+  const shopifyWalletId = (_c = getMetaTag("shopify-digital-wallet")) == null ? void 0 : _c.split("/")[1];
+  const myShopifySubdomainMatch = html.match(/['"](.*?\.myshopify\.com)['"]/);
+  const myShopifySubdomain = myShopifySubdomainMatch ? myShopifySubdomainMatch[1] : null;
+  let logoUrl = getPropertyMetaTag("og:image") || getPropertyMetaTag("og:image:secure_url");
+  if (!logoUrl) {
+    const logoMatch = html.match(
+      /<img[^>]+src=["']([^"']+\/cdn\/shop\/[^"']+)["']/
+    );
+    const matchedUrl = logoMatch == null ? void 0 : logoMatch[1];
+    logoUrl = matchedUrl ? matchedUrl.replace("http://", "https://") : null;
+  } else {
+    logoUrl = logoUrl.replace("http://", "https://");
+  }
+  const socialLinks = {};
+  const socialRegex = /<a[^>]+href=["']([^"']*(?:facebook|twitter|instagram|pinterest|youtube|linkedin|tiktok|vimeo)\.com[^"']*)["']/g;
+  for (const match of html.matchAll(socialRegex)) {
+    const str = match[1];
+    if (!str) continue;
+    let href = str;
+    try {
+      if (href.startsWith("//")) {
+        href = `https:${href}`;
+      } else if (href.startsWith("/")) {
+        href = new URL(href, baseUrl).toString();
+      }
+      const parsed = new URL(href);
+      const domain = parsed.hostname.replace("www.", "").split(".")[0];
+      if (domain) {
+        socialLinks[domain] = parsed.toString();
+      }
+    } catch {
+    }
+  }
+  const contactLinks = {
+    tel: null,
+    email: null,
+    contactPage: null
+  };
+  for (const match of html.matchAll(/href=["']tel:([^"']+)["']/g)) {
+    contactLinks.tel = ((_d = match == null ? void 0 : match[1]) == null ? void 0 : _d.trim()) || null;
+  }
+  for (const match of html.matchAll(/href=["']mailto:([^"']+)["']/g)) {
+    contactLinks.email = ((_e = match == null ? void 0 : match[1]) == null ? void 0 : _e.trim()) || null;
+  }
+  for (const match of html.matchAll(
+    /href=["']([^"']*(?:\/contact|\/pages\/contact)[^"']*)["']/g
+  )) {
+    contactLinks.contactPage = (match == null ? void 0 : match[1]) || null;
+  }
+  const extractedProductLinks = ((_g = (_f = html.match(/href=["']([^"']*\/products\/[^"']+)["']/g)) == null ? void 0 : _f.map(
+    (match) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = match == null ? void 0 : match.split("href=")[1]) == null ? void 0 : _a2.replace(/["']/g, "")) == null ? void 0 : _b2.split("/").at(-1);
+    }
+  )) == null ? void 0 : _g.filter(Boolean)) || [];
+  const extractedCollectionLinks = ((_i = (_h = html.match(/href=["']([^"']*\/collections\/[^"']+)["']/g)) == null ? void 0 : _h.map(
+    (match) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = match == null ? void 0 : match.split("href=")[1]) == null ? void 0 : _a2.replace(/["']/g, "")) == null ? void 0 : _b2.split("/").at(-1);
+    }
+  )) == null ? void 0 : _i.filter(Boolean)) || [];
+  const headerLinks = (_k = (_j = html.match(
+    /<(header|nav|div|section)\b[^>]*\b(?:id|class)=["'][^"']*(?=.*shopify-section)(?=.*\b(header|navigation|nav|menu)\b)[^"']*["'][^>]*>[\s\S]*?<\/\1>/gi
+  )) == null ? void 0 : _j.flatMap((header) => {
+    var _a2, _b2;
+    const links = (_a2 = header.match(/href=["']([^"']+)["']/g)) == null ? void 0 : _a2.filter(
+      (link) => link.includes("/products/") || link.includes("/collections/") || link.includes("/pages/")
+    );
+    return (_b2 = links == null ? void 0 : links.map((link) => {
+      var _a3;
+      const href = (_a3 = link.match(/href=["']([^"']+)["']/)) == null ? void 0 : _a3[1];
+      if (href && !href.startsWith("#") && !href.startsWith("javascript:")) {
+        try {
+          const url = new URL(href, storeDomain);
+          return url.pathname.replace(/^\/|\/$/g, "");
+        } catch {
+          return href.replace(/^\/|\/$/g, "");
+        }
+      }
+      return null;
+    }).filter((item) => Boolean(item))) != null ? _b2 : [];
+  })) != null ? _k : [];
+  const slug = generateStoreSlug(baseUrl);
+  const countryDetection = await detectShopifyCountry(html);
+  const [homePageProductLinks, homePageCollectionLinks] = await Promise.all([
+    validateLinksInBatches(
+      extractedProductLinks.filter(
+        (handle) => Boolean(handle)
+      ),
+      (handle) => validateProductExists(handle)
+    ),
+    validateLinksInBatches(
+      extractedCollectionLinks.filter(
+        (handle) => Boolean(handle)
+      ),
+      (handle) => validateCollectionExists(handle)
+    )
+  ]);
+  const info = {
+    name: name || slug,
+    domain: sanitizeDomain(baseUrl),
+    slug,
+    title: title || null,
+    description: description || null,
+    logoUrl,
+    socialLinks,
+    contactLinks,
+    headerLinks,
+    showcase: {
+      products: (0, import_remeda.unique)(homePageProductLinks != null ? homePageProductLinks : []),
+      collections: (0, import_remeda.unique)(homePageCollectionLinks != null ? homePageCollectionLinks : [])
+    },
+    jsonLdData: ((_m = (_l = html.match(
+      /<script[^>]*type="application\/ld\+json"[^>]*>([^<]+)<\/script>/g
+    )) == null ? void 0 : _l.map(
+      (match) => {
+        var _a2;
+        return ((_a2 = match == null ? void 0 : match.split(">")[1]) == null ? void 0 : _a2.replace(/<\/script/g, "")) || null;
+      }
+    )) == null ? void 0 : _m.map((json) => json ? JSON.parse(json) : null)) || [],
+    techProvider: {
+      name: "shopify",
+      walletId: shopifyWalletId,
+      subDomain: myShopifySubdomain != null ? myShopifySubdomain : null
+    },
+    country: countryDetection.country
+  };
+  const currencyCode = countryDetection == null ? void 0 : countryDetection.currencyCode;
+  return { info, currencyCode };
+}
+
+// src/collections.ts
+var import_remeda2 = require("remeda");
+function createCollectionOperations(baseUrl, storeDomain, fetchCollections, collectionsDto2, fetchPaginatedProductsFromCollection, getStoreInfo, findCollection) {
+  function applyCurrencyOverride(product, currency) {
+    var _a, _b, _c, _d, _e, _f;
+    const priceMin = (_b = (_a = product.priceMin) != null ? _a : product.price) != null ? _b : 0;
+    const priceMax = (_d = (_c = product.priceMax) != null ? _c : product.price) != null ? _d : 0;
+    const compareAtMin = (_f = (_e = product.compareAtPriceMin) != null ? _e : product.compareAtPrice) != null ? _f : 0;
+    return {
+      ...product,
+      currency,
+      localizedPricing: {
+        currency,
+        priceFormatted: formatPrice(priceMin, currency),
+        priceMinFormatted: formatPrice(priceMin, currency),
+        priceMaxFormatted: formatPrice(priceMax, currency),
+        compareAtPriceFormatted: formatPrice(compareAtMin, currency)
+      }
+    };
+  }
+  function maybeOverrideProductsCurrency(products, currency) {
+    if (!products || !currency) return products;
+    return products.map((p) => applyCurrencyOverride(p, currency));
+  }
+  return {
+    /**
+     * Fetches collections with pagination support.
+     *
+     * @param options - Pagination options
+     * @param options.page - Page number (default: 1)
+     * @param options.limit - Number of collections per page (default: 10, max: 250)
+     *
+     * @returns {Promise<Collection[] | null>} Collections for the requested page, or null on error
+     */
+    paginated: async (options) => {
+      var _a, _b;
+      const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+      const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 10;
+      if (page < 1 || limit < 1 || limit > 250) {
+        throw new Error(
+          "Invalid pagination parameters: page must be >= 1, limit must be between 1 and 250"
+        );
+      }
+      try {
+        const collections = await fetchCollections(page, limit);
+        return collections != null ? collections : null;
+      } catch (error) {
+        console.error(
+          "Failed to fetch paginated collections:",
+          storeDomain,
+          error
+        );
+        return null;
+      }
+    },
+    /**
+     * Fetches all collections from the store across all pages.
+     *
+     * @returns {Promise<Collection[]>} Array of all collections
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const allCollections = await shop.collections.all();
+     *
+     * console.log(`Found ${allCollections.length} collections`);
+     * allCollections.forEach(collection => {
+     *   console.log(collection.title, collection.handle);
+     * });
+     * ```
+     */
+    all: async () => {
+      const limit = 250;
+      const allCollections = [];
+      async function fetchAll() {
+        let currentPage = 1;
+        while (true) {
+          const collections = await fetchCollections(currentPage, limit);
+          if (!collections || collections.length === 0 || collections.length < limit) {
+            if (!collections) {
+              console.warn(
+                "fetchCollections returned null, treating as empty array."
+              );
+              break;
+            }
+            if (collections && collections.length > 0) {
+              allCollections.push(...collections);
+            }
+            break;
+          }
+          allCollections.push(...collections);
+          currentPage++;
+        }
+        return allCollections;
+      }
+      try {
+        const collections = await fetchAll();
+        return collections || [];
+      } catch (error) {
+        console.error("Failed to fetch all collections:", storeDomain, error);
+        throw error;
+      }
+    },
+    /**
+     * Finds a specific collection by its handle.
+     *
+     * @param collectionHandle - The collection handle (URL slug) to search for
+     *
+     * @returns {Promise<Collection | null>} The collection if found, null if not found
+     *
+     * @throws {Error} When the handle is invalid or there's a network error
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://example.myshopify.com');
+     * const collection = await shop.collections.find('summer-collection');
+     * if (collection) {
+     *   console.log(collection.title); // "Summer Collection"
+     * }
+     * ```
+     */
+    find: async (collectionHandle) => {
+      var _a, _b;
+      if (!collectionHandle || typeof collectionHandle !== "string") {
+        throw new Error("Collection handle is required and must be a string");
+      }
+      const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+      if (!sanitizedHandle) {
+        throw new Error("Invalid collection handle format");
+      }
+      if (sanitizedHandle.length > 255) {
+        throw new Error("Collection handle is too long");
+      }
+      try {
+        const url = `${baseUrl}collections/${encodeURIComponent(sanitizedHandle)}.json`;
+        const response = await rateLimitedFetch(url);
+        if (!response.ok) {
+          if (response.status === 404) {
+            return null;
+          }
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        let collectionImage = result.collection.image;
+        if (!collectionImage) {
+          const collectionProduct = (_a = await fetchPaginatedProductsFromCollection(
+            result.collection.handle,
+            {
+              limit: 1,
+              page: 1
+            }
+          )) == null ? void 0 : _a.at(0);
+          const collectionProductImage = (_b = collectionProduct == null ? void 0 : collectionProduct.images) == null ? void 0 : _b[0];
+          if (collectionProduct && collectionProductImage) {
+            collectionImage = {
+              id: collectionProductImage.id,
+              src: collectionProductImage.src,
+              alt: collectionProductImage.alt || collectionProduct.title,
+              created_at: collectionProductImage.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        }
+        const collectionData = collectionsDto2([
+          {
+            ...result.collection,
+            image: collectionImage
+          }
+        ]);
+        return collectionData[0] || null;
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(
+            `Error fetching collection ${sanitizedHandle}:`,
+            baseUrl,
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+    /**
+     * Fetches collections that are showcased/featured on the store's homepage.
+     *
+     * @returns {Promise<Collection[]>} Array of showcased collections found on the homepage
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const showcasedCollections = await shop.collections.showcased();
+     *
+     * console.log(`Found ${showcasedCollections.length} showcased collections`);
+     * showcasedCollections.forEach(collection => {
+     *   console.log(`Featured: ${collection.title} - ${collection.productsCount} products`);
+     * });
+     * ```
+     */
+    showcased: async () => {
+      const storeInfo = await getStoreInfo();
+      const collections = await Promise.all(
+        storeInfo.showcase.collections.map(
+          (collectionHandle) => findCollection(collectionHandle)
+        )
+      );
+      return (0, import_remeda2.filter)(collections, import_remeda2.isNonNullish);
+    },
+    products: {
+      /**
+       * Fetches products from a specific collection with pagination support.
+       *
+       * @param collectionHandle - The collection handle to fetch products from
+       * @param options - Pagination options
+       * @param options.page - Page number (default: 1)
+       * @param options.limit - Number of products per page (default: 250, max: 250)
+       *
+       * @returns {Promise<Product[] | null>} Array of products from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://example.myshopify.com');
+       *
+       * // Get first page of products from a collection
+       * const products = await shop.collections.products.paginated('summer-collection');
+       *
+       * // Get second page with custom limit
+       * const moreProducts = await shop.collections.products.paginated(
+       *   'summer-collection',
+       *   { page: 2, limit: 50 }
+       * );
+       * ```
+       */
+      paginated: async (collectionHandle, options) => {
+        var _a, _b;
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+        const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 250;
+        if (page < 1 || limit < 1 || limit > 250) {
+          throw new Error(
+            "Invalid pagination parameters: page must be >= 1, limit must be between 1 and 250"
+          );
+        }
+        const products = await fetchPaginatedProductsFromCollection(
+          sanitizedHandle,
+          { page, limit }
+        );
+        return maybeOverrideProductsCurrency(products, options == null ? void 0 : options.currency);
+      },
+      /**
+       * Fetches all products from a specific collection.
+       *
+       * @param collectionHandle - The collection handle to fetch products from
+       *
+       * @returns {Promise<Product[] | null>} Array of all products from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://exampleshop.com');
+       * const allProducts = await shop.collections.products.all('summer-collection');
+       *
+       * if (allProducts) {
+       *   console.log(`Found ${allProducts.length} products in the collection`);
+       *   allProducts.forEach(product => {
+       *     console.log(`${product.title} - $${product.price}`);
+       *   });
+       * }
+       * ```
+       */
+      all: async (collectionHandle, options) => {
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        try {
+          const limit = 250;
+          const allProducts = [];
+          let currentPage = 1;
+          while (true) {
+            const products = await fetchPaginatedProductsFromCollection(
+              sanitizedHandle,
+              {
+                page: currentPage,
+                limit
+              }
+            );
+            if (!products || products.length === 0 || products.length < limit) {
+              if (products && products.length > 0) {
+                allProducts.push(...products);
+              }
+              break;
+            }
+            allProducts.push(...products);
+            currentPage++;
+          }
+          return maybeOverrideProductsCurrency(allProducts, options == null ? void 0 : options.currency);
+        } catch (error) {
+          console.error(
+            `Error fetching all products for collection ${sanitizedHandle}:`,
+            baseUrl,
+            error
+          );
+          return null;
+        }
+      },
+      /**
+       * Fetches all product slugs from a specific collection.
+       *
+       * @param collectionHandle - The collection handle to fetch product slugs from
+       *
+       * @returns {Promise<string[] | null>} Array of product slugs from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://exampleshop.com');
+       * const productSlugs = await shop.collections.products.slugs('summer-collection');
+       * console.log(productSlugs);
+       * ```
+       */
+      slugs: async (collectionHandle) => {
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        try {
+          const limit = 250;
+          const slugs = [];
+          let currentPage = 1;
+          while (true) {
+            const products = await fetchPaginatedProductsFromCollection(
+              sanitizedHandle,
+              {
+                page: currentPage,
+                limit
+              }
+            );
+            if (!products || products.length === 0 || products.length < limit) {
+              if (products && products.length > 0) {
+                slugs.push(...products.map((p) => p.slug));
+              }
+              break;
+            }
+            slugs.push(...products.map((p) => p.slug));
+            currentPage++;
+          }
+          return slugs;
+        } catch (error) {
+          console.error(
+            `Error fetching product slugs for collection ${sanitizedHandle}:`,
+            baseUrl,
+            error
+          );
+          return null;
+        }
+      }
+    }
+  };
+}
+
+// src/dto/collections.dto.ts
+function collectionsDto(collections) {
+  if (!collections || collections.length === 0) return null;
+  return collections.map((collection) => ({
+    id: collection.id.toString(),
+    title: collection.title,
+    handle: collection.handle,
+    description: collection.description,
+    image: collection.image ? {
+      id: collection.image.id,
+      createdAt: collection.image.created_at,
+      src: collection.image.src,
+      alt: collection.image.alt
+    } : void 0,
+    productsCount: collection.products_count,
+    publishedAt: collection.published_at,
+    updatedAt: collection.updated_at
+  }));
+}
+
+// src/dto/products.mapped.ts
+function mapVariants(product) {
+  var _a;
+  const variants = (_a = product.variants) != null ? _a : [];
+  return variants.map((variant) => {
+    var _a2;
+    return {
+      id: variant.id.toString(),
+      platformId: variant.id.toString(),
+      name: variant.name,
+      title: variant.title,
+      option1: variant.option1 || null,
+      option2: variant.option2 || null,
+      option3: variant.option3 || null,
+      options: [variant.option1, variant.option2, variant.option3].filter(
+        Boolean
+      ),
+      sku: variant.sku || null,
+      requiresShipping: variant.requires_shipping,
+      taxable: variant.taxable,
+      featuredImage: variant.featured_image ? {
+        id: variant.featured_image.id,
+        src: variant.featured_image.src,
+        width: variant.featured_image.width,
+        height: variant.featured_image.height,
+        position: variant.featured_image.position,
+        productId: variant.featured_image.product_id,
+        aspectRatio: variant.featured_image.aspect_ratio || 0,
+        variantIds: variant.featured_image.variant_ids || [],
+        createdAt: variant.featured_image.created_at,
+        updatedAt: variant.featured_image.updated_at,
+        alt: variant.featured_image.alt
+      } : null,
+      available: Boolean(variant.available),
+      price: typeof variant.price === "string" ? Number.parseFloat(variant.price) * 100 : variant.price,
+      weightInGrams: (_a2 = variant.weightInGrams) != null ? _a2 : variant.grams,
+      compareAtPrice: variant.compare_at_price ? typeof variant.compare_at_price === "string" ? Number.parseFloat(variant.compare_at_price) * 100 : variant.compare_at_price : 0,
+      position: variant.position,
+      productId: variant.product_id,
+      createdAt: variant.created_at,
+      updatedAt: variant.updated_at
+    };
+  });
+}
+function mapProductsDto(products, ctx) {
+  if (!products || products.length === 0) return null;
+  return products.map((product) => {
+    var _a, _b, _c;
+    const optionNames = product.options.map((o) => o.name);
+    const variantOptionsMap = buildVariantOptionsMap(
+      optionNames,
+      product.variants
+    );
+    const mappedVariants = mapVariants(product);
+    const priceValues = mappedVariants.map((v) => v.price).filter((p) => typeof p === "number" && !Number.isNaN(p));
+    const compareAtValues = mappedVariants.map((v) => v.compareAtPrice || 0).filter((p) => typeof p === "number" && !Number.isNaN(p));
+    const priceMin = priceValues.length ? Math.min(...priceValues) : 0;
+    const priceMax = priceValues.length ? Math.max(...priceValues) : 0;
+    const priceVaries = mappedVariants.length > 1 && priceMin !== priceMax;
+    const compareAtMin = compareAtValues.length ? Math.min(...compareAtValues) : 0;
+    const compareAtMax = compareAtValues.length ? Math.max(...compareAtValues) : 0;
+    const compareAtVaries = mappedVariants.length > 1 && compareAtMin !== compareAtMax;
+    return {
+      slug: genProductSlug({
+        handle: product.handle,
+        storeDomain: ctx.storeDomain
+      }),
+      handle: product.handle,
+      platformId: product.id.toString(),
+      title: product.title,
+      available: mappedVariants.some((v) => v.available),
+      price: priceMin,
+      priceMin,
+      priceMax,
+      priceVaries,
+      compareAtPrice: compareAtMin,
+      compareAtPriceMin: compareAtMin,
+      compareAtPriceMax: compareAtMax,
+      compareAtPriceVaries: compareAtVaries,
+      discount: 0,
+      currency: ctx.currency,
+      localizedPricing: {
+        currency: ctx.currency,
+        priceFormatted: ctx.formatPrice(priceMin),
+        priceMinFormatted: ctx.formatPrice(priceMin),
+        priceMaxFormatted: ctx.formatPrice(priceMax),
+        compareAtPriceFormatted: ctx.formatPrice(compareAtMin)
+      },
+      options: product.options.map((option) => ({
+        key: normalizeKey(option.name),
+        data: option.values,
+        name: option.name,
+        position: option.position,
+        values: option.values
+      })),
+      variantOptionsMap,
+      bodyHtml: product.body_html || null,
+      active: true,
+      productType: product.product_type || null,
+      tags: Array.isArray(product.tags) ? product.tags : [],
+      vendor: product.vendor,
+      featuredImage: ((_b = (_a = product.images) == null ? void 0 : _a[0]) == null ? void 0 : _b.src) ? ctx.normalizeImageUrl(product.images[0].src) : null,
+      isProxyFeaturedImage: false,
+      createdAt: safeParseDate(product.created_at),
+      updatedAt: safeParseDate(product.updated_at),
+      variants: mappedVariants,
+      images: product.images.map((image) => ({
+        id: image.id,
+        productId: image.product_id,
+        alt: null,
+        position: image.position,
+        src: ctx.normalizeImageUrl(image.src),
+        width: image.width,
+        height: image.height,
+        mediaType: "image",
+        variantIds: image.variant_ids || [],
+        createdAt: image.created_at,
+        updatedAt: image.updated_at
+      })),
+      publishedAt: (_c = safeParseDate(product.published_at)) != null ? _c : null,
+      seo: null,
+      metaTags: null,
+      displayScore: void 0,
+      deletedAt: null,
+      storeSlug: ctx.storeSlug,
+      storeDomain: ctx.storeDomain,
+      url: `${ctx.storeDomain}/products/${product.handle}`
+    };
+  });
+}
+function mapProductDto(product, ctx) {
+  var _a;
+  const optionNames = product.options.map((o) => o.name);
+  const variantOptionsMap = buildVariantOptionsMap(
+    optionNames,
+    product.variants
+  );
+  const mapped = {
+    slug: genProductSlug({
+      handle: product.handle,
+      storeDomain: ctx.storeDomain
+    }),
+    handle: product.handle,
+    platformId: product.id.toString(),
+    title: product.title,
+    available: product.available,
+    price: product.price,
+    priceMin: product.price_min,
+    priceMax: product.price_max,
+    priceVaries: product.price_varies,
+    compareAtPrice: product.compare_at_price || 0,
+    compareAtPriceMin: product.compare_at_price_min,
+    compareAtPriceMax: product.compare_at_price_max,
+    compareAtPriceVaries: product.compare_at_price_varies,
+    discount: 0,
+    currency: ctx.currency,
+    localizedPricing: {
+      currency: ctx.currency,
+      priceFormatted: ctx.formatPrice(product.price),
+      priceMinFormatted: ctx.formatPrice(product.price_min),
+      priceMaxFormatted: ctx.formatPrice(product.price_max),
+      compareAtPriceFormatted: ctx.formatPrice(product.compare_at_price || 0)
+    },
+    options: product.options.map((option) => ({
+      key: normalizeKey(option.name),
+      data: option.values,
+      name: option.name,
+      position: option.position,
+      values: option.values
+    })),
+    variantOptionsMap,
+    bodyHtml: product.description || null,
+    active: true,
+    productType: product.type || null,
+    tags: Array.isArray(product.tags) ? product.tags : typeof product.tags === "string" ? [product.tags] : [],
+    vendor: product.vendor,
+    featuredImage: ctx.normalizeImageUrl(product.featured_image),
+    isProxyFeaturedImage: false,
+    createdAt: safeParseDate(product.created_at),
+    updatedAt: safeParseDate(product.updated_at),
+    variants: mapVariants(product),
+    images: Array.isArray(product.images) ? product.images.map((imageSrc, index) => ({
+      id: index + 1,
+      productId: product.id,
+      alt: null,
+      position: index + 1,
+      src: ctx.normalizeImageUrl(imageSrc),
+      width: 0,
+      height: 0,
+      mediaType: "image",
+      variantIds: [],
+      createdAt: product.created_at,
+      updatedAt: product.updated_at
+    })) : [],
+    publishedAt: (_a = safeParseDate(product.published_at)) != null ? _a : null,
+    seo: null,
+    metaTags: null,
+    displayScore: void 0,
+    deletedAt: null,
+    storeSlug: ctx.storeSlug,
+    storeDomain: ctx.storeDomain,
+    url: product.url || `${ctx.storeDomain}/products/${product.handle}`
+  };
+  return mapped;
+}
+
+// src/products.ts
+var import_remeda3 = require("remeda");
+function createProductOperations(baseUrl, storeDomain, fetchProducts, productsDto, productDto, getStoreInfo, findProduct) {
+  function applyCurrencyOverride(product, currency) {
+    var _a, _b, _c, _d, _e, _f;
+    const priceMin = (_b = (_a = product.priceMin) != null ? _a : product.price) != null ? _b : 0;
+    const priceMax = (_d = (_c = product.priceMax) != null ? _c : product.price) != null ? _d : 0;
+    const compareAtMin = (_f = (_e = product.compareAtPriceMin) != null ? _e : product.compareAtPrice) != null ? _f : 0;
+    return {
+      ...product,
+      currency,
+      localizedPricing: {
+        currency,
+        priceFormatted: formatPrice(priceMin, currency),
+        priceMinFormatted: formatPrice(priceMin, currency),
+        priceMaxFormatted: formatPrice(priceMax, currency),
+        compareAtPriceFormatted: formatPrice(compareAtMin, currency)
+      }
+    };
+  }
+  function maybeOverrideProductsCurrency(products, currency) {
+    if (!products || !currency) return products;
+    return products.map((p) => applyCurrencyOverride(p, currency));
+  }
+  const operations = {
+    /**
+     * Fetches all products from the store across all pages.
+     *
+     * @returns {Promise<Product[] | null>} Array of all products or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const allProducts = await shop.products.all();
+     *
+     * console.log(`Found ${allProducts?.length} products`);
+     * allProducts?.forEach(product => {
+     *   console.log(product.title, product.price);
+     * });
+     * ```
+     */
+    all: async (options) => {
+      const limit = 250;
+      const allProducts = [];
+      async function fetchAll() {
+        let currentPage = 1;
+        while (true) {
+          const products = await fetchProducts(currentPage, limit);
+          if (!products || products.length === 0 || products.length < limit) {
+            if (products && products.length > 0) {
+              allProducts.push(...products);
+            }
+            break;
+          }
+          allProducts.push(...products);
+          currentPage++;
+        }
+        return allProducts;
+      }
+      try {
+        const products = await fetchAll();
+        return maybeOverrideProductsCurrency(products, options == null ? void 0 : options.currency);
+      } catch (error) {
+        console.error("Failed to fetch all products:", storeDomain, error);
+        throw error;
+      }
+    },
+    /**
+     * Fetches products with pagination support.
+     *
+     * @param options - Pagination options
+     * @param options.page - Page number (default: 1)
+     * @param options.limit - Number of products per page (default: 250, max: 250)
+     *
+     * @returns {Promise<Product[] | null>} Array of products for the specified page or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://example.myshopify.com');
+     *
+     * // Get first page with default limit (250)
+     * const firstPage = await shop.products.paginated();
+     *
+     * // Get second page with custom limit
+     * const secondPage = await shop.products.paginated({ page: 2, limit: 50 });
+     * ```
+     */
+    paginated: async (options) => {
+      var _a, _b;
+      const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+      const limit = Math.min((_b = options == null ? void 0 : options.limit) != null ? _b : 250, 250);
+      const url = `${baseUrl}products.json?limit=${limit}&page=${page}`;
+      try {
+        const response = await rateLimitedFetch(url);
+        if (!response.ok) {
+          console.error(
+            `HTTP error! status: ${response.status} for ${storeDomain} page ${page}`
+          );
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        if (data.products.length === 0) {
+          return [];
+        }
+        const normalized = productsDto(data.products);
+        return maybeOverrideProductsCurrency(normalized, options == null ? void 0 : options.currency);
+      } catch (error) {
+        console.error(
+          `Error fetching products for ${storeDomain} page ${page} with limit ${limit}:`,
+          error
+        );
+        return null;
+      }
+    },
+    /**
+     * Finds a specific product by its handle.
+     *
+     * @param productHandle - The product handle (URL slug) to search for
+     *
+     * @returns {Promise<Product | null>} The product if found, null if not found
+     *
+     * @throws {Error} When the handle is invalid or there's a network error
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     *
+     * // Find product by handle
+     * const product = await shop.products.find('awesome-t-shirt');
+     *
+     * if (product) {
+     *   console.log(product.title, product.price);
+     *   console.log('Available variants:', product.variants.length);
+     * }
+     *
+     * // Handle with query string
+     * const productWithVariant = await shop.products.find('t-shirt?variant=123');
+     * ```
+     */
+    find: async (productHandle, options) => {
+      var _a, _b;
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      try {
+        let qs = null;
+        if (productHandle.includes("?")) {
+          const parts = productHandle.split("?");
+          const handlePart = (_a = parts[0]) != null ? _a : productHandle;
+          const qsPart = (_b = parts[1]) != null ? _b : null;
+          productHandle = handlePart;
+          qs = qsPart;
+        }
+        const sanitizedHandle = productHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid product handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Product handle is too long");
+        }
+        let finalHandle = sanitizedHandle;
+        try {
+          const htmlResp = await rateLimitedFetch(
+            `${baseUrl}products/${encodeURIComponent(sanitizedHandle)}`
+          );
+          if (htmlResp.ok) {
+            const finalUrl = htmlResp.url;
+            if (finalUrl) {
+              const pathname = new URL(finalUrl).pathname.replace(/\/$/, "");
+              const parts = pathname.split("/").filter(Boolean);
+              const idx = parts.indexOf("products");
+              const maybeHandle = idx >= 0 ? parts[idx + 1] : void 0;
+              if (typeof maybeHandle === "string" && maybeHandle.length) {
+                finalHandle = maybeHandle;
+              }
+            }
+          }
+        } catch {
+        }
+        const url = `${baseUrl}products/${encodeURIComponent(finalHandle)}.js${qs ? `?${qs}` : ""}`;
+        const response = await rateLimitedFetch(url);
+        if (!response.ok) {
+          if (response.status === 404) {
+            return null;
+          }
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const product = await response.json();
+        const productData = productDto(product);
+        return (options == null ? void 0 : options.currency) ? applyCurrencyOverride(productData, options.currency) : productData;
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(
+            `Error fetching product ${productHandle}:`,
+            baseUrl,
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+    /**
+     * Enrich a product by generating merged markdown from body_html and product page.
+     * Adds `enriched_content` to the returned product.
+     */
+    enriched: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) {
+        return null;
+      }
+      const handle = baseProduct.handle;
+      const enriched = await enrichProduct(storeDomain, handle, {
+        apiKey,
+        useGfm: options == null ? void 0 : options.useGfm,
+        inputType: options == null ? void 0 : options.inputType,
+        model: options == null ? void 0 : options.model,
+        outputFormat: options == null ? void 0 : options.outputFormat
+      });
+      return {
+        ...baseProduct,
+        enriched_content: enriched.mergedMarkdown
+      };
+    },
+    classify: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const enrichedProduct = await operations.enriched(productHandle, {
+        apiKey,
+        inputType: "html",
+        model: options == null ? void 0 : options.model,
+        outputFormat: "json"
+      });
+      if (!enrichedProduct || !enrichedProduct.enriched_content) return null;
+      let productContent = enrichedProduct.enriched_content;
+      try {
+        const obj = JSON.parse(enrichedProduct.enriched_content);
+        const lines = [];
+        if (obj.title && typeof obj.title === "string")
+          lines.push(`Title: ${obj.title}`);
+        if (obj.description && typeof obj.description === "string")
+          lines.push(`Description: ${obj.description}`);
+        if (Array.isArray(obj.materials) && obj.materials.length)
+          lines.push(`Materials: ${obj.materials.join(", ")}`);
+        if (Array.isArray(obj.care) && obj.care.length)
+          lines.push(`Care: ${obj.care.join(", ")}`);
+        if (obj.fit && typeof obj.fit === "string")
+          lines.push(`Fit: ${obj.fit}`);
+        if (obj.returnPolicy && typeof obj.returnPolicy === "string")
+          lines.push(`ReturnPolicy: ${obj.returnPolicy}`);
+        productContent = lines.join("\n");
+      } catch {
+      }
+      const classification = await classifyProduct(productContent, {
+        apiKey,
+        model: options == null ? void 0 : options.model
+      });
+      return classification;
+    },
+    generateSEOContent: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) return null;
+      const payload = {
+        title: baseProduct.title,
+        description: baseProduct.bodyHtml || void 0,
+        vendor: baseProduct.vendor,
+        price: baseProduct.price,
+        tags: baseProduct.tags
+      };
+      const seo = await generateSEOContent(payload, {
+        apiKey,
+        model: options == null ? void 0 : options.model
+      });
+      return seo;
+    },
+    /**
+     * Fetches products that are showcased/featured on the store's homepage.
+     *
+     * @returns {Promise<Product[]>} Array of showcased products found on the homepage
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const showcasedProducts = await shop.products.showcased();
+     *
+     * console.log(`Found ${showcasedProducts.length} showcased products`);
+     * showcasedProducts.forEach(product => {
+     *   console.log(`Featured: ${product.title} - ${product.price}`);
+     * });
+     * ```
+     */
+    showcased: async () => {
+      const storeInfo = await getStoreInfo();
+      const products = await Promise.all(
+        storeInfo.showcase.products.map(
+          (productHandle) => findProduct(productHandle)
+        )
+      );
+      return (0, import_remeda3.filter)(products, import_remeda3.isNonNullish);
+    },
+    /**
+     * Creates a filter map of variant options and their distinct values from all products.
+     *
+     * @returns {Promise<Record<string, string[]> | null>} Map of option names to their distinct values or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const filters = await shop.products.filter();
+     *
+     * console.log('Available filters:', filters);
+     * // Output: { "Size": ["S", "M", "L", "XL"], "Color": ["Red", "Blue", "Green"] }
+     *
+     * // Use filters for UI components
+     * Object.entries(filters || {}).forEach(([optionName, values]) => {
+     *   console.log(`${optionName}: ${values.join(', ')}`);
+     * });
+     * ```
+     */
+    filter: async () => {
+      try {
+        const products = await operations.all();
+        if (!products || products.length === 0) {
+          return {};
+        }
+        const filterMap = {};
+        products.forEach((product) => {
+          if (product.variants && product.variants.length > 0) {
+            if (product.options && product.options.length > 0) {
+              product.options.forEach((option) => {
+                const lowercaseOptionName = option.name.toLowerCase();
+                if (!filterMap[lowercaseOptionName]) {
+                  filterMap[lowercaseOptionName] = /* @__PURE__ */ new Set();
+                }
+                option.values.forEach((value) => {
+                  const trimmed = value == null ? void 0 : value.trim();
+                  if (trimmed) {
+                    let set = filterMap[lowercaseOptionName];
+                    if (!set) {
+                      set = /* @__PURE__ */ new Set();
+                      filterMap[lowercaseOptionName] = set;
+                    }
+                    set.add(trimmed.toLowerCase());
+                  }
+                });
+              });
+            }
+            product.variants.forEach((variant) => {
+              var _a, _b, _c, _d, _e, _f;
+              if (variant.option1) {
+                const optionName = (((_b = (_a = product.options) == null ? void 0 : _a[0]) == null ? void 0 : _b.name) || "Option 1").toLowerCase();
+                let set1 = filterMap[optionName];
+                if (!set1) {
+                  set1 = /* @__PURE__ */ new Set();
+                  filterMap[optionName] = set1;
+                }
+                set1.add(variant.option1.trim().toLowerCase());
+              }
+              if (variant.option2) {
+                const optionName = (((_d = (_c = product.options) == null ? void 0 : _c[1]) == null ? void 0 : _d.name) || "Option 2").toLowerCase();
+                let set2 = filterMap[optionName];
+                if (!set2) {
+                  set2 = /* @__PURE__ */ new Set();
+                  filterMap[optionName] = set2;
+                }
+                set2.add(variant.option2.trim().toLowerCase());
+              }
+              if (variant.option3) {
+                const optionName = (((_f = (_e = product.options) == null ? void 0 : _e[2]) == null ? void 0 : _f.name) || "Option 3").toLowerCase();
+                if (!filterMap[optionName]) {
+                  filterMap[optionName] = /* @__PURE__ */ new Set();
+                }
+                filterMap[optionName].add(variant.option3.trim().toLowerCase());
+              }
+            });
+          }
+        });
+        const result = {};
+        Object.entries(filterMap).forEach(([optionName, valueSet]) => {
+          result[optionName] = Array.from(valueSet).sort();
+        });
+        return result;
+      } catch (error) {
+        console.error("Failed to create product filters:", storeDomain, error);
+        throw error;
+      }
+    }
+  };
+  return operations;
+}
+
+// src/store.ts
+function createStoreOperations(context) {
+  return {
+    /**
+     * Fetches comprehensive store information including metadata, social links, and showcase content.
+     *
+     * @returns {Promise<StoreInfo>} Store information object containing:
+     * - `name` - Store name from meta tags or domain
+     * - `domain` - Store domain URL
+     * - `slug` - Generated store slug
+     * - `title` - Store title from meta tags
+     * - `description` - Store description from meta tags
+     * - `logoUrl` - Store logo URL from Open Graph or CDN
+     * - `socialLinks` - Object with social media links (facebook, twitter, instagram, etc.)
+     * - `contactLinks` - Object with contact information (tel, email, contactPage)
+     * - `headerLinks` - Array of navigation links from header
+     * - `showcase` - Object with featured products and collections from homepage
+     * - `jsonLdData` - Structured data from JSON-LD scripts
+     * - `techProvider` - Shopify-specific information (walletId, subDomain)
+     * - `country` - Country detection results with ISO 3166-1 alpha-2 codes (e.g., "US", "GB")
+     *
+     * @throws {Error} When the store URL is unreachable or returns an error
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const storeInfo = await shop.getInfo();
+     *
+     * console.log(storeInfo.name); // "Example Store"
+     * console.log(storeInfo.socialLinks.instagram); // "https://instagram.com/example"
+     * console.log(storeInfo.showcase.products); // ["product-handle-1", "product-handle-2"]
+     * console.log(storeInfo.country); // "US"
+     * ```
+     */
+    info: async () => {
+      try {
+        const { info } = await getInfoForStore({
+          baseUrl: context.baseUrl,
+          storeDomain: context.storeDomain,
+          validateProductExists: context.validateProductExists,
+          validateCollectionExists: context.validateCollectionExists,
+          validateLinksInBatches: context.validateLinksInBatches
+        });
+        return info;
+      } catch (error) {
+        context.handleFetchError(error, "fetching store info", context.baseUrl);
+      }
+    }
+  };
+}
+
+// src/index.ts
+var ShopClient = class {
+  /**
+   * Creates a new ShopClient instance for interacting with a Shopify store.
+   *
+   * @param urlPath - The Shopify store URL (e.g., 'https://exampleshop.com' or 'exampleshop.com')
+   *
+   * @throws {Error} When the URL is invalid or contains malicious patterns
+   *
+   * @example
+   * ```typescript
+   * // With full URL
+   * const shop = new ShopClient('https://exampleshop.com');
+   *
+   * // Without protocol (automatically adds https://)
+   * const shop = new ShopClient('exampleshop.com');
+   *
+   * // Works with any Shopify store domain
+   * const shop1 = new ShopClient('https://example.myshopify.com');
+   * const shop2 = new ShopClient('https://boutique.fashion');
+   * ```
+   */
+  constructor(urlPath) {
+    this.validationCache = /* @__PURE__ */ new Map();
+    // Simple cache for validation results
+    this.cacheExpiry = 5 * 60 * 1e3;
+    // 5 minutes cache expiry
+    this.cacheTimestamps = /* @__PURE__ */ new Map();
+    this.normalizeImageUrlCache = /* @__PURE__ */ new Map();
+    if (!urlPath || typeof urlPath !== "string") {
+      throw new Error("Store URL is required and must be a string");
+    }
+    let normalizedUrl = urlPath.trim();
+    if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://")) {
+      normalizedUrl = `https://${normalizedUrl}`;
+    }
+    let storeUrl;
+    try {
+      storeUrl = new URL(normalizedUrl);
+    } catch (_error) {
+      throw new Error("Invalid store URL format");
+    }
+    const hostname = storeUrl.hostname;
+    if (!hostname || hostname.length < 3) {
+      throw new Error("Invalid domain name");
+    }
+    if (hostname.includes("..") || hostname.includes("//") || hostname.includes("@")) {
+      throw new Error("Invalid characters in domain name");
+    }
+    if (!hostname.includes(".") || hostname.startsWith(".") || hostname.endsWith(".")) {
+      throw new Error(
+        "Invalid domain format - must be a valid domain with TLD"
+      );
+    }
+    const domainPattern = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    if (!domainPattern.test(hostname)) {
+      throw new Error("Invalid domain format");
+    }
+    this.storeDomain = `https://${hostname}`;
+    let fetchUrl = `https://${hostname}${storeUrl.pathname}`;
+    if (!fetchUrl.endsWith("/")) {
+      fetchUrl = `${fetchUrl}/`;
+    }
+    this.baseUrl = fetchUrl;
+    this.storeSlug = generateStoreSlug(this.storeDomain);
+    this.storeOperations = createStoreOperations({
+      baseUrl: this.baseUrl,
+      storeDomain: this.storeDomain,
+      validateProductExists: this.validateProductExists.bind(this),
+      validateCollectionExists: this.validateCollectionExists.bind(this),
+      validateLinksInBatches: this.validateLinksInBatches.bind(this),
+      handleFetchError: this.handleFetchError.bind(this)
+    });
+    this.products = createProductOperations(
+      this.baseUrl,
+      this.storeDomain,
+      this.fetchProducts.bind(this),
+      this.productsDto.bind(this),
+      this.productDto.bind(this),
+      () => this.getInfo(),
+      (handle) => this.products.find(handle)
+    );
+    this.collections = createCollectionOperations(
+      this.baseUrl,
+      this.storeDomain,
+      this.fetchCollections.bind(this),
+      this.collectionsDto.bind(this),
+      this.fetchPaginatedProductsFromCollection.bind(this),
+      () => this.getInfo(),
+      (handle) => this.collections.find(handle)
+    );
+    this.checkout = createCheckoutOperations(this.baseUrl);
+  }
+  /**
+   * Optimized image URL normalization with caching
+   */
+  normalizeImageUrl(url) {
+    if (!url) {
+      return "";
+    }
+    if (this.normalizeImageUrlCache.has(url)) {
+      return this.normalizeImageUrlCache.get(url);
+    }
+    const normalized = url.startsWith("//") ? `https:${url}` : url;
+    this.normalizeImageUrlCache.set(url, normalized);
+    return normalized;
+  }
+  /**
+   * Format a price amount (in cents) using the store currency.
+   */
+  formatPrice(amountInCents) {
+    var _a;
+    const currency = (_a = this.storeCurrency) != null ? _a : "USD";
+    try {
+      return new Intl.NumberFormat(void 0, {
+        style: "currency",
+        currency
+      }).format((amountInCents || 0) / 100);
+    } catch {
+      const val = (amountInCents || 0) / 100;
+      return `${val} ${currency}`;
+    }
+  }
+  /**
+   * Transform Shopify products to our Product format
+   */
+  productsDto(products) {
+    var _a;
+    return mapProductsDto(products, {
+      storeDomain: this.storeDomain,
+      storeSlug: this.storeSlug,
+      currency: (_a = this.storeCurrency) != null ? _a : "USD",
+      normalizeImageUrl: (url) => this.normalizeImageUrl(url),
+      formatPrice: (amount) => this.formatPrice(amount)
+    });
+  }
+  productDto(product) {
+    var _a;
+    return mapProductDto(product, {
+      storeDomain: this.storeDomain,
+      storeSlug: this.storeSlug,
+      currency: (_a = this.storeCurrency) != null ? _a : "USD",
+      normalizeImageUrl: (url) => this.normalizeImageUrl(url),
+      formatPrice: (amount) => this.formatPrice(amount)
+    });
+  }
+  collectionsDto(collections) {
+    var _a;
+    return (_a = collectionsDto(collections)) != null ? _a : [];
+  }
+  /**
+   * Enhanced error handling with context
+   */
+  handleFetchError(error, context, url) {
+    let errorMessage = `Error ${context}`;
+    let statusCode;
+    if (error instanceof Error) {
+      errorMessage += `: ${error.message}`;
+      if ("status" in error) {
+        statusCode = error.status;
+      }
+    } else if (typeof error === "string") {
+      errorMessage += `: ${error}`;
+    } else {
+      errorMessage += ": Unknown error occurred";
+    }
+    errorMessage += ` (URL: ${url})`;
+    if (statusCode) {
+      errorMessage += ` (Status: ${statusCode})`;
+    }
+    const enhancedError = new Error(errorMessage);
+    enhancedError.context = context;
+    enhancedError.url = url;
+    enhancedError.statusCode = statusCode;
+    enhancedError.originalError = error;
+    throw enhancedError;
+  }
+  /**
+   * Fetch products with pagination
+   */
+  async fetchProducts(page, limit) {
+    try {
+      const url = `${this.baseUrl}products.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.productsDto(data.products);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching products",
+        `${this.baseUrl}products.json`
+      );
+    }
+  }
+  /**
+   * Fetch collections with pagination
+   */
+  async fetchCollections(page, limit) {
+    try {
+      const url = `${this.baseUrl}collections.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.collectionsDto(data.collections);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching collections",
+        `${this.baseUrl}collections.json`
+      );
+    }
+  }
+  /**
+   * Fetch paginated products from a specific collection
+   */
+  async fetchPaginatedProductsFromCollection(collectionHandle, options = {}) {
+    try {
+      const { page = 1, limit = 250 } = options;
+      let finalHandle = collectionHandle;
+      try {
+        const htmlResp = await rateLimitedFetch(
+          `${this.baseUrl}collections/${encodeURIComponent(collectionHandle)}`
+        );
+        if (htmlResp.ok) {
+          const finalUrl = htmlResp.url;
+          if (finalUrl) {
+            const pathname = new URL(finalUrl).pathname.replace(/\/$/, "");
+            const parts = pathname.split("/").filter(Boolean);
+            const idx = parts.indexOf("collections");
+            const maybeHandle = idx >= 0 ? parts[idx + 1] : void 0;
+            if (typeof maybeHandle === "string" && maybeHandle.length) {
+              finalHandle = maybeHandle;
+            }
+          }
+        }
+      } catch {
+      }
+      const url = `${this.baseUrl}collections/${finalHandle}/products.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url);
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.productsDto(data.products);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching products from collection",
+        `${this.baseUrl}collections/${collectionHandle}/products.json`
+      );
+    }
+  }
+  /**
+   * Validate if a product exists (with caching)
+   */
+  async validateProductExists(handle) {
+    const cacheKey = `product:${handle}`;
+    if (this.isCacheValid(cacheKey)) {
+      return this.validationCache.get(cacheKey) || false;
+    }
+    try {
+      const url = `${this.baseUrl}products/${handle}.js`;
+      const response = await rateLimitedFetch(url, { method: "HEAD" });
+      const exists = response.ok;
+      this.setCacheValue(cacheKey, exists);
+      return exists;
+    } catch (_error) {
+      this.setCacheValue(cacheKey, false);
+      return false;
+    }
+  }
+  /**
+   * Validate if a collection exists (with caching)
+   */
+  async validateCollectionExists(handle) {
+    const cacheKey = `collection:${handle}`;
+    if (this.isCacheValid(cacheKey)) {
+      return this.validationCache.get(cacheKey) || false;
+    }
+    try {
+      const url = `${this.baseUrl}collections/${handle}.json`;
+      const response = await rateLimitedFetch(url, { method: "HEAD" });
+      const exists = response.ok;
+      this.setCacheValue(cacheKey, exists);
+      return exists;
+    } catch (_error) {
+      this.setCacheValue(cacheKey, false);
+      return false;
+    }
+  }
+  /**
+   * Check if cache entry is still valid
+   */
+  isCacheValid(key) {
+    const timestamp = this.cacheTimestamps.get(key);
+    if (!timestamp) return false;
+    return Date.now() - timestamp < this.cacheExpiry;
+  }
+  /**
+   * Set cache value with timestamp
+   */
+  setCacheValue(key, value) {
+    this.validationCache.set(key, value);
+    this.cacheTimestamps.set(key, Date.now());
+  }
+  /**
+   * Validate links in batches to avoid overwhelming the server
+   */
+  async validateLinksInBatches(items, validator, batchSize = 10) {
+    const validItems = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const validationPromises = batch.map(async (item) => {
+        const isValid = await validator(item);
+        return isValid ? item : null;
+      });
+      const results = await Promise.all(validationPromises);
+      const validBatchItems = results.filter(
+        (item) => item !== null
+      );
+      validItems.push(...validBatchItems);
+      if (i + batchSize < items.length) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+    return validItems;
+  }
+  /**
+   * Fetches comprehensive store information including metadata, social links, and showcase content.
+   *
+   * @returns {Promise<StoreInfo>} Store information object containing:
+   * - `name` - Store name from meta tags or domain
+   * - `domain` - Store domain URL
+   * - `slug` - Generated store slug
+   * - `title` - Store title from meta tags
+   * - `description` - Store description from meta tags
+   * - `logoUrl` - Store logo URL from Open Graph or CDN
+   * - `socialLinks` - Object with social media links (facebook, twitter, instagram, etc.)
+   * - `contactLinks` - Object with contact information (tel, email, contactPage)
+   * - `headerLinks` - Array of navigation links from header
+   * - `showcase` - Object with featured products and collections from homepage
+   * - `jsonLdData` - Structured data from JSON-LD scripts
+   * - `techProvider` - Shopify-specific information (walletId, subDomain)
+   * - `country` - Country detection results with ISO 3166-1 alpha-2 codes (e.g., "US", "GB")
+   *
+   * @throws {Error} When the store URL is unreachable or returns an error
+   *
+   * @example
+   * ```typescript
+   * const shop = new ShopClient('https://exampleshop.com');
+   * const storeInfo = await shop.getInfo();
+   *
+   * console.log(storeInfo.name); // "Example Store"
+   * console.log(storeInfo.socialLinks.instagram); // "https://instagram.com/example"
+   * console.log(storeInfo.showcase.products); // ["product-handle-1", "product-handle-2"]
+   * console.log(storeInfo.country); // "US"
+   * ```
+   */
+  async getInfo() {
+    try {
+      const { info, currencyCode } = await getInfoForStore({
+        baseUrl: this.baseUrl,
+        storeDomain: this.storeDomain,
+        validateProductExists: (handle) => this.validateProductExists(handle),
+        validateCollectionExists: (handle) => this.validateCollectionExists(handle),
+        validateLinksInBatches: (items, validator, batchSize) => this.validateLinksInBatches(items, validator, batchSize)
+      });
+      if (typeof currencyCode === "string") {
+        this.storeCurrency = currencyCode;
+      }
+      return info;
+    } catch (error) {
+      this.handleFetchError(error, "fetching store info", this.baseUrl);
+    }
+  }
+  /**
+   * Determine the store's primary vertical and target audience.
+   * Uses `getInfo()` internally; no input required.
+   */
+  async determineStoreType(options) {
+    try {
+      const breakdown = await determineStoreTypeForStore({
+        baseUrl: this.baseUrl,
+        getInfo: () => this.getInfo(),
+        findProduct: (handle) => this.products.find(handle),
+        apiKey: options == null ? void 0 : options.apiKey,
+        model: options == null ? void 0 : options.model,
+        maxShowcaseProducts: options == null ? void 0 : options.maxShowcaseProducts,
+        maxShowcaseCollections: options == null ? void 0 : options.maxShowcaseCollections
+      });
+      return breakdown;
+    } catch (error) {
+      throw this.handleFetchError(error, "determineStoreType", this.baseUrl);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShopClient,
+  calculateDiscount,
+  classifyProduct,
+  configureRateLimit,
+  detectShopifyCountry,
+  extractDomainWithoutSuffix,
+  genProductSlug,
+  generateSEOContent,
+  generateStoreSlug,
+  safeParseDate,
+  sanitizeDomain
+});
+//# sourceMappingURL=index.js.map