@fayz-ai/shop 0.9.0 → 0.11.0

package/dist/chunk-U6HV3LVP.js

@@ -0,0 +1,1170 @@
+import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS, MOCK_VARIANTS } from './chunk-IKNGCRUM.js';
+import { resolveEntityStore, createMockEntityStore } from './chunk-NWW3WJ7Y.js';
+import { buildRuleContext, computePromotionActions, discountToPromotion } from './chunk-3GERSY5F.js';
+import { resolveEntityDeclaration } from '@fayz-ai/core';
+
+// src/data/media.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "bmp"]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "mov", "webm", "m4v", "avi", "mkv"]);
+function mediaKindOf(name, mime) {
+  if (mime?.startsWith("image/")) return "image";
+  if (mime?.startsWith("video/")) return "video";
+  const ext = (name.split(".").pop() ?? "").toLowerCase();
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return "document";
+}
+function storagePathOf(url) {
+  const match = /\/object\/(?:public|sign|authenticated)\/[^/]+\/([^?]+)/.exec(url);
+  if (!match) return null;
+  try {
+    return decodeURIComponent(match[1]);
+  } catch {
+    return match[1];
+  }
+}
+function displayNameOf(path) {
+  const base = path.split("/").pop() ?? path;
+  return base.replace(/^\d{10,}-/, "");
+}
+function productImageToMediaFile(image, productName) {
+  const path = storagePathOf(image.url);
+  const name = displayNameOf(path ?? image.url);
+  return {
+    // Fall back to the URL as identity: an image row that points outside our
+    // bucket still belongs in the library, it just cannot be deleted by path.
+    id: path ?? image.url,
+    name,
+    url: image.url,
+    kind: mediaKindOf(name),
+    size: 0,
+    extension: (name.split(".").pop() ?? "").toUpperCase(),
+    createdAt: image.createdAt ?? "",
+    reference: {
+      type: "product",
+      id: image.productId,
+      label: productName?.trim() || "Produto sem nome",
+      attachmentId: image.id,
+      isCover: image.isPrimary
+    }
+  };
+}
+function mergeMediaFiles(attached, library) {
+  const seen = new Set(attached.map((f) => f.id));
+  return [...attached, ...library.filter((f) => !seen.has(f.id))].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+// src/lib/variant-matrix.ts
+var MAX_VARIANT_AXES = 3;
+var MAX_VARIANT_COMBINATIONS = 100;
+function variantOptionsKey(options) {
+  return JSON.stringify(
+    Object.keys(options).sort().map((key) => [key, options[key]])
+  );
+}
+function normalizeVariantAxes(axes) {
+  const seenNames = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const axis of axes) {
+    const name = axis.name.trim();
+    if (!name || seenNames.has(name)) continue;
+    const values = [];
+    const seenValues = /* @__PURE__ */ new Set();
+    for (const raw of axis.values) {
+      const value = raw.trim();
+      if (!value || seenValues.has(value)) continue;
+      seenValues.add(value);
+      values.push(value);
+    }
+    if (values.length === 0) continue;
+    seenNames.add(name);
+    result.push({ name, values });
+  }
+  return result;
+}
+function variantCombinations(axes) {
+  const clean = normalizeVariantAxes(axes);
+  if (clean.length === 0) return [];
+  let rows = [{}];
+  for (const axis of clean) {
+    const next = [];
+    for (const row of rows) {
+      for (const value of axis.values) next.push({ ...row, [axis.name]: value });
+    }
+    rows = next;
+  }
+  return rows;
+}
+function validateVariantAxes(axes) {
+  const clean = normalizeVariantAxes(axes);
+  if (clean.length > MAX_VARIANT_AXES) {
+    return `Um produto aceita no m\xE1ximo ${MAX_VARIANT_AXES} op\xE7\xF5es (ex.: Tamanho, Cor, Material).`;
+  }
+  const total = clean.reduce((acc, axis) => acc * axis.values.length, 1);
+  if (clean.length > 0 && total > MAX_VARIANT_COMBINATIONS) {
+    return `Essas op\xE7\xF5es gerariam ${total} variantes, e o limite \xE9 ${MAX_VARIANT_COMBINATIONS}. Reduza os valores ou separe em dois produtos.`;
+  }
+  return null;
+}
+function planVariantMatrix(axes, existing) {
+  const wanted = variantCombinations(axes);
+  const wantedKeys = new Set(wanted.map(variantOptionsKey));
+  const byKey = /* @__PURE__ */ new Map();
+  let defaultVariant = null;
+  for (const variant of existing) {
+    if (variant.isDefaultVariant) {
+      defaultVariant = variant;
+      continue;
+    }
+    byKey.set(variantOptionsKey(variant.options), variant);
+  }
+  const plan = {
+    rows: [],
+    create: [],
+    reactivate: [],
+    keep: [],
+    archive: [],
+    defaultVariant
+  };
+  for (const [position, options] of wanted.entries()) {
+    const variant = byKey.get(variantOptionsKey(options)) ?? null;
+    const row = { options, position, variant };
+    plan.rows.push(row);
+    if (!variant) plan.create.push(row);
+    else if (variant.status === "archived") plan.reactivate.push(row);
+    else plan.keep.push(row);
+  }
+  for (const [key, variant] of byKey) {
+    if (!wantedKeys.has(key) && variant.status === "active") plan.archive.push(variant);
+  }
+  return plan;
+}
+function hasOnlyDefaultVariant(variants) {
+  const active = variants.filter((variant) => variant.status === "active");
+  return active.length === 1 && Boolean(active[0].isDefaultVariant);
+}
+function leavesNothingSellable(plan) {
+  const willHaveReal = plan.keep.length + plan.reactivate.length + plan.create.length;
+  return willHaveReal === 0 && plan.defaultVariant === null;
+}
+function axesFromOptions(options) {
+  return [...options].sort((a, b) => a.position - b.position).map((option) => ({ name: option.name, values: [...option.values] }));
+}
+async function applyVariantMatrix(provider, productId, axes, existing) {
+  const refusal = validateVariantAxes(axes);
+  if (refusal) throw new Error(refusal);
+  if (!provider.saveProductOptions || !provider.createProductVariant || !provider.updateProductVariant) {
+    throw new Error("Este provider n\xE3o administra variantes.");
+  }
+  const clean = normalizeVariantAxes(axes);
+  const plan = planVariantMatrix(clean, existing);
+  await provider.saveProductOptions(productId, clean);
+  for (const row of plan.create) {
+    await provider.createProductVariant(productId, { options: row.options, position: row.position });
+  }
+  for (const row of plan.reactivate) {
+    await provider.updateProductVariant(row.variant.id, { status: "active", position: row.position });
+  }
+  for (const row of plan.keep) {
+    if (row.variant.position !== row.position) {
+      await provider.updateProductVariant(row.variant.id, { position: row.position });
+    }
+  }
+  for (const variant of plan.archive) {
+    await (provider.archiveProductVariant?.(variant.id) ?? provider.updateProductVariant(variant.id, { status: "archived" }));
+  }
+  const real = plan.create.length + plan.reactivate.length + plan.keep.length;
+  if (plan.defaultVariant) {
+    if (real > 0 && plan.defaultVariant.status === "active") {
+      await provider.updateProductVariant(plan.defaultVariant.id, { status: "archived" });
+    } else if (real === 0 && plan.defaultVariant.status === "archived") {
+      await provider.updateProductVariant(plan.defaultVariant.id, { status: "active" });
+    }
+  }
+  return plan;
+}
+function formatVariantCombination(options, axes) {
+  const order = axes?.map((axis) => axis.name) ?? Object.keys(options).sort();
+  return order.filter((name) => options[name] != null).map((name) => `${name}: ${options[name]}`).join(" \xB7 ");
+}
+function uid() {
+  return Math.random().toString(36).slice(2);
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var ORDERS_KEY = "fayz.shop.mock.orders.v1";
+var CUSTOMERS_KEY = "fayz.shop.mock.customers.v1";
+var ENQUIRIES_KEY = "fayz.shop.mock.enquiries.v1";
+var CHANNELS_KEY = "fayz.shop.mock.channels.v1";
+var SETTINGS_KEY = "fayz.shop.mock.settings.v1";
+var SHIPPING_SETTINGS_KEY = "fayz.shop.mock.shipping-settings.v1";
+var DEFAULT_CHANNELS = [
+  { id: "online-store", tenantId: "mock", kind: "online_store", label: "Loja Online", url: null, enabled: true, position: 0, createdAt: now(), updatedAt: now() }
+];
+function loadStored(key) {
+  try {
+    if (typeof localStorage === "undefined") return [];
+    const raw = localStorage.getItem(key);
+    return raw ? JSON.parse(raw) : [];
+  } catch {
+    return [];
+  }
+}
+function store(key, value) {
+  try {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+var COLLECTIONS_KEY = "fayz.shop.mock.collections.v1";
+var GIFT_CARDS_KEY = "fayz.shop.mock.gift-cards.v1";
+var EMAIL_TEMPLATES_KEY = "fayz.shop.mock.email-templates.v1";
+var CUSTOMER_GROUPS_KEY = "fayz.shop.mock.customer-groups.v1";
+var CUSTOMER_SEGMENTS_KEY = "fayz.shop.mock.customer-segments.v1";
+function mockGiftCardCode() {
+  const alphabet = "ABCDEFGHJKLMNPQRTUVWXY2346789";
+  const pick = () => alphabet[Math.floor(Math.random() * alphabet.length)];
+  const block = () => Array.from({ length: 4 }, pick).join("");
+  return `${block()}-${block()}-${block()}`;
+}
+function mockSlugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var MockShopProvider = class {
+  constructor(seed) {
+    this.collections = loadStored(COLLECTIONS_KEY);
+    this.giftCards = loadStored(GIFT_CARDS_KEY);
+    this.emailTemplates = loadStored(EMAIL_TEMPLATES_KEY);
+    this.customerGroups = loadStored(CUSTOMER_GROUPS_KEY);
+    this.customerSegments = loadStored(CUSTOMER_SEGMENTS_KEY);
+    this.orders = loadStored(ORDERS_KEY);
+    this.customers = loadStored(CUSTOMERS_KEY);
+    this.enquiries = loadStored(ENQUIRIES_KEY);
+    this.channels = (() => {
+      const stored = loadStored(CHANNELS_KEY);
+      return stored.length ? stored : DEFAULT_CHANNELS.map((c) => ({ ...c }));
+    })();
+    this.entityStores = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // Checkout sessions
+    //
+    // Mirrors the live inversion: the session holds the cart, and the ORDER is
+    // only written when the settle says the money is in. Here the "provider" is a
+    // clock — the second poll pays — which is what lets the four-step checkout be
+    // walked end to end without an acquirer, in demo stores and in the e2e suite.
+    // ---------------------------------------------------------------------------
+    this.checkoutSessions = {};
+    this.products = (seed?.products ?? MOCK_PRODUCTS).map((p) => ({ ...p }));
+    this.categories = (seed?.categories ?? MOCK_CATEGORIES).map((c) => ({ ...c }));
+    this.discounts = (seed?.discounts ?? MOCK_DISCOUNTS).map((d) => ({ ...d }));
+    this.variantSets = Object.fromEntries(
+      Object.entries(seed?.variants ?? (seed?.products ? {} : MOCK_VARIANTS)).map(([productId, set]) => [
+        productId,
+        { options: set.options.map((o) => ({ ...o, values: [...o.values] })), variants: set.variants.map((v) => ({ ...v, options: { ...v.options } })) }
+      ])
+    );
+    this.promotions = (seed?.promotions ?? []).map((p) => ({ ...p }));
+    this.entitySeed = seed?.entities ?? {};
+  }
+  /** The I5 indirection: a promoted (registered) store wins; otherwise the
+   *  entity gets a lazily-built in-memory store seeded from the mock seed.
+   *  Lazy on purpose — the seed is validated against the declaration, which
+   *  the app may register after constructing the provider. */
+  entityStore(entity) {
+    resolveEntityDeclaration(entity);
+    return resolveEntityStore(entity, (key) => {
+      let store2 = this.entityStores.get(key);
+      if (!store2) {
+        store2 = createMockEntityStore(key, { seed: this.entitySeed[key] });
+        this.entityStores.set(key, store2);
+      }
+      return store2;
+    });
+  }
+  // Re-read before mutating: HMR can re-instantiate the provider mid-session
+  // and a stale in-memory copy must not clobber persisted records.
+  syncOrders() {
+    this.orders = loadStored(ORDERS_KEY);
+  }
+  syncCustomers() {
+    this.customers = loadStored(CUSTOMERS_KEY);
+  }
+  syncEnquiries() {
+    this.enquiries = loadStored(ENQUIRIES_KEY);
+  }
+  syncChannels() {
+    const stored = loadStored(CHANNELS_KEY);
+    if (stored.length) this.channels = stored;
+  }
+  persistOrders() {
+    store(ORDERS_KEY, this.orders);
+  }
+  persistCustomers() {
+    store(CUSTOMERS_KEY, this.customers);
+  }
+  persistEnquiries() {
+    store(ENQUIRIES_KEY, this.enquiries);
+  }
+  persistChannels() {
+    store(CHANNELS_KEY, this.channels);
+  }
+  // ---------------------------------------------------------------------------
+  // Products
+  // ---------------------------------------------------------------------------
+  async listProducts(opts) {
+    let list = [...this.products];
+    if (opts?.status) list = list.filter((p) => p.status === opts.status);
+    if (opts?.categoryId) list = list.filter((p) => p.categoryId === opts.categoryId);
+    if (opts?.slug) list = list.filter((p) => p.slug === opts.slug);
+    if (opts?.search) {
+      const q = opts.search.toLowerCase();
+      list = list.filter(
+        (p) => p.name.toLowerCase().includes(q) || (p.description ?? "").toLowerCase().includes(q) || (p.sku ?? "").toLowerCase().includes(q)
+      );
+    }
+    const orderBy = opts?.orderBy ?? "sort_order";
+    const dir = opts?.order === "desc" ? -1 : 1;
+    if (opts?.search && !opts.orderBy) {
+      const q = opts.search.toLowerCase();
+      const rank = (p) => p.name.toLowerCase().startsWith(q) ? 0 : p.name.toLowerCase().includes(q) ? 1 : 2;
+      list.sort((a, b) => rank(a) - rank(b) || a.sortOrder - b.sortOrder);
+    } else {
+      list.sort((a, b) => {
+        switch (orderBy) {
+          case "name":
+            return a.name.localeCompare(b.name) * dir;
+          case "price":
+            return (a.price - b.price) * dir;
+          case "created_at":
+            return a.createdAt.localeCompare(b.createdAt) * dir;
+          default:
+            return (a.sortOrder - b.sortOrder) * dir;
+        }
+      });
+    }
+    const offset = opts?.offset ?? 0;
+    if (offset || opts?.limit) list = list.slice(offset, opts?.limit ? offset + opts.limit : void 0);
+    return list;
+  }
+  async getProduct(id) {
+    return this.products.find((p) => p.id === id) ?? null;
+  }
+  /** Option axes + variants (spine M5) — active variants only, like the 0028
+   *  storefront RLS. Answers empty sets for a variantless product. */
+  async getProductVariants(productId, opts) {
+    const set = this.variantSets[productId];
+    if (!set) return { options: [], variants: [] };
+    return {
+      options: set.options.map((o) => ({ ...o, values: [...o.values] })).sort((a, b) => a.position - b.position),
+      variants: set.variants.filter((v) => opts?.includeArchived || v.status === "active").map((v) => ({ ...v, options: { ...v.options } })).sort((a, b) => a.position - b.position)
+    };
+  }
+  // --- The variant admin ------------------------------------------------------
+  // Modelled on the SQL rather than on convenience: 0028's UNIQUE
+  // (product_id, options), 0037's default-variant triggers and 0036's mirror all
+  // have a counterpart here, so a test that passes against this mock is
+  // asserting the real semantics and not a friendlier imitation of them.
+  variantSet(productId) {
+    var _a;
+    (_a = this.variantSets)[productId] ?? (_a[productId] = { options: [], variants: [] });
+    return this.variantSets[productId];
+  }
+  async saveProductOptions(productId, input) {
+    const set = this.variantSet(productId);
+    const existing = new Map(set.options.map((o) => [o.name, o]));
+    set.options = input.map((axis, position) => ({
+      id: existing.get(axis.name)?.id ?? uid(),
+      name: axis.name,
+      values: [...axis.values],
+      position
+    }));
+    return set.options.map((o) => ({ ...o, values: [...o.values] }));
+  }
+  async createProductVariant(productId, input) {
+    const set = this.variantSet(productId);
+    const key = variantOptionsKey(input.options);
+    const existing = set.variants.find((v) => variantOptionsKey(v.options) === key);
+    if (existing) return this.updateProductVariant(existing.id, { ...input, status: input.status ?? "active" });
+    const variant = {
+      id: uid(),
+      productId,
+      options: { ...input.options },
+      sku: input.sku ?? null,
+      price: input.price ?? null,
+      compareAtPrice: input.compareAtPrice ?? null,
+      inventoryCount: 0,
+      position: input.position ?? set.variants.length,
+      status: input.status ?? "active",
+      imageId: input.imageId ?? null,
+      isDefaultVariant: false,
+      weight: input.weight ?? null,
+      weightUnit: input.weightUnit ?? null,
+      heightCm: input.heightCm ?? null,
+      widthCm: input.widthCm ?? null,
+      lengthCm: input.lengthCm ?? null
+    };
+    set.variants.push(variant);
+    for (const other of set.variants) {
+      if (other.isDefaultVariant && other.status === "active") other.status = "archived";
+    }
+    this.syncProductFromVariants(productId);
+    return { ...variant, options: { ...variant.options } };
+  }
+  async updateProductVariant(variantId, input) {
+    for (const [productId, set] of Object.entries(this.variantSets)) {
+      const variant = set.variants.find((v) => v.id === variantId);
+      if (!variant) continue;
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== void 0) variant[key] = value;
+      }
+      this.syncProductFromVariants(productId);
+      return { ...variant, options: { ...variant.options } };
+    }
+    throw new Error("Variant not found");
+  }
+  async archiveProductVariant(variantId) {
+    await this.updateProductVariant(variantId, { status: "archived" });
+  }
+  /**
+   * The 0034→0036 path, compressed: the merchant states a count, the difference
+   * is what gets recorded, and inventory_count is the mirror that follows. The
+   * ledger itself is MockStockStore's business — what matters here is that no
+   * caller ever assigns to inventoryCount.
+   */
+  async setVariantStock(variantId, count) {
+    const target = Math.max(0, Math.trunc(count));
+    for (const [productId, set] of Object.entries(this.variantSets)) {
+      const variant = set.variants.find((v) => v.id === variantId);
+      if (!variant) continue;
+      variant.inventoryCount = target;
+      this.syncProductFromVariants(productId);
+      return target;
+    }
+    throw new Error("Variant not found");
+  }
+  /** 0028's sync trigger: the product row is the SUM of active variant stock. */
+  syncProductFromVariants(productId) {
+    const product = this.products.find((p) => p.id === productId);
+    const set = this.variantSets[productId];
+    if (!product || !set) return;
+    const active = set.variants.filter((v) => v.status === "active");
+    product.inventoryCount = active.reduce((sum, v) => sum + v.inventoryCount, 0);
+  }
+  async createProduct(input) {
+    const p = { id: uid(), tenantId: "mock", name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, "-"), description: input.description ?? null, price: input.price, compareAtPrice: input.compareAtPrice ?? null, currency: input.currency ?? "BRL", status: input.status ?? "active", inventoryCount: input.inventoryCount ?? 0, sku: input.sku ?? null, sortOrder: input.sortOrder ?? 0, metadata: input.metadata ?? {}, images: [], categoryId: input.categoryId ?? null, categoryName: null, isPhysical: input.isPhysical ?? true, weight: input.weight ?? null, weightUnit: input.weightUnit ?? "kg", handling: input.handling ?? [], createdAt: now(), updatedAt: now() };
+    this.products.push(p);
+    return p;
+  }
+  async updateProduct(id, input) {
+    const i = this.products.findIndex((p) => p.id === id);
+    if (i < 0) throw new Error("Product not found");
+    this.products[i] = { ...this.products[i], ...input, updatedAt: now() };
+    return this.products[i];
+  }
+  async deleteProduct(id) {
+    this.products = this.products.filter((p) => p.id !== id);
+  }
+  async uploadProductImage(_productId, _file) {
+    throw new Error("Image upload not available in mock mode");
+  }
+  async deleteProductImage(imageId) {
+    this.products = this.products.map((p) => p.images.some((i) => i.id === imageId) ? { ...p, images: p.images.filter((i) => i.id !== imageId) } : p);
+  }
+  /** The media library, mock-side: no bucket to walk, so the catalogue's own
+   *  photos ARE the library. Uploading has nowhere to go, which is why
+   *  uploadMediaFile stays unimplemented and the screen hides its button. */
+  async listMediaFiles() {
+    const attached = this.products.flatMap((p) => p.images.map((image) => productImageToMediaFile(image, p.name)));
+    return mergeMediaFiles(attached, []);
+  }
+  async createProductEnquiry(input) {
+    this.syncEnquiries();
+    const ts = now();
+    const enquiry = {
+      id: uid(),
+      tenantId: "mock",
+      productId: input.productId ?? null,
+      productName: input.productName,
+      productSlug: input.productSlug ?? null,
+      customerName: input.customerName,
+      customerEmail: input.customerEmail,
+      customerPhone: input.customerPhone ?? null,
+      subject: input.subject ?? null,
+      message: input.message,
+      sourceUrl: input.sourceUrl ?? null,
+      status: "new",
+      metadata: input.metadata ?? {},
+      createdAt: ts,
+      updatedAt: ts
+    };
+    this.enquiries.unshift(enquiry);
+    this.persistEnquiries();
+    return enquiry;
+  }
+  async listProductEnquiries(opts) {
+    this.syncEnquiries();
+    let list = [...this.enquiries];
+    if (opts?.productId) list = list.filter((e) => e.productId === opts.productId);
+    if (opts?.customerEmail) {
+      const email = opts.customerEmail.toLowerCase();
+      list = list.filter((e) => e.customerEmail.toLowerCase() === email);
+    }
+    if (opts?.status) list = list.filter((e) => e.status === opts.status);
+    list.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const offset = opts?.offset ?? 0;
+    if (offset || opts?.limit) list = list.slice(offset, opts?.limit ? offset + opts.limit : void 0);
+    return list;
+  }
+  // ---------------------------------------------------------------------------
+  // Categories
+  // ---------------------------------------------------------------------------
+  async listCategories() {
+    return [...this.categories].sort((a, b) => a.sortOrder - b.sortOrder);
+  }
+  async createCategory(input) {
+    const c = { id: uid(), tenantId: "mock", name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, "-"), description: input.description ?? null, parentId: input.parentId ?? null, sortOrder: input.sortOrder ?? 0, createdAt: now() };
+    this.categories.push(c);
+    return c;
+  }
+  async updateCategory(id, input) {
+    const i = this.categories.findIndex((c) => c.id === id);
+    if (i < 0) throw new Error("Category not found");
+    this.categories[i] = { ...this.categories[i], ...input };
+    return this.categories[i];
+  }
+  async deleteCategory(id) {
+    this.categories = this.categories.filter((c) => c.id !== id);
+  }
+  // ---------------------------------------------------------------------------
+  // Orders
+  // ---------------------------------------------------------------------------
+  async listOrders(opts) {
+    this.syncOrders();
+    let list = [...this.orders];
+    if (opts?.status) list = list.filter((o) => o.status === opts.status);
+    if (opts?.financialStatus) list = list.filter((o) => o.financialStatus === opts.financialStatus);
+    if (opts?.fulfillmentStatus) list = list.filter((o) => o.fulfillmentStatus === opts.fulfillmentStatus);
+    if (opts?.customerId) list = list.filter((o) => o.customerId === opts.customerId);
+    if (opts?.customerEmail) {
+      const email = opts.customerEmail.toLowerCase();
+      list = list.filter((o) => (o.customerEmail ?? "").toLowerCase() === email);
+    }
+    if (opts?.search) {
+      const q = opts.search.toLowerCase();
+      list = list.filter(
+        (o) => (o.customerName ?? "").toLowerCase().includes(q) || (o.customerEmail ?? "").toLowerCase().includes(q) || String(o.orderNumber).includes(q)
+      );
+    }
+    list.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    if (opts?.limit) list = list.slice(0, opts.limit);
+    return list;
+  }
+  async getOrder(id) {
+    this.syncOrders();
+    return this.orders.find((o) => o.id === id) ?? null;
+  }
+  async createOrder(input) {
+    this.syncOrders();
+    const subtotal = input.items.reduce((s, i) => s + i.quantity * i.unitPrice, 0);
+    const discountTotal = input.discountTotal ?? 0;
+    const shippingTotal = input.shippingTotal ?? 0;
+    const total = Math.round((subtotal - discountTotal + shippingTotal) * 100) / 100;
+    const orderId = uid();
+    const maxNumber = this.orders.reduce((m, o2) => Math.max(m, o2.orderNumber), 1e3);
+    const o = {
+      id: orderId,
+      tenantId: "mock",
+      orderNumber: maxNumber + 1,
+      status: "open",
+      financialStatus: "pending",
+      fulfillmentStatus: "unfulfilled",
+      currency: input.currency ?? "BRL",
+      subtotal: Math.round(subtotal * 100) / 100,
+      taxTotal: 0,
+      discountTotal,
+      shippingTotal,
+      total,
+      customerId: input.customerId ?? null,
+      customerName: input.customerName ?? null,
+      customerEmail: input.customerEmail ?? null,
+      discountCode: input.discountCode ?? null,
+      notes: input.notes ?? null,
+      shippingAddress: null,
+      // CreateOrderInput has no payment method — that is a PlaceOrderInput
+      // concern; the mock records none rather than inventing one.
+      paymentMethodKind: null,
+      paidAt: null,
+      items: input.items.map((i) => ({ id: uid(), orderId, productId: i.productId ?? null, name: i.name, sku: i.sku ?? null, quantity: i.quantity, unitPrice: i.unitPrice, total: Math.round(i.quantity * i.unitPrice * 100) / 100, imageUrl: i.imageUrl ?? null })),
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.orders.push(o);
+    this.persistOrders();
+    return o;
+  }
+  async updateOrder(id, input) {
+    this.syncOrders();
+    const i = this.orders.findIndex((o) => o.id === id);
+    if (i < 0) throw new Error("Order not found");
+    this.orders[i] = { ...this.orders[i], ...input, updatedAt: now() };
+    this.persistOrders();
+    return this.orders[i];
+  }
+  // Trusted placement (mock parity with the shop_place_order RPC): re-reads
+  // prices + stock from the catalog, EVALUATES THE DECLARED PROMOTIONS through
+  // the rule engine, validates the legacy discount code, decrements inventory.
+  // The browser-supplied prices and totals are never used.
+  async placeOrder(input) {
+    this.syncOrders();
+    this.syncCustomers();
+    let customerId = input.customerId ?? null;
+    let customerName = input.customer?.name?.trim() || null;
+    const email = input.customer?.email?.trim().toLowerCase() || null;
+    if (!customerId && email) {
+      const existing = this.customers.find((c) => (c.email ?? "").toLowerCase() === email);
+      if (existing) {
+        customerId = existing.id;
+        customerName = customerName ?? `${existing.firstName} ${existing.lastName}`.trim();
+      } else {
+        const [first, ...rest] = (customerName ?? email).split(" ");
+        const created = await this.createCustomer({ firstName: first || email, lastName: rest.join(" "), email });
+        customerId = created.id;
+      }
+    }
+    const items = [];
+    const lineDetails = [];
+    const snapshotItems = [];
+    let subtotal = 0;
+    for (const [index, line] of input.items.entries()) {
+      const product = this.products.find((p) => p.id === line.productId);
+      if (!product || product.status !== "active") throw new Error(`Product unavailable: ${line.productId}`);
+      let variant;
+      if (line.variantId) {
+        variant = this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId && v.status === "active");
+        if (!variant) throw new Error(`Variant unavailable: ${line.variantId}`);
+        if (variant.inventoryCount < line.quantity) throw new Error(`Insufficient stock for ${product.name}`);
+      } else if (product.inventoryCount < line.quantity) {
+        throw new Error(`Insufficient stock for ${product.name}`);
+      }
+      const unitPrice = variant?.price ?? product.price;
+      const label = line.optionsLabel || (variant ? Object.entries(variant.options).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join(" \xB7 ") : "");
+      const name = label ? `${product.name} (${label})` : product.name;
+      const lineTotal = unitPrice * line.quantity;
+      subtotal += lineTotal;
+      lineDetails.push({ productId: product.id, categoryId: product.categoryId, lineTotal });
+      snapshotItems.push({
+        id: `${index}:${line.variantId ?? product.id}`,
+        productId: product.id,
+        quantity: line.quantity,
+        unitPrice,
+        categoryId: product.categoryId,
+        collectionId: typeof product.metadata?.collection === "string" ? product.metadata.collection : null
+      });
+      items.push({ productId: product.id, name, sku: variant?.sku ?? product.sku ?? void 0, quantity: line.quantity, unitPrice, imageUrl: product.images[0]?.url });
+    }
+    subtotal = Math.round(subtotal * 100) / 100;
+    let shippingTotal = Math.max(input.shippingTotal ?? 0, 0);
+    let discountTotal = 0;
+    let appliedCode = null;
+    const entered = input.discountCode ? [input.discountCode.trim()] : [];
+    const cart = {
+      items: snapshotItems,
+      shippingTotal,
+      customer: { email: input.customer?.email ?? null },
+      codes: entered,
+      currency: input.currency
+    };
+    const context = await buildRuleContext(cart);
+    const actions = computePromotionActions(cart, this.promotions, { context });
+    let promotionItemDiscount = 0;
+    let promotionShippingDiscount = 0;
+    const firedPromotionIds = /* @__PURE__ */ new Set();
+    const firedCodes = /* @__PURE__ */ new Set();
+    for (const action of actions) {
+      firedPromotionIds.add(action.promotionId);
+      if (action.code) firedCodes.add(action.code.trim().toUpperCase());
+      if (action.action === "addItemDiscount") promotionItemDiscount += action.amount;
+      else if (action.action === "addShippingDiscount") promotionShippingDiscount += action.amount;
+      else if (action.action === "addFreeItem") {
+        const granted = this.products.find((p) => p.id === action.productId);
+        if (granted) {
+          items.push({ productId: granted.id, name: granted.name, sku: granted.sku ?? void 0, quantity: action.quantity, unitPrice: 0, imageUrl: granted.images[0]?.url });
+        }
+      }
+    }
+    for (const promotion of this.promotions) {
+      if (firedPromotionIds.has(promotion.id)) promotion.timesUsed = (promotion.timesUsed ?? 0) + 1;
+    }
+    discountTotal += Math.round(promotionItemDiscount * 100) / 100;
+    shippingTotal = Math.max(0, Math.round((shippingTotal - promotionShippingDiscount) * 100) / 100);
+    if (input.discountCode && firedCodes.has(input.discountCode.trim().toUpperCase())) {
+      appliedCode = input.discountCode.trim().toUpperCase();
+    }
+    if (input.discountCode && !appliedCode) {
+      const code = input.discountCode.trim().toLowerCase();
+      const d = this.discounts.find((x) => (x.code ?? "").toLowerCase() === code);
+      const ts = now();
+      const meetsMin = !d?.minSubtotal || subtotal >= d.minSubtotal;
+      const valid = !!d && d.status === "active" && d.startsAt <= ts && (!d.endsAt || d.endsAt >= ts) && (d.usageLimit == null || d.timesUsed < d.usageLimit) && meetsMin;
+      if (valid && d) {
+        appliedCode = d.code;
+        let eligible = subtotal;
+        if (d.appliesTo === "products") {
+          eligible = lineDetails.filter((l) => d.productIds.includes(l.productId)).reduce((s, l) => s + l.lineTotal, 0);
+        } else if (d.appliesTo === "categories") {
+          eligible = lineDetails.filter((l) => l.categoryId && d.categoryIds.includes(l.categoryId)).reduce((s, l) => s + l.lineTotal, 0);
+        }
+        eligible = Math.round(eligible * 100) / 100;
+        if (d.type === "percentage") discountTotal += Math.round(eligible * d.value) / 100;
+        else if (d.type === "fixed_amount") discountTotal += Math.min(d.value, eligible);
+        else if (d.type === "free_shipping") shippingTotal = 0;
+        d.timesUsed += 1;
+      }
+    }
+    discountTotal = Math.round(Math.min(Math.max(discountTotal, 0), subtotal) * 100) / 100;
+    const order = await this.createOrder({
+      customerId: customerId ?? void 0,
+      customerName: customerName ?? void 0,
+      customerEmail: input.customer?.email ?? void 0,
+      currency: input.currency,
+      notes: input.notes,
+      discountCode: appliedCode ?? void 0,
+      discountTotal,
+      shippingTotal,
+      items
+    });
+    for (const line of input.items) {
+      const product = this.products.find((p) => p.id === line.productId);
+      if (!product) continue;
+      const variant = line.variantId ? this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId) : void 0;
+      if (variant) {
+        variant.inventoryCount = Math.max(0, variant.inventoryCount - line.quantity);
+        product.inventoryCount = this.variantSets[line.productId].variants.filter((v) => v.status === "active").reduce((sum, v) => sum + v.inventoryCount, 0);
+      } else {
+        product.inventoryCount = Math.max(0, product.inventoryCount - line.quantity);
+      }
+    }
+    return order;
+  }
+  async openCheckoutSession(input) {
+    const sessionId = uid();
+    this.checkoutSessions[sessionId] = { input, polls: 0 };
+    let total = 0;
+    for (const line of input.items) {
+      const product = this.products.find((p) => p.id === line.productId);
+      if (!product) continue;
+      const variant = line.variantId ? this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId) : void 0;
+      total += (variant?.price ?? product.price) * line.quantity;
+    }
+    return {
+      sessionId,
+      total: Math.round(total * 100) / 100,
+      state: "open",
+      charge: {
+        // Shaped like a real EMV payload so the copy button and the layout are
+        // exercised, not a placeholder that fits in one line.
+        emv: `00020126580014BR.GOV.BCB.PIX0136${sessionId}520400005303986540${total.toFixed(2)}5802BR6304MOCK`,
+        qrcodeBase64: null,
+        expiresAt: new Date(Date.now() + 30 * 6e4).toISOString()
+      }
+    };
+  }
+  async settleCheckoutSession(sessionId) {
+    const session = this.checkoutSessions[sessionId];
+    if (!session) return { state: "expired", reason: "Sess\xE3o de checkout n\xE3o encontrada." };
+    if (session.orderId) return { state: "paid", orderId: session.orderId };
+    session.polls += 1;
+    if (session.polls < 2) return { state: "open" };
+    const order = await this.placeOrder({
+      items: session.input.items,
+      customer: session.input.customer,
+      discountCode: session.input.discountCode ?? void 0,
+      shippingAddress: session.input.shippingAddress
+    });
+    await this.updateOrder(order.id, { financialStatus: "paid" });
+    session.orderId = order.id;
+    return { state: "paid", orderId: order.id };
+  }
+  // ---------------------------------------------------------------------------
+  // Customers
+  // ---------------------------------------------------------------------------
+  async listCustomers(opts) {
+    this.syncCustomers();
+    let list = [...this.customers];
+    if (opts?.search) list = list.filter((c) => `${c.firstName} ${c.lastName} ${c.email}`.toLowerCase().includes(opts.search.toLowerCase()));
+    if (opts?.limit) list = list.slice(0, opts.limit);
+    return list;
+  }
+  async getCustomer(id) {
+    this.syncCustomers();
+    return this.customers.find((c) => c.id === id) ?? null;
+  }
+  async createCustomer(input) {
+    this.syncCustomers();
+    const c = { id: uid(), tenantId: "mock", firstName: input.firstName, lastName: input.lastName ?? "", email: input.email ?? null, phone: input.phone ?? null, document: input.document ?? null, notes: input.notes ?? null, ordersCount: 0, totalSpent: 0, createdAt: now(), updatedAt: now() };
+    this.customers.push(c);
+    this.persistCustomers();
+    return c;
+  }
+  async updateCustomer(id, input) {
+    this.syncCustomers();
+    const i = this.customers.findIndex((c) => c.id === id);
+    if (i < 0) throw new Error("Customer not found");
+    this.customers[i] = { ...this.customers[i], ...input, updatedAt: now() };
+    this.persistCustomers();
+    return this.customers[i];
+  }
+  async deleteCustomer(id) {
+    this.syncCustomers();
+    this.customers = this.customers.filter((c) => c.id !== id);
+    this.persistCustomers();
+  }
+  async resolveCustomer(input) {
+    this.syncCustomers();
+    const email = input.email.trim().toLowerCase();
+    const existing = this.customers.find((c) => (c.email ?? "").toLowerCase() === email);
+    if (existing) return existing;
+    const [first, ...rest] = (input.name?.trim() || email).split(/\s+/);
+    return this.createCustomer({ firstName: first || email, lastName: rest.join(" "), email });
+  }
+  // ---------------------------------------------------------------------------
+  // Promotions (spine M6) — the mock provider IS the reference evaluator, so
+  // tests and pilot fixtures exercise the rule engine without a database.
+  // Seeded promotions ride as-is; legacy discounts ride through the adapter
+  // (a percent code = one eligibility rule on code + percentage method).
+  // ---------------------------------------------------------------------------
+  async evaluatePromotions(input) {
+    const promotions = [
+      ...this.promotions,
+      ...this.discounts.map(discountToPromotion).filter((p) => p !== null)
+    ];
+    const context = await buildRuleContext(input.cart);
+    return computePromotionActions(input.cart, promotions, { context });
+  }
+  // ---------------------------------------------------------------------------
+  // Discounts
+  // ---------------------------------------------------------------------------
+  async listDiscounts(opts) {
+    let list = [...this.discounts];
+    if (opts?.status) list = list.filter((d) => d.status === opts.status);
+    if (opts?.type) list = list.filter((d) => d.type === opts.type);
+    if (opts?.search) list = list.filter((d) => d.title.toLowerCase().includes(opts.search.toLowerCase()));
+    if (opts?.limit) list = list.slice(0, opts.limit);
+    return list;
+  }
+  async getDiscount(id) {
+    return this.discounts.find((d) => d.id === id) ?? null;
+  }
+  async createDiscount(input) {
+    const d = { id: uid(), tenantId: "mock", title: input.title, code: input.code ?? null, type: input.type, method: input.method ?? "code", value: input.value, usageLimit: input.usageLimit ?? null, oncePerCustomer: input.oncePerCustomer ?? false, minSubtotal: input.minSubtotal ?? null, appliesTo: input.appliesTo ?? "all", productIds: input.productIds ?? [], categoryIds: input.categoryIds ?? [], startsAt: input.startsAt ?? now(), endsAt: input.endsAt ?? null, status: input.status ?? "active", timesUsed: 0, createdAt: now(), updatedAt: now() };
+    this.discounts.push(d);
+    return d;
+  }
+  async updateDiscount(id, input) {
+    const i = this.discounts.findIndex((d) => d.id === id);
+    if (i < 0) throw new Error("Discount not found");
+    this.discounts[i] = { ...this.discounts[i], ...input, updatedAt: now() };
+    return this.discounts[i];
+  }
+  async deleteDiscount(id) {
+    this.discounts = this.discounts.filter((d) => d.id !== id);
+  }
+  // ---------------------------------------------------------------------------
+  // Sales channels
+  // ---------------------------------------------------------------------------
+  async listSalesChannels() {
+    this.syncChannels();
+    return [...this.channels].sort((a, b) => a.position - b.position);
+  }
+  async createSalesChannel(input) {
+    this.syncChannels();
+    const c = { id: uid(), tenantId: "mock", kind: input.kind, label: input.label, url: input.url ?? null, enabled: input.enabled ?? true, position: input.position ?? this.channels.length, createdAt: now(), updatedAt: now() };
+    this.channels.push(c);
+    this.persistChannels();
+    return c;
+  }
+  async updateSalesChannel(id, input) {
+    this.syncChannels();
+    const i = this.channels.findIndex((c) => c.id === id);
+    if (i < 0) throw new Error("Sales channel not found");
+    this.channels[i] = { ...this.channels[i], ...input, updatedAt: now() };
+    this.persistChannels();
+    return this.channels[i];
+  }
+  async deleteSalesChannel(id) {
+    this.syncChannels();
+    this.channels = this.channels.filter((c) => c.id !== id);
+    this.persistChannels();
+  }
+  // ---------------------------------------------------------------------------
+  // Store policy + delivery fallback
+  //
+  // A single object behind a list-shaped store helper, so the same loadStored /
+  // store pair serves it. Absent = null, NOT an object of defaults: "nothing
+  // decided" is a state the callers are written to handle, and manufacturing
+  // defaults here would hide the one case the live provider really has.
+  // ---------------------------------------------------------------------------
+  async getStoreSettings() {
+    return loadStored(SETTINGS_KEY)[0] ?? null;
+  }
+  async updateStoreSettings(input) {
+    const next = { ...await this.getStoreSettings() ?? {}, ...input };
+    store(SETTINGS_KEY, [next]);
+    return next;
+  }
+  /** In mock mode there is no publication gate to fail, so the shopper's read
+   *  and the merchant's are the same row. */
+  async getPublicStoreSettings() {
+    return this.getStoreSettings();
+  }
+  /**
+   * Mock mode has no delivery zones at all, so nothing is refused and no zone is
+   * the store's own. Answered rather than omitted so a screen developed against
+   * the mock sees the same shape it will see live — an absent method would make
+   * the caller take its "provider cannot check" branch and never exercise this.
+   */
+  async checkDelivery() {
+    return { refused: false, ownZone: false };
+  }
+  async getShippingSettings() {
+    return loadStored(SHIPPING_SETTINGS_KEY)[0] ?? null;
+  }
+  async updateShippingSettings(input) {
+    const current = await this.getShippingSettings();
+    const next = {
+      flatRate: input.flatRate ?? current?.flatRate ?? 0,
+      freeAbove: input.freeAbove !== void 0 ? input.freeAbove : current?.freeAbove ?? null,
+      currency: input.currency ?? current?.currency ?? "BRL"
+    };
+    store(SHIPPING_SETTINGS_KEY, [next]);
+    return next;
+  }
+  // ---------------------------------------------------------------------------
+  // Custom entities (spine M4) — same EntityStore port as the live provider.
+  // ---------------------------------------------------------------------------
+  async listEntityRecords(entity, options) {
+    return this.entityStore(entity).list(options);
+  }
+  async getEntityRecord(entity, id) {
+    return this.entityStore(entity).get(id);
+  }
+  async getEntityRecordBySlug(entity, slug) {
+    return this.entityStore(entity).getBySlug(slug);
+  }
+  async createEntityRecord(entity, input) {
+    return this.entityStore(entity).create(input);
+  }
+  async updateEntityRecord(entity, id, input) {
+    return this.entityStore(entity).update(id, input);
+  }
+  async deleteEntityRecord(entity, id) {
+    return this.entityStore(entity).delete(id);
+  }
+  // Coleções, grupos/segmentos, vale-presente e e-mails — paridade com o
+  // provider Supabase. Mídia não entra: é storage, não tem mock honesto.
+  async listCollections() {
+    this.syncCollections();
+    return [...this.collections].sort((a, b) => a.sortOrder - b.sortOrder);
+  }
+  async getCollection(id) {
+    this.syncCollections();
+    return this.collections.find((c) => c.id === id) ?? null;
+  }
+  async createCollection(input) {
+    this.syncCollections();
+    const c = {
+      id: uid(),
+      tenantId: "mock",
+      title: input.title,
+      handle: input.handle?.trim() || mockSlugify(input.title),
+      description: input.description ?? null,
+      imageUrl: input.imageUrl ?? null,
+      seoTitle: input.seoTitle ?? null,
+      seoDescription: input.seoDescription ?? null,
+      published: input.published ?? true,
+      sortOrder: input.sortOrder ?? this.collections.length,
+      productIds: input.productIds ?? [],
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.collections.push(c);
+    this.persistCollections();
+    return c;
+  }
+  async updateCollection(id, input) {
+    this.syncCollections();
+    const i = this.collections.findIndex((c) => c.id === id);
+    if (i < 0) throw new Error("Collection not found");
+    this.collections[i] = { ...this.collections[i], ...input, updatedAt: now() };
+    this.persistCollections();
+    return this.collections[i];
+  }
+  async deleteCollection(id) {
+    this.syncCollections();
+    this.collections = this.collections.filter((c) => c.id !== id);
+    this.persistCollections();
+  }
+  async listCustomerGroups() {
+    const stored = loadStored(CUSTOMER_GROUPS_KEY);
+    if (stored.length) this.customerGroups = stored;
+    return [...this.customerGroups].sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+  }
+  async createCustomerGroup(input) {
+    await this.listCustomerGroups();
+    const g = {
+      id: uid(),
+      tenantId: "mock",
+      name: input.name,
+      description: input.description ?? null,
+      color: input.color ?? null,
+      customerIds: input.customerIds ?? [],
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.customerGroups.push(g);
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+    return g;
+  }
+  async updateCustomerGroup(id, input) {
+    await this.listCustomerGroups();
+    const i = this.customerGroups.findIndex((g) => g.id === id);
+    if (i < 0) throw new Error("Customer group not found");
+    this.customerGroups[i] = { ...this.customerGroups[i], ...input, updatedAt: now() };
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+    return this.customerGroups[i];
+  }
+  async deleteCustomerGroup(id) {
+    await this.listCustomerGroups();
+    this.customerGroups = this.customerGroups.filter((g) => g.id !== id);
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+  }
+  async listCustomerSegments() {
+    const stored = loadStored(CUSTOMER_SEGMENTS_KEY);
+    if (stored.length) this.customerSegments = stored;
+    return [...this.customerSegments].sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+  }
+  async createCustomerSegment(input) {
+    await this.listCustomerSegments();
+    const s = {
+      id: uid(),
+      tenantId: "mock",
+      name: input.name,
+      description: input.description ?? null,
+      minOrders: input.minOrders ?? null,
+      maxOrders: input.maxOrders ?? null,
+      minSpent: input.minSpent ?? null,
+      maxSpent: input.maxSpent ?? null,
+      joinedAfter: input.joinedAfter ?? null,
+      joinedBefore: input.joinedBefore ?? null,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.customerSegments.push(s);
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+    return s;
+  }
+  async updateCustomerSegment(id, input) {
+    await this.listCustomerSegments();
+    const i = this.customerSegments.findIndex((s) => s.id === id);
+    if (i < 0) throw new Error("Customer segment not found");
+    this.customerSegments[i] = { ...this.customerSegments[i], ...input, updatedAt: now() };
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+    return this.customerSegments[i];
+  }
+  async deleteCustomerSegment(id) {
+    await this.listCustomerSegments();
+    this.customerSegments = this.customerSegments.filter((s) => s.id !== id);
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+  }
+  async listGiftCards() {
+    this.syncGiftCards();
+    return [...this.giftCards].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+  async createGiftCard(input) {
+    this.syncGiftCards();
+    const amount = Number(input.initialBalance) || 0;
+    const g = {
+      id: uid(),
+      tenantId: "mock",
+      code: (input.code?.trim() || mockGiftCardCode()).toUpperCase(),
+      // Same rule the supabase provider enforces: a new card is worth its face
+      // value, and only redemption moves the remaining balance.
+      initialBalance: amount,
+      balance: amount,
+      currency: input.currency ?? "BRL",
+      status: input.status ?? "active",
+      expiresAt: input.expiresAt ?? null,
+      customerId: input.customerId ?? null,
+      customerEmail: input.customerEmail ?? null,
+      note: input.note ?? null,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.giftCards.push(g);
+    this.persistGiftCards();
+    return g;
+  }
+  async updateGiftCard(id, input) {
+    this.syncGiftCards();
+    const i = this.giftCards.findIndex((g) => g.id === id);
+    if (i < 0) throw new Error("Gift card not found");
+    const code = input.code !== void 0 ? input.code.trim().toUpperCase() : this.giftCards[i].code;
+    this.giftCards[i] = { ...this.giftCards[i], ...input, code, updatedAt: now() };
+    this.persistGiftCards();
+    return this.giftCards[i];
+  }
+  async deleteGiftCard(id) {
+    this.syncGiftCards();
+    this.giftCards = this.giftCards.filter((g) => g.id !== id);
+    this.persistGiftCards();
+  }
+  async listEmailTemplates() {
+    this.syncEmailTemplates();
+    return [...this.emailTemplates];
+  }
+  async upsertEmailTemplate(input) {
+    this.syncEmailTemplates();
+    const i = this.emailTemplates.findIndex((t) => t.event === input.event);
+    const base = i >= 0 ? this.emailTemplates[i] : {
+      id: uid(),
+      tenantId: "mock",
+      event: input.event,
+      enabled: false,
+      subject: null,
+      body: null,
+      updatedAt: now()
+    };
+    const next = { ...base, ...input, updatedAt: now() };
+    if (i >= 0) this.emailTemplates[i] = next;
+    else this.emailTemplates.push(next);
+    store(EMAIL_TEMPLATES_KEY, this.emailTemplates);
+    return next;
+  }
+  syncCollections() {
+    const stored = loadStored(COLLECTIONS_KEY);
+    if (stored.length) this.collections = stored;
+  }
+  persistCollections() {
+    store(COLLECTIONS_KEY, this.collections);
+  }
+  syncGiftCards() {
+    const stored = loadStored(GIFT_CARDS_KEY);
+    if (stored.length) this.giftCards = stored;
+  }
+  persistGiftCards() {
+    store(GIFT_CARDS_KEY, this.giftCards);
+  }
+  syncEmailTemplates() {
+    const stored = loadStored(EMAIL_TEMPLATES_KEY);
+    if (stored.length) this.emailTemplates = stored;
+  }
+};
+function createMockShopProvider(seed) {
+  return new MockShopProvider(seed);
+}
+
+export { MAX_VARIANT_AXES, MAX_VARIANT_COMBINATIONS, MockShopProvider, applyVariantMatrix, axesFromOptions, createMockShopProvider, displayNameOf, formatVariantCombination, hasOnlyDefaultVariant, leavesNothingSellable, mediaKindOf, mergeMediaFiles, normalizeVariantAxes, planVariantMatrix, productImageToMediaFile, storagePathOf, validateVariantAxes, variantCombinations, variantOptionsKey };
+//# sourceMappingURL=chunk-U6HV3LVP.js.map
+//# sourceMappingURL=chunk-U6HV3LVP.js.map