@fayz-ai/shop 0.2.0

package/src/mock-catalog.ts

@@ -0,0 +1,258 @@
+import type { Product, ProductImage, Category, Discount } from './types'
+
+// ---------------------------------------------------------------------------
+// Deterministic, offline product catalog for the mock provider.
+// Product names sourced from the Fayz client repo references
+// (apps/web ShopSection mockups + original shop seeds), expanded to a
+// 16-product / 4-category Shopify-style catalog.
+// ---------------------------------------------------------------------------
+
+const T0 = '2026-01-01T12:00:00.000Z'
+
+/** 600x600 gradient SVG with product initials — no network, e2e-stable. */
+export function svgPlaceholder(label: string, hueA: number, hueB: number): string {
+  const initials = label
+    .split(/\s+/)
+    .map((w) => w[0])
+    .slice(0, 2)
+    .join('')
+    .toUpperCase()
+  const svg =
+    `<svg xmlns="http://www.w3.org/2000/svg" width="600" height="600">` +
+    `<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">` +
+    `<stop offset="0" stop-color="hsl(${hueA},45%,82%)"/>` +
+    `<stop offset="1" stop-color="hsl(${hueB},50%,62%)"/>` +
+    `</linearGradient></defs>` +
+    `<rect width="600" height="600" fill="url(#g)"/>` +
+    `<text x="300" y="330" font-family="sans-serif" font-size="120" font-weight="700" ` +
+    `fill="rgba(255,255,255,0.85)" text-anchor="middle">${initials}</text>` +
+    `</svg>`
+  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`
+}
+
+function image(productId: string, name: string, hueA: number, hueB: number, idx = 0): ProductImage {
+  return {
+    id: `img-${productId}-${idx}`,
+    productId,
+    url: svgPlaceholder(name, hueA, hueB),
+    altText: name,
+    sortOrder: idx,
+    isPrimary: idx === 0,
+    createdAt: T0,
+  }
+}
+
+export const MOCK_CATEGORIES: Category[] = [
+  { id: 'cat-apparel', tenantId: 'mock', name: 'Apparel', slug: 'apparel', description: 'Clothing and wearables', parentId: null, sortOrder: 0, createdAt: T0 },
+  { id: 'cat-bags', tenantId: 'mock', name: 'Bags & Accessories', slug: 'bags-accessories', description: 'Bags, wallets and carry gear', parentId: null, sortOrder: 1, createdAt: T0 },
+  { id: 'cat-home', tenantId: 'mock', name: 'Home & Kitchen', slug: 'home-kitchen', description: 'Everyday home goods', parentId: null, sortOrder: 2, createdAt: T0 },
+  { id: 'cat-tech', tenantId: 'mock', name: 'Stationery & Tech', slug: 'stationery-tech', description: 'Desk, audio and paper goods', parentId: null, sortOrder: 3, createdAt: T0 },
+]
+
+interface SeedProduct {
+  id: string
+  name: string
+  slug: string
+  description: string
+  price: number
+  compareAtPrice?: number
+  inventoryCount: number
+  sku: string
+  categoryId: string
+  hues: [number, number]
+  weight: number
+}
+
+const SEEDS: SeedProduct[] = [
+  // --- Apparel ---
+  { id: 'p-01', name: 'Classic T-Shirt', slug: 'classic-t-shirt', description: 'A timeless crew-neck tee in heavyweight combed cotton. Pre-shrunk, breathable, and built to outlast trends.', price: 59.9, compareAtPrice: 79.9, inventoryCount: 50, sku: 'TSH-001', categoryId: 'cat-apparel', hues: [210, 240], weight: 0.2 },
+  { id: 'p-02', name: 'Linen Shirt', slug: 'linen-shirt', description: 'A relaxed-fit shirt in 100% European linen. Naturally breathable and softer with every wash.', price: 189.9, inventoryCount: 24, sku: 'LNS-002', categoryId: 'cat-apparel', hues: [35, 20], weight: 0.3 },
+  { id: 'p-03', name: 'Denim Jacket', slug: 'denim-jacket', description: 'A structured trucker jacket in 12oz raw denim. Ages beautifully with hidden interior pockets.', price: 299.9, inventoryCount: 12, sku: 'DNJ-003', categoryId: 'cat-apparel', hues: [215, 200], weight: 0.8 },
+  { id: 'p-04', name: 'Wool Beanie', slug: 'wool-beanie', description: 'A double-layer merino wool beanie. Warm without itch, with a low-profile cuffed fit.', price: 79.9, inventoryCount: 0, sku: 'WBN-004', categoryId: 'cat-apparel', hues: [0, 350], weight: 0.1 },
+
+  // --- Bags & Accessories ---
+  { id: 'p-05', name: 'Canvas Tote Bag', slug: 'canvas-tote-bag', description: 'An everyday carryall in 16oz waxed canvas with reinforced straps and an interior zip pocket.', price: 39.9, inventoryCount: 30, sku: 'BAG-001', categoryId: 'cat-bags', hues: [80, 110], weight: 0.3 },
+  { id: 'p-06', name: 'Leather Backpack', slug: 'leather-backpack', description: 'Full-grain leather backpack with a padded 15" laptop sleeve, magnetic closures and brass hardware.', price: 549.9, inventoryCount: 8, sku: 'LBP-006', categoryId: 'cat-bags', hues: [25, 15], weight: 1.4 },
+  { id: 'p-07', name: 'Leather Card Wallet', slug: 'leather-card-wallet', description: 'A slim six-card wallet in vegetable-tanned leather. RFID-shielded with a center cash slot.', price: 89.9, compareAtPrice: 119.9, inventoryCount: 45, sku: 'LCW-007', categoryId: 'cat-bags', hues: [30, 45], weight: 0.08 },
+  { id: 'p-08', name: 'Travel Duffel', slug: 'travel-duffel', description: 'A 40L weekender in ballistic nylon with a trolley sleeve, shoe compartment and detachable strap.', price: 329.9, inventoryCount: 15, sku: 'TDF-008', categoryId: 'cat-bags', hues: [150, 170], weight: 1.1 },
+
+  // --- Home & Kitchen ---
+  { id: 'p-09', name: 'Ceramic Coffee Mug', slug: 'ceramic-coffee-mug', description: 'A 350ml stoneware mug with a matte glaze and comfortable wide handle. Dishwasher and microwave safe.', price: 34.9, inventoryCount: 0, sku: 'MUG-001', categoryId: 'cat-home', hues: [190, 210], weight: 0.4 },
+  { id: 'p-10', name: 'Scented Soy Candle', slug: 'scented-soy-candle', description: 'Hand-poured soy wax candle with cedar and bergamot notes. 45-hour burn time in a reusable glass jar.', price: 69.9, inventoryCount: 60, sku: 'SSC-010', categoryId: 'cat-home', hues: [45, 30], weight: 0.5 },
+  { id: 'p-11', name: 'Bamboo Cutting Board', slug: 'bamboo-cutting-board', description: 'An end-grain bamboo board that is gentle on knives, with a juice groove and inset handles.', price: 119.9, inventoryCount: 22, sku: 'BCB-011', categoryId: 'cat-home', hues: [90, 70], weight: 1.2 },
+  { id: 'p-12', name: 'Stoneware Plate Set', slug: 'stoneware-plate-set', description: 'A set of four reactive-glaze dinner plates. Each piece is unique, oven-safe to 220°C.', price: 249.9, inventoryCount: 10, sku: 'SPS-012', categoryId: 'cat-home', hues: [200, 180], weight: 2.4 },
+
+  // --- Stationery & Tech ---
+  { id: 'p-13', name: 'Wireless Headphones', slug: 'wireless-headphones', description: 'Over-ear headphones with active noise cancelling, 40-hour battery and multipoint Bluetooth 5.3.', price: 899.9, inventoryCount: 18, sku: 'WHP-013', categoryId: 'cat-tech', hues: [260, 280], weight: 0.35 },
+  { id: 'p-14', name: 'Notebook Set', slug: 'notebook-set', description: 'Three A5 dot-grid notebooks with 120gsm paper, lay-flat binding and numbered pages.', price: 29.9, inventoryCount: 80, sku: 'NBS-014', categoryId: 'cat-tech', hues: [330, 310], weight: 0.45 },
+  { id: 'p-15', name: 'Bluetooth Speaker', slug: 'bluetooth-speaker', description: 'A pocket-size speaker with surprising low end, IPX7 waterproofing and 14-hour playtime.', price: 199.9, compareAtPrice: 259.9, inventoryCount: 26, sku: 'BTS-015', categoryId: 'cat-tech', hues: [170, 190], weight: 0.3 },
+  { id: 'p-16', name: 'Felt Desk Mat', slug: 'felt-desk-mat', description: 'A 80x30cm merino felt desk mat with a cork base. Protects the desk and quiets the keyboard.', price: 99.9, inventoryCount: 34, sku: 'FDM-016', categoryId: 'cat-tech', hues: [220, 230], weight: 0.6 },
+]
+
+const CATEGORY_NAME: Record<string, string> = Object.fromEntries(
+  MOCK_CATEGORIES.map((c) => [c.id, c.name]),
+)
+
+export const MOCK_PRODUCTS: Product[] = SEEDS.map((s, i) => ({
+  id: s.id,
+  tenantId: 'mock',
+  name: s.name,
+  slug: s.slug,
+  description: s.description,
+  price: s.price,
+  compareAtPrice: s.compareAtPrice ?? null,
+  currency: 'BRL',
+  status: 'active',
+  inventoryCount: s.inventoryCount,
+  sku: s.sku,
+  sortOrder: i,
+  metadata: {},
+  images: [image(s.id, s.name, s.hues[0], s.hues[1])],
+  categoryId: s.categoryId,
+  categoryName: CATEGORY_NAME[s.categoryId] ?? null,
+  isPhysical: true,
+  weight: s.weight,
+  weightUnit: 'kg',
+  // staggered timestamps → deterministic 'newest' sort (p-16 newest)
+  createdAt: `2026-01-${String(i + 1).padStart(2, '0')}T12:00:00.000Z`,
+  updatedAt: `2026-01-${String(i + 1).padStart(2, '0')}T12:00:00.000Z`,
+}))
+
+export const MOCK_DISCOUNTS: Discount[] = [
+  {
+    id: 'disc-welcome',
+    tenantId: 'mock',
+    title: 'Welcome 10%',
+    code: 'BEMVINDO10',
+    type: 'percentage',
+    method: 'code',
+    value: 10,
+    usageLimit: null,
+    oncePerCustomer: false,
+    startsAt: T0,
+    endsAt: null,
+    status: 'active',
+    timesUsed: 0,
+    createdAt: T0,
+    updatedAt: T0,
+  },
+]
+
+// ---------------------------------------------------------------------------
+// buildMockCatalog — terse per-store catalog definition. Generates ids,
+// slugs, SVG imagery and staggered timestamps so every store gets a
+// deterministic, e2e-stable catalog from a few lines of data.
+// ---------------------------------------------------------------------------
+
+export interface CatalogCategoryInput {
+  name: string
+  description?: string
+  image?: string
+}
+
+export interface CatalogProductInput {
+  name: string
+  description: string
+  price: number
+  compareAtPrice?: number
+  inventory: number
+  sku: string
+  /** Category name — must match one of the categories */
+  category: string
+  hues?: [number, number]
+  weight?: number
+  image?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface CatalogInput {
+  categories: CatalogCategoryInput[]
+  products: CatalogProductInput[]
+  /** Percentage discount codes, e.g. [{ code: 'BEMVINDO10', percent: 10 }] */
+  discounts?: Array<{ code: string; percent: number; title?: string }>
+  currency?: string
+}
+
+function slugifyName(name: string): string {
+  return name
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+export function buildMockCatalog(input: CatalogInput): { products: Product[]; categories: Category[]; discounts: Discount[] } {
+  const categories: Category[] = input.categories.map((c, i) => ({
+    id: `cat-${slugifyName(c.name)}`,
+    tenantId: 'mock',
+    name: c.name,
+    slug: slugifyName(c.name),
+    description: c.description ?? null,
+    parentId: null,
+    sortOrder: i,
+    imageUrl: c.image ?? null,
+    createdAt: T0,
+  }))
+  const byName = Object.fromEntries(categories.map((c) => [c.name, c]))
+
+  const products: Product[] = input.products.map((p, i) => {
+    const cat = byName[p.category]
+    const id = `p-${String(i + 1).padStart(2, '0')}`
+    const hues = p.hues ?? [(i * 47) % 360, (i * 47 + 50) % 360]
+    const stamp = `2026-01-${String((i % 27) + 1).padStart(2, '0')}T12:00:00.000Z`
+    return {
+      id,
+      tenantId: 'mock',
+      name: p.name,
+      slug: slugifyName(p.name),
+      description: p.description,
+      price: p.price,
+      compareAtPrice: p.compareAtPrice ?? null,
+      currency: input.currency ?? 'BRL',
+      status: 'active',
+      inventoryCount: p.inventory,
+      sku: p.sku,
+      sortOrder: i,
+      metadata: p.metadata ?? {},
+      images: [
+        {
+          id: `img-${id}-0`,
+          productId: id,
+          url: p.image ?? svgPlaceholder(p.name, hues[0], hues[1]),
+          altText: p.name,
+          sortOrder: 0,
+          isPrimary: true,
+          createdAt: T0,
+        },
+      ],
+      categoryId: cat?.id ?? null,
+      categoryName: cat?.name ?? null,
+      isPhysical: true,
+      weight: p.weight ?? 0.5,
+      weightUnit: 'kg',
+      createdAt: stamp,
+      updatedAt: stamp,
+    }
+  })
+
+  const discounts: Discount[] = (input.discounts ?? []).map((d, i) => ({
+    id: `disc-${slugifyName(d.code)}`,
+    tenantId: 'mock',
+    title: d.title ?? `${d.percent}% off`,
+    code: d.code,
+    type: 'percentage',
+    method: 'code',
+    value: d.percent,
+    usageLimit: null,
+    oncePerCustomer: false,
+    startsAt: T0,
+    endsAt: null,
+    status: 'active',
+    timesUsed: 0,
+    createdAt: T0,
+    updatedAt: T0,
+  }))
+
+  return { products, categories, discounts }
+}

package/src/mock-provider.ts

@@ -0,0 +1,372 @@
+import type { ShopProvider } from './provider'
+import type {
+  Product, ProductImage, Category, Order, ShopCustomer, Discount,
+  CreateProductInput, UpdateProductInput, ListProductsOptions,
+  CreateCategoryInput, UpdateCategoryInput,
+  CreateOrderInput, UpdateOrderInput, ListOrdersOptions, PlaceOrderInput,
+  CreateCustomerInput, UpdateCustomerInput, ListCustomersOptions, ResolveCustomerInput,
+  CreateDiscountInput, UpdateDiscountInput, ListDiscountsOptions,
+} from './types'
+import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS } from './mock-catalog'
+
+function uid() { return Math.random().toString(36).slice(2) }
+function now() { return new Date().toISOString() }
+
+// Orders/customers persist to localStorage so "my purchases" survives a page
+// reload. Products/categories/discounts always reseed from the catalog —
+// the storefront sees a deterministic catalog on every load.
+const ORDERS_KEY = 'fayz.shop.mock.orders.v1'
+const CUSTOMERS_KEY = 'fayz.shop.mock.customers.v1'
+
+function loadStored<T>(key: string): T[] {
+  try {
+    if (typeof localStorage === 'undefined') return []
+    const raw = localStorage.getItem(key)
+    return raw ? (JSON.parse(raw) as T[]) : []
+  } catch {
+    return []
+  }
+}
+
+function store<T>(key: string, value: T[]): void {
+  try {
+    if (typeof localStorage === 'undefined') return
+    localStorage.setItem(key, JSON.stringify(value))
+  } catch {
+    /* quota/serialization failures are non-fatal in mock mode */
+  }
+}
+
+export interface MockShopSeed {
+  products?: Product[]
+  categories?: Category[]
+  discounts?: Discount[]
+}
+
+export class MockShopProvider implements ShopProvider {
+  private products: Product[]
+  private categories: Category[]
+  private discounts: Discount[]
+  private orders: Order[] = loadStored<Order>(ORDERS_KEY)
+  private customers: ShopCustomer[] = loadStored<ShopCustomer>(CUSTOMERS_KEY)
+
+  constructor(seed?: MockShopSeed) {
+    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 }))
+  }
+
+  // Re-read before mutating: HMR can re-instantiate the provider mid-session
+  // and a stale in-memory copy must not clobber persisted records.
+  private syncOrders() { this.orders = loadStored<Order>(ORDERS_KEY) }
+  private syncCustomers() { this.customers = loadStored<ShopCustomer>(CUSTOMERS_KEY) }
+  private persistOrders() { store(ORDERS_KEY, this.orders) }
+  private persistCustomers() { store(CUSTOMERS_KEY, this.customers) }
+
+  // ---------------------------------------------------------------------------
+  // Products
+  // ---------------------------------------------------------------------------
+
+  async listProducts(opts?: ListProductsOptions): Promise<Product[]> {
+    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
+    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 : undefined)
+    return list
+  }
+
+  async getProduct(id: string) { return this.products.find(p => p.id === id) ?? null }
+
+  async createProduct(input: CreateProductInput): Promise<Product> {
+    const p: Product = { 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', createdAt: now(), updatedAt: now() }
+    this.products.push(p); return p
+  }
+
+  async updateProduct(id: string, input: UpdateProductInput): Promise<Product> {
+    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: string) { this.products = this.products.filter(p => p.id !== id) }
+  async uploadProductImage(_productId: string, _file: File): Promise<ProductImage> { throw new Error('Image upload not available in mock mode') }
+  async deleteProductImage(_imageId: string) {}
+
+  // ---------------------------------------------------------------------------
+  // Categories
+  // ---------------------------------------------------------------------------
+
+  async listCategories() { return [...this.categories].sort((a, b) => a.sortOrder - b.sortOrder) }
+
+  async createCategory(input: CreateCategoryInput): Promise<Category> {
+    const c: Category = { 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: string, input: UpdateCategoryInput): Promise<Category> {
+    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: string) { this.categories = this.categories.filter(c => c.id !== id) }
+
+  // ---------------------------------------------------------------------------
+  // Orders
+  // ---------------------------------------------------------------------------
+
+  async listOrders(opts?: ListOrdersOptions): Promise<Order[]> {
+    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: string) {
+    this.syncOrders()
+    return this.orders.find(o => o.id === id) ?? null
+  }
+
+  async createOrder(input: CreateOrderInput): Promise<Order> {
+    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, o) => Math.max(m, o.orderNumber), 1000)
+    const o: Order = {
+      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,
+      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: string, input: UpdateOrderInput): Promise<Order> {
+    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, validates the discount, decrements
+  // inventory. The browser-supplied prices are never used.
+  async placeOrder(input: PlaceOrderInput): Promise<Order> {
+    this.syncOrders()
+    this.syncCustomers()
+
+    // Resolve / create the customer (find-or-create by email).
+    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
+      }
+    }
+
+    // Re-read price + guard stock from the catalog (never trust the client).
+    const items: CreateOrderInput['items'] = []
+    let subtotal = 0
+    for (const line of input.items) {
+      const product = this.products.find(p => p.id === line.productId)
+      if (!product || product.status !== 'active') throw new Error(`Product unavailable: ${line.productId}`)
+      if (product.inventoryCount < line.quantity) throw new Error(`Insufficient stock for ${product.name}`)
+      const name = line.optionsLabel ? `${product.name} (${line.optionsLabel})` : product.name
+      subtotal += product.price * line.quantity
+      items.push({ productId: product.id, name, sku: product.sku ?? undefined, quantity: line.quantity, unitPrice: product.price, imageUrl: product.images[0]?.url })
+    }
+    subtotal = Math.round(subtotal * 100) / 100
+
+    // Validate + apply the discount server-side.
+    let shippingTotal = Math.max(input.shippingTotal ?? 0, 0)
+    let discountTotal = 0
+    let appliedCode: string | null = null
+    if (input.discountCode) {
+      const code = input.discountCode.trim().toLowerCase()
+      const d = this.discounts.find(x => (x.code ?? '').toLowerCase() === code)
+      const ts = now()
+      const valid = !!d && d.status === 'active' && d.startsAt <= ts && (!d.endsAt || d.endsAt >= ts) && (d.usageLimit == null || d.timesUsed < d.usageLimit)
+      if (valid && d) {
+        appliedCode = d.code
+        if (d.type === 'percentage') discountTotal = Math.round(subtotal * d.value) / 100
+        else if (d.type === 'fixed_amount') discountTotal = Math.min(d.value, subtotal)
+        else if (d.type === 'free_shipping') shippingTotal = 0
+        // buy_x_get_y unsupported in v1: code recorded, no monetary effect
+        d.timesUsed += 1
+      }
+    }
+    discountTotal = Math.round(Math.min(Math.max(discountTotal, 0), subtotal) * 100) / 100
+
+    // Persist via createOrder (recomputes total from these trusted values).
+    const order = await this.createOrder({
+      customerId: customerId ?? undefined,
+      customerName: customerName ?? undefined,
+      customerEmail: input.customer?.email ?? undefined,
+      currency: input.currency,
+      notes: input.notes,
+      discountCode: appliedCode ?? undefined,
+      discountTotal,
+      shippingTotal,
+      items,
+    })
+
+    // Decrement inventory (in-memory; the mock catalog reseeds on reload).
+    for (const line of input.items) {
+      const product = this.products.find(p => p.id === line.productId)
+      if (product) product.inventoryCount = Math.max(0, product.inventoryCount - line.quantity)
+    }
+
+    return order
+  }
+
+  // ---------------------------------------------------------------------------
+  // Customers
+  // ---------------------------------------------------------------------------
+
+  async listCustomers(opts?: ListCustomersOptions) {
+    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: string) {
+    this.syncCustomers()
+    return this.customers.find(c => c.id === id) ?? null
+  }
+
+  async createCustomer(input: CreateCustomerInput): Promise<ShopCustomer> {
+    this.syncCustomers()
+    const c: ShopCustomer = { id: uid(), tenantId: 'mock', firstName: input.firstName, lastName: input.lastName ?? '', email: input.email ?? null, phone: input.phone ?? null, notes: input.notes ?? null, ordersCount: 0, totalSpent: 0, createdAt: now(), updatedAt: now() }
+    this.customers.push(c)
+    this.persistCustomers()
+    return c
+  }
+
+  async updateCustomer(id: string, input: UpdateCustomerInput): Promise<ShopCustomer> {
+    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: string) {
+    this.syncCustomers()
+    this.customers = this.customers.filter(c => c.id !== id)
+    this.persistCustomers()
+  }
+
+  async resolveCustomer(input: ResolveCustomerInput): Promise<ShopCustomer> {
+    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 })
+  }
+
+  // ---------------------------------------------------------------------------
+  // Discounts
+  // ---------------------------------------------------------------------------
+
+  async listDiscounts(opts?: ListDiscountsOptions) {
+    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: string) { return this.discounts.find(d => d.id === id) ?? null }
+
+  async createDiscount(input: CreateDiscountInput): Promise<Discount> {
+    const d: Discount = { 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, 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: string, input: UpdateDiscountInput): Promise<Discount> {
+    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: string) { this.discounts = this.discounts.filter(d => d.id !== id) }
+}
+
+export function createMockShopProvider(seed?: MockShopSeed): ShopProvider {
+  return new MockShopProvider(seed)
+}

package/src/mock.ts

@@ -0,0 +1,2 @@
+export { MockShopProvider, createMockShopProvider } from './mock-provider'
+export type { MockShopSeed } from './mock-provider'