@fayz-ai/plugin-tables 0.10.2 → 0.10.4

package/dist/index.js

@@ -1,11 +1,11 @@
+import { TablesContextProvider } from './chunk-XHRPH676.js';
 import React from 'react';
 import { createStore } from 'zustand/vanilla';
 import { PluginSettingsPanel, dedup } from '@fayz-ai/admin';
 import { toast } from 'sonner';
+import { registerComponent, getSupabaseClientOptional } from '@fayz-ai/core';
 import { createFayzClient } from '@fayz-ai/sdk';
 
-// src/index.ts
-
 // src/data/mock.ts
 var uid = 0;
 function nextId(prefix) {
@@ -60,13 +60,43 @@ function seedTables(zones) {
   tables.push(makeTable(nextId("table"), 12, 2, bar.id, bar.name, "bar", 1, 0));
   return tables;
 }
+var MENU_CATEGORIES = [
+  { id: "c-mains", name: "Pratos" },
+  { id: "c-starters", name: "Entradas" },
+  { id: "c-drinks", name: "Bebidas" },
+  { id: "c-desserts", name: "Sobremesas" }
+];
+var MENU = [
+  { id: "m-1", name: "Picanha na chapa", price: 129.9, categoryId: "c-mains", categoryName: "Pratos" },
+  { id: "m-2", name: "Moqueca de peixe", price: 98, categoryId: "c-mains", categoryName: "Pratos" },
+  { id: "m-3", name: "Bolinho de bacalhau", price: 42, categoryId: "c-starters", categoryName: "Entradas" },
+  { id: "m-4", name: "P\xE3o de alho", price: 18, categoryId: "c-starters", categoryName: "Entradas" },
+  { id: "m-5", name: "Chopp 300ml", price: 14, categoryId: "c-drinks", categoryName: "Bebidas" },
+  { id: "m-6", name: "Suco de laranja", price: 12, categoryId: "c-drinks", categoryName: "Bebidas" },
+  { id: "m-7", name: "Pudim", price: 22, categoryId: "c-desserts", categoryName: "Sobremesas" }
+];
 function createMockTablesProvider() {
   const zones = seedZones();
   const tables = seedTables(zones);
   const sessions = [];
+  const linesBySession = /* @__PURE__ */ new Map();
   function findTable(id) {
     return tables.find((t) => t.id === id) ?? null;
   }
+  function linesOf(sessionId) {
+    let lines = linesBySession.get(sessionId);
+    if (!lines) {
+      lines = [];
+      linesBySession.set(sessionId, lines);
+    }
+    return lines;
+  }
+  function recalc(sessionId) {
+    const total = linesOf(sessionId).reduce((sum, l) => sum + l.total, 0);
+    const session = sessions.find((s) => s.id === sessionId);
+    const table = session ? findTable(session.tableId) : null;
+    if (table) table.currentTotal = total;
+  }
   function matchesQuery(table, query) {
     if (!query) return true;
     if (query.zone && table.zone !== query.zone) return false;
@@ -156,6 +186,8 @@ function createMockTablesProvider() {
       sessions.push(session);
       table.status = "occupied";
       table.currentSessionId = session.id;
+      table.currentOrderId = session.id;
+      table.currentOrderReference = `#${session.id}`;
       table.currentGuests = input.guests;
       table.currentWaiterName = session.waiterName;
       table.currentElapsedMinutes = 0;
@@ -168,6 +200,7 @@ function createMockTablesProvider() {
       if (!session) throw new Error(`Session ${sessionId} not found`);
       session.status = "closed";
       session.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+      linesBySession.delete(session.id);
       const table = findTable(session.tableId);
       if (table) {
         table.status = "cleaning";
@@ -216,6 +249,84 @@ function createMockTablesProvider() {
       const idx = zones.findIndex((z) => z.id === id);
       if (idx !== -1) zones.splice(idx, 1);
     },
+    // ---- The comanda ----
+    async getTableOrder(tableId) {
+      const session = sessions.find((s) => s.tableId === tableId && s.status === "active");
+      if (!session) return null;
+      const lines = linesOf(session.id);
+      const subtotal = lines.reduce((sum, l) => sum + l.total, 0);
+      return {
+        id: session.id,
+        reference: `#${session.id}`,
+        status: "new",
+        guests: session.guests,
+        seatedAt: session.seatedAt,
+        notes: session.notes,
+        waiterId: session.waiterId,
+        waiterName: session.waiterName,
+        lines,
+        // O provider de demonstração não divide conta: participante é o eixo
+        // que só faz sentido com dado real atrás, e uma lista falsa de "Pessoa
+        // 1, Pessoa 2" ensinaria a tela errada a quem está avaliando o produto.
+        participants: [],
+        subtotal,
+        discount: 0,
+        tax: 0,
+        total: subtotal,
+        paid: 0,
+        due: subtotal,
+        currency: "BRL"
+      };
+    },
+    async getMenuCategories() {
+      return MENU_CATEGORIES;
+    },
+    async getMenuItems(search, categoryId) {
+      const term = search?.toLowerCase();
+      return MENU.filter((m) => (!term || m.name.toLowerCase().includes(term)) && (!categoryId || m.categoryId === categoryId));
+    },
+    async addOrderLine(sessionId, input) {
+      linesOf(sessionId).push({
+        id: nextId("line"),
+        productId: input.productId,
+        name: input.name,
+        quantity: input.quantity,
+        unitPrice: input.unitPrice,
+        discount: 0,
+        total: input.unitPrice * input.quantity,
+        notes: input.notes
+      });
+      recalc(sessionId);
+    },
+    async setOrderLineQuantity(lineId, quantity) {
+      for (const [sessionId, lines] of linesBySession) {
+        const idx = lines.findIndex((l) => l.id === lineId);
+        if (idx === -1) continue;
+        if (quantity <= 0) lines.splice(idx, 1);
+        else {
+          lines[idx].quantity = quantity;
+          lines[idx].total = lines[idx].unitPrice * quantity;
+        }
+        recalc(sessionId);
+        return;
+      }
+    },
+    async removeOrderLine(lineId) {
+      for (const [sessionId, lines] of linesBySession) {
+        const idx = lines.findIndex((l) => l.id === lineId);
+        if (idx === -1) continue;
+        lines.splice(idx, 1);
+        recalc(sessionId);
+        return;
+      }
+    },
+    async updateSessionGuests(sessionId, guests) {
+      const session = sessions.find((s) => s.id === sessionId);
+      if (!session) return;
+      session.guests = guests;
+      const table = findTable(session.tableId);
+      if (table) table.currentGuests = guests;
+    },
     // ---- Summary ----
     async getSummary() {
       const available = tables.filter((t) => t.status === "available").length;
@@ -260,6 +371,14 @@ function createTablesStore(provider) {
     summary: null,
     summaryLoading: false,
     selectedTableId: null,
+    openOrder: null,
+    openOrderLoading: false,
+    activeGuestId: null,
+    settings: null,
+    cancelReasons: [],
+    transfers: [],
+    comandaSupported: typeof provider.getTableOrder === "function",
+    menuCategories: [],
     async fetchTables(query) {
       return dedup("tables:tables:" + JSON.stringify(query), async () => {
         set({ tablesLoading: true });
@@ -295,8 +414,217 @@ function createTablesStore(provider) {
         set({ summary, summaryLoading: false });
       });
     },
+    /** After a write. Deliberately not `fetchTables`: that one dedups, and a
+     *  refresh that joins an in-flight read shows the state before the write. */
+    async refreshAfterWrite() {
+      const tableId = get().selectedTableId;
+      const [tables, summary] = await Promise.all([
+        provider.getTables(),
+        provider.getSummary()
+      ]);
+      set({ tables, summary });
+      if (tableId) await get().fetchOpenOrder(tableId);
+    },
     selectTable(id) {
-      set({ selectedTableId: id });
+      set({ selectedTableId: id, openOrder: null, activeGuestId: null, transfers: [] });
+      if (id) void get().fetchOpenOrder(id);
+    },
+    async fetchOpenOrder(tableId) {
+      if (!provider.getTableOrder) return;
+      set({ openOrderLoading: true });
+      try {
+        const openOrder = await provider.getTableOrder(tableId);
+        if (get().selectedTableId !== tableId) return;
+        set({ openOrder });
+      } catch (err) {
+        set({ openOrder: null });
+        toast.error("N\xE3o foi poss\xEDvel ler a comanda", { description: err?.message });
+      } finally {
+        set({ openOrderLoading: false });
+      }
+    },
+    async fetchMenuCategories() {
+      if (!provider.getMenuCategories) return;
+      return dedup("tables:menuCategories", async () => {
+        try {
+          set({ menuCategories: await provider.getMenuCategories() });
+        } catch {
+          set({ menuCategories: [] });
+        }
+      });
+    },
+    async addOrderLine(input) {
+      const order = get().openOrder;
+      if (!order || !provider.addOrderLine) return;
+      try {
+        await provider.addOrderLine(order.id, input);
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel lan\xE7ar o item", { description: err?.message });
+        throw err;
+      }
+    },
+    async setOrderLineQuantity(lineId, quantity) {
+      if (!provider.setOrderLineQuantity) return;
+      try {
+        await provider.setOrderLineQuantity(lineId, quantity);
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel alterar o item", { description: err?.message });
+      }
+    },
+    selectGuest(guestId) {
+      set({ activeGuestId: guestId });
+    },
+    async fetchSettings() {
+      if (!provider.getSettings) return;
+      try {
+        set({ settings: await provider.getSettings() });
+      } catch {
+        set({ settings: null });
+      }
+    },
+    async saveSettings(patch) {
+      if (!provider.saveSettings) return;
+      try {
+        await provider.saveSettings(patch);
+        await get().fetchSettings();
+        await get().refreshAfterWrite();
+        toast.success("Configura\xE7\xF5es salvas");
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel salvar", { description: err?.message });
+      }
+    },
+    async addGuest(label) {
+      const order = get().openOrder;
+      if (!order || !provider.addGuest) return;
+      try {
+        const guest = await provider.addGuest(order.id, label);
+        set({ activeGuestId: guest.id });
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel acrescentar o participante", { description: err?.message });
+      }
+    },
+    async removeGuest(guestId) {
+      if (!provider.removeGuest) return;
+      try {
+        await provider.removeGuest(guestId);
+        if (get().activeGuestId === guestId) set({ activeGuestId: null });
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel remover o participante", { description: err?.message });
+      }
+    },
+    async setGuestServiceCharge(guestId, percent) {
+      if (!provider.setGuestServiceCharge) return;
+      try {
+        await provider.setGuestServiceCharge(guestId, percent);
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel mudar a taxa", { description: err?.message });
+      }
+    },
+    async setOrderServiceCharge(percent) {
+      const order = get().openOrder;
+      if (!order || !provider.setOrderServiceCharge) return;
+      try {
+        await provider.setOrderServiceCharge(order.id, percent);
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel mudar a taxa", { description: err?.message });
+      }
+    },
+    async discountLines(input) {
+      const order = get().openOrder;
+      if (!order || !provider.discountLines) return;
+      try {
+        await provider.discountLines(order.id, input);
+        await get().refreshAfterWrite();
+        toast.success("Desconto aplicado");
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel aplicar o desconto", { description: err?.message });
+      }
+    },
+    async fetchCancelReasons() {
+      if (!provider.getCancelReasons) return;
+      try {
+        set({ cancelReasons: await provider.getCancelReasons() });
+      } catch {
+        set({ cancelReasons: [] });
+      }
+    },
+    async addCancelReason(label) {
+      if (!provider.addCancelReason) return;
+      try {
+        await provider.addCancelReason(label);
+        await get().fetchCancelReasons();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel criar o motivo", { description: err?.message });
+      }
+    },
+    async updateCancelReason(id, patch) {
+      if (!provider.updateCancelReason) return;
+      try {
+        await provider.updateCancelReason(id, patch);
+        await get().fetchCancelReasons();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel alterar o motivo", { description: err?.message });
+      }
+    },
+    async deleteCancelReason(id) {
+      if (!provider.deleteCancelReason) return;
+      try {
+        await provider.deleteCancelReason(id);
+        await get().fetchCancelReasons();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel excluir o motivo", { description: err?.message });
+      }
+    },
+    async cancelLines(input) {
+      const order = get().openOrder;
+      if (!order || !provider.cancelLines) return;
+      try {
+        await provider.cancelLines(order.id, input);
+        await get().refreshAfterWrite();
+        toast.success(input.lineIds.length === 1 ? "Item cancelado" : `${input.lineIds.length} itens cancelados`);
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel cancelar", { description: err?.message });
+      }
+    },
+    async transfer(input) {
+      const order = get().openOrder;
+      if (!order || !provider.transfer) return;
+      try {
+        await provider.transfer(order.id, input);
+        await get().refreshAfterWrite();
+        await get().fetchTransfers();
+        toast.success("Transfer\xEAncia feita");
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel transferir", { description: err?.message });
+      }
+    },
+    async fetchTransfers() {
+      const order = get().openOrder;
+      if (!order || !provider.getTransfers) {
+        set({ transfers: [] });
+        return;
+      }
+      try {
+        set({ transfers: await provider.getTransfers(order.id) });
+      } catch {
+        set({ transfers: [] });
+      }
+    },
+    async setSessionGuests(guests) {
+      const order = get().openOrder;
+      if (!order || !provider.updateSessionGuests) return;
+      try {
+        await provider.updateSessionGuests(order.id, guests);
+        await get().refreshAfterWrite();
+      } catch (err) {
+        toast.error("N\xE3o foi poss\xEDvel mudar o n\xFAmero de pessoas", { description: err?.message });
+      }
     },
     async seatGuests(input) {
       try {
@@ -307,10 +635,12 @@ function createTablesStore(provider) {
           provider.getSummary()
         ]);
         set({ tables, activeSessions, summary });
-        toast.success("Guests seated");
+        const tableId = get().selectedTableId;
+        if (tableId) await get().fetchOpenOrder(tableId);
+        toast.success("Mesa aberta");
         return session;
       } catch (err) {
-        toast.error("Failed to seat guests", { description: err?.message });
+        toast.error("N\xE3o foi poss\xEDvel abrir a mesa", { description: err?.message });
         throw err;
       }
     },
@@ -322,10 +652,10 @@ function createTablesStore(provider) {
           provider.getActiveSessions(),
           provider.getSummary()
         ]);
-        set({ tables, activeSessions, summary });
-        toast.success("Session closed");
+        set({ tables, activeSessions, summary, openOrder: null });
+        toast.success("Conta fechada");
       } catch (err) {
-        toast.error("Failed to close session", { description: err?.message });
+        toast.error("N\xE3o foi poss\xEDvel fechar a conta", { description: err?.message });
         throw err;
       }
     },
@@ -337,9 +667,9 @@ function createTablesStore(provider) {
           provider.getSummary()
         ]);
         set({ tables, summary });
-        toast.success("Table status updated");
+        toast.success("Mesa atualizada");
       } catch (err) {
-        toast.error("Failed to update table status", { description: err?.message });
+        toast.error("N\xE3o foi poss\xEDvel atualizar a mesa", { description: err?.message });
         throw err;
       }
     },
@@ -351,10 +681,10 @@ function createTablesStore(provider) {
           provider.getSummary()
         ]);
         set({ tables, summary });
-        toast.success("Table created");
+        toast.success("Mesa criada");
         return table;
       } catch (err) {
-        toast.error("Failed to create table", { description: err?.message });
+        toast.error("N\xE3o foi poss\xEDvel criar a mesa", { description: err?.message });
         throw err;
       }
     }
