@asteby/storefront 0.0.0-stage → 0.2.0

package/dist/mock.cjs

@@ -0,0 +1,998 @@
+'use strict';
+
+// src/mock/seed.ts
+var MOCK_IMAGE_URL = (seed, width = 800, height = 800) => `https://picsum.photos/seed/${encodeURIComponent(seed)}/${width}/${height}`;
+var MOCK_CURRENCY = "MXN";
+var MOCK_CUSTOMER_EMAIL = "cliente@example.com";
+var OPT = {
+  size: (values = ["S", "M", "L"]) => ({ name: "Talla", values }),
+  color: (values) => ({ name: "Color", values })
+};
+var COLLECTION_SPECS = [
+  { handle: "ropa", title: "Ropa", description: "Prendas b\xE1sicas para todos los d\xEDas." },
+  { handle: "hogar", title: "Hogar", description: "Objetos \xFAtiles y bonitos para tu casa." },
+  { handle: "accesorios", title: "Accesorios", description: "Complementos para llevar contigo." },
+  { handle: "llantas", title: "Llantas", description: "Llantas para auto por medida." }
+];
+var tire = (width, aspect, rim) => ({
+  width,
+  aspect,
+  rim,
+  size_key: `${width}/${aspect}R${rim}`
+});
+var PRODUCT_SPECS = [
+  // Ropa
+  { handle: "playera-basica", title: "Playera b\xE1sica", collection: "ropa", type: "Playera", vendor: "Casa Textil", price: 249, compareAt: 299, options: [OPT.size(), OPT.color(["Blanco", "Negro"])], tags: ["algod\xF3n", "nuevo"], stock: (i) => i === 5 ? 0 : 15, description: "Playera de algod\xF3n peinado, corte recto." },
+  { handle: "sudadera-capucha", title: "Sudadera con capucha", collection: "ropa", type: "Sudadera", vendor: "Casa Textil", price: 699, options: [OPT.size(["S", "M", "L", "XL"]), OPT.color(["Gris", "Azul"])], priceDelta: { XL: 50 }, tags: ["invierno"], description: "Sudadera afelpada con bolsa canguro." },
+  { handle: "pantalon-chino", title: "Pantal\xF3n chino", collection: "ropa", type: "Pantal\xF3n", vendor: "Taller Urbano", price: 899, options: [OPT.size(["28", "30", "32", "34"])], stock: (i) => i === 0 ? 0 : 6, description: "Pantal\xF3n de gabardina con un toque de elasticidad." },
+  { handle: "chamarra-ligera", title: "Chamarra ligera", collection: "ropa", type: "Chamarra", vendor: "Taller Urbano", price: 1299, compareAt: 1599, options: [OPT.size()], tags: ["oferta"], description: "Chamarra rompevientos plegable." },
+  { handle: "gorra-clasica", title: "Gorra cl\xE1sica", collection: "ropa", type: "Gorra", vendor: "Casa Textil", price: 199, options: [OPT.color(["Negro", "Beige", "Verde"])], description: "Gorra de seis paneles con ajuste trasero." },
+  { handle: "calcetines-paquete", title: "Calcetines (paquete de 3)", collection: "ropa", type: "Calcetines", vendor: "Casa Textil", price: 149, stock: 0, description: "Tres pares de calcetines de algod\xF3n." },
+  // Hogar
+  { handle: "taza-ceramica", title: "Taza de cer\xE1mica", collection: "hogar", type: "Cocina", vendor: "Barro Vivo", price: 129, options: [OPT.color(["Blanco", "Terracota"])], tags: ["regalo"], description: "Taza de 350 ml hecha a mano." },
+  { handle: "lampara-mesa", title: "L\xE1mpara de mesa", collection: "hogar", type: "Iluminaci\xF3n", vendor: "Luz Serena", price: 1199, description: "L\xE1mpara con pantalla de lino y base de madera." },
+  { handle: "cojin-decorativo", title: "Coj\xEDn decorativo", collection: "hogar", type: "Textil", vendor: "Casa Textil", price: 349, compareAt: 399, options: [OPT.color(["Mostaza", "Verde", "Gris"])], description: "Coj\xEDn de 45 \xD7 45 cm con funda removible." },
+  { handle: "set-sartenes", title: "Set de sartenes", collection: "hogar", type: "Cocina", vendor: "Cocina Diaria", price: 1899, compareAt: 2299, tags: ["oferta"], description: "Tres sartenes antiadherentes de 20, 24 y 28 cm." },
+  { handle: "manta-tejida", title: "Manta tejida", collection: "hogar", type: "Textil", vendor: "Casa Textil", price: 799, description: "Manta de punto grueso, 130 \xD7 170 cm." },
+  { handle: "maceta-barro", title: "Maceta de barro", collection: "hogar", type: "Jard\xEDn", vendor: "Barro Vivo", price: 189, options: [{ name: "Tama\xF1o", values: ["Chica", "Mediana", "Grande"] }], priceDelta: { Mediana: 60, Grande: 140 }, description: "Maceta de barro natural con plato." },
+  // Accesorios
+  { handle: "mochila-diaria", title: "Mochila diaria", collection: "accesorios", type: "Mochila", vendor: "Ruta Libre", price: 999, options: [OPT.color(["Negro", "Azul"])], tags: ["nuevo"], description: "Mochila de 20 L con compartimento para laptop." },
+  { handle: "botella-termica", title: "Botella t\xE9rmica", collection: "accesorios", type: "Botella", vendor: "Ruta Libre", price: 399, options: [{ name: "Capacidad", values: ["500 ml", "750 ml"] }], priceDelta: { "750 ml": 80 }, description: "Mantiene fr\xEDo 24 h y caliente 12 h." },
+  { handle: "lentes-sol", title: "Lentes de sol", collection: "accesorios", type: "Lentes", vendor: "Vista Clara", price: 599, compareAt: 749, description: "Lentes polarizados con protecci\xF3n UV400." },
+  { handle: "reloj-analogico", title: "Reloj anal\xF3gico", collection: "accesorios", type: "Reloj", vendor: "Vista Clara", price: 1499, description: "Reloj con correa de piel y cristal mineral." },
+  { handle: "cartera-piel", title: "Cartera de piel", collection: "accesorios", type: "Cartera", vendor: "Taller Urbano", price: 549, options: [OPT.color(["Caf\xE9", "Negro"])], description: "Cartera delgada con seis ranuras." },
+  { handle: "paraguas-compacto", title: "Paraguas compacto", collection: "accesorios", type: "Paraguas", vendor: "Ruta Libre", price: 299, stock: 3, description: "Paraguas plegable resistente al viento." },
+  // Llantas (exercise attribute facets)
+  { handle: "llanta-205-55-r16-touring", title: "Llanta 205/55 R16 Touring", collection: "llantas", type: "Llanta", vendor: "Marca Norte", price: 1899, compareAt: 2099, attributes: { ...tire(205, 55, 16), load_index: 91, speed_rating: "V", runflat: false }, tags: ["auto"], description: "Llanta de turismo silenciosa y de bajo consumo." },
+  { handle: "llanta-205-55-r16-sport", title: "Llanta 205/55 R16 Sport", collection: "llantas", type: "Llanta", vendor: "Marca Sur", price: 2199, attributes: { ...tire(205, 55, 16), load_index: 94, speed_rating: "W", runflat: false }, tags: ["auto"], description: "Agarre deportivo en seco y mojado." },
+  { handle: "llanta-195-65-r15-eco", title: "Llanta 195/65 R15 Eco", collection: "llantas", type: "Llanta", vendor: "Marca Norte", price: 1499, attributes: { ...tire(195, 65, 15), load_index: 91, speed_rating: "H", runflat: false }, tags: ["auto"], description: "Baja resistencia al rodamiento." },
+  { handle: "llanta-225-45-r17-runflat", title: "Llanta 225/45 R17 Run Flat", collection: "llantas", type: "Llanta", vendor: "Marca Centro", price: 3299, attributes: { ...tire(225, 45, 17), load_index: 91, speed_rating: "W", runflat: true }, tags: ["auto"], stock: 2, description: "Permite rodar hasta 80 km sin presi\xF3n." },
+  { handle: "llanta-265-70-r16-at", title: "Llanta 265/70 R16 All Terrain", collection: "llantas", type: "Llanta", vendor: "Marca Sur", price: 3599, attributes: { ...tire(265, 70, 16), load_index: 112, speed_rating: "T", runflat: false }, tags: ["camioneta"], description: "Para camioneta, asfalto y terracer\xEDa." },
+  { handle: "llanta-175-70-r13-city", title: "Llanta 175/70 R13 City", collection: "llantas", type: "Llanta", vendor: "Marca Centro", price: 999, attributes: { ...tire(175, 70, 13), load_index: 82, speed_rating: "T", runflat: false }, tags: ["auto"], stock: 0, description: "Econ\xF3mica y durable para ciudad." }
+];
+var money = (n, currency) => ({ amount: n.toFixed(2), currency_code: currency });
+function cartesian(options) {
+  let combos = [{}];
+  for (const opt of options) {
+    const next = [];
+    for (const c of combos) for (const v of opt.values) next.push({ ...c, [opt.name]: v });
+    combos = next;
+  }
+  return combos;
+}
+var BASE_DATE = Date.UTC(2026, 8, 30, 12, 0, 0);
+function image(url, seed, alt) {
+  return { url: url(seed), alt, width: 800, height: 800 };
+}
+function buildProducts(currency, imageUrl = MOCK_IMAGE_URL) {
+  return PRODUCT_SPECS.map((spec, pi) => {
+    const options = spec.options ?? [];
+    const combos = options.length ? cartesian(options) : [{}];
+    const images = [image(imageUrl, spec.handle, spec.title), image(imageUrl, `${spec.handle}-2`, `${spec.title}, detalle`)];
+    const variants = combos.map((opts, vi) => {
+      const delta = Object.values(opts).reduce((sum, v) => sum + (spec.priceDelta?.[v] ?? 0), 0);
+      const price = spec.price + delta;
+      const stock = typeof spec.stock === "function" ? spec.stock(vi, opts) : spec.stock ?? 12;
+      const title = Object.values(opts).join(" / ") || "Predeterminado";
+      const firstValue = Object.values(opts)[0];
+      return {
+        id: `var_${pi + 1}_${vi + 1}`,
+        sku: `${spec.handle.toUpperCase().replace(/-/g, "")}-${vi + 1}`.slice(0, 32),
+        title,
+        selected_options: Object.entries(opts).map(([name, value]) => ({ name, value })),
+        price: money(price, currency),
+        compare_at_price: spec.compareAt ? money(spec.compareAt + delta, currency) : null,
+        available_for_sale: stock > 0,
+        quantity_available: stock,
+        image: firstValue ? image(imageUrl, `${spec.handle}-${firstValue}`, `${spec.title} ${firstValue}`) : null,
+        barcode: `75000000${String(pi * 100 + vi).padStart(5, "0")}`
+      };
+    });
+    const prices = variants.map((v) => Number(v.price.amount));
+    const compares = variants.map((v) => v.compare_at_price ? Number(v.compare_at_price.amount) : null).filter((n) => n !== null);
+    const collection = COLLECTION_SPECS.find((c) => c.handle === spec.collection);
+    return {
+      id: `prod_${pi + 1}`,
+      handle: spec.handle,
+      title: spec.title,
+      description: spec.description,
+      description_html: `<p>${spec.description}</p>`,
+      vendor: spec.vendor,
+      product_type: spec.type,
+      category: { id: `cat_${spec.collection}`, handle: collection.handle, title: collection.title },
+      tags: spec.tags ?? [],
+      attributes: spec.attributes ?? {},
+      featured_image: images[0] ?? null,
+      images,
+      options,
+      variants,
+      price_range: { min: money(Math.min(...prices), currency), max: money(Math.max(...prices), currency) },
+      compare_at_price_range: compares.length ? { min: money(Math.min(...compares), currency), max: money(Math.max(...compares), currency) } : null,
+      available_for_sale: variants.some((v) => v.available_for_sale),
+      seo: { title: `${spec.title} | Mi tienda`, description: spec.description },
+      updated_at: new Date(BASE_DATE - pi * 864e5).toISOString()
+    };
+  });
+}
+function buildMemberships() {
+  const out = {};
+  for (const p of PRODUCT_SPECS) out[p.handle] = [p.collection];
+  return out;
+}
+function buildCollections(imageUrl = MOCK_IMAGE_URL) {
+  return COLLECTION_SPECS.map((c) => ({
+    id: `col_${c.handle}`,
+    handle: c.handle,
+    title: c.title,
+    description: c.description,
+    image: image(imageUrl, `col-${c.handle}`, c.title),
+    seo: { title: `${c.title} | Mi tienda`, description: c.description },
+    parent_handle: c.parent ?? null
+  }));
+}
+function buildShop(currency, imageUrl = MOCK_IMAGE_URL) {
+  return {
+    name: "Mi tienda",
+    description: "Tienda de ejemplo para desarrollar sin backend.",
+    domain: "mi-tienda.example",
+    currency_code: currency,
+    locale: "es-MX",
+    locales: ["es-MX", "en-US"],
+    country_code: "MX",
+    logo: { url: imageUrl("logo", 256, 256), alt: "Mi tienda", width: 256, height: 256 },
+    contact: { email: "hola@mi-tienda.example", phone: "+52 55 0000 0000", whatsapp: "+5215500000000" },
+    branches: [
+      { id: "br_centro", name: "Sucursal Centro", address: "Av. Principal 100, Col. Centro", city: "Ciudad de M\xE9xico", phone: "+52 55 0000 0001", lat: 19.4326, lng: -99.1332, hours: "Mo-Fr 09:00-19:00, Sa 09:00-14:00" },
+      { id: "br_norte", name: "Sucursal Norte", address: "Calle Secundaria 25, Col. Norte", city: "Monterrey", phone: null, lat: 25.6866, lng: -100.3161, hours: "Mo-Sa 10:00-18:00" }
+    ],
+    policies: { free_shipping_min: money(999, currency), returns_days: 30 }
+  };
+}
+function buildTheme() {
+  return {
+    tokens: {
+      background: "#ffffff",
+      foreground: "#111827",
+      primary: "#0f766e",
+      "primary-foreground": "#ffffff",
+      secondary: "#f1f5f9",
+      "secondary-foreground": "#0f172a",
+      muted: "#f8fafc",
+      "muted-foreground": "#64748b",
+      accent: "#f59e0b",
+      "accent-foreground": "#111827",
+      border: "#e2e8f0",
+      destructive: "#dc2626"
+    },
+    fonts: { heading: "Inter", body: "Inter" },
+    radius: "0.5rem"
+  };
+}
+function buildPages(imageUrl = MOCK_IMAGE_URL) {
+  return [
+    {
+      handle: "home",
+      title: "Inicio",
+      seo: { title: "Mi tienda", description: "Ropa, hogar, accesorios y llantas con env\xEDo a todo el pa\xEDs." },
+      sections: [
+        { id: "hero-1", type: "hero", props: { title: "Todo lo que necesitas, en un solo lugar", subtitle: "Env\xEDo gratis desde $999", cta_label: "Ver productos", cta_url: "/collections/ropa", image: imageUrl("hero", 1600, 700) } },
+        { id: "grid-1", type: "product_grid", props: { title: "Lo m\xE1s nuevo", collection: "ropa", limit: 8 } },
+        { id: "collections-1", type: "collection_list", props: { title: "Compra por categor\xEDa", handles: ["ropa", "hogar", "accesorios", "llantas"] } },
+        { id: "text-1", type: "rich_text", props: { title: "Sobre nosotros", html: "<p>Somos una tienda de ejemplo. Edita este texto desde el panel.</p>" } },
+        {
+          id: "faq-1",
+          type: "faq",
+          props: {
+            title: "Preguntas frecuentes",
+            items: [
+              { question: "\xBFCu\xE1nto tarda el env\xEDo?", answer: "De 2 a 5 d\xEDas h\xE1biles." },
+              { question: "\xBFPuedo recoger en tienda?", answer: "S\xED, elige recoger en sucursal al pagar." },
+              { question: "\xBFC\xF3mo pido factura?", answer: "Desde tu cuenta, en el detalle del pedido." }
+            ]
+          }
+        }
+      ]
+    },
+    legal("terminos", "T\xE9rminos y condiciones", "Al comprar en Mi tienda aceptas estos t\xE9rminos."),
+    legal("privacidad", "Aviso de privacidad", "Tratamos tus datos solo para procesar tus pedidos."),
+    legal("devoluciones", "Pol\xEDtica de devoluciones", "Tienes 30 d\xEDas para devolver tu compra.")
+  ];
+}
+function legal(handle, title, body) {
+  return {
+    handle,
+    title,
+    seo: { title: `${title} | Mi tienda`, description: body },
+    sections: [{ id: `${handle}-text`, type: "rich_text", props: { title, html: `<p>${body}</p>` } }]
+  };
+}
+function buildMenus() {
+  return [
+    {
+      handle: "main",
+      items: [
+        { title: "Inicio", url: "/" },
+        {
+          title: "Tienda",
+          url: "/search",
+          items: COLLECTION_SPECS.map((c) => ({ title: c.title, url: `/collections/${c.handle}` }))
+        },
+        { title: "Blog", url: "/blogs/noticias" }
+      ]
+    },
+    {
+      handle: "footer",
+      items: [
+        { title: "T\xE9rminos y condiciones", url: "/pages/terminos" },
+        { title: "Aviso de privacidad", url: "/pages/privacidad" },
+        { title: "Devoluciones", url: "/pages/devoluciones" }
+      ]
+    }
+  ];
+}
+function buildArticles(imageUrl = MOCK_IMAGE_URL) {
+  return [
+    {
+      id: "art_1",
+      handle: "como-elegir-llantas",
+      title: "C\xF3mo elegir las llantas correctas",
+      excerpt: "Lee la medida en el costado de tu llanta: ancho, perfil y rin.",
+      content_html: "<p>La medida 205/55 R16 indica 205 mm de ancho, perfil del 55 % y rin de 16 pulgadas.</p>",
+      image: image(imageUrl, "blog-llantas", "Llantas"),
+      author: "Equipo Mi tienda",
+      tags: ["llantas", "gu\xEDas"],
+      published_at: "2026-09-15T15:00:00.000Z",
+      seo: { title: "C\xF3mo elegir llantas | Mi tienda", description: "Gu\xEDa r\xE1pida para leer la medida de tus llantas." }
+    },
+    {
+      id: "art_2",
+      handle: "cuidado-prendas-algodon",
+      title: "Cuida tus prendas de algod\xF3n",
+      excerpt: "Tres consejos para que tus playeras duren m\xE1s.",
+      content_html: "<p>Lava en fr\xEDo, seca a la sombra y plancha al rev\xE9s.</p>",
+      image: image(imageUrl, "blog-algodon", "Prendas de algod\xF3n"),
+      author: "Equipo Mi tienda",
+      tags: ["ropa", "gu\xEDas"],
+      published_at: "2026-09-01T15:00:00.000Z",
+      seo: { title: "Cuida tus prendas | Mi tienda", description: "Consejos de lavado para prendas de algod\xF3n." }
+    }
+  ];
+}
+function buildCustomers() {
+  return [
+    {
+      id: "cus_1",
+      email: MOCK_CUSTOMER_EMAIL,
+      phone: "+525500000002",
+      first_name: "Cliente",
+      last_name: "Demo",
+      default_address_id: null,
+      created_at: "2026-01-10T12:00:00.000Z"
+    }
+  ];
+}
+
+// src/mock/index.ts
+var HttpError = class extends Error {
+  constructor(status, code, message, field) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.field = field;
+  }
+  status;
+  code;
+  field;
+};
+var PUBLIC_CACHE = "public, max-age=60, stale-while-revalidate=600";
+var PRIVATE_CACHE = "private, no-store";
+var toCents = (amount) => Math.round(Number.parseFloat(amount) * 100);
+var fromCents = (cents, currency) => ({ amount: (cents / 100).toFixed(2), currency_code: currency });
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function encodeCursor(offset) {
+  return btoa(`o:${offset}`);
+}
+function decodeCursor(cursor) {
+  if (!cursor) return 0;
+  try {
+    const raw = atob(cursor);
+    if (!raw.startsWith("o:")) throw new Error("bad cursor");
+    const n = Number(raw.slice(2));
+    if (!Number.isInteger(n) || n < 0) throw new Error("bad cursor");
+    return n;
+  } catch {
+    throw new HttpError(400, "validation", "Invalid cursor", "after");
+  }
+}
+function paginate(items, search, defaultFirst = 24, maxFirst = 100) {
+  const first = search.has("first") ? Number(search.get("first")) : defaultFirst;
+  if (!Number.isInteger(first) || first < 1 || first > maxFirst) throw new HttpError(400, "validation", `\`first\` must be between 1 and ${maxFirst}`, "first");
+  const start = decodeCursor(search.get("after"));
+  const nodes = items.slice(start, start + first);
+  const end = start + nodes.length;
+  return {
+    nodes,
+    page_info: { has_next_page: end < items.length, end_cursor: nodes.length ? encodeCursor(end) : null },
+    total_count: items.length
+  };
+}
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+function createMockStorefront(options = {}) {
+  const currency = options.currency ?? MOCK_CURRENCY;
+  const imageUrl = options.imageUrl ?? MOCK_IMAGE_URL;
+  const otpCode = options.otpCode ?? "000000";
+  const discountCodes = Object.fromEntries(
+    Object.entries(options.discountCodes ?? { BIENVENIDA10: 10 }).map(([k, v]) => [k.toUpperCase(), v])
+  );
+  const flatShippingCents = Math.round((options.flatShipping ?? 149) * 100);
+  const enforceScopes = options.enforceScopes ?? true;
+  function seed() {
+    return {
+      shop: { ...buildShop(currency, imageUrl), ...options.shop },
+      products: structuredClone(options.products ?? buildProducts(currency, imageUrl)),
+      collections: structuredClone(options.collections ?? buildCollections(imageUrl)),
+      memberships: structuredClone(options.memberships ?? buildMemberships()),
+      theme: structuredClone(options.theme ?? buildTheme()),
+      pages: structuredClone(options.pages ?? buildPages(imageUrl)),
+      menus: structuredClone(options.menus ?? buildMenus()),
+      articles: structuredClone(options.articles ?? buildArticles(imageUrl)),
+      carts: /* @__PURE__ */ new Map(),
+      customers: buildCustomers(),
+      addresses: /* @__PURE__ */ new Map(),
+      orders: [
+        {
+          id: "ord_seed_1",
+          number: "1000",
+          status: "fulfilled",
+          created_at: "2026-08-20T18:00:00.000Z",
+          total: fromCents(24900, currency),
+          customer_id: "cus_1",
+          lines: [
+            { title: "Playera b\xE1sica", variant_title: "M / Blanco", sku: null, quantity: 1, unit: fromCents(24900, currency), total: fromCents(24900, currency), image: null }
+          ]
+        }
+      ],
+      otps: /* @__PURE__ */ new Map(),
+      sessions: /* @__PURE__ */ new Map(),
+      idempotency: /* @__PURE__ */ new Map(),
+      seq: 0
+    };
+  }
+  let state = seed();
+  const nextId = (prefix) => `${prefix}_${(++state.seq).toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  function findVariant(variantId) {
+    for (const product of state.products) {
+      const variant = product.variants.find((v) => v.id === variantId);
+      if (variant) return { product, variant };
+    }
+    return null;
+  }
+  const minPriceCents = (p) => toCents(p.price_range.min.amount);
+  function attrValue(p, key) {
+    if (key === "vendor") return p.vendor;
+    if (key === "product_type") return p.product_type;
+    if (key === "tag") return null;
+    const v = p.attributes[key];
+    return v === void 0 ? null : String(v);
+  }
+  function matchesText(p, q) {
+    const terms = q.toLowerCase().split(/\s+/).filter(Boolean);
+    const hay = [p.title, p.description, p.vendor ?? "", p.product_type ?? "", ...p.tags, ...Object.values(p.attributes).map(String)].join(" ").toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+      if (!hay.includes(t)) return 0;
+      score += p.title.toLowerCase().includes(t) ? 2 : 1;
+    }
+    return score;
+  }
+  function listProducts(search) {
+    let items = state.products.slice();
+    const q = search.get("q")?.trim();
+    const scores = /* @__PURE__ */ new Map();
+    if (q) {
+      items = items.filter((p) => {
+        const s = matchesText(p, q);
+        scores.set(p.id, s);
+        return s > 0;
+      });
+    }
+    const collection = search.get("collection");
+    if (collection) {
+      if (!state.collections.some((c) => c.handle === collection)) throw new HttpError(404, "not_found", `Collection ${collection} not found`, "collection");
+      items = items.filter((p) => state.memberships[p.handle]?.includes(collection));
+    }
+    const handles = search.get("handles");
+    if (handles) {
+      const list = handles.split(",").map((h) => h.trim()).filter(Boolean);
+      if (list.length > 100) throw new HttpError(400, "validation", "At most 100 handles", "handles");
+      items = items.filter((p) => list.includes(p.handle));
+    }
+    const base = items;
+    if (search.get("available") === "true") items = items.filter((p) => p.available_for_sale);
+    const priceMin = search.get("price_min");
+    const priceMax = search.get("price_max");
+    if (priceMin) items = items.filter((p) => minPriceCents(p) >= Math.round(Number(priceMin) * 100));
+    if (priceMax) items = items.filter((p) => minPriceCents(p) <= Math.round(Number(priceMax) * 100));
+    const filters = /* @__PURE__ */ new Map();
+    for (const [key, value] of search) {
+      if (!key.startsWith("filter.")) continue;
+      const name = key.slice(7);
+      filters.set(name, [...filters.get(name) ?? [], value]);
+    }
+    for (const [key, values] of filters) {
+      if (key === "tag") items = items.filter((p) => values.some((v) => p.tags.includes(v)));
+      else items = items.filter((p) => values.includes(attrValue(p, key) ?? "\0"));
+    }
+    const sort = search.get("sort") ?? "relevance";
+    const sorters = {
+      relevance: (a, b) => (scores.get(b.id) ?? 0) - (scores.get(a.id) ?? 0),
+      price_asc: (a, b) => minPriceCents(a) - minPriceCents(b),
+      price_desc: (a, b) => minPriceCents(b) - minPriceCents(a),
+      newest: (a, b) => b.updated_at.localeCompare(a.updated_at),
+      title_asc: (a, b) => a.title.localeCompare(b.title, "es")
+    };
+    const sorter = sorters[sort];
+    if (!sorter) throw new HttpError(400, "validation", `Unknown sort ${sort}`, "sort");
+    items = items.slice().sort(sorter);
+    return { ...paginate(items, search), facets: buildFacets(base) };
+  }
+  function buildFacets(products) {
+    const facets = [];
+    const listFacet = (key, label, pick) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const p of products) {
+        const v = pick(p);
+        if (v !== null && v !== "") counts.set(v, (counts.get(v) ?? 0) + 1);
+      }
+      if (counts.size === 0) return;
+      const values = [...counts.entries()].sort(([a], [b]) => a.localeCompare(b, "es", { numeric: true })).map(([value, count]) => ({ value, label: value, count }));
+      facets.push({ key, label, type: "list", values });
+    };
+    listFacet("vendor", "Marca", (p) => p.vendor);
+    listFacet("product_type", "Tipo", (p) => p.product_type);
+    const attrKeys = /* @__PURE__ */ new Set();
+    for (const p of products) for (const k of Object.keys(p.attributes)) attrKeys.add(k);
+    const labels = { width: "Ancho", aspect: "Perfil", rim: "Rin", size_key: "Medida", load_index: "\xCDndice de carga", speed_rating: "\xCDndice de velocidad", runflat: "Run flat" };
+    for (const k of [...attrKeys].sort()) listFacet(k, labels[k] ?? k, (p) => p.attributes[k] === void 0 ? null : String(p.attributes[k]));
+    if (products.length) {
+      const prices = products.map(minPriceCents);
+      const min = Math.min(...prices);
+      const max = Math.max(...prices);
+      facets.push({
+        key: "price",
+        label: "Precio",
+        type: "price_range",
+        values: [
+          { value: (min / 100).toFixed(2), label: "min", count: products.length },
+          { value: (max / 100).toFixed(2), label: "max", count: products.length }
+        ]
+      });
+    }
+    return facets;
+  }
+  function getCartRecord(id) {
+    const cart = state.carts.get(id);
+    if (!cart) throw new HttpError(404, "not_found", `Cart ${id} not found`, "id");
+    return cart;
+  }
+  function validateLines(lines, cart) {
+    if (!Array.isArray(lines)) throw new HttpError(400, "validation", "`lines` must be an array", "lines");
+    return lines.map((raw, i) => {
+      const l = raw;
+      if (typeof l.variant_id !== "string") throw new HttpError(400, "validation", "variant_id is required", `lines[${i}].variant_id`);
+      const quantity = l.quantity === void 0 ? 1 : l.quantity;
+      if (typeof quantity !== "number" || !Number.isInteger(quantity) || quantity < 1) {
+        throw new HttpError(400, "validation", "quantity must be a positive integer", `lines[${i}].quantity`);
+      }
+      const found = findVariant(l.variant_id);
+      if (!found) throw new HttpError(400, "validation", `Unknown variant ${l.variant_id}`, `lines[${i}].variant_id`);
+      const already = cart?.lines.find((x) => x.variant_id === l.variant_id)?.quantity ?? 0;
+      checkStock(found.variant, already + quantity, `lines[${i}].quantity`);
+      return { variant_id: l.variant_id, quantity };
+    });
+  }
+  function checkStock(variant, quantity, field) {
+    if (!variant.available_for_sale || variant.quantity_available !== null && quantity > variant.quantity_available) {
+      throw new HttpError(409, "insufficient_stock", `Only ${variant.quantity_available ?? 0} available for ${variant.sku}`, field);
+    }
+  }
+  function addLines(cart, lines) {
+    for (const l of lines) {
+      const existing = cart.lines.find((x) => x.variant_id === l.variant_id);
+      if (existing) existing.quantity += l.quantity;
+      else cart.lines.push({ id: nextId("line"), variant_id: l.variant_id, quantity: l.quantity });
+    }
+  }
+  const isKnownCode = (code) => code.toUpperCase() in discountCodes;
+  const percentFor = (code) => discountCodes[code.toUpperCase()] ?? 0;
+  function shippingRates(subtotalCents) {
+    const freeMin = state.shop.policies.free_shipping_min;
+    const free = freeMin !== null && subtotalCents >= toCents(freeMin.amount);
+    return [
+      { id: "flat", title: free ? "Env\xEDo est\xE1ndar (gratis)" : "Env\xEDo est\xE1ndar", cost: fromCents(free ? 0 : flatShippingCents, currency), eta: "2 a 5 d\xEDas h\xE1biles" },
+      { id: "express", title: "Env\xEDo expr\xE9s", cost: fromCents(flatShippingCents + 1e4, currency), eta: "1 a 2 d\xEDas h\xE1biles" }
+    ];
+  }
+  function renderCart(cart) {
+    const lines = [];
+    let subtotal = 0;
+    let quantity = 0;
+    for (const l of cart.lines) {
+      const found = findVariant(l.variant_id);
+      if (!found) continue;
+      const { product, variant } = found;
+      const unit = toCents(variant.price.amount);
+      subtotal += unit * l.quantity;
+      quantity += l.quantity;
+      lines.push({
+        id: l.id,
+        quantity: l.quantity,
+        merchandise: {
+          ...variant,
+          product: { handle: product.handle, title: product.title, featured_image: product.featured_image }
+        },
+        cost: {
+          unit: variant.price,
+          total: fromCents(unit * l.quantity, currency),
+          compare_at_unit: variant.compare_at_price
+        }
+      });
+    }
+    const codes = cart.codes.map((code) => ({ code, applicable: isKnownCode(code) && subtotal > 0 }));
+    const percent = codes.filter((d) => d.applicable).reduce((max, d) => Math.max(max, percentFor(d.code)), 0);
+    const discount = Math.round(subtotal * percent / 100);
+    let shipping = null;
+    if (cart.delivery.method === "pickup") shipping = 0;
+    else if (cart.delivery.method === "shipping" && cart.delivery.rate_id) {
+      const rate = shippingRates(subtotal - discount).find((r) => r.id === cart.delivery.rate_id);
+      shipping = rate ? toCents(rate.cost.amount) : null;
+    }
+    const total = subtotal - discount + (shipping ?? 0);
+    const tax = Math.round(total - total / 1.16);
+    return {
+      id: cart.id,
+      lines,
+      total_quantity: quantity,
+      discount_codes: codes,
+      buyer: { ...cart.buyer },
+      shipping_address: cart.shipping_address ? { ...cart.shipping_address } : null,
+      delivery: { ...cart.delivery },
+      cost: {
+        subtotal: fromCents(subtotal, currency),
+        discount: fromCents(discount, currency),
+        shipping: shipping === null ? null : fromCents(shipping, currency),
+        tax: fromCents(tax, currency),
+        total: fromCents(total, currency),
+        tax_included: true
+      },
+      updated_at: cart.updated_at
+    };
+  }
+  function requireCustomer(headers) {
+    const token = headers.get("x-customer-token");
+    const id = token ? state.sessions.get(token) : void 0;
+    const customer = id ? state.customers.find((c) => c.id === id) : void 0;
+    if (!customer) throw new HttpError(401, "unauthorized", "Missing or invalid customer session");
+    return customer;
+  }
+  function identifierOf(body) {
+    const email = typeof body.email === "string" ? body.email.trim().toLowerCase() : "";
+    const phone = typeof body.phone === "string" ? body.phone.replace(/\s+/g, "") : "";
+    if (!email && !phone) throw new HttpError(400, "validation", "email or phone is required", "email");
+    if (email && !/^[^@\s]+@[^@\s]+$/.test(email)) throw new HttpError(400, "validation", "Invalid email", "email");
+    return email ? `email:${email}` : `phone:${phone}`;
+  }
+  function validateAddress(body, partial = false) {
+    const required = ["address1", "city", "zip", "country_code"];
+    if (!partial) {
+      for (const f of required) {
+        if (typeof body[f] !== "string" || !body[f].trim()) throw new HttpError(400, "validation", `${f} is required`, f);
+      }
+    }
+    const fields = ["first_name", "last_name", "company", "address1", "address2", "city", "province", "zip", "country_code", "phone"];
+    const out = {};
+    for (const f of fields) {
+      if (f in body) out[f] = body[f] ?? null;
+      else if (!partial) out[f] = null;
+    }
+    return out;
+  }
+  const routes = [];
+  const route = (method, path, scope, handler) => {
+    const pattern = new RegExp("^" + path.replace(/:[a-z_]+/g, "([^/]+)") + "$");
+    routes.push({ method, pattern, scope, handler });
+  };
+  const requireNode = (value, what, field = "handle") => {
+    if (value === void 0) throw new HttpError(404, "not_found", `${what} not found`, field);
+    return value;
+  };
+  route("GET", "/shop", "catalog:read", () => ({ body: state.shop, cache: "public" }));
+  route("GET", "/products", "catalog:read", ({ search }) => ({ body: listProducts(search), cache: "public" }));
+  route("GET", "/products/:handle", "catalog:read", ({ params }) => ({
+    body: requireNode(state.products.find((p) => p.handle === params[0]), `Product ${params[0]}`),
+    cache: "public"
+  }));
+  route("GET", "/products/:handle/recommendations", "catalog:read", ({ params }) => {
+    const product = requireNode(state.products.find((p) => p.handle === params[0]), `Product ${params[0]}`);
+    const cols = state.memberships[product.handle] ?? [];
+    const nodes = state.products.filter((p) => p.id !== product.id && p.available_for_sale && (state.memberships[p.handle] ?? []).some((c) => cols.includes(c))).slice(0, 4);
+    return { body: { nodes }, cache: "public" };
+  });
+  route("GET", "/collections", "catalog:read", ({ search }) => ({ body: paginate(state.collections, search), cache: "public" }));
+  route("GET", "/collections/:handle", "catalog:read", ({ params }) => ({
+    body: requireNode(state.collections.find((c) => c.handle === params[0]), `Collection ${params[0]}`),
+    cache: "public"
+  }));
+  route("GET", "/stock", "catalog:read", ({ search }) => {
+    const skus = search.getAll("sku");
+    if (skus.length > 250) throw new HttpError(400, "validation", "At most 250 SKUs", "sku");
+    const nodes = skus.flatMap((sku) => {
+      for (const p of state.products) {
+        const v = p.variants.find((x) => x.sku === sku);
+        if (v) return [{ sku, quantity_available: v.quantity_available }];
+      }
+      return [];
+    });
+    return { body: { nodes }, cache: "public" };
+  });
+  route("POST", "/carts", "cart:write", ({ body }) => {
+    const cart = {
+      id: nextId("cart"),
+      lines: [],
+      codes: [],
+      buyer: { email: null, phone: null, customer_id: null },
+      shipping_address: null,
+      delivery: { method: null, rate_id: null, branch_id: null },
+      updated_at: now()
+    };
+    if (body.lines !== void 0) addLines(cart, validateLines(body.lines));
+    state.carts.set(cart.id, cart);
+    return { status: 201, body: renderCart(cart), cache: "private" };
+  });
+  route("GET", "/carts/:id", "cart:write", ({ params }) => ({ body: renderCart(getCartRecord(params[0])), cache: "private" }));
+  route("POST", "/carts/:id/lines", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    addLines(cart, validateLines(body.lines, cart));
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("PATCH", "/carts/:id/lines", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    if (!Array.isArray(body.lines)) throw new HttpError(400, "validation", "`lines` must be an array", "lines");
+    const updates = body.lines;
+    updates.forEach((u, i) => {
+      const line = cart.lines.find((l) => l.id === u.id);
+      if (!line) throw new HttpError(400, "validation", `Unknown line ${String(u.id)}`, `lines[${i}].id`);
+      if (typeof u.quantity !== "number" || !Number.isInteger(u.quantity) || u.quantity < 0) {
+        throw new HttpError(400, "validation", "quantity must be a non-negative integer", `lines[${i}].quantity`);
+      }
+      if (u.quantity > 0) checkStock(findVariant(line.variant_id).variant, u.quantity, `lines[${i}].quantity`);
+    });
+    for (const u of updates) {
+      const line = cart.lines.find((l) => l.id === u.id);
+      line.quantity = u.quantity;
+    }
+    cart.lines = cart.lines.filter((l) => l.quantity > 0);
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("PUT", "/carts/:id/discount-codes", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    if (!Array.isArray(body.codes) || body.codes.some((c) => typeof c !== "string")) {
+      throw new HttpError(400, "validation", "`codes` must be an array of strings", "codes");
+    }
+    cart.codes = [...new Set(body.codes.map((c) => c.trim().toUpperCase()).filter(Boolean))];
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("PUT", "/carts/:id/buyer", "cart:write", ({ params, body, headers }) => {
+    const cart = getCartRecord(params[0]);
+    const email = typeof body.email === "string" ? body.email.trim() : null;
+    const phone = typeof body.phone === "string" ? body.phone.trim() : null;
+    if (email && !/^[^@\s]+@[^@\s]+$/.test(email)) throw new HttpError(400, "validation", "Invalid email", "email");
+    const token = headers.get("x-customer-token");
+    const customerId = token ? state.sessions.get(token) ?? null : null;
+    cart.buyer = { email: email || null, phone: phone || null, customer_id: customerId };
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("PUT", "/carts/:id/shipping-address", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    cart.shipping_address = validateAddress(body);
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("GET", "/carts/:id/delivery-options", "cart:write", ({ params }) => {
+    const cart = renderCart(getCartRecord(params[0]));
+    const net = toCents(cart.cost.subtotal.amount) - toCents(cart.cost.discount.amount);
+    return {
+      body: { rates: shippingRates(net), pickup: state.shop.branches.map((b) => ({ branch_id: b.id, name: b.name })), partial: false, unavailable: [] },
+      cache: "private"
+    };
+  });
+  route("GET", "/carts/:id/payment-methods", "cart:write", ({ params }) => {
+    getCartRecord(params[0]);
+    return { body: { methods: [{ key: "mock", kind: "builtin", default: true }], market: null }, cache: "private" };
+  });
+  route("PUT", "/carts/:id/delivery", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    if (body.method === "shipping") {
+      const rateId = body.rate_id;
+      if (typeof rateId !== "string" || !shippingRates(0).some((r) => r.id === rateId)) {
+        throw new HttpError(400, "validation", "Unknown rate_id", "rate_id");
+      }
+      cart.delivery = { method: "shipping", rate_id: rateId, branch_id: null };
+    } else if (body.method === "pickup") {
+      const branchId = body.branch_id;
+      if (typeof branchId !== "string" || !state.shop.branches.some((b) => b.id === branchId)) {
+        throw new HttpError(400, "validation", "Unknown branch_id", "branch_id");
+      }
+      cart.delivery = { method: "pickup", rate_id: null, branch_id: branchId };
+    } else {
+      throw new HttpError(400, "validation", "method must be shipping or pickup", "method");
+    }
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("POST", "/carts/:id/checkout", "checkout:write", ({ params, body, headers }) => {
+    const key = headers.get("idempotency-key");
+    if (key) {
+      const prev = state.idempotency.get(`${params[0]}:${key}`);
+      if (prev) return { status: prev.status, body: prev.body, cache: "private" };
+    }
+    const record = getCartRecord(params[0]);
+    const cart = renderCart(record);
+    if (cart.lines.length === 0) throw new HttpError(422, "invalid_state", "Cart is empty", "lines");
+    if (!cart.buyer.email && !cart.buyer.phone) throw new HttpError(422, "invalid_state", "Buyer email or phone is required", "buyer");
+    if (!cart.delivery.method) throw new HttpError(422, "invalid_state", "Delivery method is required", "delivery");
+    if (cart.delivery.method === "shipping" && !cart.shipping_address) {
+      throw new HttpError(422, "invalid_state", "Shipping address is required", "shipping_address");
+    }
+    if (typeof body.payment_method !== "string" || !body.payment_method) throw new HttpError(400, "validation", "payment_method is required", "payment_method");
+    if (typeof body.return_url !== "string" || !body.return_url) throw new HttpError(400, "validation", "return_url is required", "return_url");
+    record.lines.forEach((l, i) => checkStock(findVariant(l.variant_id).variant, l.quantity, `lines[${i}].quantity`));
+    for (const l of record.lines) {
+      const v = findVariant(l.variant_id).variant;
+      if (v.quantity_available !== null) {
+        v.quantity_available -= l.quantity;
+        v.available_for_sale = v.quantity_available > 0;
+      }
+    }
+    for (const p of state.products) p.available_for_sale = p.variants.some((v) => v.available_for_sale);
+    const orderId = nextId("ord");
+    const number = String(1001 + state.orders.length - 1);
+    const customerId = cart.buyer.customer_id ?? state.customers.find((c) => c.email && c.email === cart.buyer.email)?.id ?? null;
+    state.orders.push({
+      id: orderId,
+      number,
+      status: "pending_payment",
+      created_at: now(),
+      total: cart.cost.total,
+      customer_id: customerId,
+      lines: cart.lines.map((l) => ({
+        title: l.merchandise.product.title,
+        variant_title: l.merchandise.title,
+        sku: l.merchandise.sku,
+        quantity: l.quantity,
+        unit: l.cost.unit,
+        total: l.cost.total,
+        image: l.merchandise.image ?? l.merchandise.product.featured_image
+      }))
+    });
+    const redirect = new URL(`https://mock.local/pay/${orderId}`);
+    redirect.searchParams.set("return_url", body.return_url);
+    const checkoutId = nextId("chk");
+    const result = {
+      order: { id: orderId, number },
+      payment: { provider: "mock", status: "pending", redirect_url: redirect.toString(), client_secret: null, instructions: null },
+      checkout: {
+        id: checkoutId,
+        status: "pending",
+        external_order_id: orderId,
+        total: cart.cost.total,
+        stock_hold_expires_at: new Date(Date.now() + 30 * 6e4).toISOString()
+      }
+    };
+    if (key) state.idempotency.set(`${params[0]}:${key}`, { status: 201, body: result });
+    return { status: 201, body: result, cache: "private" };
+  });
+  route("POST", "/customer/otp", "customer:write", ({ body }) => {
+    state.otps.set(identifierOf(body), otpCode);
+    return { status: 204 };
+  });
+  route("POST", "/customer/session", "customer:write", ({ body }) => {
+    const id = identifierOf(body);
+    if (typeof body.code !== "string" || state.otps.get(id) !== body.code) {
+      throw new HttpError(401, "unauthorized", "Invalid or expired code", "code");
+    }
+    state.otps.delete(id);
+    const [kind, value] = id.split(/:(.*)/s);
+    let customer = state.customers.find((c) => kind === "email" ? c.email === value : c.phone === value);
+    if (!customer) {
+      customer = {
+        id: nextId("cus"),
+        email: kind === "email" ? value : null,
+        phone: kind === "phone" ? value : null,
+        first_name: null,
+        last_name: null,
+        default_address_id: null,
+        created_at: now()
+      };
+      state.customers.push(customer);
+    }
+    const token = `ct_${customer.id}_${Math.random().toString(36).slice(2)}`;
+    state.sessions.set(token, customer.id);
+    return {
+      status: 201,
+      body: { token, expires_at: new Date(Date.now() + 30 * 864e5).toISOString(), customer },
+      cache: "private"
+    };
+  });
+  route("GET", "/customer", "customer:read", ({ headers }) => ({ body: requireCustomer(headers), cache: "private" }));
+  const stripOrder = ({ customer_id: _c, ...o }) => o;
+  route("GET", "/customer/orders", "orders:read", ({ headers, search }) => {
+    const c = requireCustomer(headers);
+    const orders = state.orders.filter((o) => o.customer_id === c.id).sort((a, b) => b.created_at.localeCompare(a.created_at)).map(stripOrder);
+    return { body: paginate(orders, search, 20), cache: "private" };
+  });
+  const findOrder = (headers, id) => {
+    const c = requireCustomer(headers);
+    return requireNode(state.orders.find((o) => o.id === id && o.customer_id === c.id), `Order ${id}`, "id");
+  };
+  route("GET", "/customer/orders/:id", "orders:read", ({ headers, params }) => ({ body: stripOrder(findOrder(headers, params[0])), cache: "private" }));
+  route("POST", "/customer/orders/:id/returns", "customer:write", ({ headers, params, body }) => {
+    const order = findOrder(headers, params[0]);
+    if (!Array.isArray(body.lines) || body.lines.length === 0) throw new HttpError(400, "validation", "lines are required", "lines");
+    return { status: 201, body: { id: nextId("ret"), order_id: order.id, status: "requested" }, cache: "private" };
+  });
+  route("POST", "/customer/orders/:id/invoice", "customer:write", ({ headers, params }) => {
+    findOrder(headers, params[0]);
+    return { status: 202, body: { status: "requested", url: null }, cache: "private" };
+  });
+  route("GET", "/customer/addresses", "customer:read", ({ headers }) => {
+    const c = requireCustomer(headers);
+    return { body: { nodes: state.addresses.get(c.id) ?? [] }, cache: "private" };
+  });
+  route("POST", "/customer/addresses", "customer:write", ({ headers, body }) => {
+    const c = requireCustomer(headers);
+    const address = { ...validateAddress(body), id: nextId("addr") };
+    state.addresses.set(c.id, [...state.addresses.get(c.id) ?? [], address]);
+    if (!c.default_address_id) c.default_address_id = address.id;
+    return { status: 201, body: address, cache: "private" };
+  });
+  route("PATCH", "/customer/addresses/:id", "customer:write", ({ headers, params, body }) => {
+    const c = requireCustomer(headers);
+    const list = state.addresses.get(c.id) ?? [];
+    const idx = list.findIndex((a) => a.id === params[0]);
+    if (idx < 0) throw new HttpError(404, "not_found", "Address not found", "id");
+    const updated = { ...list[idx], ...validateAddress(body, true), id: list[idx].id };
+    list[idx] = updated;
+    return { body: updated, cache: "private" };
+  });
+  route("DELETE", "/customer/addresses/:id", "customer:write", ({ headers, params }) => {
+    const c = requireCustomer(headers);
+    const list = state.addresses.get(c.id) ?? [];
+    if (!list.some((a) => a.id === params[0])) throw new HttpError(404, "not_found", "Address not found", "id");
+    state.addresses.set(c.id, list.filter((a) => a.id !== params[0]));
+    if (c.default_address_id === params[0]) c.default_address_id = null;
+    return { status: 204 };
+  });
+  const previewCache = (search) => search.has("preview") ? "private" : "public";
+  route("GET", "/content/theme", "content:read", () => ({ body: state.theme, cache: "public" }));
+  route("GET", "/content/pages/:handle", "content:read", ({ params, search }) => {
+    const page = requireNode(state.pages.find((p) => p.handle === params[0]), `Page ${params[0]}`);
+    const body = search.has("preview") ? { ...page, title: `${page.title} (borrador)` } : page;
+    return { body, cache: previewCache(search) };
+  });
+  route("GET", "/content/menus/:handle", "content:read", ({ params }) => ({
+    body: requireNode(state.menus.find((m) => m.handle === params[0]), `Menu ${params[0]}`),
+    cache: "public"
+  }));
+  route("GET", "/content/articles", "content:read", ({ search }) => {
+    let items = state.articles.slice().sort((a, b) => b.published_at.localeCompare(a.published_at));
+    const tag = search.get("tag");
+    if (tag) items = items.filter((a) => a.tags.includes(tag));
+    const q = search.get("q")?.toLowerCase();
+    if (q) items = items.filter((a) => `${a.title} ${a.excerpt ?? ""}`.toLowerCase().includes(q));
+    return { body: paginate(items, search, 10, 50), cache: "public" };
+  });
+  route("GET", "/content/articles/:handle", "content:read", ({ params, search }) => ({
+    body: requireNode(state.articles.find((a) => a.handle === params[0]), `Article ${params[0]}`),
+    cache: previewCache(search)
+  }));
+  function scopesFor(token) {
+    if (!token) return null;
+    if (token.startsWith("pk_")) return /* @__PURE__ */ new Set(["catalog:read", "content:read", "cart:write"]);
+    if (token.startsWith("sk_")) return /* @__PURE__ */ new Set(["catalog:read", "content:read", "cart:write", "checkout:write", "customer:read", "customer:write", "orders:read"]);
+    return null;
+  }
+  function json(status, body, headers = {}) {
+    return new Response(status === 204 || body === void 0 ? null : JSON.stringify(body), {
+      status,
+      headers: { "Content-Type": "application/json; charset=utf-8", ...headers }
+    });
+  }
+  function errorResponse(err) {
+    return json(err.status, { error: { code: err.code, message: err.message, ...err.field ? { field: err.field } : {} } }, { "Cache-Control": PRIVATE_CACHE });
+  }
+  async function handle(request) {
+    const url = new URL(request.url);
+    const idx = url.pathname.indexOf("/storefront/");
+    if (idx < 0) return errorResponse(new HttpError(404, "not_found", `No route for ${url.pathname}`));
+    const path = url.pathname.slice(idx + "/storefront".length).replace(/\/+$/, "") || "/";
+    const method = request.method.toUpperCase();
+    const matching = routes.filter((r2) => r2.pattern.test(path));
+    if (matching.length === 0) return errorResponse(new HttpError(404, "not_found", `No route for ${method} ${path}`));
+    const r = matching.find((x) => x.method === method);
+    if (!r) return json(405, { error: { code: "method_not_allowed", message: `${method} not allowed on ${path}` } }, { Allow: matching.map((x) => x.method).join(", ") });
+    const auth = request.headers.get("authorization");
+    const token = auth?.match(/^Bearer\s+(.+)$/i)?.[1] ?? null;
+    const scopes = scopesFor(token);
+    if (!scopes) return errorResponse(new HttpError(401, "unauthorized", "Missing or invalid storefront token"));
+    if (enforceScopes && !scopes.has(r.scope)) return errorResponse(new HttpError(403, "forbidden", `Token lacks scope ${r.scope}`));
+    let body = {};
+    if (method !== "GET" && method !== "DELETE") {
+      const text = await request.text();
+      if (text) {
+        try {
+          const parsed = JSON.parse(text);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("not an object");
+          body = parsed;
+        } catch {
+          return errorResponse(new HttpError(400, "validation", "Body must be a JSON object"));
+        }
+      }
+    }
+    const params = (r.pattern.exec(path) ?? []).slice(1).map((p) => decodeURIComponent(p));
+    try {
+      const result = await r.handler({ method, params, search: url.searchParams, headers: request.headers, body, scopes });
+      const status = result.status ?? 200;
+      const headers = { ...result.headers };
+      if (result.cache === "public") headers["Cache-Control"] = PUBLIC_CACHE;
+      if (result.cache === "private") headers["Cache-Control"] = PRIVATE_CACHE;
+      if (method === "GET" && result.cache === "public" && status === 200) {
+        const etag = `W/"${fnv1a(JSON.stringify(result.body))}"`;
+        headers.ETag = etag;
+        if (request.headers.get("if-none-match") === etag) return new Response(null, { status: 304, headers });
+      }
+      return json(status, result.body, headers);
+    } catch (err) {
+      if (err instanceof HttpError) return errorResponse(err);
+      return json(500, { error: { code: "server_error", message: err instanceof Error ? err.message : "Internal error" } });
+    }
+  }
+  const mockFetch = async (input, init) => {
+    if (options.latencyMs) await new Promise((r) => setTimeout(r, options.latencyMs));
+    const request = input instanceof Request && !init ? input : new Request(input instanceof Request ? input.url : String(input), init);
+    if (request.signal?.aborted) throw request.signal.reason ?? new DOMException("Aborted", "AbortError");
+    return handle(request);
+  };
+  return {
+    /** Drop-in `fetch` serving `/storefront/*` from memory. */
+    fetch: mockFetch,
+    /** Live in-memory state (mutable; useful in tests). */
+    get state() {
+      return state;
+    },
+    /** Restores the seed data and clears carts, sessions and orders. */
+    reset() {
+      state = seed();
+    },
+    /** OTP code accepted by `/customer/session`. */
+    otpCode
+  };
+}
+
+exports.MOCK_CURRENCY = MOCK_CURRENCY;
+exports.MOCK_CUSTOMER_EMAIL = MOCK_CUSTOMER_EMAIL;
+exports.MOCK_IMAGE_URL = MOCK_IMAGE_URL;
+exports.createMockStorefront = createMockStorefront;
+//# sourceMappingURL=mock.cjs.map
+//# sourceMappingURL=mock.cjs.map