@fayz-ai/plugin-menu 0.9.4 → 0.10.1

package/dist/index.js

@@ -1,12 +1,11 @@
+import { countExtracted, normalizeName } from './chunk-C6W53TML.js';
 import React from 'react';
-import { registerTranslations } from '@fayz-ai/core';
+import { registerTranslations, createSafeDataProvider, tl, getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core';
 import { createStore } from 'zustand/vanilla';
-import { PluginSettingsPanel, dedup } from '@fayz-ai/admin';
 import { toast } from 'sonner';
+import { PluginSettingsPanel, dedup } from '@fayz-ai/admin';
 import { createFayzClient } from '@fayz-ai/sdk';
 
-// src/index.ts
-
 // src/data/mock.ts
 var uid = 0;
 function nextId(prefix) {
@@ -17,103 +16,318 @@ function now() {
 }
 function paginate(items, page, pageSize) {
   const p = page ?? 1;
-  const ps = pageSize ?? 50;
+  const ps = pageSize ?? 200;
   const start = (p - 1) * ps;
   return { data: items.slice(start, start + ps), total: items.length };
 }
-function seedCategories() {
-  const t = "mock-tenant";
+var TENANT = "mock-tenant";
+function createMockMenuProvider() {
   const ts = now();
-  return [
-    { id: nextId("cat"), name: "Burgers", icon: "\u{1F354}", color: "#f59e0b", sortOrder: 0, isActive: true, itemCount: 3, tenantId: t, createdAt: ts, updatedAt: ts },
-    { id: nextId("cat"), name: "Sides", icon: "\u{1F35F}", color: "#22c55e", sortOrder: 1, isActive: true, itemCount: 3, tenantId: t, createdAt: ts, updatedAt: ts },
-    { id: nextId("cat"), name: "Drinks", icon: "\u{1F964}", color: "#3b82f6", sortOrder: 2, isActive: true, itemCount: 4, tenantId: t, createdAt: ts, updatedAt: ts },
-    { id: nextId("cat"), name: "Desserts", icon: "\u{1F370}", color: "#ec4899", sortOrder: 3, isActive: true, itemCount: 2, tenantId: t, createdAt: ts, updatedAt: ts },
-    { id: nextId("cat"), name: "Combos", icon: "\u2B50", color: "#8b5cf6", sortOrder: 4, isActive: true, itemCount: 0, tenantId: t, createdAt: ts, updatedAt: ts }
+  const menus = [
+    {
+      id: nextId("menu"),
+      name: "Card\xE1pio principal",
+      description: "O de todo dia",
+      isActive: true,
+      sortOrder: 0,
+      channels: ["pos", "delivery", "digital"],
+      availability: {},
+      tenantId: TENANT,
+      createdAt: ts,
+      updatedAt: ts
+    },
+    {
+      id: nextId("menu"),
+      name: "Executivo",
+      description: "Almo\xE7o de segunda a sexta",
+      isActive: true,
+      sortOrder: 1,
+      channels: ["pos"],
+      availability: { days: [1, 2, 3, 4, 5], start: "11:30", end: "15:00" },
+      tenantId: TENANT,
+      createdAt: ts,
+      updatedAt: ts
+    }
   ];
-}
-function seedItems(categories) {
-  const t = "mock-tenant";
-  const ts = now();
-  const [burgers, sides, drinks, desserts] = categories.map((c) => c.id);
-  const item = (name, price, categoryId, categoryName, opts = {}) => ({
+  const section = (menuId, name, order) => ({
+    id: nextId("sec"),
+    menuId,
+    name,
+    sortOrder: order,
+    isActive: true,
+    availability: {},
+    tenantId: TENANT,
+    createdAt: ts,
+    updatedAt: ts
+  });
+  const sections = [
+    section(menus[0].id, "Entradas", 0),
+    section(menus[0].id, "Pratos principais", 1),
+    section(menus[0].id, "Bebidas", 2),
+    section(menus[0].id, "Sobremesas", 3),
+    section(menus[1].id, "Prato do dia", 0),
+    section(menus[1].id, "Bebida inclusa", 1)
+  ];
+  const item = (name, price, extra = {}) => ({
     id: nextId("mi"),
     name,
     price,
     currency: "BRL",
-    categoryId,
-    categoryName,
     status: "available",
     isActive: true,
     availableForPos: true,
     availableForDelivery: true,
     sortOrder: 0,
     isFeatured: false,
-    tenantId: t,
+    allergens: [],
+    dietaryTags: [],
+    tenantId: TENANT,
     createdAt: ts,
     updatedAt: ts,
-    ...opts
+    ...extra
   });
-  let order = 0;
-  return [
-    item("Classic Burger", 32, burgers, "Burgers", { prepTimeMinutes: 12, sortOrder: order++, isFeatured: true }),
-    item("Cheese Burger", 36, burgers, "Burgers", { prepTimeMinutes: 12, sortOrder: order++ }),
-    item("BBQ Bacon", 42, burgers, "Burgers", { prepTimeMinutes: 15, sortOrder: order++, isFeatured: true }),
-    item("Fries", 15, sides, "Sides", { prepTimeMinutes: 8, sortOrder: order++ }),
-    item("Onion Rings", 18, sides, "Sides", { prepTimeMinutes: 8, sortOrder: order++ }),
-    item("Coleslaw", 12, sides, "Sides", { prepTimeMinutes: 2, sortOrder: order++, availableForDelivery: false }),
-    item("Soda", 8, drinks, "Drinks", { prepTimeMinutes: 1, sortOrder: order++ }),
-    item("Juice", 12, drinks, "Drinks", { prepTimeMinutes: 3, sortOrder: order++ }),
-    item("Water", 5, drinks, "Drinks", { prepTimeMinutes: 0, sortOrder: order++ }),
-    item("Milkshake", 16, drinks, "Drinks", { prepTimeMinutes: 5, sortOrder: order++, isFeatured: true }),
-    item("Brownie", 14, desserts, "Desserts", { prepTimeMinutes: 1, sortOrder: order++ }),
-    item("Ice Cream", 12, desserts, "Desserts", { prepTimeMinutes: 2, sortOrder: order++, availableForDelivery: false })
+  const items = [
+    item("Bolinho de bacalhau", 38, { description: "6 unidades", prepTimeMinutes: 15 }),
+    item("P\xE3o de alho", 18, { prepTimeMinutes: 8, dietaryTags: ["Vegetariano"] }),
+    item("Picanha na chapa", 129, { description: "Serve 2 pessoas", prepTimeMinutes: 25, isFeatured: true }),
+    item("Moqueca de peixe", 98, { prepTimeMinutes: 30, allergens: ["Frutos do mar"] }),
+    item("Risoto de funghi", 72, { prepTimeMinutes: 22, dietaryTags: ["Vegetariano"] }),
+    item("Suco natural", 14, { prepTimeMinutes: 3 }),
+    item("Refrigerante", 9, { prepTimeMinutes: 1 }),
+    item("\xC1gua", 6, { prepTimeMinutes: 1 }),
+    item("Pudim da casa", 19, { prepTimeMinutes: 2, isFeatured: true }),
+    item("Petit g\xE2teau", 26, { prepTimeMinutes: 12, allergens: ["Gl\xFAten", "Lactose"] }),
+    item("Prato executivo do dia", 42, { description: "Prato + bebida", prepTimeMinutes: 15 })
   ];
-}
-function seedModifierGroups() {
-  const t = "mock-tenant";
-  const ts = now();
-  const g1Id = nextId("mg");
-  const g2Id = nextId("mg");
-  return [
+  const placement = (sectionId, itemId, order, priceOverride) => ({
+    id: nextId("pl"),
+    sectionId,
+    itemId,
+    sortOrder: order,
+    priceOverride,
+    isActive: true,
+    tenantId: TENANT
+  });
+  const placements = [
+    placement(sections[0].id, items[0].id, 0),
+    placement(sections[0].id, items[1].id, 1),
+    placement(sections[1].id, items[2].id, 0),
+    placement(sections[1].id, items[3].id, 1),
+    placement(sections[1].id, items[4].id, 2),
+    placement(sections[2].id, items[5].id, 0),
+    placement(sections[2].id, items[6].id, 1),
+    placement(sections[2].id, items[7].id, 2),
+    placement(sections[3].id, items[8].id, 0),
+    placement(sections[3].id, items[9].id, 1),
+    placement(sections[4].id, items[10].id, 0),
+    // The same risotto, cheaper at lunch — the reason placements carry a price.
+    placement(sections[4].id, items[4].id, 1, 49),
+    placement(sections[5].id, items[5].id, 0, 0)
+  ];
+  const categories = [];
+  const g1 = nextId("mg");
+  const g2 = nextId("mg");
+  const modifierGroups = [
     {
-      id: g1Id,
-      name: "Extra Toppings",
-      minSelections: 0,
-      maxSelections: 3,
-      isRequired: false,
+      id: g1,
+      name: "Ponto da carne",
+      minSelections: 1,
+      maxSelections: 1,
+      isRequired: true,
       sortOrder: 0,
-      tenantId: t,
+      tenantId: TENANT,
       createdAt: ts,
       items: [
-        { id: nextId("mod"), groupId: g1Id, name: "Extra Cheese", priceAdjustment: 5, isActive: true, sortOrder: 0 },
-        { id: nextId("mod"), groupId: g1Id, name: "Bacon", priceAdjustment: 7, isActive: true, sortOrder: 1 },
-        { id: nextId("mod"), groupId: g1Id, name: "Jalape\xF1os", priceAdjustment: 4, isActive: true, sortOrder: 2 }
+        { id: nextId("mod"), groupId: g1, name: "Mal passada", priceAdjustment: 0, isActive: true, sortOrder: 0 },
+        { id: nextId("mod"), groupId: g1, name: "Ao ponto", priceAdjustment: 0, isActive: true, sortOrder: 1 },
+        { id: nextId("mod"), groupId: g1, name: "Bem passada", priceAdjustment: 0, isActive: true, sortOrder: 2 }
       ]
     },
     {
-      id: g2Id,
-      name: "Drink Size",
-      minSelections: 1,
-      maxSelections: 1,
-      isRequired: true,
+      id: g2,
+      name: "Acompanhamentos",
+      minSelections: 0,
+      maxSelections: 3,
+      isRequired: false,
       sortOrder: 1,
-      tenantId: t,
+      tenantId: TENANT,
       createdAt: ts,
       items: [
-        { id: nextId("mod"), groupId: g2Id, name: "Small", priceAdjustment: 0, isActive: true, sortOrder: 0 },
-        { id: nextId("mod"), groupId: g2Id, name: "Medium", priceAdjustment: 3, isActive: true, sortOrder: 1 },
-        { id: nextId("mod"), groupId: g2Id, name: "Large", priceAdjustment: 5, isActive: true, sortOrder: 2 }
+        { id: nextId("mod"), groupId: g2, name: "Farofa", priceAdjustment: 8, isActive: true, sortOrder: 0 },
+        { id: nextId("mod"), groupId: g2, name: "Vinagrete", priceAdjustment: 6, isActive: true, sortOrder: 1 },
+        { id: nextId("mod"), groupId: g2, name: "Arroz branco", priceAdjustment: 10, isActive: true, sortOrder: 2 }
       ]
     }
   ];
-}
-function createMockMenuProvider() {
-  const tenantId = "mock-tenant";
-  const categories = seedCategories();
-  const items = seedItems(categories);
-  const modifierGroups = seedModifierGroups();
-  return {
+  const provider = {
+    // --- Menus ---
+    async getMenus() {
+      return menus.map((m) => {
+        const mine = sections.filter((s) => s.menuId === m.id);
+        const ids = new Set(mine.map((s) => s.id));
+        return { ...m, sectionCount: mine.length, itemCount: placements.filter((p) => ids.has(p.sectionId)).length };
+      }).sort((a, b) => a.sortOrder - b.sortOrder);
+    },
+    async createMenu(input) {
+      const menu = {
+        id: nextId("menu"),
+        name: input.name,
+        description: input.description,
+        isActive: input.isActive ?? true,
+        sortOrder: input.sortOrder ?? menus.length,
+        channels: input.channels ?? ["pos", "delivery", "digital"],
+        availability: input.availability ?? {},
+        tenantId: TENANT,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      menus.push(menu);
+      return menu;
+    },
+    async updateMenu(id, patch) {
+      const menu = menus.find((m) => m.id === id);
+      if (!menu) throw new Error("Menu not found");
+      Object.assign(menu, patch, { updatedAt: now() });
+      return menu;
+    },
+    async deleteMenu(id) {
+      const mine = sections.filter((s) => s.menuId === id);
+      for (const s of mine) {
+        for (let i = placements.length - 1; i >= 0; i--) if (placements[i].sectionId === s.id) placements.splice(i, 1);
+        sections.splice(sections.indexOf(s), 1);
+      }
+      const index = menus.findIndex((m) => m.id === id);
+      if (index >= 0) menus.splice(index, 1);
+    },
+    async duplicateMenu(id, name) {
+      const source = menus.find((m) => m.id === id);
+      if (!source) throw new Error("Menu not found");
+      const copy = await provider.createMenu({
+        name,
+        description: source.description,
+        channels: source.channels,
+        availability: source.availability,
+        isActive: false
+      });
+      for (const s of sections.filter((x) => x.menuId === id)) {
+        const clone = await provider.createSection({
+          menuId: copy.id,
+          name: s.name,
+          description: s.description,
+          sortOrder: s.sortOrder,
+          isActive: s.isActive,
+          availability: s.availability
+        });
+        for (const p of placements.filter((x) => x.sectionId === s.id)) {
+          await provider.placeItem({
+            sectionId: clone.id,
+            itemId: p.itemId,
+            sortOrder: p.sortOrder,
+            priceOverride: p.priceOverride,
+            isActive: p.isActive
+          });
+        }
+      }
+      return copy;
+    },
+    async reorderMenus(ids) {
+      ids.forEach((id, index) => {
+        const menu = menus.find((m) => m.id === id);
+        if (menu) menu.sortOrder = index;
+      });
+    },
+    // --- Sections ---
+    async getSections(menuId) {
+      return sections.filter((s) => s.menuId === menuId).sort((a, b) => a.sortOrder - b.sortOrder);
+    },
+    async createSection(input) {
+      const created = {
+        id: nextId("sec"),
+        menuId: input.menuId,
+        name: input.name,
+        description: input.description,
+        imageUrl: input.imageUrl,
+        sortOrder: input.sortOrder ?? sections.filter((s) => s.menuId === input.menuId).length,
+        isActive: input.isActive ?? true,
+        availability: input.availability ?? {},
+        tenantId: TENANT,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      sections.push(created);
+      return created;
+    },
+    async updateSection(id, patch) {
+      const found = sections.find((s) => s.id === id);
+      if (!found) throw new Error("Section not found");
+      Object.assign(found, patch, { updatedAt: now() });
+      return found;
+    },
+    async deleteSection(id) {
+      for (let i = placements.length - 1; i >= 0; i--) if (placements[i].sectionId === id) placements.splice(i, 1);
+      const index = sections.findIndex((s) => s.id === id);
+      if (index >= 0) sections.splice(index, 1);
+    },
+    async reorderSections(_menuId, ids) {
+      ids.forEach((id, index) => {
+        const found = sections.find((s) => s.id === id);
+        if (found) found.sortOrder = index;
+      });
+    },
+    // --- Placements ---
+    async getPlacements(menuId) {
+      const ids = new Set(sections.filter((s) => s.menuId === menuId).map((s) => s.id));
+      return placements.filter((p) => ids.has(p.sectionId)).sort((a, b) => a.sortOrder - b.sortOrder);
+    },
+    async placeItem(input) {
+      const existing = placements.find((p) => p.sectionId === input.sectionId && p.itemId === input.itemId);
+      if (existing) {
+        Object.assign(existing, input);
+        return existing;
+      }
+      const created = placement(
+        input.sectionId,
+        input.itemId,
+        input.sortOrder ?? placements.filter((p) => p.sectionId === input.sectionId).length,
+        input.priceOverride
+      );
+      created.isActive = input.isActive ?? true;
+      placements.push(created);
+      return created;
+    },
+    async updatePlacement(id, patch) {
+      const found = placements.find((p) => p.id === id);
+      if (!found) throw new Error("Placement not found");
+      if (patch.sectionId !== void 0) found.sectionId = patch.sectionId;
+      if (patch.sortOrder !== void 0) found.sortOrder = patch.sortOrder;
+      if (patch.priceOverride !== void 0) found.priceOverride = patch.priceOverride;
+      if (patch.isActive !== void 0) found.isActive = patch.isActive;
+      return found;
+    },
+    async removePlacement(id) {
+      const index = placements.findIndex((p) => p.id === id);
+      if (index >= 0) placements.splice(index, 1);
+    },
+    async reorderPlacements(_sectionId, ids) {
+      ids.forEach((id, index) => {
+        const found = placements.find((p) => p.id === id);
+        if (found) found.sortOrder = index;
+      });
+    },
+    async movePlacement(id, toSectionId, toIndex) {
+      const found = placements.find((p) => p.id === id);
+      if (!found) return;
+      found.sectionId = toSectionId;
+      found.sortOrder = toIndex;
+      placements.filter((p) => p.sectionId === toSectionId && p.id !== id).sort((a, b) => a.sortOrder - b.sortOrder).forEach((p, i) => {
+        p.sortOrder = i >= toIndex ? i + 1 : i;
+      });
+    },
+    // --- Media ---
+    async uploadImage(file) {
+      return typeof URL !== "undefined" && URL.createObjectURL ? URL.createObjectURL(file) : "";
+    },
+    // --- Categories (legacy surface, still answered) ---
     async getCategories() {
       return [...categories].sort((a, b) => a.sortOrder - b.sortOrder);
     },
@@ -121,7 +335,7 @@ function createMockMenuProvider() {
       return categories.find((c) => c.id === id) ?? null;
     },
     async createCategory(input) {
-      const cat = {
+      const created = {
         id: nextId("cat"),
         name: input.name,
         parentId: input.parentId,
@@ -129,257 +343,1686 @@ function createMockMenuProvider() {
         color: input.color,
         sortOrder: input.sortOrder ?? categories.length,
         isActive: true,
-        itemCount: 0,
-        tenantId,
+        tenantId: TENANT,
         createdAt: now(),
         updatedAt: now()
       };
-      categories.push(cat);
-      return cat;
+      categories.push(created);
+      return created;
     },
-    async updateCategory(id, data) {
-      const cat = categories.find((c) => c.id === id);
-      if (!cat) throw new Error(`Category ${id} not found`);
-      Object.assign(cat, data, { updatedAt: now() });
-      return cat;
+    async updateCategory(id, patch) {
+      const found = categories.find((c) => c.id === id);
+      if (!found) throw new Error("Category not found");
+      Object.assign(found, patch, { updatedAt: now() });
+      return found;
     },
     async deleteCategory(id) {
-      const idx = categories.findIndex((c) => c.id === id);
-      if (idx >= 0) categories.splice(idx, 1);
+      const index = categories.findIndex((c) => c.id === id);
+      if (index >= 0) categories.splice(index, 1);
     },
     async reorderCategories(ids) {
-      ids.forEach((id, i) => {
-        const cat = categories.find((c) => c.id === id);
-        if (cat) cat.sortOrder = i;
+      ids.forEach((id, index) => {
+        const found = categories.find((c) => c.id === id);
+        if (found) found.sortOrder = index;
       });
     },
+    // --- Items ---
     async getMenuItems(query) {
-      let results = [...items];
-      if (query.categoryId) results = results.filter((i) => i.categoryId === query.categoryId);
+      let result = [...items];
+      if (query.search) {
+        const term = query.search.toLowerCase();
+        result = result.filter((i) => i.name.toLowerCase().includes(term) || (i.description ?? "").toLowerCase().includes(term));
+      }
+      if (query.categoryId) result = result.filter((i) => i.categoryId === query.categoryId);
       if (query.status) {
         const statuses = Array.isArray(query.status) ? query.status : [query.status];
-        results = results.filter((i) => statuses.includes(i.status));
-      }
-      if (query.availableForPos !== void 0) results = results.filter((i) => i.availableForPos === query.availableForPos);
-      if (query.availableForDelivery !== void 0) results = results.filter((i) => i.availableForDelivery === query.availableForDelivery);
-      if (query.isFeatured !== void 0) results = results.filter((i) => i.isFeatured === query.isFeatured);
-      if (query.search) {
-        const s = query.search.toLowerCase();
-        results = results.filter((i) => i.name.toLowerCase().includes(s) || i.description?.toLowerCase().includes(s));
+        result = result.filter((i) => statuses.includes(i.status));
       }
-      results.sort((a, b) => a.sortOrder - b.sortOrder);
-      return paginate(results, query.page, query.pageSize);
+      if (query.availableForPos !== void 0) result = result.filter((i) => i.availableForPos === query.availableForPos);
+      if (query.availableForDelivery !== void 0) result = result.filter((i) => i.availableForDelivery === query.availableForDelivery);
+      if (query.isFeatured !== void 0) result = result.filter((i) => i.isFeatured === query.isFeatured);
+      return paginate(result, query.page, query.pageSize);
     },
     async getMenuItemById(id) {
       return items.find((i) => i.id === id) ?? null;
     },
     async createMenuItem(input) {
-      const cat = input.categoryId ? categories.find((c) => c.id === input.categoryId) : void 0;
-      const item = {
-        id: nextId("mi"),
-        name: input.name,
+      const created = item(input.name, input.price, {
         description: input.description,
-        price: input.price,
         cost: input.cost,
-        currency: "BRL",
         imageUrl: input.imageUrl,
         categoryId: input.categoryId,
-        categoryName: cat?.name,
         status: input.status ?? "available",
-        isActive: true,
         prepTimeMinutes: input.prepTimeMinutes,
-        allergens: input.allergens,
-        dietaryTags: input.dietaryTags,
+        allergens: input.allergens ?? [],
+        dietaryTags: input.dietaryTags ?? [],
         availableForPos: input.availableForPos ?? true,
         availableForDelivery: input.availableForDelivery ?? true,
         deliveryPrice: input.deliveryPrice,
-        sortOrder: items.length,
         isFeatured: input.isFeatured ?? false,
-        modifierGroupIds: input.modifierGroupIds,
-        tenantId,
-        createdAt: now(),
-        updatedAt: now()
-      };
-      items.push(item);
-      if (cat) cat.itemCount = (cat.itemCount ?? 0) + 1;
-      return item;
+        modifierGroupIds: input.modifierGroupIds
+      });
+      items.push(created);
+      if (input.sectionId) await provider.placeItem({ sectionId: input.sectionId, itemId: created.id });
+      return created;
     },
-    async updateMenuItem(id, data) {
-      const item = items.find((i) => i.id === id);
-      if (!item) throw new Error(`MenuItem ${id} not found`);
-      Object.assign(item, data, { updatedAt: now() });
-      return item;
+    async updateMenuItem(id, patch) {
+      const found = items.find((i) => i.id === id);
+      if (!found) throw new Error("Item not found");
+      Object.assign(found, patch, { updatedAt: now() });
+      return found;
     },
     async deleteMenuItem(id) {
-      const idx = items.findIndex((i) => i.id === id);
-      if (idx >= 0) {
-        const [removed] = items.splice(idx, 1);
-        if (removed.categoryId) {
-          const cat = categories.find((c) => c.id === removed.categoryId);
-          if (cat && cat.itemCount) cat.itemCount--;
-        }
-      }
+      for (let i = placements.length - 1; i >= 0; i--) if (placements[i].itemId === id) placements.splice(i, 1);
+      const index = items.findIndex((i) => i.id === id);
+      if (index >= 0) items.splice(index, 1);
     },
     async toggleAvailability(id, field, value) {
-      const item = items.find((i) => i.id === id);
-      if (!item) throw new Error(`MenuItem ${id} not found`);
-      item[field] = value;
-      item.updatedAt = now();
-      return item;
+      const found = items.find((i) => i.id === id);
+      if (!found) throw new Error("Item not found");
+      found[field] = value;
+      found.updatedAt = now();
+      return found;
     },
-    async reorderItems(categoryId, ids) {
-      ids.forEach((id, i) => {
-        const item = items.find((it) => it.id === id && it.categoryId === categoryId);
-        if (item) item.sortOrder = i;
+    async reorderItems(_categoryId, ids) {
+      ids.forEach((id, index) => {
+        const found = items.find((i) => i.id === id);
+        if (found) found.sortOrder = index;
       });
     },
+    // --- Modifier groups ---
     async getModifierGroups() {
       return [...modifierGroups].sort((a, b) => a.sortOrder - b.sortOrder);
     },
     async createModifierGroup(input) {
-      const group = {
+      const created = {
         id: nextId("mg"),
-        name: input.name ?? "",
+        name: input.name ?? "Grupo",
         minSelections: input.minSelections ?? 0,
         maxSelections: input.maxSelections ?? 1,
         isRequired: input.isRequired ?? false,
         sortOrder: input.sortOrder ?? modifierGroups.length,
         items: input.items ?? [],
-        tenantId,
+        tenantId: TENANT,
         createdAt: now()
       };
-      modifierGroups.push(group);
-      return group;
+      modifierGroups.push(created);
+      return created;
     },
-    async updateModifierGroup(id, data) {
-      const group = modifierGroups.find((g) => g.id === id);
-      if (!group) throw new Error(`ModifierGroup ${id} not found`);
-      Object.assign(group, data);
-      return group;
+    async updateModifierGroup(id, patch) {
+      const found = modifierGroups.find((g) => g.id === id);
+      if (!found) throw new Error("Modifier group not found");
+      Object.assign(found, patch);
+      return found;
     },
     async deleteModifierGroup(id) {
-      const idx = modifierGroups.findIndex((g) => g.id === id);
-      if (idx >= 0) modifierGroups.splice(idx, 1);
+      const index = modifierGroups.findIndex((g) => g.id === id);
+      if (index >= 0) modifierGroups.splice(index, 1);
     },
+    // --- Summary ---
     async getSummary() {
-      const available = items.filter((i) => i.status === "available");
-      const soldOut = items.filter((i) => i.status === "sold_out");
-      const hidden = items.filter((i) => i.status === "hidden");
-      const prices = items.filter((i) => i.price > 0).map((i) => i.price);
+      const prices = items.map((i) => i.price);
       return {
         totalItems: items.length,
-        availableItems: available.length,
-        soldOutItems: soldOut.length,
-        hiddenItems: hidden.length,
-        categoryCount: categories.length,
+        availableItems: items.filter((i) => i.status === "available").length,
+        soldOutItems: items.filter((i) => i.status === "sold_out").length,
+        hiddenItems: items.filter((i) => i.status === "hidden").length,
+        categoryCount: sections.length,
         averagePrice: prices.length ? prices.reduce((a, b) => a + b, 0) / prices.length : 0,
         featuredCount: items.filter((i) => i.isFeatured).length
       };
     }
   };
+  return provider;
 }
-function createMenuStore(provider) {
-  return createStore((set, get) => ({
-    categories: [],
-    categoriesLoading: false,
-    menuItems: [],
-    menuItemsTotal: 0,
-    menuItemsLoading: false,
-    menuItemQuery: {},
-    modifierGroups: [],
-    modifiersLoading: false,
-    summary: null,
-    summaryLoading: false,
-    async fetchCategories() {
-      return dedup("menu:categories", async () => {
-        set({ categoriesLoading: true });
-        const categories = await provider.getCategories();
-        set({ categories, categoriesLoading: false });
+
+// src/data/tables.ts
+var T = {
+  menus: "plg_menu_menus",
+  sections: "plg_menu_sections",
+  placements: "plg_menu_placements",
+  items: "plg_menu_items",
+  allergens: "plg_menu_allergens",
+  dietaryTags: "plg_menu_dietary_tags",
+  modifierGroups: "plg_menu_modifier_groups",
+  modifiers: "plg_menu_modifiers",
+  /** Spine tables this plugin reads/writes through. */
+  products: "products",
+  categories: "categories",
+  /** Bucket for item, section and import photos. */
+  mediaBucket: "menu-images"
+};
+
+// src/data/supabase.ts
+var CATEGORY_KIND = "menu_category";
+function rowToMenu(row, counts) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? void 0,
+    isActive: row.is_active ?? true,
+    sortOrder: row.sort_order ?? 0,
+    channels: row.channels ?? ["pos", "delivery", "digital"],
+    availability: row.availability ?? {},
+    sectionCount: counts?.sections,
+    itemCount: counts?.items,
+    tenantId: row.tenant_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToSection(row) {
+  return {
+    id: row.id,
+    menuId: row.menu_id,
+    name: row.name,
+    description: row.description ?? void 0,
+    imageUrl: row.image_url ?? void 0,
+    sortOrder: row.sort_order ?? 0,
+    isActive: row.is_active ?? true,
+    availability: row.availability ?? {},
+    tenantId: row.tenant_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToPlacement(row) {
+  return {
+    id: row.id,
+    sectionId: row.section_id,
+    itemId: row.item_id,
+    sortOrder: row.sort_order ?? 0,
+    priceOverride: row.price_override ?? void 0,
+    isActive: row.is_active ?? true,
+    tenantId: row.tenant_id
+  };
+}
+function rowToCategory(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    parentId: row.parent_id ?? void 0,
+    icon: row.icon ?? void 0,
+    color: row.color ?? void 0,
+    sortOrder: row.sort_order ?? 0,
+    isActive: row.is_active ?? true,
+    tenantId: row.tenant_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToItem(row, currency) {
+  const ext = Array.isArray(row.plg_menu_items) ? row.plg_menu_items[0] : row.plg_menu_items;
+  const meta = row.metadata ?? {};
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? void 0,
+    price: Number(row.price ?? 0),
+    cost: row.cost != null ? Number(row.cost) : void 0,
+    currency,
+    sku: row.sku ?? void 0,
+    imageUrl: row.image_url ?? void 0,
+    categoryId: row.category_id ?? void 0,
+    status: ext?.status ?? "available",
+    isActive: row.is_active ?? true,
+    prepTimeMinutes: ext?.prep_time_minutes ?? void 0,
+    allergens: ext?.allergens ?? [],
+    dietaryTags: ext?.dietary_tags ?? [],
+    availableForPos: ext?.available_for_pos ?? true,
+    availableForDelivery: ext?.available_for_delivery ?? true,
+    deliveryPrice: ext?.delivery_price != null ? Number(ext.delivery_price) : void 0,
+    sortOrder: ext?.sort_order ?? 0,
+    isFeatured: ext?.is_featured ?? false,
+    metadata: meta,
+    tenantId: row.tenant_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function createSupabaseMenuProvider(options) {
+  const currency = options?.currencyCode ?? "BRL";
+  function db() {
+    const client = getSupabaseClientOptional();
+    if (!client) throw new Error("Supabase not initialized");
+    return client;
+  }
+  function tenant() {
+    return getActiveTenantId() ?? void 0;
+  }
+  function fail(error) {
+    if (error) throw new Error(error.message ?? "Menu request failed");
+  }
+  async function nextOrder(table, column, value) {
+    const { data } = await db().from(table).select("sort_order").eq(column, value).order("sort_order", { ascending: false }).limit(1);
+    return (data?.[0]?.sort_order ?? 0) + 1;
+  }
+  const provider = {
+    // --- Menus -------------------------------------------------------------
+    async getMenus() {
+      const { data, error } = await db().from(T.menus).select("*").order("sort_order", { ascending: true });
+      fail(error);
+      let menus = data ?? [];
+      if (menus.length === 0) {
+        const created = await provider.createMenu({ name: "Card\xE1pio principal" });
+        menus = [{
+          ...created,
+          is_active: true,
+          sort_order: 0,
+          tenant_id: created.tenantId,
+          created_at: created.createdAt,
+          updated_at: created.updatedAt,
+          availability: {},
+          channels: created.channels
+        }];
+      }
+      const menuIds = menus.map((m) => m.id);
+      const { data: sections } = await db().from(T.sections).select("id, menu_id").in("menu_id", menuIds);
+      const sectionIds = (sections ?? []).map((s) => s.id);
+      const { data: placements } = sectionIds.length ? await db().from(T.placements).select("section_id").in("section_id", sectionIds) : { data: [] };
+      const sectionToMenu = new Map((sections ?? []).map((s) => [s.id, s.menu_id]));
+      return menus.map((row) => {
+        const mySections = (sections ?? []).filter((s) => s.menu_id === row.id);
+        const myItems = (placements ?? []).filter((p) => sectionToMenu.get(p.section_id) === row.id);
+        return rowToMenu(row, { sections: mySections.length, items: myItems.length });
       });
     },
-    async fetchMenuItems(query) {
-      return dedup("menu:items:" + JSON.stringify(query), async () => {
-        set({ menuItemsLoading: true, menuItemQuery: query });
-        const result = await provider.getMenuItems(query);
-        set({ menuItems: result.data, menuItemsTotal: result.total, menuItemsLoading: false });
-      });
+    async createMenu(input) {
+      const { data, error } = await db().from(T.menus).insert({
+        tenant_id: tenant(),
+        name: input.name,
+        description: input.description ?? null,
+        is_active: input.isActive ?? true,
+        sort_order: input.sortOrder ?? await nextOrder(T.menus, "tenant_id", tenant() ?? ""),
+        channels: input.channels ?? ["pos", "delivery", "digital"],
+        availability: input.availability ?? {}
+      }).select().single();
+      fail(error);
+      return rowToMenu(data);
     },
-    async fetchModifierGroups() {
-      return dedup("menu:modifiers", async () => {
-        set({ modifiersLoading: true });
-        const modifierGroups = await provider.getModifierGroups();
-        set({ modifierGroups, modifiersLoading: false });
-      });
+    async updateMenu(id, patch) {
+      const row = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+      if (patch.name !== void 0) row.name = patch.name;
+      if (patch.description !== void 0) row.description = patch.description;
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      if (patch.sortOrder !== void 0) row.sort_order = patch.sortOrder;
+      if (patch.channels !== void 0) row.channels = patch.channels;
+      if (patch.availability !== void 0) row.availability = patch.availability;
+      const { data, error } = await db().from(T.menus).update(row).eq("id", id).select().single();
+      fail(error);
+      return rowToMenu(data);
     },
-    async fetchSummary() {
-      return dedup("menu:summary", async () => {
-        set({ summaryLoading: true });
-        const summary = await provider.getSummary();
-        set({ summary, summaryLoading: false });
+    async deleteMenu(id) {
+      const { error } = await db().from(T.menus).delete().eq("id", id);
+      fail(error);
+    },
+    async duplicateMenu(id, name) {
+      const { data: source, error } = await db().from(T.menus).select("*").eq("id", id).single();
+      fail(error);
+      const copy = await provider.createMenu({
+        name,
+        description: source.description ?? void 0,
+        channels: source.channels,
+        availability: source.availability,
+        isActive: false
+        // a copy starts off-air: it is edited before it is served
       });
+      const sections = await provider.getSections(id);
+      const placements = await provider.getPlacements(id);
+      for (const section of sections) {
+        const clone = await provider.createSection({
+          menuId: copy.id,
+          name: section.name,
+          description: section.description,
+          imageUrl: section.imageUrl,
+          sortOrder: section.sortOrder,
+          isActive: section.isActive,
+          availability: section.availability
+        });
+        const mine = placements.filter((p) => p.sectionId === section.id);
+        for (const placement of mine) {
+          await provider.placeItem({
+            sectionId: clone.id,
+            itemId: placement.itemId,
+            sortOrder: placement.sortOrder,
+            priceOverride: placement.priceOverride,
+            isActive: placement.isActive
+          });
+        }
+      }
+      return copy;
+    },
+    async reorderMenus(ids) {
+      await Promise.all(ids.map((id, index) => db().from(T.menus).update({ sort_order: index }).eq("id", id)));
+    },
+    // --- Sections ----------------------------------------------------------
+    async getSections(menuId) {
+      const { data, error } = await db().from(T.sections).select("*").eq("menu_id", menuId).order("sort_order", { ascending: true });
+      fail(error);
+      return (data ?? []).map(rowToSection);
+    },
+    async createSection(input) {
+      const { data, error } = await db().from(T.sections).insert({
+        tenant_id: tenant(),
+        menu_id: input.menuId,
+        name: input.name,
+        description: input.description ?? null,
+        image_url: input.imageUrl ?? null,
+        sort_order: input.sortOrder ?? await nextOrder(T.sections, "menu_id", input.menuId),
+        is_active: input.isActive ?? true,
+        availability: input.availability ?? {}
+      }).select().single();
+      fail(error);
+      return rowToSection(data);
+    },
+    async updateSection(id, patch) {
+      const row = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+      if (patch.name !== void 0) row.name = patch.name;
+      if (patch.description !== void 0) row.description = patch.description;
+      if (patch.imageUrl !== void 0) row.image_url = patch.imageUrl;
+      if (patch.sortOrder !== void 0) row.sort_order = patch.sortOrder;
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      if (patch.availability !== void 0) row.availability = patch.availability;
+      const { data, error } = await db().from(T.sections).update(row).eq("id", id).select().single();
+      fail(error);
+      return rowToSection(data);
+    },
+    async deleteSection(id) {
+      const { error } = await db().from(T.sections).delete().eq("id", id);
+      fail(error);
+    },
+    async reorderSections(_menuId, ids) {
+      await Promise.all(ids.map((id, index) => db().from(T.sections).update({ sort_order: index }).eq("id", id)));
+    },
+    // --- Placements --------------------------------------------------------
+    async getPlacements(menuId) {
+      const { data: sections } = await db().from(T.sections).select("id").eq("menu_id", menuId);
+      const ids = (sections ?? []).map((s) => s.id);
+      if (ids.length === 0) return [];
+      const { data, error } = await db().from(T.placements).select("*").in("section_id", ids).order("sort_order", { ascending: true });
+      fail(error);
+      return (data ?? []).map(rowToPlacement);
+    },
+    async placeItem(input) {
+      const { data, error } = await db().from(T.placements).upsert({
+        tenant_id: tenant(),
+        section_id: input.sectionId,
+        item_id: input.itemId,
+        sort_order: input.sortOrder ?? await nextOrder(T.placements, "section_id", input.sectionId),
+        price_override: input.priceOverride ?? null,
+        is_active: input.isActive ?? true
+      }, { onConflict: "section_id,item_id" }).select().single();
+      fail(error);
+      return rowToPlacement(data);
+    },
+    async updatePlacement(id, patch) {
+      const row = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+      if (patch.sectionId !== void 0) row.section_id = patch.sectionId;
+      if (patch.sortOrder !== void 0) row.sort_order = patch.sortOrder;
+      if (patch.priceOverride !== void 0) row.price_override = patch.priceOverride;
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      const { data, error } = await db().from(T.placements).update(row).eq("id", id).select().single();
+      fail(error);
+      return rowToPlacement(data);
+    },
+    async removePlacement(id) {
+      const { error } = await db().from(T.placements).delete().eq("id", id);
+      fail(error);
+    },
+    async reorderPlacements(_sectionId, placementIds) {
+      await Promise.all(placementIds.map((id, index) => db().from(T.placements).update({ sort_order: index }).eq("id", id)));
+    },
+    async movePlacement(placementId2, toSectionId, toIndex) {
+      const { error } = await db().from(T.placements).update({ section_id: toSectionId, sort_order: toIndex, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", placementId2);
+      fail(error);
+    },
+    // --- Media -------------------------------------------------------------
+    async uploadImage(file, kind) {
+      const tenantId = tenant();
+      if (!tenantId) throw new Error("No active workspace for the upload");
+      const ext = (file.name.split(".").pop() ?? "jpg").toLowerCase().replace(/[^a-z0-9]/g, "") || "jpg";
+      const path = `${tenantId}/${kind}/${crypto.randomUUID()}.${ext}`;
+      const { error } = await db().storage.from(T.mediaBucket).upload(path, file, { contentType: file.type, upsert: false });
+      fail(error);
+      const { data } = db().storage.from(T.mediaBucket).getPublicUrl(path);
+      return data.publicUrl;
+    },
+    // --- Categories (legacy flat grouping, still readable) -----------------
+    async getCategories() {
+      const { data, error } = await db().from(T.categories).select("*").eq("kind", CATEGORY_KIND).order("sort_order", { ascending: true });
+      fail(error);
+      return (data ?? []).map(rowToCategory);
+    },
+    async getCategoryById(id) {
+      const { data } = await db().from(T.categories).select("*").eq("id", id).maybeSingle();
+      return data ? rowToCategory(data) : null;
+    },
+    async createCategory(input) {
+      const { data, error } = await db().from(T.categories).insert({
+        tenant_id: tenant(),
+        kind: CATEGORY_KIND,
+        name: input.name,
+        parent_id: input.parentId ?? null,
+        icon: input.icon ?? null,
+        color: input.color ?? null,
+        sort_order: input.sortOrder ?? 0,
+        is_active: true
+      }).select().single();
+      fail(error);
+      return rowToCategory(data);
+    },
+    async updateCategory(id, patch) {
+      const row = {};
+      if (patch.name !== void 0) row.name = patch.name;
+      if (patch.sortOrder !== void 0) row.sort_order = patch.sortOrder;
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      if (patch.icon !== void 0) row.icon = patch.icon;
+      if (patch.color !== void 0) row.color = patch.color;
+      const { data, error } = await db().from(T.categories).update(row).eq("id", id).select().single();
+      fail(error);
+      return rowToCategory(data);
+    },
+    async deleteCategory(id) {
+      const { error } = await db().from(T.categories).delete().eq("id", id);
+      fail(error);
+    },
+    async reorderCategories(ids) {
+      await Promise.all(ids.map((id, index) => db().from(T.categories).update({ sort_order: index }).eq("id", id)));
+    },
+    // --- Items -------------------------------------------------------------
+    async getMenuItems(query) {
+      let qb = db().from(T.products).select(`*, ${T.items}!inner(*)`, { count: "exact" });
+      if (query.search) qb = qb.ilike("name", `%${query.search}%`);
+      if (query.categoryId) qb = qb.eq("category_id", query.categoryId);
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status];
+        qb = qb.in(`${T.items}.status`, statuses);
+      }
+      if (query.availableForPos !== void 0) qb = qb.eq(`${T.items}.available_for_pos`, query.availableForPos);
+      if (query.availableForDelivery !== void 0) qb = qb.eq(`${T.items}.available_for_delivery`, query.availableForDelivery);
+      if (query.isFeatured !== void 0) qb = qb.eq(`${T.items}.is_featured`, query.isFeatured);
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 200;
+      qb = qb.range((page - 1) * pageSize, page * pageSize - 1).order("name", { ascending: true });
+      const { data, count, error } = await qb;
+      fail(error);
+      return { data: (data ?? []).map((row) => rowToItem(row, currency)), total: count ?? 0 };
+    },
+    async getMenuItemById(id) {
+      const { data } = await db().from(T.products).select(`*, ${T.items}(*)`).eq("id", id).maybeSingle();
+      return data ? rowToItem(data, currency) : null;
     },
     async createMenuItem(input) {
-      try {
-        const item = await provider.createMenuItem(input);
-        const query = get().menuItemQuery;
-        const [result, summary] = await Promise.all([provider.getMenuItems(query), provider.getSummary()]);
-        set({ menuItems: result.data, menuItemsTotal: result.total, summary });
-        toast.success("Menu item created");
-        return item;
-      } catch (err) {
-        toast.error("Failed to create menu item", { description: err?.message });
-        throw err;
+      const tenantId = tenant();
+      const { data: product, error } = await db().from(T.products).insert({
+        tenant_id: tenantId,
+        name: input.name,
+        description: input.description ?? null,
+        price: input.price ?? 0,
+        cost: input.cost ?? 0,
+        image_url: input.imageUrl ?? null,
+        category_id: input.categoryId ?? null,
+        is_active: true,
+        metadata: { productType: "sale" }
+      }).select().single();
+      fail(error);
+      const { error: extError } = await db().from(T.items).insert({
+        product_id: product.id,
+        tenant_id: tenantId,
+        status: input.status ?? "available",
+        available_for_pos: input.availableForPos ?? true,
+        available_for_delivery: input.availableForDelivery ?? true,
+        delivery_price: input.deliveryPrice ?? null,
+        prep_time_minutes: input.prepTimeMinutes ?? null,
+        allergens: input.allergens ?? [],
+        dietary_tags: input.dietaryTags ?? [],
+        is_featured: input.isFeatured ?? false
+      });
+      if (extError) {
+        await db().from(T.products).delete().eq("id", product.id);
+        throw new Error(extError.message);
+      }
+      if (input.sectionId) {
+        await provider.placeItem({ sectionId: input.sectionId, itemId: product.id });
       }
+      return await provider.getMenuItemById(product.id);
     },
-    async updateMenuItem(id, data) {
-      try {
-        const item = await provider.updateMenuItem(id, data);
-        const query = get().menuItemQuery;
-        const result = await provider.getMenuItems(query);
-        set({ menuItems: result.data, menuItemsTotal: result.total });
-        toast.success("Menu item updated");
-        return item;
-      } catch (err) {
-        toast.error("Failed to update menu item", { description: err?.message });
-        throw err;
+    async updateMenuItem(id, patch) {
+      const spine = {};
+      if (patch.name !== void 0) spine.name = patch.name;
+      if (patch.description !== void 0) spine.description = patch.description;
+      if (patch.price !== void 0) spine.price = patch.price;
+      if (patch.cost !== void 0) spine.cost = patch.cost;
+      if (patch.imageUrl !== void 0) spine.image_url = patch.imageUrl;
+      if (patch.categoryId !== void 0) spine.category_id = patch.categoryId ?? null;
+      if (Object.keys(spine).length > 0) {
+        const { error } = await db().from(T.products).update(spine).eq("id", id);
+        fail(error);
       }
+      const ext = {};
+      if (patch.status !== void 0) ext.status = patch.status;
+      if (patch.availableForPos !== void 0) ext.available_for_pos = patch.availableForPos;
+      if (patch.availableForDelivery !== void 0) ext.available_for_delivery = patch.availableForDelivery;
+      if (patch.deliveryPrice !== void 0) ext.delivery_price = patch.deliveryPrice;
+      if (patch.prepTimeMinutes !== void 0) ext.prep_time_minutes = patch.prepTimeMinutes;
+      if (patch.allergens !== void 0) ext.allergens = patch.allergens;
+      if (patch.dietaryTags !== void 0) ext.dietary_tags = patch.dietaryTags;
+      if (patch.isFeatured !== void 0) ext.is_featured = patch.isFeatured;
+      if (Object.keys(ext).length > 0) {
+        ext.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        const { error } = await db().from(T.items).upsert({ product_id: id, tenant_id: tenant(), ...ext }, { onConflict: "product_id" });
+        fail(error);
+      }
+      return await provider.getMenuItemById(id);
     },
     async deleteMenuItem(id) {
-      try {
-        await provider.deleteMenuItem(id);
-        const query = get().menuItemQuery;
-        const [result, summary] = await Promise.all([provider.getMenuItems(query), provider.getSummary()]);
-        set({ menuItems: result.data, menuItemsTotal: result.total, summary });
-        toast.success("Menu item deleted");
-      } catch (err) {
-        toast.error("Failed to delete menu item", { description: err?.message });
-        throw err;
-      }
+      const { error } = await db().from(T.items).delete().eq("product_id", id);
+      fail(error);
+      await db().from(T.placements).delete().eq("item_id", id);
     },
     async toggleAvailability(id, field, value) {
-      try {
-        await provider.toggleAvailability(id, field, value);
-        const query = get().menuItemQuery;
-        const result = await provider.getMenuItems(query);
-        set({ menuItems: result.data, menuItemsTotal: result.total });
-      } catch (err) {
-        toast.error("Failed to update availability", { description: err?.message });
-        throw err;
-      }
+      const column = field === "status" ? "status" : field === "availableForPos" ? "available_for_pos" : field === "isFeatured" ? "is_featured" : "available_for_delivery";
+      const { error } = await db().from(T.items).upsert(
+        { product_id: id, tenant_id: tenant(), [column]: value, updated_at: (/* @__PURE__ */ new Date()).toISOString() },
+        { onConflict: "product_id" }
+      );
+      fail(error);
+      return await provider.getMenuItemById(id);
     },
-    async createCategory(input) {
+    async reorderItems(_categoryId, ids) {
+      await Promise.all(ids.map((id, index) => db().from(T.items).update({ sort_order: index }).eq("product_id", id)));
+    },
+    // --- Modifier groups ---------------------------------------------------
+    async getModifierGroups() {
+      const { data, error } = await db().from(T.modifierGroups).select(`*, ${T.modifiers}(*)`).order("sort_order", { ascending: true });
+      fail(error);
+      return (data ?? []).map((row) => ({
+        id: row.id,
+        name: row.name,
+        minSelections: row.min_selections ?? 0,
+        maxSelections: row.max_selections ?? 1,
+        isRequired: row.is_required ?? false,
+        sortOrder: row.sort_order ?? 0,
+        items: (row[T.modifiers] ?? []).map((m) => ({
+          id: m.id,
+          groupId: m.group_id,
+          name: m.name,
+          priceAdjustment: Number(m.price_adjustment ?? 0),
+          isActive: m.is_active ?? true,
+          sortOrder: m.sort_order ?? 0
+        })),
+        tenantId: row.tenant_id,
+        createdAt: row.created_at
+      }));
+    },
+    async createModifierGroup(input) {
+      const { data, error } = await db().from(T.modifierGroups).insert({
+        tenant_id: tenant(),
+        name: input.name ?? "Grupo",
+        min_selections: input.minSelections ?? 0,
+        max_selections: input.maxSelections ?? 1,
+        is_required: input.isRequired ?? false,
+        sort_order: input.sortOrder ?? 0
+      }).select().single();
+      fail(error);
+      return { ...data, items: [], minSelections: data.min_selections, maxSelections: data.max_selections, isRequired: data.is_required, sortOrder: data.sort_order, tenantId: data.tenant_id, createdAt: data.created_at };
+    },
+    async updateModifierGroup(id, patch) {
+      const row = {};
+      if (patch.name !== void 0) row.name = patch.name;
+      if (patch.minSelections !== void 0) row.min_selections = patch.minSelections;
+      if (patch.maxSelections !== void 0) row.max_selections = patch.maxSelections;
+      if (patch.isRequired !== void 0) row.is_required = patch.isRequired;
+      if (patch.sortOrder !== void 0) row.sort_order = patch.sortOrder;
+      const { error } = await db().from(T.modifierGroups).update(row).eq("id", id);
+      fail(error);
+      const groups = await provider.getModifierGroups();
+      return groups.find((g) => g.id === id);
+    },
+    async deleteModifierGroup(id) {
+      const { error } = await db().from(T.modifierGroups).delete().eq("id", id);
+      fail(error);
+    },
+    // --- Summary -----------------------------------------------------------
+    async getSummary() {
+      const [{ data: items }, { data: sections }] = await Promise.all([
+        db().from(T.items).select("status, is_featured"),
+        db().from(T.sections).select("id")
+      ]);
+      const { data: prices } = await db().from(T.products).select(`price, ${T.items}!inner(product_id)`);
+      const rows = items ?? [];
+      const priceList = (prices ?? []).map((p) => Number(p.price ?? 0));
+      return {
+        totalItems: rows.length,
+        availableItems: rows.filter((r) => r.status === "available").length,
+        soldOutItems: rows.filter((r) => r.status === "sold_out").length,
+        hiddenItems: rows.filter((r) => r.status === "hidden").length,
+        categoryCount: (sections ?? []).length,
+        averagePrice: priceList.length ? priceList.reduce((a, b) => a + b, 0) / priceList.length : 0,
+        featuredCount: rows.filter((r) => r.is_featured).length
+      };
+    }
+  };
+  return provider;
+}
+
+// src/migrations/index.ts
+var MIGRATION_001_MENU_BASE = `-- Menu Plugin: base tables.
+--
+-- Three levels, because a restaurant does not have "a menu": it has a lunch
+-- menu, a weekend menu and a delivery menu, and the same dish appears in more
+-- than one of them at more than one price.
+--   plg_menu_menus       \u2014 the menu itself, with when and where it is served
+--   plg_menu_sections    \u2014 ordered sections inside a menu
+--   plg_menu_placements  \u2014 an item's seat in a section (order + price override)
+-- Items stay in public.products (the spine); plg_menu_items carries only what
+-- is menu-specific about a product.
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_menus (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  description text,
+  is_active boolean NOT NULL DEFAULT true,
+  sort_order integer NOT NULL DEFAULT 0,
+  -- Where it shows: pos | delivery | digital.
+  channels text[] NOT NULL DEFAULT ARRAY['pos','delivery','digital']::text[],
+  -- { days:[0..6], start:'HH:MM', end:'HH:MM', from:'YYYY-MM-DD', to:'YYYY-MM-DD' }
+  -- An empty object means "always", which is the common case.
+  availability jsonb NOT NULL DEFAULT '{}'::jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_menus ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_menus_tenant ON public.plg_menu_menus(tenant_id, sort_order);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_sections (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  menu_id uuid NOT NULL REFERENCES public.plg_menu_menus(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  description text,
+  image_url text,
+  sort_order integer NOT NULL DEFAULT 0,
+  is_active boolean NOT NULL DEFAULT true,
+  availability jsonb NOT NULL DEFAULT '{}'::jsonb,
+  -- Set when the section was adopted from a legacy flat category, so the
+  -- backfill can run twice without doubling the sections.
+  legacy_category_id uuid,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_sections ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_sections_menu ON public.plg_menu_sections(menu_id, sort_order);
+CREATE INDEX IF NOT EXISTS idx_plg_menu_sections_tenant ON public.plg_menu_sections(tenant_id);
+CREATE UNIQUE INDEX IF NOT EXISTS uq_plg_menu_sections_legacy ON public.plg_menu_sections(menu_id, legacy_category_id)
+  WHERE legacy_category_id IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_placements (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  section_id uuid NOT NULL REFERENCES public.plg_menu_sections(id) ON DELETE CASCADE,
+  item_id uuid NOT NULL REFERENCES public.products(id) ON DELETE CASCADE,
+  sort_order integer NOT NULL DEFAULT 0,
+  price_override numeric(14,2),
+  is_active boolean NOT NULL DEFAULT true,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_placements ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_placements_section ON public.plg_menu_placements(section_id, sort_order);
+CREATE INDEX IF NOT EXISTS idx_plg_menu_placements_item ON public.plg_menu_placements(item_id);
+CREATE UNIQUE INDEX IF NOT EXISTS uq_plg_menu_placements_seat ON public.plg_menu_placements(section_id, item_id);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_items (
+  product_id uuid PRIMARY KEY REFERENCES public.products(id) ON DELETE CASCADE,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  status text NOT NULL DEFAULT 'available',
+  available_for_pos boolean NOT NULL DEFAULT true,
+  available_for_delivery boolean NOT NULL DEFAULT true,
+  delivery_price numeric(14,2),
+  prep_time_minutes integer,
+  allergens text[] NOT NULL DEFAULT ARRAY[]::text[],
+  dietary_tags text[] NOT NULL DEFAULT ARRAY[]::text[],
+  is_featured boolean NOT NULL DEFAULT false,
+  sort_order integer NOT NULL DEFAULT 0,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_items ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_items_tenant ON public.plg_menu_items(tenant_id);
+
+-- Modifier groups (add-ons): declared by the plugin's registries, owned here.
+CREATE TABLE IF NOT EXISTS public.plg_menu_modifier_groups (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  min_selections integer NOT NULL DEFAULT 0,
+  max_selections integer NOT NULL DEFAULT 1,
+  is_required boolean NOT NULL DEFAULT false,
+  sort_order integer NOT NULL DEFAULT 0,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_modifier_groups ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_modifier_groups_tenant ON public.plg_menu_modifier_groups(tenant_id);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_modifiers (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  group_id uuid NOT NULL REFERENCES public.plg_menu_modifier_groups(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  price_adjustment numeric(14,2) NOT NULL DEFAULT 0,
+  is_active boolean NOT NULL DEFAULT true,
+  sort_order integer NOT NULL DEFAULT 0,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_modifiers ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_modifiers_group ON public.plg_menu_modifiers(group_id, sort_order);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_item_modifier_groups (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  product_id uuid NOT NULL REFERENCES public.products(id) ON DELETE CASCADE,
+  group_id uuid NOT NULL REFERENCES public.plg_menu_modifier_groups(id) ON DELETE CASCADE,
+  sort_order integer NOT NULL DEFAULT 0
+);
+ALTER TABLE public.plg_menu_item_modifier_groups ENABLE ROW LEVEL SECURITY;
+CREATE UNIQUE INDEX IF NOT EXISTS uq_plg_menu_item_modifier_groups ON public.plg_menu_item_modifier_groups(product_id, group_id);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_allergens (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  icon text,
+  is_active boolean NOT NULL DEFAULT true,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_allergens ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_allergens_tenant ON public.plg_menu_allergens(tenant_id);
+
+CREATE TABLE IF NOT EXISTS public.plg_menu_dietary_tags (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  color text,
+  is_active boolean NOT NULL DEFAULT true,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_menu_dietary_tags ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_plg_menu_dietary_tags_tenant ON public.plg_menu_dietary_tags(tenant_id);
+
+-- Canonical per-tenant RLS + grants for every table above.
+DO $$
+DECLARE t text;
+BEGIN
+  FOR t IN SELECT unnest(ARRAY[
+    'plg_menu_menus','plg_menu_sections','plg_menu_placements','plg_menu_items',
+    'plg_menu_modifier_groups','plg_menu_modifiers','plg_menu_item_modifier_groups',
+    'plg_menu_allergens','plg_menu_dietary_tags'
+  ])
+  LOOP
+    EXECUTE format('ALTER TABLE public.%I ENABLE ROW LEVEL SECURITY', t);
+    EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON public.%I TO authenticated', t);
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename=t AND policyname=t||'_select') THEN
+      EXECUTE format('CREATE POLICY %I ON public.%I FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()))', t||'_select', t);
+    END IF;
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename=t AND policyname=t||'_insert') THEN
+      EXECUTE format('CREATE POLICY %I ON public.%I FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()))', t||'_insert', t);
+    END IF;
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename=t AND policyname=t||'_update') THEN
+      EXECUTE format('CREATE POLICY %I ON public.%I FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()))', t||'_update', t);
+    END IF;
+    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename=t AND policyname=t||'_delete') THEN
+      EXECUTE format('CREATE POLICY %I ON public.%I FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()))', t||'_delete', t);
+    END IF;
+  END LOOP;
+END $$;
+`;
+var MIGRATION_002_MENU_BACKFILL = `-- Menu Plugin: adopt whatever menu already exists in the pool.
+--
+-- Pools that ran the incubator version of this plugin have a flat world:
+-- categories in public.categories (kind='menu_category'), item flags in a
+-- public.menu_items extension, and no menus at all. Rather than ask the
+-- restaurant to type its menu again, the first menu is BUILT from that data:
+-- one "Card\xE1pio principal" per tenant, its sections are the old categories, and
+-- every product already sitting in a category takes its seat.
+--
+-- Every step is guarded twice: by the existence of the legacy object (a fresh
+-- pool has none of it) and by a NOT EXISTS on the target, so re-applying does
+-- nothing. The legacy tables are never written to or dropped \u2014 an app still
+-- reading them keeps working.
+
+DO $$
+DECLARE
+  has_categories boolean := to_regclass('public.categories') IS NOT NULL;
+  has_legacy_items boolean := to_regclass('public.menu_items') IS NOT NULL;
+  has_products boolean := to_regclass('public.products') IS NOT NULL;
+  has_category_kind boolean := EXISTS (
+    SELECT 1 FROM information_schema.columns
+    WHERE table_schema='public' AND table_name='categories' AND column_name='kind'
+  );
+  has_product_category boolean := EXISTS (
+    SELECT 1 FROM information_schema.columns
+    WHERE table_schema='public' AND table_name='products' AND column_name='category_id'
+  );
+BEGIN
+  -- 1. One default menu per tenant that has menu categories or menu items.
+  IF has_categories AND has_category_kind THEN
+    EXECUTE $sql$
+      INSERT INTO public.plg_menu_menus (tenant_id, name, description, sort_order)
+      SELECT DISTINCT c.tenant_id, 'Card\xE1pio principal', NULL, 0
+      FROM public.categories c
+      WHERE c.kind = 'menu_category'
+        AND c.tenant_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM public.plg_menu_menus m WHERE m.tenant_id = c.tenant_id)
+    $sql$;
+  END IF;
+
+  IF has_legacy_items THEN
+    EXECUTE $sql$
+      INSERT INTO public.plg_menu_menus (tenant_id, name, description, sort_order)
+      SELECT DISTINCT mi.tenant_id, 'Card\xE1pio principal', NULL, 0
+      FROM public.menu_items mi
+      WHERE mi.tenant_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM public.plg_menu_menus m WHERE m.tenant_id = mi.tenant_id)
+    $sql$;
+  END IF;
+
+  -- 2. Sections from the flat categories, keeping name and order.
+  IF has_categories AND has_category_kind THEN
+    EXECUTE $sql$
+      INSERT INTO public.plg_menu_sections (tenant_id, menu_id, name, sort_order, is_active, legacy_category_id)
+      SELECT c.tenant_id, m.id, c.name,
+             COALESCE(NULLIF(c.sort_order, 0), row_number() OVER (PARTITION BY c.tenant_id ORDER BY c.sort_order, c.name)),
+             COALESCE(c.is_active, true), c.id
+      FROM public.categories c
+      JOIN public.plg_menu_menus m
+        ON m.tenant_id = c.tenant_id AND m.sort_order = 0
+      WHERE c.kind = 'menu_category'
+        AND NOT EXISTS (
+          SELECT 1 FROM public.plg_menu_sections s
+          WHERE s.menu_id = m.id AND s.legacy_category_id = c.id
+        )
+    $sql$;
+  END IF;
+
+  -- 3. Seat every product that already belongs to one of those categories.
+  IF has_products AND has_product_category AND has_categories AND has_category_kind THEN
+    EXECUTE $sql$
+      INSERT INTO public.plg_menu_placements (tenant_id, section_id, item_id, sort_order)
+      SELECT p.tenant_id, s.id, p.id,
+             row_number() OVER (PARTITION BY s.id ORDER BY p.name)
+      FROM public.products p
+      JOIN public.plg_menu_sections s ON s.legacy_category_id = p.category_id AND s.tenant_id = p.tenant_id
+      WHERE NOT EXISTS (
+        SELECT 1 FROM public.plg_menu_placements pl
+        WHERE pl.section_id = s.id AND pl.item_id = p.id
+      )
+    $sql$;
+  END IF;
+
+  -- 4. Carry the menu-specific item flags over from the legacy extension.
+  IF has_legacy_items THEN
+    EXECUTE $sql$
+      INSERT INTO public.plg_menu_items (
+        product_id, tenant_id, status, available_for_pos, available_for_delivery,
+        delivery_price, prep_time_minutes, allergens, dietary_tags, is_featured, sort_order
+      )
+      SELECT mi.product_id, mi.tenant_id,
+             COALESCE(mi.status, 'available'),
+             COALESCE(mi.available_for_pos, true),
+             COALESCE(mi.available_for_delivery, true),
+             mi.delivery_price, mi.prep_time_minutes,
+             COALESCE(mi.allergens, ARRAY[]::text[]),
+             COALESCE(mi.dietary_tags, ARRAY[]::text[]),
+             COALESCE(mi.is_featured, false),
+             COALESCE(mi.sort_order, 0)
+      FROM public.menu_items mi
+      WHERE mi.tenant_id IS NOT NULL
+      ON CONFLICT (product_id) DO NOTHING
+    $sql$;
+  END IF;
+END $$;
+
+-- Seed the allergen / dietary registries once per tenant that has a menu.
+INSERT INTO public.plg_menu_allergens (tenant_id, name, icon)
+SELECT m.tenant_id, v.name, v.icon
+FROM (SELECT DISTINCT tenant_id FROM public.plg_menu_menus) m
+CROSS JOIN (VALUES
+  ('Gl\xFAten', 'Wheat'), ('Lactose', 'Milk'), ('Ovos', 'Egg'),
+  ('Amendoim', 'Nut'), ('Frutos do mar', 'Fish'), ('Soja', 'Bean')
+) AS v(name, icon)
+WHERE NOT EXISTS (
+  SELECT 1 FROM public.plg_menu_allergens a WHERE a.tenant_id = m.tenant_id AND a.name = v.name
+);
+
+INSERT INTO public.plg_menu_dietary_tags (tenant_id, name, color)
+SELECT m.tenant_id, v.name, v.color
+FROM (SELECT DISTINCT tenant_id FROM public.plg_menu_menus) m
+CROSS JOIN (VALUES
+  ('Vegetariano', 'green'), ('Vegano', 'emerald'), ('Sem gl\xFAten', 'amber')
+) AS v(name, color)
+WHERE NOT EXISTS (
+  SELECT 1 FROM public.plg_menu_dietary_tags d WHERE d.tenant_id = m.tenant_id AND d.name = v.name
+);
+`;
+var MIGRATION_003_MENU_STORAGE = `-- Menu Plugin: bucket for item, section and import photos.
+--
+-- Public on read: these images are the menu the customer looks at, and a signed
+-- URL per dish would mean re-signing the whole menu on every render. Writing is
+-- the guarded half \u2014 only a member of the tenant whose folder it is.
+-- Path grammar: {tenant_id}/{item|section|menu|import}/{uuid}.{ext}
+
+INSERT INTO storage.buckets (id, name, public, file_size_limit, allowed_mime_types)
+VALUES (
+  'menu-images',
+  'menu-images',
+  true,
+  8388608, -- 8 MB: a phone photo of a menu page, already compressed by the client
+  ARRAY['image/jpeg','image/png','image/webp','image/heic','image/heif']
+)
+ON CONFLICT (id) DO UPDATE SET
+  public             = EXCLUDED.public,
+  file_size_limit    = EXCLUDED.file_size_limit,
+  allowed_mime_types = EXCLUDED.allowed_mime_types;
+
+DROP POLICY IF EXISTS plg_menu_images_read ON storage.objects;
+DROP POLICY IF EXISTS plg_menu_images_insert ON storage.objects;
+DROP POLICY IF EXISTS plg_menu_images_update ON storage.objects;
+DROP POLICY IF EXISTS plg_menu_images_delete ON storage.objects;
+
+CREATE POLICY plg_menu_images_read ON storage.objects
+  FOR SELECT TO anon, authenticated
+  USING (bucket_id = 'menu-images');
+
+CREATE POLICY plg_menu_images_insert ON storage.objects
+  FOR INSERT TO authenticated
+  WITH CHECK (
+    bucket_id = 'menu-images'
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+
+CREATE POLICY plg_menu_images_update ON storage.objects
+  FOR UPDATE TO authenticated
+  USING (
+    bucket_id = 'menu-images'
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+
+CREATE POLICY plg_menu_images_delete ON storage.objects
+  FOR DELETE TO authenticated
+  USING (
+    bucket_id = 'menu-images'
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+`;
+var MIGRATION_004_THE_MENU_DECLARES_ITS_SPECIES = `-- ---------------------------------------------------------------------------
+-- 004_the_menu_declares_its_species.sql \u2014 the card\xE1pio's taxonomy becomes a row
+-- (#274, ADR 0017).
+--
+-- The base owns the FORM of a Category; this plugin owns the species of it that
+-- a restaurant has. 147 named this case explicitly and left the declaring here,
+-- which is the rule the registry exists to make enforceable: a species is
+-- written by a plugin, in a row, with a foreign key behind it \u2014 not chosen as a
+-- literal and hoped to be unique.
+-- ---------------------------------------------------------------------------
+
+DO $$
+BEGIN
+  IF to_regprocedure('public.register_kind(text, text, text, text[], jsonb, text)') IS NULL THEN
+    RAISE NOTICE 'plugin-menu 004: register_kind missing (spine < 147) \u2014 skipped';
+    RETURN;
+  END IF;
+
+  PERFORM public.register_kind(
+    'category', 'menu_category', 'menu', NULL, NULL,
+    'Uma se\xE7\xE3o do card\xE1pio: entradas, pratos, bebidas, sobremesas.');
+END $$;
+`;
+var MIGRATIONS = [
+  { id: "001_menu_base", sql: MIGRATION_001_MENU_BASE },
+  { id: "002_menu_backfill", sql: MIGRATION_002_MENU_BACKFILL },
+  { id: "003_menu_storage", sql: MIGRATION_003_MENU_STORAGE },
+  { id: "004_the_menu_declares_its_species", sql: MIGRATION_004_THE_MENU_DECLARES_ITS_SPECIES }
+];
+
+// src/data/types.ts
+function supportsMenus(provider) {
+  return typeof provider.getMenus === "function" && typeof provider.createSection === "function";
+}
+
+// src/data/legacy-adapter.ts
+var LEGACY_MENU_ID = "__default__";
+var placementId = (itemId) => `legacy:${itemId}`;
+var itemIdOf = (placement) => placement.replace(/^legacy:/, "");
+function unsupported(what) {
+  throw new Error(`[menu] This workspace's menu backend does not support ${what} yet.`);
+}
+function wrapLegacyProvider(provider) {
+  async function allItems() {
+    const result = await provider.getMenuItems({ pageSize: 1e3 });
+    return result.data;
+  }
+  const legacyMenu = async () => {
+    const [categories, items] = await Promise.all([provider.getCategories(), allItems()]);
+    const first = items[0];
+    return {
+      id: LEGACY_MENU_ID,
+      name: "Card\xE1pio principal",
+      isActive: true,
+      sortOrder: 0,
+      channels: ["pos", "delivery", "digital"],
+      availability: {},
+      sectionCount: categories.length,
+      itemCount: items.length,
+      tenantId: first?.tenantId ?? "",
+      createdAt: first?.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      updatedAt: first?.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  };
+  const overrides = {
+    async getMenus() {
+      return [await legacyMenu()];
+    },
+    async createMenu() {
+      unsupported("multiple menus");
+    },
+    async updateMenu() {
+      unsupported("multiple menus");
+    },
+    async deleteMenu() {
+      unsupported("multiple menus");
+    },
+    async duplicateMenu() {
+      unsupported("multiple menus");
+    },
+    async reorderMenus() {
+    },
+    async getSections() {
+      const categories = await provider.getCategories();
+      return categories.map((c) => ({
+        id: c.id,
+        menuId: LEGACY_MENU_ID,
+        name: c.name,
+        sortOrder: c.sortOrder,
+        isActive: c.isActive,
+        tenantId: c.tenantId,
+        createdAt: c.createdAt,
+        updatedAt: c.updatedAt
+      }));
+    },
+    async createSection(input) {
+      const category = await provider.createCategory({ name: input.name, sortOrder: input.sortOrder });
+      return {
+        id: category.id,
+        menuId: LEGACY_MENU_ID,
+        name: category.name,
+        sortOrder: category.sortOrder,
+        isActive: category.isActive,
+        tenantId: category.tenantId,
+        createdAt: category.createdAt,
+        updatedAt: category.updatedAt
+      };
+    },
+    async updateSection(id, data) {
+      const category = await provider.updateCategory(id, {
+        name: data.name,
+        sortOrder: data.sortOrder,
+        isActive: data.isActive
+      });
+      return {
+        id: category.id,
+        menuId: LEGACY_MENU_ID,
+        name: category.name,
+        sortOrder: category.sortOrder,
+        isActive: category.isActive,
+        tenantId: category.tenantId,
+        createdAt: category.createdAt,
+        updatedAt: category.updatedAt
+      };
+    },
+    async deleteSection(id) {
+      await provider.deleteCategory(id);
+    },
+    async reorderSections(_menuId, ids) {
+      await provider.reorderCategories(ids);
+    },
+    async getPlacements() {
+      const items = await allItems();
+      return items.filter((item) => !!item.categoryId).map((item) => ({
+        id: placementId(item.id),
+        sectionId: item.categoryId,
+        itemId: item.id,
+        sortOrder: item.sortOrder ?? 0,
+        isActive: item.status !== "hidden",
+        tenantId: item.tenantId
+      }));
+    },
+    async placeItem(input) {
+      await provider.updateMenuItem(input.itemId, { categoryId: input.sectionId });
+      return {
+        id: placementId(input.itemId),
+        sectionId: input.sectionId,
+        itemId: input.itemId,
+        sortOrder: input.sortOrder ?? 0,
+        isActive: input.isActive ?? true,
+        tenantId: ""
+      };
+    },
+    async updatePlacement(id, data) {
+      if (data.sectionId) await provider.updateMenuItem(itemIdOf(id), { categoryId: data.sectionId });
+      return {
+        id,
+        sectionId: data.sectionId ?? "",
+        itemId: itemIdOf(id),
+        sortOrder: data.sortOrder ?? 0,
+        isActive: data.isActive ?? true,
+        tenantId: ""
+      };
+    },
+    async removePlacement(id) {
+      await provider.updateMenuItem(itemIdOf(id), { categoryId: void 0 });
+    },
+    async reorderPlacements(sectionId, placementIds) {
+      await provider.reorderItems(sectionId, placementIds.map(itemIdOf));
+    },
+    async movePlacement(id, toSectionId) {
+      await provider.updateMenuItem(itemIdOf(id), { categoryId: toSectionId });
+    }
+  };
+  return new Proxy({}, {
+    get: (_t, prop) => overrides[prop] ?? provider[prop]
+  });
+}
+
+// src/store.ts
+var optimisticSeq = 0;
+function createMenuStore(rawProvider) {
+  const multiMenu = supportsMenus(rawProvider);
+  const provider = multiMenu ? rawProvider : wrapLegacyProvider(rawProvider);
+  return createStore((set, get) => {
+    async function writeItemField(id, field, value) {
+      const previous = get().menuItems;
+      set({ menuItems: previous.map((i) => i.id === id ? { ...i, [field]: value } : i) });
       try {
-        const category = await provider.createCategory(input);
-        const categories = await provider.getCategories();
-        set({ categories });
-        toast.success("Category created");
-        return category;
+        await provider.toggleAvailability(id, field, value);
       } catch (err) {
-        toast.error("Failed to create category", { description: err?.message });
-        throw err;
+        set({ menuItems: previous });
+        toast.error(tl("Could not update the item", "N\xE3o foi poss\xEDvel atualizar o item"), { description: err?.message });
       }
     }
-  }));
+    return {
+      multiMenu,
+      menus: [],
+      menusLoading: false,
+      activeMenuId: null,
+      sections: [],
+      placements: [],
+      menuLoading: false,
+      pendingIds: [],
+      menuItems: [],
+      menuItemsTotal: 0,
+      menuItemsLoading: false,
+      menuItemQuery: {},
+      modifierGroups: [],
+      modifiersLoading: false,
+      summary: null,
+      summaryLoading: false,
+      // --- Reads -------------------------------------------------------------
+      async fetchMenus() {
+        set({ menusLoading: true });
+        try {
+          const menus = await dedup("menu:menus", () => provider.getMenus());
+          const active = get().activeMenuId && menus.some((m) => m.id === get().activeMenuId) ? get().activeMenuId : menus[0]?.id ?? null;
+          set({ menus, activeMenuId: active, menusLoading: false });
+          if (active) await get().fetchMenuContent(active);
+        } catch (err) {
+          set({ menusLoading: false });
+          toast.error(tl("Could not load the menus", "N\xE3o foi poss\xEDvel carregar os card\xE1pios"), { description: err?.message });
+        }
+      },
+      async openMenu(menuId) {
+        set({ activeMenuId: menuId });
+        await get().fetchMenuContent(menuId);
+      },
+      async fetchMenuContent(menuId) {
+        set({ menuLoading: true });
+        try {
+          const [sections, placements] = await Promise.all([
+            provider.getSections(menuId),
+            provider.getPlacements(menuId)
+          ]);
+          set({ sections, placements, menuLoading: false });
+        } catch (err) {
+          set({ menuLoading: false });
+          toast.error(tl("Could not load the menu", "N\xE3o foi poss\xEDvel carregar o card\xE1pio"), { description: err?.message });
+        }
+      },
+      async fetchMenuItems(query = {}) {
+        set({ menuItemsLoading: true, menuItemQuery: query });
+        try {
+          const result = await provider.getMenuItems(query);
+          set({ menuItems: result.data, menuItemsTotal: result.total, menuItemsLoading: false });
+        } catch (err) {
+          set({ menuItemsLoading: false });
+          toast.error(tl("Could not load the items", "N\xE3o foi poss\xEDvel carregar os itens"), { description: err?.message });
+        }
+      },
+      async fetchModifierGroups() {
+        set({ modifiersLoading: true });
+        try {
+          const modifierGroups = await dedup("menu:modifiers", () => provider.getModifierGroups());
+          set({ modifierGroups, modifiersLoading: false });
+        } catch {
+          set({ modifiersLoading: false, modifierGroups: [] });
+        }
+      },
+      async fetchSummary() {
+        set({ summaryLoading: true });
+        try {
+          const summary = await dedup("menu:summary", () => provider.getSummary());
+          set({ summary, summaryLoading: false });
+        } catch {
+          set({ summaryLoading: false });
+        }
+      },
+      // --- Menus -------------------------------------------------------------
+      async createMenu(input) {
+        const menu = await provider.createMenu(input);
+        set({ menus: [...get().menus, menu] });
+        await get().openMenu(menu.id);
+        toast.success(tl("Menu created", "Card\xE1pio criado"));
+        return menu;
+      },
+      async updateMenu(id, data) {
+        const updated = await provider.updateMenu(id, data);
+        set({ menus: get().menus.map((m) => m.id === id ? { ...m, ...updated } : m) });
+      },
+      async deleteMenu(id) {
+        await provider.deleteMenu(id);
+        const menus = get().menus.filter((m) => m.id !== id);
+        set({ menus });
+        const next = menus[0]?.id ?? null;
+        set({ activeMenuId: next, sections: [], placements: [] });
+        if (next) await get().fetchMenuContent(next);
+        toast.success(tl("Menu deleted", "Card\xE1pio exclu\xEDdo"));
+      },
+      async duplicateMenu(id, name) {
+        const copy = await provider.duplicateMenu(id, name);
+        await get().fetchMenus();
+        await get().openMenu(copy.id);
+        toast.success(tl("Menu duplicated", "Card\xE1pio duplicado"), { description: tl("The copy starts inactive \u2014 publish it when it is ready.", "A c\xF3pia come\xE7a desativada \u2014 publique quando estiver pronta.") });
+        return copy;
+      },
+      // --- Sections ----------------------------------------------------------
+      async createSection(name, extra) {
+        const menuId = get().activeMenuId;
+        if (!menuId) return null;
+        const tempId = `pending-${++optimisticSeq}`;
+        const optimistic = {
+          id: tempId,
+          menuId,
+          name,
+          sortOrder: extra?.sortOrder ?? get().sections.length,
+          isActive: extra?.isActive ?? true,
+          availability: extra?.availability ?? {},
+          tenantId: "",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        set({
+          sections: [...get().sections, optimistic],
+          pendingIds: [...get().pendingIds, tempId]
+        });
+        try {
+          const section = await provider.createSection({ menuId, name, ...extra });
+          set({
+            sections: get().sections.map((s) => s.id === tempId ? section : s),
+            pendingIds: get().pendingIds.filter((id) => id !== tempId)
+          });
+          return section;
+        } catch (err) {
+          set({
+            sections: get().sections.filter((s) => s.id !== tempId),
+            pendingIds: get().pendingIds.filter((id) => id !== tempId)
+          });
+          toast.error(tl("Could not create the section", "N\xE3o foi poss\xEDvel criar a se\xE7\xE3o"), { description: err?.message });
+          return null;
+        }
+      },
+      async updateSection(id, data) {
+        const previous = get().sections;
+        set({ sections: previous.map((s) => s.id === id ? { ...s, ...data } : s) });
+        try {
+          await provider.updateSection(id, data);
+        } catch (err) {
+          set({ sections: previous });
+          toast.error(tl("Could not save the section", "N\xE3o foi poss\xEDvel salvar a se\xE7\xE3o"), { description: err?.message });
+        }
+      },
+      async deleteSection(id) {
+        try {
+          await provider.deleteSection(id);
+          set({
+            sections: get().sections.filter((s) => s.id !== id),
+            placements: get().placements.filter((p) => p.sectionId !== id)
+          });
+          toast.success(tl("Section removed", "Se\xE7\xE3o removida"));
+        } catch (err) {
+          toast.error(tl("Could not remove the section", "N\xE3o foi poss\xEDvel remover a se\xE7\xE3o"), { description: err?.message });
+        }
+      },
+      async reorderSections(orderedIds) {
+        const menuId = get().activeMenuId;
+        if (!menuId) return;
+        const previous = get().sections;
+        set({
+          sections: orderedIds.map((id, index) => {
+            const section = previous.find((s) => s.id === id);
+            return section ? { ...section, sortOrder: index } : null;
+          }).filter(Boolean)
+        });
+        try {
+          await provider.reorderSections(menuId, orderedIds);
+        } catch (err) {
+          set({ sections: previous });
+          toast.error(tl("Could not save the new order", "N\xE3o foi poss\xEDvel salvar a ordem"), { description: err?.message });
+        }
+      },
+      // --- Items in the open menu -------------------------------------------
+      async addItemToSection(sectionId, input) {
+        const tempId = `pending-${++optimisticSeq}`;
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const optimisticItem = {
+          id: tempId,
+          name: input.name,
+          description: input.description,
+          price: input.price ?? 0,
+          currency: "",
+          imageUrl: input.imageUrl,
+          status: input.status ?? "available",
+          isActive: true,
+          availableForPos: input.availableForPos ?? true,
+          availableForDelivery: input.availableForDelivery ?? true,
+          deliveryPrice: input.deliveryPrice,
+          prepTimeMinutes: input.prepTimeMinutes,
+          allergens: input.allergens ?? [],
+          dietaryTags: input.dietaryTags ?? [],
+          sortOrder: 0,
+          isFeatured: input.isFeatured ?? false,
+          tenantId: "",
+          createdAt: now2,
+          updatedAt: now2
+        };
+        const optimisticPlacement = {
+          id: `pending-placement-${optimisticSeq}`,
+          sectionId,
+          itemId: tempId,
+          sortOrder: get().placements.filter((p) => p.sectionId === sectionId).length,
+          isActive: true,
+          tenantId: ""
+        };
+        set({
+          menuItems: [...get().menuItems, optimisticItem],
+          placements: [...get().placements, optimisticPlacement],
+          pendingIds: [...get().pendingIds, optimisticPlacement.id]
+        });
+        try {
+          const item = await provider.createMenuItem({ ...input, sectionId });
+          const menuId = get().activeMenuId;
+          set({ menuItems: get().menuItems.map((i) => i.id === tempId ? item : i) });
+          if (menuId) await get().fetchMenuContent(menuId);
+          set({ pendingIds: get().pendingIds.filter((id) => id !== optimisticPlacement.id) });
+          void get().fetchSummary();
+          return item;
+        } catch (err) {
+          set({
+            menuItems: get().menuItems.filter((i) => i.id !== tempId),
+            placements: get().placements.filter((p) => p.id !== optimisticPlacement.id),
+            pendingIds: get().pendingIds.filter((id) => id !== optimisticPlacement.id)
+          });
+          toast.error(tl("Could not create the item", "N\xE3o foi poss\xEDvel criar o item"), { description: err?.message });
+          return null;
+        }
+      },
+      async placeExistingItem(sectionId, itemId) {
+        try {
+          const placement = await provider.placeItem({ sectionId, itemId });
+          set({ placements: [...get().placements.filter((p) => p.id !== placement.id), placement] });
+        } catch (err) {
+          toast.error(tl("Could not add it to the menu", "N\xE3o foi poss\xEDvel adicionar ao card\xE1pio"), { description: err?.message });
+        }
+      },
+      async removePlacement(placementId2) {
+        const previous = get().placements;
+        set({ placements: previous.filter((p) => p.id !== placementId2) });
+        try {
+          await provider.removePlacement(placementId2);
+        } catch (err) {
+          set({ placements: previous });
+          toast.error(tl("Could not remove it from the menu", "N\xE3o foi poss\xEDvel remover do card\xE1pio"), { description: err?.message });
+        }
+      },
+      async setPlacementPrice(placementId2, price) {
+        const previous = get().placements;
+        set({ placements: previous.map((p) => p.id === placementId2 ? { ...p, priceOverride: price } : p) });
+        try {
+          await provider.updatePlacement(placementId2, { priceOverride: price });
+        } catch (err) {
+          set({ placements: previous });
+          toast.error(tl("Could not save the price", "N\xE3o foi poss\xEDvel salvar o pre\xE7o"), { description: err?.message });
+        }
+      },
+      async reorderPlacements(sectionId, orderedIds) {
+        const previous = get().placements;
+        const reordered = previous.map((p) => {
+          const index = orderedIds.indexOf(p.id);
+          return index >= 0 ? { ...p, sortOrder: index } : p;
+        });
+        set({ placements: reordered });
+        try {
+          await provider.reorderPlacements(sectionId, orderedIds);
+        } catch (err) {
+          set({ placements: previous });
+          toast.error(tl("Could not save the new order", "N\xE3o foi poss\xEDvel salvar a ordem"), { description: err?.message });
+        }
+      },
+      async movePlacement(placementId2, toSectionId, toIndex) {
+        const previous = get().placements;
+        set({
+          placements: previous.map((p) => p.id === placementId2 ? { ...p, sectionId: toSectionId, sortOrder: toIndex } : p)
+        });
+        try {
+          await provider.movePlacement(placementId2, toSectionId, toIndex);
+        } catch (err) {
+          set({ placements: previous });
+          toast.error(tl("Could not move the item", "N\xE3o foi poss\xEDvel mover o item"), { description: err?.message });
+        }
+      },
+      // --- Items -------------------------------------------------------------
+      async updateMenuItem(id, data) {
+        const previous = get().menuItems;
+        set({ menuItems: previous.map((i) => i.id === id ? { ...i, ...data } : i) });
+        try {
+          const updated = await provider.updateMenuItem(id, data);
+          set({ menuItems: get().menuItems.map((i) => i.id === id ? updated : i) });
+        } catch (err) {
+          set({ menuItems: previous });
+          toast.error(tl("Could not save the item", "N\xE3o foi poss\xEDvel salvar o item"), { description: err?.message });
+        }
+      },
+      async deleteMenuItem(id) {
+        try {
+          await provider.deleteMenuItem(id);
+          set({
+            menuItems: get().menuItems.filter((i) => i.id !== id),
+            placements: get().placements.filter((p) => p.itemId !== id)
+          });
+          void get().fetchSummary();
+          toast.success(tl("Item removed", "Item removido"));
+        } catch (err) {
+          toast.error(tl("Could not remove the item", "N\xE3o foi poss\xEDvel remover o item"), { description: err?.message });
+        }
+      },
+      async duplicateMenuItem(id, sectionId) {
+        const source = get().menuItems.find((i) => i.id === id);
+        if (!source) return;
+        await get().addItemToSection(sectionId ?? get().placements.find((p) => p.itemId === id)?.sectionId ?? "", {
+          name: `${source.name} (c\xF3pia)`,
+          description: source.description,
+          price: source.price,
+          cost: source.cost,
+          imageUrl: source.imageUrl,
+          prepTimeMinutes: source.prepTimeMinutes,
+          allergens: source.allergens,
+          dietaryTags: source.dietaryTags,
+          availableForPos: source.availableForPos,
+          availableForDelivery: source.availableForDelivery,
+          deliveryPrice: source.deliveryPrice
+        });
+      },
+      async setItemStatus(id, status) {
+        await writeItemField(id, "status", status);
+      },
+      async toggleAvailability(id, field, value) {
+        await writeItemField(id, field, value);
+      },
+      async uploadImage(file, kind) {
+        if (!provider.uploadImage) {
+          toast.error(tl("This workspace does not store menu photos yet.", "Este espa\xE7o ainda n\xE3o guarda fotos do card\xE1pio."));
+          return null;
+        }
+        try {
+          return await provider.uploadImage(file, kind);
+        } catch (err) {
+          toast.error("N\xE3o foi poss\xEDvel enviar a foto", { description: err?.message });
+          return null;
+        }
+      },
+      // --- AI import ---------------------------------------------------------
+      extracting: false,
+      draft: null,
+      async runExtraction(images, extract) {
+        if (images.length === 0) return;
+        set({ extracting: true });
+        try {
+          const result = await extract(images);
+          const counts = countExtracted(result);
+          if (counts.items === 0) {
+            set({ extracting: false });
+            toast.error(tl("I could not read any items in those photos", "N\xE3o consegui ler itens nessas fotos"), {
+              description: tl("Try one photo per page, closer and without glare.", "Tente uma foto por p\xE1gina, mais perto e sem reflexo.")
+            });
+            return;
+          }
+          const existing = get().sections;
+          let key = 0;
+          const draft = {
+            source: "photo",
+            model: result.model,
+            sections: result.sections.map((section) => ({
+              key: `ds-${++key}`,
+              name: section.name,
+              targetSectionId: existing.find((s) => normalizeName(s.name) === normalizeName(section.name))?.id,
+              items: section.items.map((item) => ({
+                key: `di-${++key}`,
+                name: item.name,
+                price: item.price,
+                description: item.description
+              }))
+            }))
+          };
+          set({ draft, extracting: false });
+        } catch (err) {
+          set({ extracting: false });
+          toast.error(tl("I could not read the photos", "N\xE3o consegui ler as fotos"), { description: err?.message });
+        }
+      },
+      updateDraftItem(sectionKey, itemKey, patch) {
+        const draft = get().draft;
+        if (!draft) return;
+        set({
+          draft: {
+            ...draft,
+            sections: draft.sections.map((section) => section.key !== sectionKey ? section : {
+              ...section,
+              items: section.items.map((item) => item.key === itemKey ? { ...item, ...patch } : item)
+            })
+          }
+        });
+      },
+      removeDraftItem(sectionKey, itemKey) {
+        const draft = get().draft;
+        if (!draft) return;
+        const sections = draft.sections.map((section) => section.key !== sectionKey ? section : {
+          ...section,
+          items: section.items.filter((item) => item.key !== itemKey)
+        }).filter((section) => section.items.length > 0);
+        set({ draft: sections.length > 0 ? { ...draft, sections } : null });
+      },
+      updateDraftSection(sectionKey, patch) {
+        const draft = get().draft;
+        if (!draft) return;
+        set({
+          draft: {
+            ...draft,
+            sections: draft.sections.map((section) => section.key === sectionKey ? { ...section, ...patch } : section)
+          }
+        });
+      },
+      removeDraftSection(sectionKey) {
+        const draft = get().draft;
+        if (!draft) return;
+        const sections = draft.sections.filter((section) => section.key !== sectionKey);
+        set({ draft: sections.length > 0 ? { ...draft, sections } : null });
+      },
+      discardDraft() {
+        set({ draft: null });
+      },
+      async commitDraft() {
+        const draft = get().draft;
+        const menuId = get().activeMenuId;
+        if (!draft || !menuId) return { sectionsCreated: 0, itemsCreated: 0, failed: 0 };
+        const result = await get().applyImportPlan({
+          menuId,
+          sections: draft.sections.map((section) => ({
+            sectionId: section.targetSectionId,
+            name: section.name,
+            items: section.items.map(({ name, price, description }) => ({ name, price, description }))
+          }))
+        });
+        set({ draft: null });
+        return result;
+      },
+      async applyImportPlan(plan) {
+        const result = { sectionsCreated: 0, itemsCreated: 0, failed: 0 };
+        for (const section of plan.sections) {
+          let sectionId = section.sectionId;
+          if (!sectionId) {
+            const created = await provider.createSection({ menuId: plan.menuId, name: section.name });
+            sectionId = created.id;
+            result.sectionsCreated++;
+          }
+          for (const item of section.items) {
+            try {
+              await provider.createMenuItem({
+                name: item.name,
+                description: item.description,
+                price: item.price,
+                sectionId
+              });
+              result.itemsCreated++;
+            } catch {
+              result.failed++;
+            }
+          }
+        }
+        await get().fetchMenus();
+        void get().fetchSummary();
+        return result;
+      }
+    };
+  });
 }
 
 // src/data/registries.ts
@@ -394,7 +2037,7 @@ var allergenEntity = {
     { key: "icon", label: "Icon", type: "text", showInTable: true },
     { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
   ],
-  data: { table: "menu_allergens", tenantScoped: true }
+  data: { table: T.allergens, tenantScoped: true }
 };
 var dietaryTagEntity = {
   name: "Dietary Tag",
@@ -407,7 +2050,7 @@ var dietaryTagEntity = {
     { key: "color", label: "Color", type: "text", showInTable: true },
     { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
   ],
-  data: { table: "menu_dietary_tags", tenantScoped: true }
+  data: { table: T.dietaryTags, tenantScoped: true }
 };
 var modifierGroupEntity = {
   name: "Modifier Group",
@@ -421,7 +2064,7 @@ var modifierGroupEntity = {
     { key: "maxSelections", label: "Max Selections", type: "number", showInTable: true, defaultValue: 1 },
     { key: "isRequired", label: "Required", type: "boolean", showInTable: true, defaultValue: false }
   ],
-  data: { table: "menu_modifier_groups", tenantScoped: true }
+  data: { table: T.modifierGroups, tenantScoped: true }
 };
 var menuRegistries = [
   {
@@ -466,132 +2109,282 @@ var menuRegistries = [
 var en = {
   "menu.title": "Menu",
   "menu.nav.manager": "Menu",
-  "menu.nav.categories": "Categories",
-  "menu.nav.items": "Items",
-  "menu.nav.modifiers": "Modifiers",
-  "menu.manager.title": "Menu Manager",
-  "menu.manager.subtitle": "Manage your menu items and categories",
-  "menu.manager.search": "Search menu...",
-  "menu.manager.allCategories": "All Categories",
-  "menu.manager.newItem": "New Item",
-  "menu.manager.noItems": "No menu items yet",
-  "menu.manager.noItemsDesc": "Add your first menu item to get started",
-  "menu.manager.addFirst": "Add first item",
+  // Manager
+  "menu.manager.title": "Menu",
+  "menu.manager.subtitle": "Build your menus, with sections and order",
+  "menu.manager.search": "Search the menu...",
+  "menu.manager.newMenu": "New menu",
+  "menu.manager.menuActions": "Menu actions",
+  "menu.manager.editMenu": "Edit menu",
+  "menu.manager.duplicateMenu": "Duplicate menu",
+  "menu.manager.activateMenu": "Activate menu",
+  "menu.manager.deactivateMenu": "Deactivate menu",
+  "menu.manager.deleteMenu": "Delete menu",
+  "menu.manager.menuOff": "Off",
+  "menu.manager.servingNow": "Serving now",
+  "menu.manager.notServing": "Outside its hours",
+  "menu.manager.addSection": "New section",
+  "menu.manager.newSectionName": "New section",
+  "menu.manager.editSection": "Turn section on/off",
+  "menu.manager.deleteSection": "Delete section",
+  "menu.manager.sectionActions": "Section actions",
+  "menu.manager.sectionOff": "Section off",
+  "menu.manager.emptySection": "Nothing here yet \u2014 click to add",
+  "menu.manager.addItem": "Add item",
+  "menu.manager.itemActions": "Item actions",
+  "menu.manager.itemsCount": "{{count}} items",
+  "menu.manager.edit": "Edit",
+  "menu.manager.duplicate": "Duplicate",
+  "menu.manager.markSoldOut": "Mark sold out",
+  "menu.manager.markAvailable": "Mark available",
+  "menu.manager.feature": "Feature",
+  "menu.manager.unfeature": "Remove from featured",
+  "menu.manager.removeFromMenu": "Remove from this menu",
+  "menu.manager.deleteItem": "Delete item",
+  "menu.manager.dragSection": "Drag section",
+  "menu.manager.dragItem": "Drag item",
+  "menu.manager.expand": "Expand",
+  "menu.manager.collapse": "Collapse",
   "menu.manager.available": "Available",
-  "menu.manager.soldOut": "Sold Out",
+  "menu.manager.soldOut": "Sold out",
   "menu.manager.hidden": "Hidden",
   "menu.manager.pos": "POS",
   "menu.manager.delivery": "Delivery",
   "menu.manager.featured": "Featured",
-  "menu.manager.prepTime": "Prep time",
-  "menu.manager.min": "min",
-  "menu.manager.addCategory": "Add Category",
-  "menu.manager.addProduct": "Add Product",
-  "menu.manager.item": "Item",
-  "menu.manager.price": "Price",
-  "menu.manager.deliveryPrice": "Delivery $",
-  "menu.manager.itemsCount": "{{count}} items",
-  "menu.manager.noResults": "No categories or items match your search.",
-  "menu.manager.noResultsDesc": "Try a different search term or category filter.",
-  "menu.itemForm.newTitle": "New Menu Item",
-  "menu.itemForm.editTitle": "Edit Menu Item",
-  "menu.itemForm.name": "Item name",
+  "menu.manager.overridden": "this menu",
+  "menu.manager.overriddenHint": "This item costs a different price on this menu",
+  "menu.manager.empty": "Your menu is still empty",
+  "menu.manager.emptyHint": "Create the first section, or send photos of the printed menu and the assistant fills it in.",
+  // Menu dialog
+  "menu.menuDialog.newTitle": "New menu",
+  "menu.menuDialog.editTitle": "Edit menu",
+  "menu.menuDialog.name": "Name",
+  "menu.menuDialog.namePlaceholder": "Lunch, Weekend, Delivery...",
+  "menu.menuDialog.description": "Description",
+  "menu.menuDialog.descriptionPlaceholder": "Weekday lunch",
+  "menu.menuDialog.channels": "Where it shows",
+  "menu.menuDialog.active": "Menu active",
+  "menu.menuDialog.activeHint": "Turned off it leaves the floor and delivery without being deleted",
+  "menu.channel.pos": "Dine-in / POS",
+  "menu.channel.delivery": "Delivery",
+  "menu.channel.digital": "Digital menu",
+  // Schedule
+  "menu.schedule.always": "Every day, all day",
+  "menu.schedule.restrict": "Only on certain days and hours",
+  "menu.schedule.restrictHint": "This is how a weekday lunch menu is born",
+  "menu.schedule.days": "Days",
+  "menu.schedule.from": "From",
+  "menu.schedule.to": "To",
+  "menu.schedule.overnightHint": "If the end is before the start, the menu crosses midnight (22:00\u201302:00).",
+  "menu.schedule.presetWeekdays": "Weekdays",
+  "menu.schedule.presetWeekend": "Weekend",
+  "menu.schedule.presetEveryDay": "Every day",
+  // Item form
+  "menu.itemForm.newTitle": "New item",
+  "menu.itemForm.editTitle": "Edit item",
+  "menu.itemForm.name": "Name",
+  "menu.itemForm.namePlaceholder": "Grilled picanha",
   "menu.itemForm.description": "Description",
+  "menu.itemForm.descriptionPlaceholder": "Serves 2, comes with farofa",
+  "menu.itemForm.photo": "Photo",
+  "menu.itemForm.photoHint": "Square, well lit. Shows on the digital menu and delivery.",
+  "menu.itemForm.pricingGroup": "Pricing",
+  "menu.itemForm.menuGroup": "On the menu",
+  "menu.itemForm.posHint": "Shows for whoever is serving the floor",
+  "menu.itemForm.deliveryHint": "Shows for orders from outside",
+  "menu.itemForm.featuredHint": "Moves to the top of its section",
   "menu.itemForm.price": "Price",
   "menu.itemForm.cost": "Cost",
-  "menu.itemForm.category": "Category",
-  "menu.itemForm.prepTime": "Prep time (min)",
-  "menu.itemForm.image": "Image URL",
-  "menu.itemForm.allergens": "Allergens",
-  "menu.itemForm.dietaryTags": "Dietary tags",
-  "menu.itemForm.availableForPos": "Available for POS",
-  "menu.itemForm.availableForDelivery": "Available for Delivery",
   "menu.itemForm.deliveryPrice": "Delivery price",
-  "menu.itemForm.isFeatured": "Featured item",
-  "menu.itemForm.save": "Save",
-  "menu.itemForm.cancel": "Cancel",
-  "menu.itemForm.saving": "Saving...",
-  "menu.categories.title": "Categories",
-  "menu.categories.newCategory": "New Category",
-  "menu.categories.name": "Category name",
-  "menu.settings.title": "Menu Settings",
-  "menu.settings.general": "General",
-  "menu.settings.taxRate": "Default tax rate",
-  "menu.settings.currency": "Currency",
-  "menu.form.categoryName": "Category name",
-  "menu.form.itemName": "Item name",
-  "menu.form.description": "Description",
-  "menu.form.category": "Category",
-  "menu.form.uncategorized": "Uncategorized",
-  "menu.form.optional": "optional",
+  "menu.itemForm.prepTime": "Prep (min)",
+  "menu.itemForm.section": "Section",
+  "menu.itemForm.status": "Status",
+  "menu.itemForm.priceOverride": "Price on this menu only",
+  "menu.itemForm.priceOverrideHint": "The same dish can cost less at lunch. Empty = the item price.",
+  "menu.itemForm.clearOverride": "Use the item price",
+  // AI import
+  "menu.import.action": "Add with AI",
+  "menu.import.uploadCta": "Upload a photo of the menu",
+  "menu.import.uploadHint": "One photo per page, straight on, no glare. Several at once is fine.",
+  "menu.import.askPrompt": "I want to add my menu from photos.",
+  "menu.import.askHint": "Describe the menu, or ask to start from photos\u2026",
+  "menu.import.askPersona": "Menu setup",
+  "menu.import.askPitch": "Send me photos of the menu and I will type it in.",
+  "menu.import.askDescription": "One photo per page, straight on, no glare. I read them, show what I understood right here on the screen, and we check it together before saving.",
+  "menu.import.askSuggestion.0": "I will send photos of the printed menu",
+  "menu.import.askSuggestion.1": "Create a weekday lunch menu",
+  "menu.import.askSuggestion.2": "Add a desserts section",
+  "menu.import.createSection": "Create new section",
+  "menu.import.intoSection": "Add into: {{name}}",
+  "menu.import.willAppend": "goes into {{name}}",
+  "menu.import.dropItem": "Drop item",
+  "menu.import.dropSection": "Drop section",
+  "menu.import.draftCount": "{{items}} items read across {{sections}} sections",
+  "menu.import.draftHint": "Check and fix them right here \u2014 nothing is saved yet.",
+  "menu.import.draftMissingPrice": "{{count}} items came without a price. Fill them in before saving.",
+  "menu.import.discard": "Discard",
+  "menu.import.commit": "Save {{count}} items",
+  "menu.import.done": "{{items}} items in {{sections}} sections created",
+  "menu.import.someFailed": "{{count}} items could not be created",
+  // Preview
+  "menu.preview.action": "Preview",
+  "menu.preview.title": "Menu",
+  "menu.preview.notServingNow": "outside its hours right now",
+  // Confirmations
+  "menu.confirm.sectionTitle": "Delete the section {{name}}?",
+  "menu.confirm.sectionDesc": "Its items leave this menu but stay registered.",
+  "menu.confirm.itemTitle": "Delete the item {{name}}?",
+  "menu.confirm.itemDesc": "It leaves every menu it appears in.",
+  "menu.confirm.menuTitle": "Delete the menu {{name}}?",
+  "menu.confirm.menuDesc": "Its sections go with it. The dishes stay registered.",
+  "menu.confirm.delete": "Delete",
+  // Shared form bits
   "menu.form.save": "Save",
-  "menu.form.cancel": "Cancel"
+  "menu.form.saving": "Saving...",
+  "menu.form.cancel": "Cancel",
+  // Settings
+  "menu.settings.title": "Menu settings"
 };
 
 // src/locales/pt-BR.ts
 var ptBR = {
   "menu.title": "Card\xE1pio",
   "menu.nav.manager": "Card\xE1pio",
-  "menu.nav.categories": "Categorias",
-  "menu.nav.items": "Itens",
-  "menu.nav.modifiers": "Modificadores",
-  "menu.manager.title": "Gerenciar Card\xE1pio",
-  "menu.manager.subtitle": "Gerencie itens e categorias do card\xE1pio",
-  "menu.manager.search": "Buscar no card\xE1pio...",
-  "menu.manager.allCategories": "Todas as Categorias",
-  "menu.manager.newItem": "Novo Item",
-  "menu.manager.noItems": "Nenhum item no card\xE1pio",
-  "menu.manager.noItemsDesc": "Adicione o primeiro item para come\xE7ar",
-  "menu.manager.addFirst": "Adicionar primeiro item",
+  // Manager
+  "menu.manager.title": "Card\xE1pio",
+  "menu.manager.subtitle": "Monte os card\xE1pios da casa, com se\xE7\xF5es e ordem",
+  "menu.manager.search": "Buscar item no card\xE1pio...",
+  "menu.manager.newMenu": "Novo card\xE1pio",
+  "menu.manager.menuActions": "A\xE7\xF5es do card\xE1pio",
+  "menu.manager.editMenu": "Editar card\xE1pio",
+  "menu.manager.duplicateMenu": "Duplicar card\xE1pio",
+  "menu.manager.activateMenu": "Ativar card\xE1pio",
+  "menu.manager.deactivateMenu": "Desativar card\xE1pio",
+  "menu.manager.deleteMenu": "Excluir card\xE1pio",
+  "menu.manager.menuOff": "Desativado",
+  "menu.manager.servingNow": "Servindo agora",
+  "menu.manager.notServing": "Fora do hor\xE1rio",
+  "menu.manager.addSection": "Nova se\xE7\xE3o",
+  "menu.manager.newSectionName": "Nova se\xE7\xE3o",
+  "menu.manager.editSection": "Ativar/desativar se\xE7\xE3o",
+  "menu.manager.deleteSection": "Excluir se\xE7\xE3o",
+  "menu.manager.sectionActions": "A\xE7\xF5es da se\xE7\xE3o",
+  "menu.manager.sectionOff": "Se\xE7\xE3o desativada",
+  "menu.manager.emptySection": "Nenhum item aqui ainda \u2014 clique para adicionar",
+  "menu.manager.addItem": "Adicionar item",
+  "menu.manager.itemActions": "A\xE7\xF5es do item",
+  "menu.manager.itemsCount": "{{count}} itens",
+  "menu.manager.edit": "Editar",
+  "menu.manager.duplicate": "Duplicar",
+  "menu.manager.markSoldOut": "Marcar como esgotado",
+  "menu.manager.markAvailable": "Marcar como dispon\xEDvel",
+  "menu.manager.feature": "Colocar em destaque",
+  "menu.manager.unfeature": "Tirar do destaque",
+  "menu.manager.removeFromMenu": "Tirar deste card\xE1pio",
+  "menu.manager.deleteItem": "Excluir item",
+  "menu.manager.dragSection": "Arrastar se\xE7\xE3o",
+  "menu.manager.dragItem": "Arrastar item",
+  "menu.manager.expand": "Expandir",
+  "menu.manager.collapse": "Recolher",
   "menu.manager.available": "Dispon\xEDvel",
   "menu.manager.soldOut": "Esgotado",
   "menu.manager.hidden": "Oculto",
   "menu.manager.pos": "PDV",
   "menu.manager.delivery": "Delivery",
   "menu.manager.featured": "Destaque",
-  "menu.manager.prepTime": "Tempo de preparo",
-  "menu.manager.min": "min",
-  "menu.manager.addCategory": "Adicionar Categoria",
-  "menu.manager.addProduct": "Adicionar Produto",
-  "menu.manager.item": "Item",
-  "menu.manager.price": "Pre\xE7o",
-  "menu.manager.deliveryPrice": "Delivery R$",
-  "menu.manager.itemsCount": "{{count}} itens",
-  "menu.manager.noResults": "Nenhuma categoria ou item encontrado.",
-  "menu.manager.noResultsDesc": "Tente um termo diferente ou filtro de categoria.",
-  "menu.itemForm.newTitle": "Novo Item do Card\xE1pio",
-  "menu.itemForm.editTitle": "Editar Item do Card\xE1pio",
-  "menu.itemForm.name": "Nome do item",
+  "menu.manager.overridden": "pre\xE7o deste card\xE1pio",
+  "menu.manager.overriddenHint": "Este item custa diferente neste card\xE1pio",
+  "menu.manager.empty": "Seu card\xE1pio ainda est\xE1 vazio",
+  "menu.manager.emptyHint": "Crie a primeira se\xE7\xE3o, ou mande fotos do card\xE1pio impresso e o assistente cadastra pra voc\xEA.",
+  // Menu dialog
+  "menu.menuDialog.newTitle": "Novo card\xE1pio",
+  "menu.menuDialog.editTitle": "Editar card\xE1pio",
+  "menu.menuDialog.name": "Nome",
+  "menu.menuDialog.namePlaceholder": "Executivo, Fim de semana, Delivery...",
+  "menu.menuDialog.description": "Descri\xE7\xE3o",
+  "menu.menuDialog.descriptionPlaceholder": "Almo\xE7o de segunda a sexta",
+  "menu.menuDialog.channels": "Onde aparece",
+  "menu.menuDialog.active": "Card\xE1pio ativo",
+  "menu.menuDialog.activeHint": "Desativado, ele some do sal\xE3o e do delivery sem ser apagado",
+  "menu.channel.pos": "Sal\xE3o / PDV",
+  "menu.channel.delivery": "Delivery",
+  "menu.channel.digital": "Card\xE1pio digital",
+  // Schedule
+  "menu.schedule.always": "Todo dia, o dia inteiro",
+  "menu.schedule.restrict": "S\xF3 em certos dias e hor\xE1rios",
+  "menu.schedule.restrictHint": "\xC9 assim que nasce um executivo de segunda a sexta",
+  "menu.schedule.days": "Dias",
+  "menu.schedule.from": "Das",
+  "menu.schedule.to": "At\xE9",
+  "menu.schedule.overnightHint": "Se o fim for antes do come\xE7o, o card\xE1pio atravessa a meia-noite (22:00\u201302:00).",
+  "menu.schedule.presetWeekdays": "Dias de semana",
+  "menu.schedule.presetWeekend": "Fim de semana",
+  "menu.schedule.presetEveryDay": "Todo dia",
+  // Item form
+  "menu.itemForm.newTitle": "Novo item",
+  "menu.itemForm.editTitle": "Editar item",
+  "menu.itemForm.name": "Nome",
+  "menu.itemForm.namePlaceholder": "Picanha na chapa",
   "menu.itemForm.description": "Descri\xE7\xE3o",
+  "menu.itemForm.descriptionPlaceholder": "Serve 2 pessoas, acompanha farofa",
+  "menu.itemForm.photo": "Foto",
+  "menu.itemForm.photoHint": "Quadrada, boa luz. Aparece no card\xE1pio digital e no delivery.",
+  "menu.itemForm.pricingGroup": "Pre\xE7os",
+  "menu.itemForm.menuGroup": "No card\xE1pio",
+  "menu.itemForm.posHint": "Aparece para quem atende no sal\xE3o",
+  "menu.itemForm.deliveryHint": "Aparece para quem pede de fora",
+  "menu.itemForm.featuredHint": "Sobe para o topo da se\xE7\xE3o",
   "menu.itemForm.price": "Pre\xE7o",
   "menu.itemForm.cost": "Custo",
-  "menu.itemForm.category": "Categoria",
-  "menu.itemForm.prepTime": "Tempo de preparo (min)",
-  "menu.itemForm.image": "URL da imagem",
-  "menu.itemForm.allergens": "Al\xE9rgenos",
-  "menu.itemForm.dietaryTags": "Tags diet\xE9ticas",
-  "menu.itemForm.availableForPos": "Dispon\xEDvel no PDV",
-  "menu.itemForm.availableForDelivery": "Dispon\xEDvel para Delivery",
   "menu.itemForm.deliveryPrice": "Pre\xE7o delivery",
-  "menu.itemForm.isFeatured": "Item em destaque",
-  "menu.itemForm.save": "Salvar",
-  "menu.itemForm.cancel": "Cancelar",
-  "menu.itemForm.saving": "Salvando...",
-  "menu.categories.title": "Categorias",
-  "menu.categories.newCategory": "Nova Categoria",
-  "menu.categories.name": "Nome da categoria",
-  "menu.settings.title": "Configura\xE7\xF5es do Card\xE1pio",
-  "menu.settings.general": "Geral",
-  "menu.settings.taxRate": "Taxa padr\xE3o",
-  "menu.settings.currency": "Moeda",
-  "menu.form.categoryName": "Nome da categoria",
-  "menu.form.itemName": "Nome do item",
-  "menu.form.description": "Descri\xE7\xE3o",
-  "menu.form.category": "Categoria",
-  "menu.form.uncategorized": "Sem categoria",
-  "menu.form.optional": "opcional",
+  "menu.itemForm.prepTime": "Preparo (min)",
+  "menu.itemForm.section": "Se\xE7\xE3o",
+  "menu.itemForm.status": "Situa\xE7\xE3o",
+  "menu.itemForm.priceOverride": "Pre\xE7o s\xF3 neste card\xE1pio",
+  "menu.itemForm.priceOverrideHint": "O mesmo prato pode custar menos no executivo. Em branco, vale o pre\xE7o do item.",
+  "menu.itemForm.clearOverride": "Usar o pre\xE7o do item",
+  // AI import
+  "menu.import.action": "Inserir com IA",
+  "menu.import.uploadCta": "Subir foto do card\xE1pio",
+  "menu.import.uploadHint": "Uma foto por p\xE1gina, de frente e sem reflexo. Pode mandar v\xE1rias.",
+  "menu.import.askPrompt": "Quero cadastrar meu card\xE1pio a partir de fotos.",
+  "menu.import.askHint": "Descreva o card\xE1pio, ou pe\xE7a para come\xE7ar pelas fotos\u2026",
+  "menu.import.askPersona": "Cadastro de card\xE1pio",
+  "menu.import.askPitch": "Me manda as fotos do card\xE1pio que eu cadastro.",
+  "menu.import.askDescription": "Uma foto por p\xE1gina, de frente e sem reflexo. Eu leio, mostro o que entendi aqui na tela e a gente confere junto antes de gravar.",
+  "menu.import.askSuggestion.0": "Vou mandar as fotos do card\xE1pio impresso",
+  "menu.import.askSuggestion.1": "Cria um card\xE1pio executivo de segunda a sexta",
+  "menu.import.askSuggestion.2": "Adiciona uma se\xE7\xE3o de sobremesas",
+  "menu.import.createSection": "Criar se\xE7\xE3o nova",
+  "menu.import.intoSection": "Somar em: {{name}}",
+  "menu.import.willAppend": "entra em {{name}}",
+  "menu.import.dropItem": "Descartar item",
+  "menu.import.dropSection": "Descartar se\xE7\xE3o",
+  "menu.import.draftCount": "{{items}} itens lidos em {{sections}} se\xE7\xF5es",
+  "menu.import.draftHint": "Confira e ajuste aqui mesmo \u2014 nada foi gravado ainda.",
+  "menu.import.draftMissingPrice": "{{count}} itens vieram sem pre\xE7o. Preencha antes de gravar.",
+  "menu.import.discard": "Descartar",
+  "menu.import.commit": "Gravar {{count}} itens",
+  "menu.import.done": "{{items}} itens em {{sections}} se\xE7\xF5es cadastrados",
+  "menu.import.someFailed": "{{count}} itens n\xE3o puderam ser criados",
+  // Preview
+  "menu.preview.action": "Ver como fica",
+  "menu.preview.title": "Card\xE1pio",
+  "menu.preview.notServingNow": "fora do hor\xE1rio agora",
+  // Confirmations
+  "menu.confirm.sectionTitle": "Excluir a se\xE7\xE3o {{name}}?",
+  "menu.confirm.sectionDesc": "Os itens dela saem deste card\xE1pio, mas continuam cadastrados.",
+  "menu.confirm.itemTitle": "Excluir o item {{name}}?",
+  "menu.confirm.itemDesc": "Ele sai de todos os card\xE1pios em que aparece.",
+  "menu.confirm.menuTitle": "Excluir o card\xE1pio {{name}}?",
+  "menu.confirm.menuDesc": "As se\xE7\xF5es deste card\xE1pio somem. Os pratos continuam cadastrados.",
+  "menu.confirm.delete": "Excluir",
+  // Shared form bits
   "menu.form.save": "Salvar",
-  "menu.form.cancel": "Cancelar"
+  "menu.form.saving": "Salvando...",
+  "menu.form.cancel": "Cancelar",
+  // Settings
+  "menu.settings.title": "Configura\xE7\xF5es do Card\xE1pio"
 };
 
 // src/locales/index.ts
@@ -613,7 +2406,7 @@ function menuMetadata(row) {
   const raw = row.metadata?.[MENU_METADATA_KEY];
   return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
 }
-function rowToCategory(row, itemCount = 0) {
+function rowToCategory2(row, itemCount = 0) {
   return {
     id: row.id,
     name: row.name,
@@ -628,7 +2421,7 @@ function rowToCategory(row, itemCount = 0) {
     updatedAt: row.updated_at ?? row.created_at ?? nowIso()
   };
 }
-function rowToItem(row, categoryName) {
+function rowToItem2(row, categoryName) {
   const metadata = menuMetadata(row);
   const status = metadata.status ?? row.status ?? "available";
   return {
@@ -782,7 +2575,7 @@ function createFayzMenuProvider(options = {}) {
   }
   async function getItems() {
     const [rows, categoryMap] = await Promise.all([getItemsRaw(), getCategoryMap()]);
-    return rows.map((row) => rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0)).sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
+    return rows.map((row) => rowToItem2(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0)).sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
   }
   return {
     async getCategories() {
@@ -791,7 +2584,7 @@ function createFayzMenuProvider(options = {}) {
       for (const item of items) {
         if (item.category_id) counts.set(item.category_id, (counts.get(item.category_id) ?? 0) + 1);
       }
-      return categories.map((category) => rowToCategory(category, counts.get(category.id) ?? 0));
+      return categories.map((category) => rowToCategory2(category, counts.get(category.id) ?? 0));
     },
     async getCategoryById(id) {
       const response = await client.data.listRows({
@@ -800,7 +2593,7 @@ function createFayzMenuProvider(options = {}) {
         filters: [{ column: "id", operator: "eq", value: id }],
         limit: 1
       });
-      return response.rows[0] ? rowToCategory(response.rows[0]) : null;
+      return response.rows[0] ? rowToCategory2(response.rows[0]) : null;
     },
     async createCategory(input) {
       const row = await client.data.createRow({
@@ -808,7 +2601,7 @@ function createFayzMenuProvider(options = {}) {
         table: categoriesTable,
         row: categoryPayload(input, categoryKind)
       });
-      return rowToCategory(row);
+      return rowToCategory2(row);
     },
     async updateCategory(id, data) {
       const row = await client.data.updateRow({
@@ -824,7 +2617,7 @@ function createFayzMenuProvider(options = {}) {
           is_active: data.isActive
         }
       });
-      return rowToCategory(row);
+      return rowToCategory2(row);
     },
     async deleteCategory(id) {
       await client.data.updateRow({
@@ -851,7 +2644,7 @@ function createFayzMenuProvider(options = {}) {
       if (!response.rows[0]) return null;
       const categoryMap = await getCategoryMap();
       const row = response.rows[0];
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
+      return rowToItem2(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
     },
     async createMenuItem(input) {
       const row = await client.data.createRow({
@@ -860,7 +2653,7 @@ function createFayzMenuProvider(options = {}) {
         row: itemCreatePayload(input)
       });
       const categoryMap = await getCategoryMap();
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
+      return rowToItem2(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
     },
     async updateMenuItem(id, data) {
       const existing = await this.getMenuItemById(id);
@@ -871,7 +2664,7 @@ function createFayzMenuProvider(options = {}) {
         row: itemUpdatePayload(data, existing ?? void 0)
       });
       const categoryMap = await getCategoryMap();
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
+      return rowToItem2(row, row.category_id ? categoryMap.get(row.category_id)?.name : void 0);
     },
     async deleteMenuItem(id) {
       await client.data.updateRow({
@@ -924,7 +2717,7 @@ function createFayzMenuProvider(options = {}) {
 }
 
 // src/index.ts
-var MenuPage = React.lazy(() => import('./MenuPage-ZNKKQJKD.js').then((m) => ({ default: m.MenuPage })));
+var MenuPage = React.lazy(() => import('./MenuPage-2LLWRJGN.js').then((m) => ({ default: m.MenuPage })));
 var DEFAULT_LABELS = {
   pageTitle: "Menu",
   menuManager: "Menu Manager",
@@ -945,7 +2738,10 @@ function resolveConfig(options) {
 function createMenuPlugin(options) {
   const config = resolveConfig(options);
   registerTranslations(menuLocales);
-  const provider = options?.dataProvider ?? createMockMenuProvider();
+  const provider = options?.dataProvider ?? createSafeDataProvider(
+    () => createSupabaseMenuProvider({ currencyCode: config.currency.code }),
+    () => createMockMenuProvider()
+  );
   const store = createMenuStore(provider);
   const PageComponent = () => React.createElement(
     React.Suspense,
@@ -954,6 +2750,7 @@ function createMenuPlugin(options) {
   );
   return {
     id: "menu",
+    defaultAgentRole: "operations",
     name: config.labels.pageTitle,
     icon: "UtensilsCrossed",
     version: "1.0.0",
@@ -965,9 +2762,18 @@ function createMenuPlugin(options) {
     scaffolds: ["saas", "ecommerce"],
     defaultEnabled: true,
     dependencies: [],
+    declaredFeatures: [
+      { id: "menu", label: config.labels.pageTitle, group: config.labels.pageTitle }
+    ],
     declaredLimits: [
-      { key: "menu_items", label: "Menu items", table: "menu_items" }
+      { key: "menu_items", label: "Menu items", table: T.items }
     ],
+    migrations: MIGRATIONS.map((migration) => ({
+      id: `menu-${migration.id}`,
+      version: "1.0.0",
+      sql: migration.sql,
+      description: `plugin-menu ${migration.id}`
+    })),
     navigation: [
       {
         section: options?.navSection ?? "main",
@@ -1006,6 +2812,19 @@ function createMenuPlugin(options) {
           { label: "Which items are sold out right now?" }
         ]
       },
+      {
+        id: "menu.list-menus",
+        name: "listMenus",
+        description: "Lists the menus of the place (regular, executive lunch, weekend) with when each one is served.",
+        icon: "UtensilsCrossed",
+        mode: "read",
+        category: "Menu",
+        parameters: { type: "object", properties: {} },
+        suggestions: [
+          { label: "Quais card\xE1pios existem?" },
+          { label: "Que card\xE1pio est\xE1 no ar agora?" }
+        ]
+      },
       {
         id: "menu.toggle-availability",
         name: "toggleMenuItemAvailability",
@@ -1033,7 +2852,6 @@ function createMenuPlugin(options) {
         component: (() => {
           const MenuSettingsTab = () => React.createElement(PluginSettingsPanel, {
             title: "Menu Settings",
-            subtitle: "Categories, allergens, and modifiers",
             registries: menuRegistries,
             routeBase: "/settings/menu"
           });