@@ -370,12 +700,67 @@ var zoneEntity = {
   defaultSort: "sortOrder",
   fields: [
     { key: "name", label: "Name", type: "text", required: true, showInTable: true },
-    { key: "color", label: "Color", type: "text", showInTable: true },
+    { key: "color", label: "Color", type: "color", showInTable: true },
     { key: "sortOrder", label: "Order", type: "number", showInTable: true, defaultValue: 0 },
     { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
   ],
-  data: { table: "restaurant_zones", tenantScoped: true }
+  data: { table: "plg_tables_zones", tenantScoped: true }
 };
+var tableEntity = {
+  name: "Table",
+  namePlural: "Tables",
+  icon: "Utensils",
+  displayField: "name",
+  defaultSort: "number",
+  fields: [
+    { key: "number", label: "Number", type: "number", required: true, showInTable: true },
+    { key: "name", label: "Name", type: "text", required: true, showInTable: true },
+    { key: "seats", label: "Seats", type: "number", showInTable: true, defaultValue: 2 },
+    // The zone is a real FK, so it is picked from the zones registry rather
+    // than typed: the salão a mesa belongs to has to be one that exists, and
+    // `v_tables` joins on this id to group the floor plan.
+    {
+      key: "zoneId",
+      label: "Zone",
+      type: "relation",
+      relation: { table: "plg_tables_zones", labelField: "name" },
+      showInTable: true
+    },
+    {
+      key: "shape",
+      label: "Shape",
+      type: "select",
+      showInTable: true,
+      defaultValue: "square",
+      options: [
+        { value: "square", label: "Square" },
+        { value: "round", label: "Round" },
+        { value: "rectangle", label: "Rectangle" },
+        { value: "bar", label: "Bar" }
+      ]
+    },
+    // `occupied` is deliberately absent: a mesa is occupied when a comanda is
+    // open on it, which `v_tables` derives. Offering it here would let someone
+    // type a state the floor plan then contradicts.
+    {
+      key: "status",
+      label: "Status",
+      type: "select",
+      showInTable: true,
+      defaultValue: "available",
+      options: [
+        { value: "available", label: "Available" },
+        { value: "reserved", label: "Reserved" },
+        { value: "cleaning", label: "Cleaning" }
+      ]
+    },
+    { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
+  ],
+  data: { table: "plg_tables_tables", tenantScoped: true }
+};
+zoneEntity.relatedLists = [
+  { entity: tableEntity, foreignKey: "zoneId", label: "Tables", icon: "Utensils" }
+];
 var tablesRegistries = [
   {
     id: "zones",
@@ -383,11 +768,20 @@ var tablesRegistries = [
     icon: "MapPin",
     description: "Floor plan zones (indoor, outdoor, bar, etc.)",
     display: "table",
+    // No seed ids: the primary key is a uuid the database generates, and the
+    // hand-written 'z-indoor' this used to carry could never be inserted.
     seedData: [
-      { id: "z-indoor", name: "Indoor", color: "#3b82f6", sortOrder: 0, isActive: true },
-      { id: "z-outdoor", name: "Outdoor", color: "#22c55e", sortOrder: 1, isActive: true },
-      { id: "z-bar", name: "Bar", color: "#f59e0b", sortOrder: 2, isActive: true }
+      { name: "Indoor", color: "#3b82f6", sortOrder: 0, isActive: true },
+      { name: "Outdoor", color: "#22c55e", sortOrder: 1, isActive: true },
+      { name: "Bar", color: "#f59e0b", sortOrder: 2, isActive: true }
     ]
+  },
+  {
+    id: "tables",
+    entity: tableEntity,
+    icon: "Utensils",
+    description: "The mesas themselves \u2014 number, seats and which zone they sit in.",
+    display: "table"
   }
 ];
 
@@ -398,6 +792,7 @@ var en = {
   "tables.nav.zones": "Zones",
   "tables.nav.history": "Session History",
   "tables.floorPlan.title": "Floor Plan",
+  "tables.floorPlan.manage": "Manage tables and zones",
   "tables.floorPlan.subtitle": "Manage table layout and seating",
   "tables.floorPlan.available": "Available",
   "tables.floorPlan.occupied": "Occupied",
@@ -435,7 +830,53 @@ var en = {
   "tables.history.waiter": "Waiter",
   "tables.history.duration": "Duration",
   "tables.history.noSessions": "No session history yet",
-  "tables.settings.title": "Tables Settings"
+  "tables.settings.title": "Tables Settings",
+  // -- The table's panel (right rail) ----------------------------------------
+  "tables.panel.ticket": "Ticket",
+  "tables.panel.ticketLoading": "Reading the ticket\u2026",
+  "tables.panel.ticketEmpty": "Empty ticket",
+  "tables.panel.ticketEmptyDesc": "Nothing has been rung up for this table yet.",
+  "tables.panel.noReader": "This install does not read tickets from the floor plan \u2014 open the order under Orders.",
+  "tables.panel.addItem": "Add item",
+  "tables.panel.searchMenu": "Search the menu",
+  "tables.panel.menuEmpty": "Nothing by that name on the menu.",
+  "tables.panel.each": "each",
+  "tables.panel.addOne": "Add {item}",
+  "tables.panel.removeOne": "Remove one {item}",
+  "tables.panel.removeItem": "Remove {item}",
+  "tables.panel.howManyGuests": "How many guests",
+  "tables.panel.guestsAtTable": "Guests at the table",
+  "tables.panel.oneLess": "One guest fewer",
+  "tables.panel.oneMore": "One guest more",
+  "tables.panel.overCapacity": "This table seats {seats}, for {guests} guests.",
+  "tables.panel.tableNote": "Table note",
+  "tables.panel.cleaningDesc": "The table is out of service for cleaning. Mark it ready to free it up.",
+  "tables.panel.subtotal": "Subtotal",
+  "tables.panel.service": "Service {percent}%",
+  "tables.panel.serviceMixed": "Service (mixed rates)",
+  "tables.panel.cancelledTotal": "Cancelled",
+  "tables.panel.paid": "Paid",
+  "tables.panel.due": "Balance due",
+  "tables.panel.discount": "Discount",
+  "tables.panel.total": "Total",
+  "tables.panel.perPerson": "Per person ({guests})",
+  "tables.panel.openTable": "Open table",
+  "tables.panel.cancelReservation": "Cancel reservation",
+  "tables.panel.seat": "Seat",
+  "tables.panel.closeBill": "Close bill",
+  "tables.panel.backToTicket": "Back to the ticket",
+  "tables.panel.closingEmpty": "This ticket has nothing on it.",
+  "tables.panel.closingSummary": "{count} items \xB7 {total}",
+  "tables.panel.closingSummaryOne": "1 item \xB7 {total}",
+  "tables.panel.closingPerPerson": "{amount} per person",
+  "tables.panel.confirmClose": "Confirm close",
+  "tables.panel.guestOne": "guest",
+  "tables.panel.guestMany": "guests",
+  "tables.panel.pickerTitle": "Pick items",
+  "tables.panel.allCategories": "All",
+  "tables.panel.columnItem": "Item",
+  "tables.panel.columnCategory": "Category",
+  "tables.panel.columnPrice": "Price"
 };
 
 // src/locales/pt-BR.ts
@@ -445,6 +886,7 @@ var ptBR = {
   "tables.nav.zones": "\xC1reas",
   "tables.nav.history": "Hist\xF3rico",
   "tables.floorPlan.title": "Mapa de Mesas",
+  "tables.floorPlan.manage": "Cadastrar mesas e sal\xF5es",
   "tables.floorPlan.subtitle": "Gerencie o layout e a ocupa\xE7\xE3o das mesas",
   "tables.floorPlan.available": "Dispon\xEDvel",
   "tables.floorPlan.occupied": "Ocupada",
@@ -482,7 +924,53 @@ var ptBR = {
   "tables.history.waiter": "Gar\xE7om",
   "tables.history.duration": "Dura\xE7\xE3o",
   "tables.history.noSessions": "Nenhum hist\xF3rico de sess\xF5es",
-  "tables.settings.title": "Configura\xE7\xF5es de Mesas"
+  "tables.settings.title": "Configura\xE7\xF5es de Mesas",
+  // -- The mesa's panel (right rail) -----------------------------------------
+  "tables.panel.ticket": "Comanda",
+  "tables.panel.ticketLoading": "Lendo a comanda\u2026",
+  "tables.panel.ticketEmpty": "Comanda vazia",
+  "tables.panel.ticketEmptyDesc": "Nada foi lan\xE7ado ainda para esta mesa.",
+  "tables.panel.noReader": "Esta instala\xE7\xE3o n\xE3o l\xEA comandas pelo mapa de mesas \u2014 abra o pedido em Pedidos.",
+  "tables.panel.addItem": "Lan\xE7ar item",
+  "tables.panel.searchMenu": "Buscar no card\xE1pio",
+  "tables.panel.menuEmpty": "Nada com esse nome no card\xE1pio.",
+  "tables.panel.each": "cada",
+  "tables.panel.addOne": "Adicionar {item}",
+  "tables.panel.removeOne": "Tirar um {item}",
+  "tables.panel.removeItem": "Remover {item}",
+  "tables.panel.howManyGuests": "Quantas pessoas",
+  "tables.panel.guestsAtTable": "Pessoas na mesa",
+  "tables.panel.oneLess": "Menos uma pessoa",
+  "tables.panel.oneMore": "Mais uma pessoa",
+  "tables.panel.overCapacity": "Esta mesa tem {seats} lugares para {guests} pessoas.",
+  "tables.panel.tableNote": "Observa\xE7\xE3o da mesa",
+  "tables.panel.cleaningDesc": "A mesa saiu de servi\xE7o e est\xE1 em limpeza. Marque como pronta para liber\xE1-la.",
+  "tables.panel.subtotal": "Subtotal",
+  "tables.panel.service": "Servi\xE7o {percent}%",
+  "tables.panel.serviceMixed": "Servi\xE7o (taxas diferentes)",
+  "tables.panel.cancelledTotal": "Cancelado",
+  "tables.panel.paid": "J\xE1 pago",
+  "tables.panel.due": "Saldo devedor",
+  "tables.panel.discount": "Desconto",
+  "tables.panel.total": "Total",
+  "tables.panel.perPerson": "Por pessoa ({guests})",
+  "tables.panel.openTable": "Abrir mesa",
+  "tables.panel.cancelReservation": "Cancelar reserva",
+  "tables.panel.seat": "Sentar",
+  "tables.panel.closeBill": "Fechar conta",
+  "tables.panel.backToTicket": "Voltar \xE0 comanda",
+  "tables.panel.closingEmpty": "Esta comanda n\xE3o tem nenhum item lan\xE7ado.",
+  "tables.panel.closingSummary": "{count} itens \xB7 {total}",
+  "tables.panel.closingSummaryOne": "1 item \xB7 {total}",
+  "tables.panel.closingPerPerson": "{amount} por pessoa",
+  "tables.panel.confirmClose": "Confirmar fechamento",
+  "tables.panel.guestOne": "pessoa",
+  "tables.panel.guestMany": "pessoas",
+  "tables.panel.pickerTitle": "Selecionar itens",
+  "tables.panel.allCategories": "Tudo",
+  "tables.panel.columnItem": "Item",
+  "tables.panel.columnCategory": "Categoria",
+  "tables.panel.columnPrice": "Pre\xE7o"
 };
 
 // src/locales/index.ts
@@ -752,9 +1240,702 @@ function createFayzTablesProvider(options = {}) {
     }
   };
 }
+var ZONES = "plg_tables_zones";
+var TABLES = "plg_tables_tables";
+var ORDER_EXT = "plg_tables_order_extensions";
+var VIEW = "v_tables";
+var LINES = "items";
+var CATALOG = "products";
+var SETTINGS = "plg_tables_settings";
+var GUESTS = "plg_tables_order_guests";
+var ITEM_GUESTS = "plg_tables_item_guests";
+var CANCEL_REASONS = "plg_tables_cancel_reasons";
+var TRANSFERS = "plg_tables_order_transfers";
+var GUESTS_VIEW = "v_comanda_guests";
+var BALANCES = "v_invoice_balances";
+var SECTIONS = "plg_menu_sections";
+var PLACEMENTS = "plg_menu_placements";
+var SEATING_KIND = "dine_in";
+var READ_ONLY = "This provider reads the floor plan; pass `writes` to let the app that owns it change tables.";
+function createCoreTablesProvider(options) {
+  const db = () => {
+    const client = getSupabaseClientOptional();
+    if (!client) throw new Error("Supabase client is not configured");
+    return client;
+  };
+  function requireWrites() {
+    if (!options?.writes) throw new Error(READ_ONLY);
+    return options.writes;
+  }
+  async function nextReference() {
+    const spec = options?.writes?.reference;
+    if (!spec) return void 0;
+    try {
+      const { data, error } = await db().rpc("next_sequence_authorized", {
+        p_kind: spec.sequenceKind,
+        p_permission: spec.permission ?? "orders.create"
+      });
+      if (error) throw new Error(error.message);
+      return `${spec.prefix ?? ""}${String(data).padStart(spec.pad ?? 6, "0")}`;
+    } catch (err) {
+      console.warn("[tables] next_sequence_authorized unavailable:", err?.message);
+      return void 0;
+    }
+  }
+  function tenant() {
+    const id = requireWrites().tenantId();
+    if (!id) throw new Error("No active organization: the floor plan cannot be changed without one");
+    return id;
+  }
+  function shortRef(orderId) {
+    return orderId ? `#${String(orderId).slice(0, 8)}` : void 0;
+  }
+  function num(value) {
+    return Number(value) || 0;
+  }
+  function rowToLine(r) {
+    const meta = r.metadata ?? {};
+    return {
+      id: r.id,
+      productId: r.product_id ?? void 0,
+      name: r.name ?? "",
+      quantity: num(r.quantity),
+      unitPrice: num(r.unit_price),
+      discount: num(r.discount),
+      total: num(r.total),
+      notes: typeof meta.kitchenNotes === "string" ? meta.kitchenNotes : void 0,
+      guestId: r.guest_id ?? void 0,
+      cancelledAt: r.cancelled_at ?? void 0,
+      cancelReason: r.cancel_reason ?? void 0
+    };
+  }
+  function rowToGuest(r) {
+    return {
+      id: r.id,
+      seatNo: Number(r.seat_no) || 0,
+      label: r.label ?? void 0,
+      ownServiceChargePercent: r.own_service_charge_percent == null ? void 0 : num(r.own_service_charge_percent),
+      serviceChargePercent: num(r.service_charge_percent),
+      subtotal: num(r.subtotal),
+      serviceCharge: num(r.service_charge),
+      cancelledTotal: num(r.cancelled_total),
+      itemCount: Number(r.item_count) || 0
+    };
+  }
+  async function recalc(orderId) {
+    const { error } = await db().rpc("comanda_recalc", { p_order_id: orderId });
+    if (error) throw new Error(error.message);
+  }
+  function rowToTable2(r) {
+    const elapsed = r.seated_at ? Math.max(0, Math.round((Date.now() - new Date(r.seated_at).getTime()) / 6e4)) : void 0;
+    return {
+      id: r.id,
+      name: r.name,
+      number: Number(r.number) || 0,
+      seats: Number(r.seats) || 0,
+      status: r.status ?? "available",
+      zone: r.zone_id ?? "",
+      zoneName: r.zone_name ?? void 0,
+      shape: r.shape ?? "square",
+      gridCol: Number(r.grid_col) || 0,
+      gridRow: Number(r.grid_row) || 0,
+      isActive: r.is_active !== false,
+      // The session IS the comanda, so the two ids are deliberately the same:
+      // closing one closes the other, and there is no third row to disagree.
+      currentSessionId: r.current_order_id ?? void 0,
+      currentOrderId: r.current_order_id ?? void 0,
+      // A comanda opened by `seatGuests` has no reference_number — nothing in
+      // the pool numbers one — so the short id stands in. It is still shorter
+      // than the uuid the panel used to print in full.
+      currentOrderReference: r.current_order_reference ?? shortRef(r.current_order_id),
+      currentGuests: r.current_guests ?? void 0,
+      currentElapsedMinutes: r.current_order_id ? elapsed : void 0,
+      currentTotal: r.current_order_id ? Number(r.current_total) || 0 : void 0,
+      tenantId: r.tenant_id,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    };
+  }
+  async function loadTables(query) {
+    let q = db().from(VIEW).select("*").order("number");
+    if (query?.zone) q = q.eq("zone_id", query.zone);
+    if (query?.search) q = q.ilike("name", `%${query.search}%`);
+    const { data, error } = await q;
+    if (error) throw new Error(error.message);
+    let tables = (data ?? []).map(rowToTable2);
+    if (query?.status) {
+      const wanted = Array.isArray(query.status) ? query.status : [query.status];
+      tables = tables.filter((t) => wanted.includes(t.status));
+    }
+    return tables;
+  }
+  async function tableById(id) {
+    const { data, error } = await db().from(VIEW).select("*").eq("id", id).maybeSingle();
+    if (error) throw new Error(error.message);
+    if (!data) throw new Error("Table not found");
+    return rowToTable2(data);
+  }
+  async function openSeatings(tableId) {
+    let q = db().from(ORDER_EXT).select("order_id, table_id, guests, seated_at, tenant_id, orders!inner(id, status, notes, assignee_id)").not("orders.status", "in", '("completed","cancelled")');
+    const { data, error } = await q;
+    if (error) throw new Error(error.message);
+    return data ?? [];
+  }
+  function rowToSession(r, tableName) {
+    const order = Array.isArray(r.orders) ? r.orders[0] : r.orders;
+    const closed = order && ["completed", "cancelled"].includes(order.status);
+    return {
+      id: r.order_id,
+      tableId: r.table_id,
+      tableName,
+      orderId: r.order_id,
+      guests: r.guests ?? 0,
+      waiterId: order?.assignee_id ?? void 0,
+      seatedAt: r.seated_at,
+      status: closed ? "closed" : "active",
+      notes: order?.notes ?? void 0,
+      tenantId: r.tenant_id,
+      createdAt: r.seated_at
+    };
+  }
+  return {
+    getTables: (query) => loadTables(query),
+    async getTableById(id) {
+      const { data, error } = await db().from(VIEW).select("*").eq("id", id).maybeSingle();
+      if (error) throw new Error(error.message);
+      return data ? rowToTable2(data) : null;
+    },
+    async createTable(input) {
+      const tenantId = tenant();
+      const { data, error } = await db().from(TABLES).insert({
+        tenant_id: tenantId,
+        zone_id: input.zone || null,
+        name: input.name,
+        number: input.number,
+        seats: input.seats,
+        shape: input.shape ?? "square",
+        grid_col: input.gridCol ?? 0,
+        grid_row: input.gridRow ?? 0
+      }).select("id").single();
+      if (error) throw new Error(error.message);
+      return tableById(data.id);
+    },
+    async updateTable(id, data) {
+      requireWrites();
+      const patch = {};
+      if (data.name !== void 0) patch.name = data.name;
+      if (data.number !== void 0) patch.number = data.number;
+      if (data.seats !== void 0) patch.seats = data.seats;
+      if (data.shape !== void 0) patch.shape = data.shape;
+      if (data.zone !== void 0) patch.zone_id = data.zone || null;
+      if (data.gridCol !== void 0) patch.grid_col = data.gridCol;
+      if (data.gridRow !== void 0) patch.grid_row = data.gridRow;
+      if (data.isActive !== void 0) patch.is_active = data.isActive;
+      if (data.status !== void 0 && data.status !== "occupied") patch.status = data.status;
+      if (Object.keys(patch).length) {
+        const { error } = await db().from(TABLES).update(patch).eq("id", id);
+        if (error) throw new Error(error.message);
+      }
+      return tableById(id);
+    },
+    async deleteTable(id) {
+      requireWrites();
+      const { error } = await db().from(TABLES).delete().eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async updateTableStatus(input) {
+      requireWrites();
+      if (input.status === "occupied") {
+        throw new Error('Uma mesa fica ocupada ao abrir a comanda \u2014 use "sentar" em vez de marcar o estado.');
+      }
+      const { error } = await db().from(TABLES).update({ status: input.status }).eq("id", input.tableId);
+      if (error) throw new Error(error.message);
+      return tableById(input.tableId);
+    },
+    async updateTablePositions(positions) {
+      requireWrites();
+      for (const p of positions) {
+        const { error } = await db().from(TABLES).update({ grid_col: p.gridCol, grid_row: p.gridRow }).eq("id", p.id);
+        if (error) throw new Error(error.message);
+      }
+    },
+    async seatGuests(input) {
+      const tenantId = tenant();
+      const table = await tableById(input.tableId);
+      if (table.status === "occupied") throw new Error(`${table.name} j\xE1 tem uma comanda aberta`);
+      const reference = await nextReference();
+      const { data: order, error } = await db().from("orders").insert({
+        tenant_id: tenantId,
+        kind: SEATING_KIND,
+        status: "new",
+        channel: "dine_in",
+        ...reference ? { reference_number: reference } : {},
+        ...input.waiterId ? { assignee_id: input.waiterId } : {},
+        ...input.notes ? { notes: input.notes } : {},
+        subtotal: 0,
+        total: 0,
+        currency: "BRL"
+      }).select("id, status, notes, assignee_id").single();
+      if (error) throw new Error(error.message);
+      const { data: ext, error: extError } = await db().from(ORDER_EXT).insert({
+        order_id: order.id,
+        tenant_id: tenantId,
+        table_id: input.tableId,
+        guests: input.guests
+      }).select("order_id, table_id, guests, seated_at, tenant_id").single();
+      if (extError) {
+        await db().from("orders").delete().eq("id", order.id);
+        throw new Error(extError.message);
+      }
+      return rowToSession({ ...ext, orders: order }, table.name);
+    },
+    async closeSession(sessionId) {
+      requireWrites();
+      const { data: order, error } = await db().from("orders").update({ status: "completed" }).eq("id", sessionId).select("id, status, notes, assignee_id").single();
+      if (error) throw new Error(error.message);
+      const { data: ext } = await db().from(ORDER_EXT).select("order_id, table_id, guests, seated_at, tenant_id").eq("order_id", sessionId).maybeSingle();
+      return rowToSession({ ...ext ?? { order_id: sessionId }, orders: order });
+    },
+    async getActiveSessions() {
+      const [rows, tables] = await Promise.all([openSeatings(), loadTables()]);
+      const names = new Map(tables.map((t) => [t.id, t.name]));
+      return rows.map((r) => rowToSession(r, names.get(r.table_id)));
+    },
+    async getSessionHistory(tableId) {
+      let q = db().from(ORDER_EXT).select("order_id, table_id, guests, seated_at, tenant_id, orders(id, status, notes, assignee_id)").order("seated_at", { ascending: false }).limit(200);
+      if (tableId) q = q.eq("table_id", tableId);
+      const { data, error } = await q;
+      if (error) throw new Error(error.message);
+      const names = new Map((await loadTables()).map((t) => [t.id, t.name]));
+      return (data ?? []).map((r) => rowToSession(r, names.get(r.table_id)));
+    },
+    async getZones() {
+      const { data, error } = await db().from(ZONES).select("*").order("sort_order");
+      if (error) throw new Error(error.message);
+      return (data ?? []).map((z) => ({
+        id: z.id,
+        name: z.name,
+        color: z.color ?? void 0,
+        sortOrder: z.sort_order ?? 0,
+        isActive: z.is_active !== false,
+        tenantId: z.tenant_id,
+        createdAt: z.created_at
+      }));
+    },
+    async createZone(data) {
+      const tenantId = tenant();
+      const { data: row, error } = await db().from(ZONES).insert({
+        tenant_id: tenantId,
+        name: data.name ?? "Sal\xE3o",
+        color: data.color ?? null,
+        sort_order: data.sortOrder ?? 0
+      }).select("*").single();
+      if (error) throw new Error(error.message);
+      return {
+        id: row.id,
+        name: row.name,
+        color: row.color ?? void 0,
+        sortOrder: row.sort_order ?? 0,
+        isActive: true,
+        tenantId: row.tenant_id,
+        createdAt: row.created_at
+      };
+    },
+    async updateZone(id, data) {
+      requireWrites();
+      const patch = {};
+      if (data.name !== void 0) patch.name = data.name;
+      if (data.color !== void 0) patch.color = data.color;
+      if (data.sortOrder !== void 0) patch.sort_order = data.sortOrder;
+      if (data.isActive !== void 0) patch.is_active = data.isActive;
+      const { data: row, error } = await db().from(ZONES).update(patch).eq("id", id).select("*").single();
+      if (error) throw new Error(error.message);
+      return {
+        id: row.id,
+        name: row.name,
+        color: row.color ?? void 0,
+        sortOrder: row.sort_order ?? 0,
+        isActive: row.is_active !== false,
+        tenantId: row.tenant_id,
+        createdAt: row.created_at
+      };
+    },
+    async deleteZone(id) {
+      requireWrites();
+      const { error } = await db().from(ZONES).delete().eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    // -- The comanda ---------------------------------------------------------
+    async getTableOrder(tableId) {
+      const { data, error } = await db().from(ORDER_EXT).select("order_id, guests, seated_at, service_charge_percent, orders!inner(id, reference_number, status, notes, assignee_id, party_id, subtotal, discount, tax, total, currency)").eq("table_id", tableId).not("orders.status", "in", '("completed","cancelled")').order("seated_at", { ascending: false }).limit(1);
+      if (error) throw new Error(error.message);
+      const row = (data ?? [])[0];
+      if (!row) return null;
+      const order = Array.isArray(row.orders) ? row.orders[0] : row.orders;
+      const [
+        { data: lines, error: linesError },
+        { data: people },
+        { data: guestRows },
+        { data: itemGuests },
+        { data: balance }
+      ] = await Promise.all([
+        // `cancelled_at` e `cancel_reason` entram no select: a linha cancelada
+        // CONTINUA na comanda, riscada. Filtrá-la aqui esconderia justamente o
+        // que o gerente abre a comanda para ver.
+        db().from(LINES).select("id, product_id, name, quantity, unit_price, discount, total, sort_order, metadata, cancelled_at, cancel_reason").eq("order_id", order.id).order("sort_order"),
+        order.assignee_id || order.party_id ? db().from("people").select("id, name").in("id", [order.assignee_id, order.party_id].filter(Boolean)) : Promise.resolve({ data: [] }),
+        db().from(GUESTS_VIEW).select("*").eq("order_id", order.id).order("seat_no"),
+        db().from(ITEM_GUESTS).select("item_id, guest_id"),
+        db().from(BALANCES).select("paid, balance").eq("invoice_id", order.id).maybeSingle()
+      ]);
+      if (linesError) throw new Error(linesError.message);
+      const nameById = new Map((people ?? []).map((p) => [p.id, p.name]));
+      const guestOfItem = new Map(
+        (itemGuests ?? []).map((r) => [r.item_id, r.guest_id])
+      );
+      return {
+        id: order.id,
+        reference: order.reference_number ?? shortRef(order.id),
+        status: order.status,
+        guests: row.guests ?? 0,
+        seatedAt: row.seated_at,
+        notes: order.notes ?? void 0,
+        waiterId: order.assignee_id ?? void 0,
+        waiterName: order.assignee_id ? nameById.get(order.assignee_id) : void 0,
+        partyName: order.party_id ? nameById.get(order.party_id) : void 0,
+        lines: (lines ?? []).map((l) => rowToLine({ ...l, guest_id: guestOfItem.get(l.id) ?? null })),
+        participants: (guestRows ?? []).map(rowToGuest),
+        serviceChargePercent: row.service_charge_percent == null ? void 0 : num(row.service_charge_percent),
+        subtotal: num(order.subtotal),
+        discount: num(order.discount),
+        tax: num(order.tax),
+        total: num(order.total),
+        // Sem fatura levantada ainda, nada foi pago e tudo é devido. É a
+        // resposta certa e não um buraco: a comanda aberta é, por definição,
+        // dinheiro a receber.
+        paid: num(balance?.paid),
+        due: balance ? num(balance.balance) : num(order.total),
+        currency: order.currency ?? "BRL"
+      };
+    },
+    async getMenuCategories() {
+      const sections = await db().from(SECTIONS).select("id, name, sort_order").eq("is_active", true).order("sort_order");
+      if (!sections.error && (sections.data ?? []).length > 0) {
+        return (sections.data ?? []).map((r) => ({ id: r.id, name: r.name }));
+      }
+      const { data, error } = await db().from("categories").select("id, name").order("name");
+      if (error) throw new Error(error.message);
+      return (data ?? []).map((c) => ({ id: c.id, name: c.name }));
+    },
+    async getMenuItems(search, categoryId) {
+      let sectionFilter = null;
+      if (categoryId) {
+        const placed = await db().from(PLACEMENTS).select("item_id").eq("section_id", categoryId).eq("is_active", true);
+        if (!placed.error) {
+          const placedIds = (placed.data ?? []).map((r) => r.item_id);
+          if (placedIds.length === 0) return [];
+          sectionFilter = placedIds;
+        }
+      }
+      let q = db().from(CATALOG).select("id, name, price, category_id, image_url").eq("is_active", true).order("name").limit(60);
+      if (search) q = q.ilike("name", `%${search}%`);
+      if (sectionFilter) q = q.in("id", sectionFilter);
+      else if (categoryId) q = q.eq("category_id", categoryId);
+      const { data, error } = await q;
+      if (error) throw new Error(error.message);
+      const rows = data ?? [];
+      if (rows.length === 0) return [];
+      const ids = rows.map((r) => r.id);
+      const placements = await db().from(PLACEMENTS).select("item_id, section_id").in("item_id", ids).eq("is_active", true);
+      const sectionByProduct = /* @__PURE__ */ new Map();
+      if (!placements.error && (placements.data ?? []).length > 0) {
+        const sectionIds = [...new Set((placements.data ?? []).map((r) => r.section_id).filter(Boolean))];
+        const { data: sections } = await db().from(SECTIONS).select("id, name").in("id", sectionIds);
+        const nameById = new Map((sections ?? []).map((r) => [r.id, r.name]));
+        for (const row of placements.data ?? []) {
+          const name = nameById.get(row.section_id);
+          if (name) sectionByProduct.set(row.item_id, name);
+        }
+      }
+      const categoryIds = [...new Set(rows.map((r) => r.category_id).filter(Boolean))];
+      const { data: categories } = categoryIds.length ? await db().from("categories").select("id, name").in("id", categoryIds) : { data: [] };
+      const categoryById = new Map((categories ?? []).map((c) => [c.id, c.name]));
+      return rows.map((r) => ({
+        id: r.id,
+        name: r.name,
+        price: num(r.price),
+        categoryId: r.category_id ?? void 0,
+        // The section wins where there is one: it is the word the Cardápio
+        // screen shows, and the two lists have to say the same thing.
+        categoryName: sectionByProduct.get(r.id) ?? (r.category_id ? categoryById.get(r.category_id) : void 0),
+        imageUrl: r.image_url ?? void 0
+      }));
+    },
+    async addOrderLine(orderId, input) {
+      const tenantId = tenant();
+      const { count } = await db().from(LINES).select("id", { count: "exact", head: true }).eq("order_id", orderId);
+      const { data, error } = await db().from(LINES).insert({
+        tenant_id: tenantId,
+        order_id: orderId,
+        product_id: input.productId ?? null,
+        name: input.name,
+        quantity: input.quantity,
+        unit_price: input.unitPrice,
+        discount: 0,
+        total: input.unitPrice * input.quantity,
+        sort_order: count ?? 0,
+        metadata: input.notes ? { kitchenNotes: input.notes } : {}
+      }).select("id").single();
+      if (error) throw new Error(error.message);
+      if (input.guestId && data?.id) {
+        const { error: linkError } = await db().from(ITEM_GUESTS).insert({
+          item_id: data.id,
+          guest_id: input.guestId,
+          tenant_id: tenantId
+        });
+        if (linkError) throw new Error(linkError.message);
+      }
+      await recalc(orderId);
+    },
+    async setOrderLineQuantity(lineId, quantity) {
+      requireWrites();
+      const { data: line, error } = await db().from(LINES).select("id, order_id, unit_price, discount").eq("id", lineId).maybeSingle();
+      if (error) throw new Error(error.message);
+      if (!line) throw new Error("Item n\xE3o encontrado na comanda");
+      if (quantity <= 0) {
+        const { error: delError } = await db().from(LINES).delete().eq("id", lineId);
+        if (delError) throw new Error(delError.message);
+      } else {
+        const { error: upError } = await db().from(LINES).update({
+          quantity,
+          total: num(line.unit_price) * quantity - num(line.discount)
+        }).eq("id", lineId);
+        if (upError) throw new Error(upError.message);
+      }
+      await recalc(line.order_id);
+    },
+    async removeOrderLine(lineId) {
+      requireWrites();
+      const { data: line, error } = await db().from(LINES).select("order_id").eq("id", lineId).maybeSingle();
+      if (error) throw new Error(error.message);
+      if (!line) return;
+      const { error: delError } = await db().from(LINES).delete().eq("id", lineId);
+      if (delError) throw new Error(delError.message);
+      await recalc(line.order_id);
+    },
+    // -- A política da casa ---------------------------------------------------
+    async getSettings() {
+      const { data, error } = await db().from(SETTINGS).select("service_charge_percent, cancel_requires_pin, operational_day_start").maybeSingle();
+      if (error) throw new Error(error.message);
+      return {
+        serviceChargePercent: num(data?.service_charge_percent),
+        cancelRequiresPin: data?.cancel_requires_pin === true,
+        operationalDayStart: data?.operational_day_start ?? "06:00"
+      };
+    },
+    async saveSettings(patch) {
+      const tenantId = tenant();
+      const row = { tenant_id: tenantId };
+      if (patch.serviceChargePercent != null) row.service_charge_percent = patch.serviceChargePercent;
+      if (patch.cancelRequiresPin != null) row.cancel_requires_pin = patch.cancelRequiresPin;
+      if (patch.operationalDayStart != null) row.operational_day_start = patch.operationalDayStart;
+      const { error } = await db().from(SETTINGS).upsert(row, { onConflict: "tenant_id" });
+      if (error) throw new Error(error.message);
+    },
+    // -- Participantes --------------------------------------------------------
+    async addGuest(orderId, label) {
+      const tenantId = tenant();
+      const { data: taken } = await db().from(GUESTS).select("seat_no").eq("order_id", orderId).order("seat_no");
+      const used = new Set((taken ?? []).map((r) => Number(r.seat_no)));
+      let seat = 1;
+      while (used.has(seat)) seat += 1;
+      const { data, error } = await db().from(GUESTS).insert({
+        tenant_id: tenantId,
+        order_id: orderId,
+        seat_no: seat,
+        label: label ?? null
+      }).select("id, seat_no, label").single();
+      if (error) throw new Error(error.message);
+      return {
+        id: data.id,
+        seatNo: Number(data.seat_no),
+        label: data.label ?? void 0,
+        serviceChargePercent: 0,
+        subtotal: 0,
+        serviceCharge: 0,
+        cancelledTotal: 0,
+        itemCount: 0
+      };
+    },
+    async removeGuest(guestId) {
+      requireWrites();
+      const { data: guest } = await db().from(GUESTS).select("order_id").eq("id", guestId).maybeSingle();
+      const { error } = await db().from(GUESTS).delete().eq("id", guestId);
+      if (error) throw new Error(error.message);
+      if (guest?.order_id) await recalc(guest.order_id);
+    },
+    async setGuestServiceCharge(guestId, percent) {
+      requireWrites();
+      const { data: guest } = await db().from(GUESTS).select("order_id").eq("id", guestId).maybeSingle();
+      const { error } = await db().from(GUESTS).update({ service_charge_percent: percent }).eq("id", guestId);
+      if (error) throw new Error(error.message);
+      if (guest?.order_id) await recalc(guest.order_id);
+    },
+    async setOrderServiceCharge(orderId, percent) {
+      requireWrites();
+      const { error } = await db().from(ORDER_EXT).update({ service_charge_percent: percent }).eq("order_id", orderId);
+      if (error) throw new Error(error.message);
+      await recalc(orderId);
+    },
+    // -- Desconto -------------------------------------------------------------
+    async discountLines(orderId, input) {
+      requireWrites();
+      if (input.lineIds.length === 0) return;
+      const { data: lines, error } = await db().from(LINES).select("id, quantity, unit_price").in("id", input.lineIds);
+      if (error) throw new Error(error.message);
+      for (const line of lines ?? []) {
+        const gross = num(line.unit_price) * num(line.quantity);
+        const raw = input.mode === "percent" ? gross * (input.value / 100) : input.value;
+        const discount = Math.min(Math.max(raw, 0), gross);
+        const { error: upError } = await db().from(LINES).update({ discount, total: gross - discount }).eq("id", line.id);
+        if (upError) throw new Error(upError.message);
+      }
+      await recalc(orderId);
+    },
+    // -- Cancelamento ---------------------------------------------------------
+    async getCancelReasons() {
+      const { data, error } = await db().from(CANCEL_REASONS).select("id, label, is_active, sort_order").order("sort_order");
+      if (error) throw new Error(error.message);
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        label: r.label,
+        isActive: r.is_active !== false,
+        sortOrder: Number(r.sort_order) || 0
+      }));
+    },
+    async addCancelReason(label) {
+      const tenantId = tenant();
+      const { count } = await db().from(CANCEL_REASONS).select("id", { count: "exact", head: true });
+      const { data, error } = await db().from(CANCEL_REASONS).insert({ tenant_id: tenantId, label, sort_order: count ?? 0 }).select("id, label, is_active, sort_order").single();
+      if (error) throw new Error(error.message);
+      return { id: data.id, label: data.label, isActive: data.is_active !== false, sortOrder: Number(data.sort_order) || 0 };
+    },
+    async updateCancelReason(id, patch) {
+      requireWrites();
+      const row = {};
+      if (patch.label != null) row.label = patch.label;
+      if (patch.isActive != null) row.is_active = patch.isActive;
+      if (patch.sortOrder != null) row.sort_order = patch.sortOrder;
+      const { error } = await db().from(CANCEL_REASONS).update(row).eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async deleteCancelReason(id) {
+      requireWrites();
+      const { error } = await db().from(CANCEL_REASONS).delete().eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async cancelLines(orderId, input) {
+      requireWrites();
+      if (input.lineIds.length === 0) return;
+      const { error } = await db().from(LINES).update({ cancelled_at: (/* @__PURE__ */ new Date()).toISOString(), cancel_reason: input.reason }).in("id", input.lineIds);
+      if (error) throw new Error(error.message);
+      await recalc(orderId);
+    },
+    // -- Transferência --------------------------------------------------------
+    async transfer(orderId, input) {
+      const tenantId = tenant();
+      const audit = {
+        tenant_id: tenantId,
+        order_id: orderId,
+        kind: input.kind,
+        note: input.note ?? null,
+        item_ids: input.lineIds ?? []
+      };
+      if (input.kind === "table") {
+        if (!input.toTableId) throw new Error("Escolha a mesa de destino");
+        const { data: current } = await db().from(ORDER_EXT).select("table_id").eq("order_id", orderId).maybeSingle();
+        const { data: busy } = await db().from(ORDER_EXT).select("order_id, orders!inner(status)").eq("table_id", input.toTableId).not("orders.status", "in", '("completed","cancelled")').limit(1);
+        if ((busy ?? []).length > 0) throw new Error("A mesa de destino j\xE1 tem comanda aberta");
+        const { error } = await db().from(ORDER_EXT).update({ table_id: input.toTableId }).eq("order_id", orderId);
+        if (error) throw new Error(error.message);
+        audit.from_table_id = current?.table_id ?? null;
+        audit.to_table_id = input.toTableId;
+      } else if (input.kind === "guest") {
+        if (!input.guestId || !input.toOrderId) throw new Error("Escolha o participante e a comanda de destino");
+        const { error } = await db().from(GUESTS).update({ order_id: input.toOrderId }).eq("id", input.guestId);
+        if (error) throw new Error(error.message);
+        const { data: moved } = await db().from(ITEM_GUESTS).select("item_id").eq("guest_id", input.guestId);
+        const ids = (moved ?? []).map((r) => r.item_id);
+        if (ids.length > 0) {
+          const { error: itemError } = await db().from(LINES).update({ order_id: input.toOrderId }).in("id", ids);
+          if (itemError) throw new Error(itemError.message);
+        }
+        audit.guest_id = input.guestId;
+        audit.target_order_id = input.toOrderId;
+        audit.item_ids = ids;
+        await recalc(input.toOrderId);
+      } else {
+        if (!input.lineIds || input.lineIds.length === 0) throw new Error("Escolha os itens");
+        const { error: delError } = await db().from(ITEM_GUESTS).delete().in("item_id", input.lineIds);
+        if (delError) throw new Error(delError.message);
+        if (input.toGuestId) {
+          const { error: insError } = await db().from(ITEM_GUESTS).insert(
+            input.lineIds.map((id) => ({ item_id: id, guest_id: input.toGuestId, tenant_id: tenantId }))
+          );
+          if (insError) throw new Error(insError.message);
+        }
+        audit.guest_id = input.toGuestId ?? null;
+      }
+      const { error: auditError } = await db().from(TRANSFERS).insert(audit);
+      if (auditError) throw new Error(auditError.message);
+      await recalc(orderId);
+    },
+    async getTransfers(orderId) {
+      const { data, error } = await db().from(TRANSFERS).select("id, kind, from_table_id, to_table_id, guest_id, item_ids, note, created_at").eq("order_id", orderId).order("created_at", { ascending: false });
+      if (error) throw new Error(error.message);
+      const rows = data ?? [];
+      const tableIds = Array.from(new Set(
+        rows.flatMap((r) => [r.from_table_id, r.to_table_id]).filter(Boolean)
+      ));
+      const { data: tables } = tableIds.length ? await db().from(TABLES).select("id, number").in("id", tableIds) : { data: [] };
+      const numberById = new Map((tables ?? []).map((t) => [t.id, t.number]));
+      const named = (id) => id && numberById.has(id) ? `Mesa ${numberById.get(id)}` : void 0;
+      return rows.map((r) => ({
+        id: r.id,
+        kind: r.kind,
+        fromTableName: named(r.from_table_id),
+        toTableName: named(r.to_table_id),
+        itemCount: (r.item_ids ?? []).length,
+        note: r.note ?? void 0,
+        createdAt: r.created_at
+      }));
+    },
+    async updateSessionGuests(orderId, guests) {
+      requireWrites();
+      const { error } = await db().from(ORDER_EXT).update({ guests }).eq("order_id", orderId);
+      if (error) throw new Error(error.message);
+    },
+    async getSummary() {
+      const tables = await loadTables();
+      const count = (status) => tables.filter((t) => t.status === status).length;
+      const elapsed = tables.map((t) => t.currentElapsedMinutes).filter((m) => typeof m === "number");
+      return {
+        totalTables: tables.length,
+        availableCount: count("available"),
+        occupiedCount: count("occupied"),
+        reservedCount: count("reserved"),
+        cleaningCount: count("cleaning"),
+        totalSeats: tables.reduce((sum, t) => sum + t.seats, 0),
+        occupiedSeats: tables.filter((t) => t.status === "occupied").reduce((sum, t) => sum + t.seats, 0),
+        averageSessionMinutes: elapsed.length ? Math.round(elapsed.reduce((a, b) => a + b, 0) / elapsed.length) : 0
+      };
+    }
+  };
+}
 
 // src/index.ts
-var TablesPage = React.lazy(() => import('./TablesPage-GKTE4SD2.js').then((m) => ({ default: m.TablesPage })));
+var TablesPage = React.lazy(() => import('./TablesPage-VVDNK3GN.js').then((m) => ({ default: m.TablesPage })));
+var ComandaSettingsView = React.lazy(() => import('./ComandaSettingsView-ZB5RK7TP.js').then((m) => ({ default: m.ComandaSettingsView })));
 var DEFAULT_LABELS = {
   pageTitle: "Tables",
   floorPlan: "Floor Plan",
@@ -773,10 +1954,12 @@ function resolveConfig(options) {
       { name: "Outdoor", color: "#22c55e" },
       { name: "Bar", color: "#f59e0b" }
     ],
+    serviceChargePercent: options?.serviceChargePercent ?? 0,
     onTableSeated: options?.onTableSeated,
     onTableClosed: options?.onTableClosed
   };
 }
+var FLOOR_PLAN_COMPONENT_ID = "tables.floor-plan";
 function createTablesPlugin(options) {
   const config = resolveConfig(options);
   const provider = options?.dataProvider ?? createMockTablesProvider();
@@ -786,6 +1969,9 @@ function createTablesPlugin(options) {
     { fallback: null },
     React.createElement(TablesPage, { config, provider, store, registries: tablesRegistries })
   );
+  registerComponent(FLOOR_PLAN_COMPONENT_ID, PageComponent);
+  const ContextBoundary = ({ children }) => React.createElement(TablesContextProvider, { config, provider, store }, children);
+  ContextBoundary.displayName = "TablesContextBoundary";
   return {
     id: "tables",
     defaultAgentRole: "operations",
@@ -869,12 +2055,39 @@ function createTablesPlugin(options) {
         })(),
         order: 21,
         permission: { feature: "tables", action: "read" }
+      },
+      // Duas abas, e cada uma responde uma pergunta diferente: a de cima é o
+      // CADASTRO do salão (praças, mesas — trabalho de implantação), esta é a
+      // POLÍTICA da comanda (taxa, cancelamento, dia operacional — decisões do
+      // dono). Juntá-las daria uma tela em que quem vem mudar a taxa passa
+      // primeiro pelas mesas.
+      {
+        id: "comanda",
+        label: "Comanda",
+        icon: "Receipt",
+        component: (() => {
+          const ComandaSettingsTab = () => React.createElement(
+            ContextBoundary,
+            null,
+            React.createElement(
+              React.Suspense,
+              { fallback: null },
+              React.createElement(ComandaSettingsView)
+            )
+          );
+          ComandaSettingsTab.displayName = "ComandaSettingsTab";
+          return ComandaSettingsTab;
+        })(),
+        order: 22,
+        // A política é do dono, não do garçom: quem só atende mesa não decide a
+        // taxa da casa nem apaga motivo de cancelamento.
+        permission: { feature: "tables", action: "edit" }
       }
     ],
     locales: tablesLocales
   };
 }
 
-export { createFayzTablesProvider, createTablesPlugin };
+export { FLOOR_PLAN_COMPONENT_ID, createCoreTablesProvider, createFayzTablesProvider, createTablesPlugin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map