@fayz-ai/financial 0.0.0-stage → 0.1.1

package/dist/chunk-2XWEZXFT.js

@@ -0,0 +1,2805 @@
+import { hasCriteriaValue } from './chunk-J7BWATQU.js';
+import { ensureReferenceRates } from './chunk-4S5GK776.js';
+import { createIdempotencyKey } from './chunk-IP5YH4S5.js';
+import { NAME_AMOUNT_TOLERANCE, matchStatementLines, scorePair } from './chunk-ZFUQBYBG.js';
+import { emptyStatement, ledgerBalance, buildStatement } from './chunk-HJPUHTI2.js';
+import { transferLegs } from './chunk-YUNLQYOZ.js';
+import { cancellationReason, invoiceTotal, itemsDescription, summarizeInvoiceLines, lineTotal } from './chunk-7HISDBUG.js';
+import { paymentFee, ledgerMethod, toLedgerDirection, fromLedgerDirection } from './chunk-4GXBOEI3.js';
+import { sessionCashFlow } from './chunk-56NQHYL7.js';
+import { runReconcileAsBill, runReconcileLink } from './chunk-FNXIAIUZ.js';
+import { transferForStatementLine, statementLegOf, candidateTolerance, candidateScore, statementLinesPage, pageTotals } from './chunk-MCSPCXQK.js';
+import { round2 } from './chunk-XVELDCSL.js';
+import { T } from './chunk-4FWWKKZB.js';
+import { getActiveTenantId, getSupabaseClientOptional } from '@fayz-ai/core';
+
+var INVESTMENT_CODES = ["INVESTMENTS", "AUTOMATICINVESTMENT", "PROCEEDSINTERESTSANDDIVIDENDS", "MUTUALFUNDS", "FIXEDINCOME"];
+function invoiceLinesPayload(items, lineTotal2) {
+  return items.map((item, i) => ({
+    name: item.description,
+    quantity: item.quantity,
+    unit_price: item.unitPrice,
+    discount: item.discount ?? 0,
+    total: lineTotal2(item),
+    sort_order: i,
+    metadata: { ...item.metadata, itemKind: item.itemKind, referenceId: item.referenceId }
+  }));
+}
+async function invoiceTenantId(pub, invoiceId) {
+  const { data, error } = await pub.from("plg_financial_invoices").select("tenant_id").eq("id", invoiceId).maybeSingle();
+  if (error) throw error;
+  const tenant = data?.tenant_id ?? getActiveTenantId();
+  if (!tenant) throw new Error("N\xE3o foi poss\xEDvel identificar a conta desta fatura");
+  return tenant;
+}
+function snakeToCamel(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())] = value;
+  }
+  return result;
+}
+function camelToSnake(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("_")) continue;
+    result[key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`)] = value;
+  }
+  return result;
+}
+function getClients() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase not initialized");
+  return { core: supabase, pub: supabase };
+}
+async function anexaContraparte(rows) {
+  const ids = [...new Set(rows.map((r) => r.matchedMovementId).filter(Boolean))];
+  if (ids.length === 0) return;
+  const { core, pub } = getClients();
+  const { data: movs } = await pub.from(T.movements).select("id, invoice_id, financial_invoice_id, notes").in("id", ids);
+  const porMovimento = /* @__PURE__ */ new Map();
+  const faturaPorMovimento = /* @__PURE__ */ new Map();
+  const faturas = /* @__PURE__ */ new Map();
+  for (const m of movs ?? []) {
+    const faturaId = m.financial_invoice_id ?? m.invoice_id;
+    if (faturaId) {
+      faturaPorMovimento.set(m.id, faturaId);
+      const lista = faturas.get(faturaId) ?? [];
+      lista.push(m.id);
+      faturas.set(faturaId, lista);
+    } else if (m.notes) {
+      porMovimento.set(m.id, m.notes);
+    }
+  }
+  if (faturas.size > 0) {
+    const { data: orders } = await core.from("orders").select("id, metadata").in("id", [...faturas.keys()]);
+    for (const o of orders ?? []) {
+      const nome = o.metadata?.contactName;
+      if (!nome) continue;
+      for (const movId of faturas.get(o.id) ?? []) porMovimento.set(movId, nome);
+    }
+  }
+  for (const linha of rows) {
+    if (linha.matchedMovementId) {
+      linha.matchedCounterpartyName = porMovimento.get(linha.matchedMovementId);
+      linha.matchedInvoiceId = faturaPorMovimento.get(linha.matchedMovementId);
+    }
+  }
+}
+function toStatementLine(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id ?? void 0,
+    unitId: row.unit_id ?? void 0,
+    bankAccountId: row.bank_account_id ?? void 0,
+    externalId: row.external_id,
+    externalSource: row.external_source,
+    date: row.posted_on,
+    effectiveAt: row.effective_at ?? void 0,
+    direction: row.direction,
+    amount: Number(row.amount) || 0,
+    balanceAfter: row.balance_after == null ? void 0 : Number(row.balance_after),
+    description: row.description ?? "",
+    counterpartyName: row.counterparty_name ?? void 0,
+    counterpartyDocument: row.counterparty_document ?? void 0,
+    document: row.document ?? void 0,
+    code: row.code ?? void 0,
+    category: row.category ?? void 0,
+    transactionType: row.transaction_type ?? void 0,
+    rawPayload: row.raw_payload ?? void 0,
+    providerDeleted: row.provider_deleted ?? false,
+    reconciledAt: row.reconciled_at ?? void 0,
+    matchedMovementId: row.matched_movement_id ?? void 0,
+    createdAt: row.created_at ?? void 0,
+    updatedAt: row.updated_at ?? void 0
+  };
+}
+function mapRecurringBill(row, counterpartyName) {
+  const items = Array.isArray(row.items) ? row.items.map((item) => ({
+    itemKind: item.itemKind ?? item.item_kind ?? (item.product_id ? "product" : "other"),
+    referenceId: item.referenceId ?? item.reference_id ?? item.product_id ?? void 0,
+    description: item.description ?? "",
+    quantity: Number(item.quantity) || 1,
+    unitPrice: Number(item.unitPrice ?? item.unit_price) || 0,
+    discount: Number(item.discount) || 0,
+    surcharge: Number(item.surcharge ?? item.addition) || 0,
+    accountId: item.accountId ?? item.account_id ?? item.chart_account_id ?? void 0,
+    costCenterId: item.costCenterId ?? item.cost_center_id ?? void 0
+  })) : [];
+  return {
+    id: row.id,
+    direction: row.direction,
+    description: row.description,
+    counterpartyPersonId: row.counterparty_person_id,
+    counterpartyName,
+    amount: Number(row.amount) || 0,
+    items,
+    unitId: row.unit_id,
+    chartAccountId: row.chart_account_id,
+    costCenterId: row.cost_center_id,
+    frequency: row.frequency,
+    dueDay: Number(row.due_day) || 1,
+    startsOn: row.starts_on,
+    endsOn: row.ends_on,
+    isActive: Boolean(row.is_active),
+    notes: row.notes,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+async function findInvoiceIdsByLineAccounting(core, pub, filters) {
+  if (!filters.accountId && !filters.costCenterId) return void 0;
+  let sideQ = pub.from(T.invoiceItems).select("item_id");
+  if (filters.accountId) sideQ = sideQ.eq("chart_account_id", filters.accountId);
+  if (filters.costCenterId) sideQ = sideQ.eq("cost_center_id", filters.costCenterId);
+  const { data: sideRows } = await sideQ;
+  const itemIds = (sideRows ?? []).map((r) => r.item_id).filter(Boolean);
+  let legacyQ = core.from("items").select("id");
+  if (filters.accountId) legacyQ = legacyQ.filter("metadata->>accountId", "eq", filters.accountId);
+  if (filters.costCenterId) legacyQ = legacyQ.filter("metadata->>costCenterId", "eq", filters.costCenterId);
+  const { data: legacyRows } = await legacyQ;
+  for (const r of legacyRows ?? []) if (r.id) itemIds.push(r.id);
+  if (itemIds.length === 0) return [];
+  const { data: items } = await core.from("items").select("invoice_id").in("id", Array.from(new Set(itemIds)));
+  const ids = (items ?? []).map((r) => r.invoice_id).filter((v) => typeof v === "string" && v);
+  return Array.from(new Set(ids));
+}
+async function writeLineAccounting(pub, tenantId, insertedItems, inputItems) {
+  if (!tenantId || !insertedItems?.length) return;
+  const rows = insertedItems.map((row) => {
+    const src = inputItems[row.sort_order ?? -1];
+    if (!src || !src.accountId && !src.costCenterId) return null;
+    return {
+      item_id: row.id,
+      parent_kind: "invoice",
+      tenant_id: tenantId,
+      chart_account_id: src.accountId ?? null,
+      cost_center_id: src.costCenterId ?? null
+    };
+  }).filter(Boolean);
+  if (rows.length === 0) return;
+  const { error } = await pub.from(T.invoiceItems).upsert(rows, { onConflict: "item_id" });
+  if (error) console.warn("[financial] line accounting mirror skipped:", error.message);
+}
+function shiftIsoDate(value, days) {
+  const d = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
+}
+function matchScore(line, m) {
+  const amount = Number(line.amount) || 0;
+  const amtDiff = Math.abs((Number(m.amount) || 0) - amount);
+  const amtScore = amount > 0 ? Math.max(0, 1 - amtDiff / amount) : 0;
+  const refDate = m.dueDate ?? m.paymentDate;
+  const days = line.date && refDate ? Math.abs((new Date(line.date).getTime() - new Date(refDate).getTime()) / 864e5) : 30;
+  return round2(0.7 * amtScore + 0.3 * Math.max(0, 1 - days / 30));
+}
+function billRowToMovement(r) {
+  return {
+    id: r.installment_id,
+    invoiceId: r.invoice_id,
+    direction: fromLedgerDirection(r.direction),
+    movementKind: "bill",
+    amount: Number(r.amount) || 0,
+    paidAmount: Number(r.paid) || 0,
+    status: r.status,
+    dueDate: r.due_date,
+    installmentNumber: r.number,
+    unitId: r.unit_id ?? void 0,
+    metadata: r.metadata ?? void 0,
+    tenantId: r.tenant_id,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+async function attachCurrency(pub, invoices) {
+  const ids = [...new Set(invoices.map((inv) => inv.invoiceId ?? inv.id).filter(Boolean))];
+  if (ids.length === 0) return;
+  try {
+    const { data, error } = await pub.from("plg_financial_invoices").select("id, currency").in("id", ids);
+    if (error || !Array.isArray(data)) return;
+    const byId = new Map(data.map((r) => [r.id, r.currency]));
+    for (const inv of invoices) inv.currency = byId.get(inv.invoiceId ?? inv.id) ?? inv.currency;
+  } catch {
+  }
+}
+async function attachTags(pub, invoice) {
+  try {
+    const { data, error } = await pub.from("plg_financial_invoices").select("tags").eq("id", invoice.id).maybeSingle();
+    if (!error && Array.isArray(data?.tags)) invoice.tags = data.tags;
+  } catch {
+  }
+}
+function rowToInvoiceLine(r) {
+  return {
+    id: r.installment_id,
+    invoiceId: r.invoice_id,
+    direction: fromLedgerDirection(r.direction),
+    invoiceDate: (r.competence_date ?? r.issue_date ?? "").slice(0, 10),
+    dueDate: (r.due_date ?? "").slice(0, 10) || void 0,
+    fiscalNumber: r.number ?? void 0,
+    totalAmount: Number(r.amount) || 0,
+    paidAmount: Number(r.paid) || 0,
+    status: r.status === "pending" ? "open" : r.status,
+    installmentNumber: Number(r.installment_number) || 1,
+    totalInstallments: Number(r.installment_count) || 1,
+    contactId: r.counterparty_person_id ?? void 0,
+    contactName: r.counterparty_name ?? r.metadata?.contactName,
+    observations: r.notes ?? void 0,
+    itemsSummary: r.description ?? r.metadata?.itemsSummary,
+    unitId: r.unit_id ?? void 0,
+    metadata: r.metadata ?? void 0,
+    tenantId: r.tenant_id,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    createdBy: r.created_by ?? void 0
+  };
+}
+function rowToInvoice(r) {
+  return {
+    id: r.id,
+    // O tipo do plugin fala débito/crédito; o banco fala pagar/receber.
+    direction: fromLedgerDirection(r.direction),
+    invoiceDate: (r.competence_date ?? r.issue_date ?? "").slice(0, 10),
+    dueDate: (r.due_date ?? "").slice(0, 10) || void 0,
+    fiscalNumber: r.number ?? void 0,
+    totalAmount: Number(r.total) || 0,
+    paidAmount: Number(r.paid) || 0,
+    status: r.status,
+    totalInstallments: Number(r.installment_count) || 1,
+    contactId: r.counterparty_person_id ?? void 0,
+    contactName: r.counterparty_name ?? r.metadata?.contactName,
+    observations: r.notes ?? void 0,
+    itemsSummary: r.description ?? r.metadata?.itemsSummary,
+    unitId: r.unit_id ?? void 0,
+    metadata: r.metadata ?? void 0,
+    tenantId: r.tenant_id,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    createdBy: r.created_by ?? void 0
+  };
+}
+async function getMethodFeePct(pub, paymentMethodId) {
+  if (!paymentMethodId) return 0;
+  const { data, error } = await pub.from(T.paymentMethods).select("discount_value").eq("id", paymentMethodId).single();
+  if (error) throw error;
+  return Number(data?.discount_value) || 0;
+}
+function genId() {
+  try {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+  } catch {
+  }
+  return "tr-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 10);
+}
+function createSupabaseFinancialProvider() {
+  async function readStatementLine(id) {
+    const { pub } = getClients();
+    const { data } = await pub.from(T.statementLines).select("*").eq("id", id).single();
+    if (!data) throw new Error("Linha do extrato n\xE3o encontrada");
+    return {
+      id: data.id,
+      amount: Number(data.amount) || 0,
+      // `posted_on` é a coluna; `date` é o nome que o domínio usa.
+      date: data.posted_on,
+      direction: data.direction,
+      description: data.description ?? void 0,
+      bankAccountId: data.bank_account_id ?? void 0,
+      externalSource: data.external_source
+    };
+  }
+  async function searchBillTargets(line, query) {
+    const { pub } = getClients();
+    const pageSize = query.pageSize ?? 50;
+    const page = query.page ?? 1;
+    let qb = pub.from("v_financial_invoice_lines_due").select("installment_id,invoice_id,direction,number,due_date,description,counterparty_name,installment_number,installment_count,amount,paid,status").eq("direction", line.direction === "debit" ? "payable" : "receivable");
+    const status = query.status ?? "all";
+    qb = status === "open" ? qb.in("status", ["pending", "partial", "overdue"]) : status === "paid" ? qb.eq("status", "paid") : qb.neq("status", "cancelled");
+    if (query.dueFrom) qb = qb.gte("due_date", query.dueFrom);
+    if (query.dueTo) qb = qb.lte("due_date", query.dueTo);
+    if (query.amountMin != null) qb = qb.gte("amount", query.amountMin);
+    if (query.amountMax != null) qb = qb.lte("amount", query.amountMax);
+    const termo = query.search?.trim().replace(/[,()*%]/g, " ").replace(/\s+/g, " ");
+    if (termo) {
+      qb = qb.or(["description", "number", "counterparty_name"].map((c) => `${c}.ilike.%${termo}%`).join(","));
+    }
+    const { data, error } = await qb.order("due_date", { ascending: true }).range((page - 1) * pageSize, page * pageSize);
+    if (error) throw error;
+    const rows = data ?? [];
+    const hasMore = rows.length > pageSize;
+    const visiveis = rows.slice(0, pageSize);
+    const pagas = visiveis.filter((r) => r.status === "paid").map((r) => r.installment_id);
+    const pagamentoDe = /* @__PURE__ */ new Map();
+    if (pagas.length) {
+      const { data: allocs } = await pub.from(T.allocations).select("installment_id,payment_movement_id").in("installment_id", pagas);
+      const ids = [...new Set((allocs ?? []).map((a) => a.payment_movement_id).filter(Boolean))];
+      const { data: pays } = ids.length ? await pub.from(T.movements).select("*").in("id", ids).neq("status", "cancelled").is("reversed_by_id", null) : { data: [] };
+      const byId = new Map((pays ?? []).map((p) => [p.id, p]));
+      for (const a of allocs ?? []) {
+        const p = byId.get(a.payment_movement_id);
+        if (p) pagamentoDe.set(a.installment_id, p);
+      }
+    }
+    const candidates = [];
+    for (const r of visiveis) {
+      const invoice = {
+        id: r.invoice_id,
+        contactName: r.counterparty_name ?? void 0,
+        fiscalNumber: r.number ?? void 0
+      };
+      let movement;
+      if (r.status === "paid") {
+        const p = pagamentoDe.get(r.installment_id);
+        if (!p || p.reconciled_at) continue;
+        movement = {
+          ...snakeToCamel(p),
+          invoiceId: r.invoice_id,
+          settlesMovementId: r.installment_id,
+          dueDate: r.due_date,
+          notes: p.notes ?? r.description ?? void 0
+        };
+      } else {
+        movement = {
+          id: r.installment_id,
+          invoiceId: r.invoice_id,
+          direction: line.direction,
+          movementKind: "bill",
+          amount: Number(r.amount) || 0,
+          paidAmount: Number(r.paid) || 0,
+          status: r.status,
+          dueDate: r.due_date,
+          installmentNumber: r.installment_number ?? void 0,
+          notes: r.description ?? void 0
+        };
+      }
+      const pareado = scorePair(
+        { amount: line.amount, date: line.date, direction: line.direction, description: line.description ?? "" },
+        movement,
+        { contactName: r.counterparty_name ?? void 0 }
+      );
+      candidates.push({
+        movement,
+        invoice,
+        score: pareado > 0 ? pareado : round2(0.6 * matchScore(line, movement)),
+        installmentCount: r.installment_count ?? void 0
+      });
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    return { data: candidates, hasMore };
+  }
+  async function markReconciled(statementLineId, matchedMovementId) {
+    const { pub } = getClients();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await pub.from(T.statementLines).update({
+      reconciled_at: now,
+      matched_movement_id: matchedMovementId ?? null
+    }).eq("id", statementLineId);
+    if (matchedMovementId) {
+      await pub.from(T.movements).update({ reconciled_at: now }).eq("id", matchedMovementId);
+    }
+  }
+  function reconcileFacade() {
+    return {
+      createInvoice: (input) => provider.createInvoice(input),
+      getMovements: (query) => provider.getMovements(query),
+      payMovement: (input) => provider.payMovement(input),
+      reconcileMovement: ({ bankMovementId, matchedMovementId }) => markReconciled(bankMovementId, matchedMovementId),
+      addInstallmentCharge: (input) => provider.addInstallmentCharge(input)
+    };
+  }
+  const provider = {
+    // --- Contas (plg_financial_invoices) ---
+    // A conta NÃO é uma order: `orders_kind_guard` aposentou invoice_payable e
+    // invoice_receivable, e o motivo está no HINT do próprio erro — ADR 0004,
+    // "orders is the Venda; money lives in the financial plugin". Uma conta a
+    // pagar não tem cliente, nem item vendido, nem entrega; era uma venda com o
+    // sinal trocado. A leitura vem de v_financial_invoice_balances, que já traz
+    // saldo e situação derivados das parcelas — e, ao contrário de
+    // v_invoice_balances, não exige que a conta tenha nascido de uma venda.
+    async getInvoices(query) {
+      const { core, pub } = getClients();
+      const COLUNAS = [
+        "installment_id",
+        "invoice_id",
+        "tenant_id",
+        "unit_id",
+        "direction",
+        "number",
+        "competence_date",
+        "due_date",
+        "description",
+        "counterparty_person_id",
+        "counterparty_name",
+        "installment_number",
+        "installment_count",
+        "amount",
+        "paid",
+        "status",
+        "created_at",
+        "updated_at"
+      ].join(",");
+      let qb = pub.from("v_financial_invoice_lines_due").select(COLUNAS, { count: "exact" });
+      if (query.direction) qb = qb.eq("direction", toLedgerDirection(query.direction));
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status];
+        qb = qb.in("status", statuses.map((st) => st === "open" ? "pending" : st));
+      } else {
+        qb = qb.neq("status", "cancelled");
+      }
+      const scoped = await findInvoiceIdsByLineAccounting(core, pub, {
+        accountId: query.accountId,
+        costCenterId: query.costCenterId
+      });
+      if (scoped) {
+        if (scoped.length === 0) return { data: [], total: 0 };
+        qb = qb.in("invoice_id", scoped);
+      }
+      if (query.contactId) qb = qb.eq("counterparty_person_id", query.contactId);
+      if (query.fiscalNumber) qb = qb.ilike("number", `%${query.fiscalNumber}%`);
+      if (query.bankAccountId) qb = qb.contains("payment_account_ids", [query.bankAccountId]);
+      const unidades = query.unitId ? ["unit_id.is.null", `unit_id.eq.${query.unitId}`] : [];
+      const buscas = query.search ? ["description", "notes", "number", "counterparty_name"].map((col) => `${col}.ilike.%${query.search}%`) : [];
+      if (unidades.length && buscas.length) {
+        qb = qb.or(unidades.flatMap((u) => buscas.map((b) => `and(${u},${b})`)).join(","));
+      } else if (unidades.length) {
+        qb = qb.or(unidades.join(","));
+      } else if (buscas.length) {
+        qb = qb.or(buscas.join(","));
+      }
+      if (query.dateRange) {
+        qb = qb.gte("due_date", query.dateRange.from.slice(0, 10)).lte("due_date", query.dateRange.to.slice(0, 10));
+      }
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      qb = qb.range((page - 1) * pageSize, page * pageSize - 1).order("due_date", { ascending: true });
+      const { data, count, error } = await qb;
+      if (error) throw error;
+      const linhas = (data ?? []).map(rowToInvoiceLine);
+      const titulos = [...new Set(linhas.map((l) => l.invoiceId).filter(Boolean))];
+      if (titulos.length) {
+        const { data: itemRows } = await pub.from("v_financial_invoice_lines").select("invoice_id,name,description,quantity").in("invoice_id", titulos);
+        const itemSummaries = summarizeInvoiceLines(itemRows ?? []);
+        for (const line of linhas) {
+          line.itemsSummary = itemSummaries.get(line.invoiceId ?? line.id) ?? line.itemsSummary;
+        }
+        const installmentIds = linhas.map((line) => line.id);
+        const { data: allocations } = await pub.from(T.allocations).select("installment_id,payment_movement_id,created_at").in("installment_id", installmentIds).order("created_at", { ascending: false });
+        const movementIds = [...new Set((allocations ?? []).map((row) => row.payment_movement_id).filter(Boolean))];
+        if (movementIds.length > 0) {
+          const { data: paymentRows } = await pub.from(T.movements).select("id,payment_method_id,payment_method_type_id,bank_account_id,card_installments,status,reversed_by_id").in("id", movementIds);
+          const paymentById = new Map((paymentRows ?? []).map((row) => [row.id, row]));
+          const latestByInstallment = /* @__PURE__ */ new Map();
+          for (const allocation of allocations ?? []) {
+            if (latestByInstallment.has(allocation.installment_id)) continue;
+            const payment = paymentById.get(allocation.payment_movement_id);
+            if (!payment || payment.status === "cancelled" || payment.reversed_by_id) continue;
+            latestByInstallment.set(allocation.installment_id, payment);
+          }
+          for (const line of linhas) {
+            const payment = latestByInstallment.get(line.id);
+            if (!payment) continue;
+            line.paymentMethodId = payment.payment_method_id ?? void 0;
+            line.paymentMethodTypeId = payment.payment_method_type_id ?? void 0;
+            line.paymentAccountId = payment.bank_account_id ?? void 0;
+            line.paymentCardInstallments = Number(payment.card_installments) || void 0;
+          }
+        }
+        const { data: docs } = await pub.from("documents").select("subject_id").eq("subject_type", "financial_invoice").eq("is_active", true).in("subject_id", titulos);
+        const porTitulo = /* @__PURE__ */ new Map();
+        for (const d of docs ?? []) {
+          porTitulo.set(d.subject_id, (porTitulo.get(d.subject_id) ?? 0) + 1);
+        }
+        for (const l of linhas) {
+          l.attachmentCount = porTitulo.get(l.invoiceId ?? l.id) ?? 0;
+        }
+      }
+      await attachCurrency(pub, linhas);
+      return { data: linhas, total: count ?? 0 };
+    },
+    async getInvoiceById(id) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_invoice_balances").select("*").eq("id", id).maybeSingle();
+      if (error) throw error;
+      if (!data) return null;
+      const invoice = rowToInvoice(data);
+      await Promise.all([attachCurrency(pub, [invoice]), attachTags(pub, invoice)]);
+      return invoice;
+    },
+    async getInvoiceItems(invoiceId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_invoice_lines").select("*").eq("invoice_id", invoiceId);
+      if (error) throw error;
+      const rows = data ?? [];
+      const metaOf = (r) => r.item_metadata ?? r.metadata ?? {};
+      const productOf = (r) => r.product_id ?? (metaOf(r).itemKind === "product" ? metaOf(r).referenceId : void 0);
+      const productIds = [...new Set(rows.map(productOf).filter(Boolean))];
+      const pictures = /* @__PURE__ */ new Map();
+      if (productIds.length > 0) {
+        try {
+          const found = await pub.from("products").select("id, image_url").in("id", productIds);
+          for (const p of Array.isArray(found.data) ? found.data : []) {
+            if (p.image_url) pictures.set(p.id, p.image_url);
+          }
+        } catch {
+        }
+      }
+      return rows.map((r) => {
+        const i = snakeToCamel(r);
+        const meta = metaOf(r);
+        const pictured = productOf(r);
+        return {
+          imageUrl: pictured ? pictures.get(pictured) : void 0,
+          // A line that names a product IS a product line, whatever it was
+          // typed as: linking it later (stock entry) must change its icon too.
+          id: i.itemId,
+          invoiceId,
+          itemKind: meta.itemKind && meta.itemKind !== "other" ? meta.itemKind : i.productId ? "product" : "other",
+          // `name` OU `description`: quem levanta a conta pelo SQL
+          // (`financial_create_payable`, o borderô de comissões) escreve o
+          // texto em `description` e deixa `name` nulo. Lendo só `name`, a
+          // linha chegava vazia na tela e sobrava o `itemKind` cru no lugar
+          // dela — era o "other" que aparecia na fatura de comissão.
+          description: i.name ?? i.description ?? "",
+          quantity: i.quantity ?? 1,
+          unitPrice: i.unitPrice ?? 0,
+          totalAmount: i.total ?? 0,
+          discount: i.discount ?? 0,
+          surcharge: 0,
+          // `product_id` quando a linha veio de uma porta que o preenche (a
+          // RPC da agenda); do metadata quando veio DESTA tela, que é onde a
+          // escolha de catálogo é gravada. Lendo só a coluna, reabrir uma
+          // fatura apagava o item escolhido de toda linha e deixava o texto
+          // solto — e salvar de novo confirmava a perda.
+          referenceId: i.productId ?? meta.referenceId,
+          accountId: i.chartAccountId,
+          costCenterId: i.costCenterId,
+          // De onde a linha veio — o pacote que a gerou, por exemplo. Sem
+          // devolvê-lo, editar a fatura desfazia o vínculo em silêncio.
+          metadata: r.item_metadata ?? r.metadata ?? void 0,
+          cancelledAt: i.itemCancelledAt ?? void 0,
+          cancelReason: i.itemCancelReason ?? void 0,
+          createdAt: i.createdAt
+        };
+      });
+    },
+    async getInvoiceAttachments(invoiceId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("documents").select("id, file_name, file_size, mime_type, file_url, storage_bucket, storage_path, storage_provider, created_at").eq("subject_type", "financial_invoice").eq("subject_id", invoiceId).eq("is_active", true).order("created_at");
+      if (error) throw error;
+      const linhas = data ?? [];
+      const assinadas = /* @__PURE__ */ new Map();
+      const porBucket = /* @__PURE__ */ new Map();
+      for (const r of linhas) {
+        if (!r.storage_bucket || !r.storage_path) continue;
+        const lista = porBucket.get(r.storage_bucket) ?? [];
+        lista.push(r.storage_path);
+        porBucket.set(r.storage_bucket, lista);
+      }
+      for (const [bucket, caminhos] of porBucket) {
+        try {
+          const { data: urls } = await pub.storage.from(bucket).createSignedUrls(caminhos, 60 * 30);
+          for (const u of urls ?? []) {
+            if (u.path && u.signedUrl) assinadas.set(u.path, u.signedUrl);
+          }
+        } catch {
+        }
+      }
+      return linhas.map((r) => {
+        const url = assinadas.get(r.storage_path) ?? void 0;
+        return {
+          id: r.id,
+          fileName: r.file_name ?? "Anexo",
+          fileSize: r.file_size ?? void 0,
+          mimeType: r.mime_type ?? void 0,
+          url,
+          // Pendente é o que NÃO ABRE: os bytes ainda no V1, ou a assinatura
+          // que não veio. O `file_url` gravado não conta — ele responde 400.
+          pending: !url,
+          createdAt: r.created_at
+        };
+      });
+    },
+    async addInvoiceAttachment(invoiceId, file) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      if (!tenantId) throw new Error("Conta sem empresa ativa");
+      const safe = file.name.replace(/[^\w.\-]+/g, "_");
+      const path = `${tenantId}/financial_invoice/${invoiceId}/${Date.now()}_${safe}`;
+      const { error: upErr } = await pub.storage.from("attachments").upload(path, file, { contentType: file.type || void 0 });
+      if (upErr) throw upErr;
+      const { error } = await pub.from("documents").insert({
+        tenant_id: tenantId,
+        kind: "attachment",
+        status: "active",
+        subject_type: "financial_invoice",
+        subject_id: invoiceId,
+        file_name: file.name,
+        file_size: file.size,
+        mime_type: file.type || null,
+        storage_provider: "supabase",
+        storage_bucket: "attachments",
+        storage_path: path
+      });
+      if (error) {
+        await pub.storage.from("attachments").remove([path]).catch(() => {
+        });
+        throw error;
+      }
+    },
+    async createInvoice(input) {
+      const { pub } = getClients();
+      getActiveTenantId();
+      const totalAmount = invoiceTotal(input.items);
+      const itemsSummary = itemsDescription(input.items);
+      const installments = (input.installments.length > 0 ? input.installments : [
+        { amount: totalAmount, dueDate: input.invoiceDate ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }
+      ]).map((inst, n) => ({
+        number: inst.installmentNumber ?? n + 1,
+        due_date: inst.dueDate,
+        amount: round2(inst.amount),
+        ...inst.metadata ? { metadata: inst.metadata } : {}
+      }));
+      const { data: res, error } = await pub.rpc("financial_create_invoice", {
+        p_direction: toLedgerDirection(input.direction),
+        p_total: totalAmount,
+        p_counterparty_person_id: input.contactId ?? null,
+        p_order_id: null,
+        p_unit_id: input.unitId ?? null,
+        p_installments: installments,
+        p_competence_date: input.invoiceDate ?? null,
+        p_description: itemsSummary || null,
+        p_notes: input.observations ?? null,
+        p_metadata: {
+          contactName: input.contactName,
+          ...input.fiscalNumber ? { fiscalNumber: input.fiscalNumber } : {},
+          ...input.currency ? { currency: input.currency } : {}
+        },
+        p_idempotency_key: genId()
+      });
+      if (error) throw error;
+      const invoiceId = res.invoice_id;
+      if (input.tags?.length) {
+        await pub.from("plg_financial_invoices").update({ tags: input.tags }).eq("id", invoiceId);
+      }
+      if (input.items.length > 0) {
+        const { data: lines, error: linesErr } = await pub.rpc("financial_set_invoice_lines", {
+          p_invoice_id: invoiceId,
+          p_lines: invoiceLinesPayload(input.items, lineTotal)
+        });
+        if (linesErr) {
+          await pub.rpc("financial_cancel_invoice", { p_invoice_id: invoiceId, p_reason: "Itens recusados ao criar a conta" });
+          throw new Error(`Os itens da conta n\xE3o foram gravados: ${linesErr.message}`);
+        }
+        await writeLineAccounting(pub, await invoiceTenantId(pub, invoiceId), lines, input.items);
+      }
+      return await provider.getInvoiceById(invoiceId);
+    },
+    // A EDIÇÃO SALVAVA UMA COISA SÓ.
+    //
+    // Este método recebia o cabeçalho inteiro — data, contato, unidade, número
+    // fiscal, total — e gravava `notes`. Todo o resto caía no chão sem erro
+    // nenhum: o formulário fechava, a tela recarregava, e o campo voltava como
+    // estava. Um salvar que não salva e não reclama é pior que um que falha.
+    //
+    // O mapa é o mesmo que a LEITURA usa (ver `rowToInvoice`), e por isso
+    // `competence_date` e não `issue_date`: a leitura prefere a competência, e
+    // gravar na outra coluna faria a tela mostrar o valor antigo depois de
+    // salvar o novo.
+    async updateInvoice(id, partial) {
+      const { pub } = getClients();
+      const row = {};
+      if (partial.observations !== void 0) row.notes = partial.observations;
+      if (partial.tags !== void 0) row.tags = partial.tags;
+      if (partial.invoiceDate !== void 0) row.competence_date = partial.invoiceDate;
+      if (partial.contactId !== void 0) row.counterparty_person_id = partial.contactId ?? null;
+      if (partial.unitId !== void 0) row.unit_id = partial.unitId ?? null;
+      if (partial.totalAmount !== void 0) row.total = partial.totalAmount;
+      if (partial.contactName !== void 0 || "fiscalNumber" in partial) {
+        const { data: cur } = await pub.from("plg_financial_invoices").select("metadata").eq("id", id).maybeSingle();
+        row.metadata = {
+          ...cur?.metadata ?? {},
+          ...partial.contactName !== void 0 ? { contactName: partial.contactName } : {},
+          ..."fiscalNumber" in partial ? { fiscalNumber: partial.fiscalNumber ?? null } : {}
+        };
+      }
+      if (Object.keys(row).length > 0) {
+        const { error } = await pub.from("plg_financial_invoices").update(row).eq("id", id);
+        if (error) throw error;
+      }
+      return await provider.getInvoiceById(id);
+    },
+    // Escreve na TABELA, não na leitura.
+    //
+    // `T.bills` é `v_financial_installment_balances` — a view que soma o pago e
+    // devolve a parcela já com saldo. Ela não tem `id` (a chave dela se chama
+    // `installment_id`) e não é atualizável, então um UPDATE ali volta 400 com
+    // "column ... does not exist". A parcela mora em
+    // `plg_financial_invoice_installments`, e é lá que a data muda.
+    async updateInstallment(id, data) {
+      const { pub } = getClients();
+      const row = {};
+      if (data.dueDate !== void 0) row.due_date = data.dueDate;
+      if (data.amount !== void 0) row.amount = data.amount;
+      if (data.metadata !== void 0) row.metadata = data.metadata;
+      if (Object.keys(row).length === 0) return;
+      const { error } = await pub.from("plg_financial_invoice_installments").update(row).eq("id", id);
+      if (error) throw error;
+    },
+    // SUBSTITUI as linhas, e o total vai junto.
+    //
+    // Casar linha a linha pediria um id estável que o formulário não carrega —
+    // ele trabalha com `_id` de rascunho —, e uma fatura tem unidades de
+    // linhas, não milhares. Apagar e reinserir é o que o cadastro já faz, pelo
+    // mesmo caminho e com a mesma contabilidade de linha.
+    //
+    // O TOTAL ENTRA NA MESMA OPERAÇÃO. Ele é a soma das linhas: gravar as
+    // linhas sem ele deixaria a conta somando um valor na tela e cobrando
+    // outro no cronograma — e o `financial_reschedule_invoice`, que compara a
+    // soma das parcelas com o total GRAVADO, recusaria o cronograma novo sem
+    // dizer por quê. 099 abriu os dois enquanto nada foi recebido.
+    //
+    // O espelho contábil (`plg_financial_invoice_items`) some sozinho: a chave
+    // dele é `item_id ON DELETE CASCADE`.
+    async replaceInvoiceItems(invoiceId, items) {
+      const { pub } = getClients();
+      const tenantId = await invoiceTenantId(pub, invoiceId);
+      const totalAmount = invoiceTotal(items);
+      const { error: totalErr } = await pub.from("plg_financial_invoices").update({ total: totalAmount, description: itemsDescription(items) || null }).eq("id", invoiceId);
+      if (totalErr) throw totalErr;
+      const { data: inserted, error: insErr } = await pub.rpc("financial_set_invoice_lines", {
+        p_invoice_id: invoiceId,
+        p_lines: invoiceLinesPayload(items, lineTotal),
+        p_replace: true
+      });
+      if (insErr) throw insErr;
+      await writeLineAccounting(pub, tenantId, inserted, items);
+    },
+    // UMA chamada, não um laço de updates.
+    //
+    // Ir de 3x para 2x apaga uma linha e reescreve as outras duas, e
+    // (invoice_id, number) é UNIQUE e não deferrable: qualquer ordem de
+    // updates do cliente passa por um estado que o banco recusa. A RPC faz o
+    // apaga-e-reinsere numa transação, confere se a soma bate com o total do
+    // título e recusa o que já recebeu alguma coisa.
+    async rescheduleInvoice(invoiceId, installments) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_reschedule_invoice", {
+        p_invoice_id: invoiceId,
+        p_installments: installments.map((inst, i) => ({
+          number: i + 1,
+          due_date: inst.dueDate,
+          amount: inst.amount,
+          // 111 faz `metadata = coalesce(v_meta, metadata)`: o que vai aqui
+          // SUBSTITUI a metadata da parcela, então o chamador manda o conjunto
+          // inteiro, não o delta.
+          ...inst.metadata ? { metadata: inst.metadata } : {}
+        })),
+        p_idempotency_key: createIdempotencyKey("financial:invoice-reschedule")
+      });
+      if (error) throw error;
+    },
+    async cancelInvoice(input) {
+      const { pub } = getClients();
+      const reason = cancellationReason(input);
+      const { error } = await pub.rpc("financial_cancel_invoice", {
+        p_invoice_id: input.invoiceId,
+        p_reason: reason,
+        p_idempotency_key: input.idempotencyKey ?? createIdempotencyKey("financial:invoice-cancel")
+      });
+      if (error) throw error;
+    },
+    async listCancellationReasons() {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_cancellation_reasons");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({ id: r.id, name: r.name }));
+    },
+    async getInvoiceStockEntries(invoiceId) {
+      const { pub } = getClients();
+      const toEntry = (r) => ({
+        itemId: r.item_id,
+        productId: r.product_id,
+        locationId: r.location_id,
+        entered: Number(r.entered ?? 0),
+        available: Number(r.available ?? 0),
+        enteredOn: r.entered_on
+      });
+      const { data, error } = await pub.rpc("financial_invoice_stock_entries", { p_invoice_id: invoiceId });
+      if (error) throw error;
+      const guessed = (data ?? []).map(toEntry);
+      const linked = await pub.rpc("financial_invoice_stock_links", { p_invoice_id: invoiceId });
+      const direct = linked.error || !Array.isArray(linked.data) ? [] : linked.data.map(toEntry);
+      const seen = new Set(direct.map((e) => e.itemId));
+      return [...direct, ...guessed.filter((e) => !seen.has(e.itemId))];
+    },
+    async listStockLocations() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_inventory_stock_locations").select("id, name").eq("is_active", true).order("name");
+      if (error) return [];
+      return (data ?? []).map((r) => ({ id: r.id, name: r.name }));
+    },
+    async listCurrencies() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_financial_accounts").select("currency").eq("tenant_id", getActiveTenantId()).eq("is_active", true).not("kind", "in", "(system,person)");
+      if (error) return [];
+      return [...new Set((Array.isArray(data) ? data : []).map((r) => String(r.currency ?? "").toUpperCase()).filter(Boolean))];
+    },
+    async getProductPictures(ids) {
+      if (ids.length === 0) return {};
+      const { pub } = getClients();
+      const { data, error } = await pub.from("products").select("id, image_url").in("id", ids);
+      if (error) return {};
+      const out = {};
+      for (const p of Array.isArray(data) ? data : []) if (p.image_url) out[p.id] = p.image_url;
+      return out;
+    },
+    async searchStockProducts(query) {
+      const { pub } = getClients();
+      let qb = pub.from("products").select("id, name").eq("kind", "good").eq("is_active", true).order("name").limit(20);
+      const q = query.trim();
+      if (q) qb = qb.ilike("name", `%${q.replace(/[%_]/g, " ")}%`);
+      const { data, error } = await qb;
+      if (error) return [];
+      return (data ?? []).map((r) => ({ id: r.id, name: r.name }));
+    },
+    async getFxRate(from, to) {
+      const { pub } = getClients();
+      if (from === to) return 1;
+      const read = async () => {
+        const { data, error } = await pub.from("plg_financial_fx_rates").select("base_currency, quote_currency, rate, rate_date").or(`and(base_currency.eq.${from},quote_currency.eq.${to}),and(base_currency.eq.${to},quote_currency.eq.${from})`).order("rate_date", { ascending: false }).limit(1);
+        const row = !error && Array.isArray(data) ? data[0] : null;
+        if (!row || !(Number(row.rate) > 0)) return null;
+        return row.base_currency === from ? Number(row.rate) : 1 / Number(row.rate);
+      };
+      const known = await read();
+      if (known !== null) return known;
+      const tenantId = getActiveTenantId();
+      if (tenantId && await ensureReferenceRates(pub, tenantId, to, [from])) return read();
+      return null;
+    },
+    async listProductVariants(productId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("product_variants").select("id, name, is_default").eq("product_id", productId).eq("is_active", true).order("sort_order").order("created_at");
+      if (error) return [];
+      return (data ?? []).map((r) => ({ id: r.id, name: r.name, isDefault: !!r.is_default }));
+    },
+    async getInvoiceStockDetails(invoiceId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_invoice_stock_link_details", { p_invoice_id: invoiceId });
+      if (error || !Array.isArray(data)) return [];
+      return data.map((r) => ({
+        itemId: r.item_id,
+        variantId: r.variant_id ?? void 0,
+        variantName: r.variant_name ?? void 0,
+        quantity: Number(r.quantity) || 0,
+        unitCost: Number(r.unit_cost) || 0,
+        currency: String(r.currency ?? ""),
+        sourceUnitCost: r.source_unit_cost == null ? void 0 : Number(r.source_unit_cost),
+        sourceCurrency: r.source_currency ?? void 0,
+        fxRate: r.fx_rate == null ? void 0 : Number(r.fx_rate),
+        locationName: r.location_name ?? void 0,
+        enteredOn: r.entered_on ?? void 0
+      }));
+    },
+    async receiveInvoiceItemStock(input) {
+      const { pub } = getClients();
+      const call = () => pub.rpc("financial_invoice_item_receive_stock_lines", {
+        p_item_id: input.itemId,
+        p_location_id: input.locationId,
+        p_lines: input.entries.map((e) => ({ variant_id: e.variantId ?? null, quantity: e.quantity })),
+        p_product_id: input.productId ?? null,
+        p_unit_cost: input.unitCost ?? null,
+        p_fx_rate: input.fxRate ?? null,
+        p_idempotency_key: input.idempotencyKey ?? null
+      });
+      let { error } = await call();
+      const pair = /de ([A-Z]{3}) para ([A-Z]{3})/.exec(String(error?.message ?? ""));
+      const tenantId = getActiveTenantId();
+      if (pair && tenantId && await ensureReferenceRates(pub, tenantId, pair[2], [pair[1]])) {
+        ({ error } = await call());
+      }
+      if (error) throw error;
+    },
+    async cancelInvoiceItems(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_cancel_invoice_items", {
+        p_invoice_id: input.invoiceId,
+        p_item_ids: input.itemIds.length ? input.itemIds : null,
+        p_reason_id: input.reasonId,
+        p_detail: input.detail?.trim() || null,
+        p_stock: input.stock.map((s) => ({ item_id: s.itemId, destination: s.destination, note: s.note?.trim() || null })),
+        p_idempotency_key: input.idempotencyKey ?? createIdempotencyKey("financial:invoice-cancel-items")
+      });
+      if (error) throw error;
+      const r = data ?? {};
+      return { whole: !!r.whole, amount: Number(r.amount ?? 0), creditAmount: Number(r.credit_amount ?? 0) };
+    },
+    async addInstallmentCharge(input) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_add_installment_charge", {
+        p_installment_id: input.installmentId,
+        p_kind: input.kind,
+        p_amount: input.amount,
+        p_chart_account_id: input.accountId ?? null,
+        p_description: input.description?.trim() || null,
+        p_idempotency_key: input.idempotencyKey ?? createIdempotencyKey("financial:installment-charge")
+      });
+      if (error) throw error;
+    },
+    async getSupplierCredit(personId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_supplier_credit", { p_person_id: personId });
+      if (error) throw error;
+      return Number(data ?? 0);
+    },
+    // --- Movements (public.financial_movements) ---
+    async getMovements(query) {
+      const { pub } = getClients();
+      const wantsSchedule = !!query.invoiceId && !query.bankAccountId && !query.cashSessionId;
+      if (wantsSchedule) {
+        let sq = pub.from(T.bills).select("*", { count: "exact" }).eq("invoice_id", query.invoiceId);
+        if (query.direction) sq = sq.eq("direction", toLedgerDirection(query.direction));
+        if (query.status) {
+          const statuses = Array.isArray(query.status) ? query.status : [query.status];
+          sq = sq.in("status", statuses);
+        }
+        if (query.dateRange) sq = sq.gte("due_date", query.dateRange.from).lte("due_date", query.dateRange.to);
+        const page2 = query.page ?? 1;
+        const pageSize2 = query.pageSize ?? 50;
+        const { data: data2, count: count2, error } = await sq.range((page2 - 1) * pageSize2, page2 * pageSize2 - 1).order("due_date");
+        if (error) throw error;
+        const bills = (data2 ?? []).map(billRowToMovement);
+        const { data: payRows } = await pub.from(T.movements).select("*").or(`financial_invoice_id.eq.${query.invoiceId},invoice_id.eq.${query.invoiceId}`).eq("movement_kind", "payment").order("payment_date");
+        const payments = (payRows ?? []).map((r) => ({
+          ...snakeToCamel(r),
+          invoiceId: r.financial_invoice_id ?? r.invoice_id
+        }));
+        return { data: [...bills, ...payments], total: count2 ?? 0 };
+      }
+      let qb = pub.from(T.movements).select("*", { count: "exact" });
+      if (query.direction) qb = qb.eq("direction", query.direction);
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status];
+        qb = qb.in("status", statuses);
+      }
+      if (query.bankAccountId) qb = qb.eq("bank_account_id", query.bankAccountId);
+      if (query.cashSessionId) qb = qb.eq("cash_session_id", query.cashSessionId);
+      if (query.invoiceId) {
+        qb = qb.or(`financial_invoice_id.eq.${query.invoiceId},invoice_id.eq.${query.invoiceId}`);
+      }
+      if (query.dateRange) qb = qb.gte("due_date", query.dateRange.from).lte("due_date", query.dateRange.to);
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      qb = qb.range((page - 1) * pageSize, page * pageSize - 1).order("due_date");
+      const { data, count } = await qb;
+      return {
+        // `invoiceId` carrega o canônico quando existe: quem lê a tela compara
+        // com o id da fatura que abriu, e esse é o do modelo novo.
+        data: (data ?? []).map((r) => ({
+          ...snakeToCamel(r),
+          invoiceId: r.financial_invoice_id ?? r.invoice_id
+        })),
+        total: count ?? 0
+      };
+    },
+    /**
+     * Receber — pela RPC, que é o único lugar onde receber dinheiro acontece.
+     *
+     * Antes isto escrevia à mão: inseria um movimento de pagamento, atualizava o
+     * cache do bill, e recalculava o status da fatura. Três escritas no ESPELHO
+     * `plg_financial_movements`, que parou de ser escrito na Fase 2 (financial
+     * 040) e hoje tem 7 linhas, a última de agosto. Tudo o mais já lia
+     * `v_financial_installment_balances`, a parcela com o seu saldo — só este caminho continuava
+     * do outro lado.
+     *
+     * Duas coisas que a mão fazia e a RPC faz melhor: ela valida a sessão de
+     * caixa aberta para dinheiro, exige conta para os métodos que precisam de
+     * uma, e tem chave de idempotência — um duplo clique deixa de virar dois
+     * recebimentos.
+     *
+     * E uma que a mão fazia e NÃO devia: escrevia `orders.status` como
+     * 'paid'/'partial'/'invoiced'. O status do pedido é do produto que o abriu —
+     * uma comanda paga estaria com um status que o fluxo do salão não conhece, e
+     * o quadro a perderia. Quem registra o dinheiro não renomeia a venda.
+     *
+     * `movementId` É o id da parcela: o modal recebe a linha de `T.bills`, que é
+     * `v_financial_installment_balances`, e ali a chave chama `installment_id`.
+     */
+    /**
+     * Estorna um pagamento. A RPC existia desde a base e NENHUMA camada de
+     * TypeScript a expunha — o dinheiro entrava pela tela e só saía pelo SQL.
+     *
+     * Estornar NÃO apaga: lança a contrapartida e aponta `reversed_by_id`, então
+     * o extrato mostra os dois lados e o balancete continua fechando. Um livro
+     * onde um lançamento some não prova nada.
+     */
+    /**
+     * A conta do cliente. `v_financial_invoice_balances` já traz total/pago/saldo
+     * por fatura, então os indicadores são uma soma — não uma segunda contagem
+     * que poderia divergir da lista logo abaixo dela.
+     */
+    async searchSellableServices(term) {
+      const { pub } = getClients();
+      let q = pub.from("products").select("id, name, price").eq("kind", "service").not("is_active", "is", false).order("name").limit(20);
+      if (term.trim()) q = q.ilike("name", `%${term.trim()}%`);
+      const { data, error } = await q;
+      if (error) throw error;
+      return (data ?? []).map((p) => ({ id: p.id, name: p.name, price: Number(p.price ?? 0) }));
+    },
+    async prepayServices(personId, lines) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("clinical_prepay_services", {
+        p_party: personId,
+        p_lines: lines.map((l) => ({
+          service_id: l.serviceId,
+          name: l.name,
+          quantity: l.quantity,
+          unit_price: l.unitPrice
+        }))
+      });
+      if (error) throw error;
+      const r = data ?? {};
+      return { ok: r.ok === true, reason: r.reason, orderId: r.order_id, total: r.total };
+    },
+    async getClientAccount(personId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_invoice_balances").select("id, number, order_id, competence_date, total, paid, balance, status, description").eq("counterparty_person_id", personId).eq("direction", "receivable").is("cancelled_at", null).order("competence_date", { ascending: false });
+      if (error) throw error;
+      const rows = data ?? [];
+      const invoices = rows.map((r) => ({
+        id: r.id,
+        number: r.number,
+        orderId: r.order_id,
+        competenceDate: r.competence_date,
+        total: Number(r.total) || 0,
+        paid: Number(r.paid) || 0,
+        balance: Number(r.balance) || 0,
+        status: r.status,
+        description: r.description
+      }));
+      let paidToExecute;
+      let openToExecute;
+      try {
+        const { data: exec } = await pub.from("v_clinical_to_execute").select("paid_to_execute, open_to_execute").eq("party_id", personId).maybeSingle();
+        if (exec) {
+          paidToExecute = Number(exec.paid_to_execute) || 0;
+          openToExecute = Number(exec.open_to_execute) || 0;
+        }
+      } catch {
+      }
+      return {
+        personId,
+        contracted: invoices.reduce((a, i) => a + i.total, 0),
+        paid: invoices.reduce((a, i) => a + i.paid, 0),
+        open: invoices.reduce((a, i) => a + i.balance, 0),
+        paidToExecute,
+        openToExecute,
+        invoices
+      };
+    },
+    /**
+     * A previsão de recebimento de cartão. `v_financial_card_receivables` já
+     * reparte o bruto pelas parcelas, aplica a taxa da bandeira/faixa e data
+     * cada liquidação — a tela só ordena e soma.
+     */
+    async getCardReceivables() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_card_receivables").select("movement_id, account_name, card_brand, card_installments, installment_k, payment_date, gross, fee_rate, fee, net, settlement_date, missing_fee_config").order("settlement_date");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        movementId: r.movement_id,
+        accountName: r.account_name,
+        cardBrand: r.card_brand,
+        cardInstallments: r.card_installments,
+        installmentK: r.installment_k,
+        paymentDate: r.payment_date,
+        gross: Number(r.gross) || 0,
+        feeRate: r.fee_rate == null ? null : Number(r.fee_rate),
+        fee: Number(r.fee) || 0,
+        net: Number(r.net) || 0,
+        settlementDate: r.settlement_date,
+        missingFeeConfig: !!r.missing_fee_config
+      }));
+    },
+    async reverseMovement(movementId, reason) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_reverse_movement", {
+        p_movement_id: movementId,
+        p_reason: reason,
+        p_idempotency_key: null
+      });
+      if (error) throw error;
+    },
+    async payMovement(input) {
+      const { pub } = getClients();
+      const { data: before } = await pub.from(T.bills).select("*").eq("installment_id", input.movementId).maybeSingle();
+      if (!before) throw new Error("Parcela n\xE3o encontrada");
+      let method = null;
+      if (input.paymentMethodTypeId) {
+        const { data: type } = await pub.from(T.paymentMethodTypes).select("transaction_type").eq("id", input.paymentMethodTypeId).maybeSingle();
+        method = type?.transaction_type ?? null;
+      }
+      const feePct = before.direction === "receivable" ? await getMethodFeePct(pub, input.paymentMethodId) : 0;
+      const fee = paymentFee(input.amount, feePct, before.direction);
+      const { error } = await pub.rpc("financial_receive_payment", {
+        p_installment_id: input.movementId,
+        p_amount: input.amount,
+        p_account_id: input.bankAccountId ?? null,
+        p_method: ledgerMethod(method),
+        p_cash_session_id: input.cashSessionId ?? null,
+        p_card_brand: input.cardBrand ?? null,
+        p_card_installments: input.cardInstallments ?? null,
+        p_payment_date: input.paymentDate,
+        p_fee_amount: fee || null,
+        p_notes: input.notes ?? null,
+        p_idempotency_key: input.idempotencyKey ?? createIdempotencyKey("financial:payment"),
+        p_metadata: input.metadata ?? {}
+      });
+      if (error) throw error;
+      try {
+        const { data: after } = await pub.from(T.bills).select("*").eq("installment_id", input.movementId).maybeSingle();
+        return billRowToMovement(after ?? before);
+      } catch {
+        return billRowToMovement(before);
+      }
+    },
+    async cancelMovement(id) {
+      const { pub } = getClients();
+      await pub.from(T.movements).update({ status: "cancelled" }).eq("id", id);
+    },
+    // --- Transfers (between accounts) ---
+    async createTransfer(input) {
+      const { pub } = getClients();
+      const transferId = genId();
+      const legs = transferLegs(input, transferId);
+      const tenantId = getActiveTenantId();
+      const rowsToInsert = legs.map((leg) => ({
+        tenant_id: tenantId,
+        movement_kind: "transfer",
+        direction: leg.direction,
+        bank_account_id: leg.bankAccountId,
+        amount: input.amount,
+        paid_amount: input.amount,
+        fee_amount: 0,
+        status: "paid",
+        due_date: input.date,
+        payment_date: input.date,
+        notes: input.notes ?? null,
+        metadata: leg.metadata
+      }));
+      let { data, error } = await pub.from(T.movements).insert(rowsToInsert).select("id, direction");
+      if (error && /fee_amount/i.test(error.message ?? "")) {
+        const stripped = rowsToInsert.map(({ fee_amount, ...rest }) => rest);
+        ({ data, error } = await pub.from(T.movements).insert(stripped).select("id, direction"));
+      }
+      if (error) throw error;
+      const rows = data ?? [];
+      const debitMovementId = rows.find((r) => r.direction === "debit")?.id ?? "";
+      const creditMovementId = rows.find((r) => r.direction === "credit")?.id ?? "";
+      return { transferId, debitMovementId, creditMovementId };
+    },
+    // --- Bank Accounts ---
+    /**
+     * As contas onde um recebimento pode CAIR — da mesma tabela que a RPC valida.
+     *
+     * `plg_financial_bank_accounts` e `plg_financial_accounts` são duas tabelas,
+     * com dois vocabulários: `account_type` ('bank_account', 'cash_register')
+     * contra `kind` ('bank', 'cash_physical', 'card_receivable_credit'…). Os ids
+     * coincidem onde as duas têm a linha — mas as contas de recebível de cartão
+     * existem SÓ na segunda, e era ela que a RPC conferia.
+     *
+     * O efeito: o seletor do modal, lendo a primeira, nunca conseguia oferecer
+     * uma conta de cartão, e `financial_receive_payment` recusava com "method
+     * credit_card must settle in a card_receivable_credit account". Cartão não
+     * estava quebrado para um tenant — estava quebrado para todos.
+     *
+     * `accountType` carrega o `kind` canônico porque é ele que o filtro de
+     * `allowed_account_types` compara. Um vocabulário, não dois.
+     */
+    async getBankAccounts() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_financial_accounts").select("*").eq("is_active", true).order("name");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        ...snakeToCamel(r),
+        accountType: r.kind
+      }));
+    },
+    async getAccountsByIds(ids) {
+      if (ids.length === 0) return [];
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_financial_accounts").select("*").in("id", ids);
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        ...snakeToCamel(r),
+        accountType: r.kind
+      }));
+    },
+    // Só a conta INTEGRADA, como no V1. A view já faz o `openfinance_configured`
+    // — uma conta sem origem ativa nunca vai trazer uma linha, e oferecê-la é
+    // convidar a pessoa a concluir que a tela está quebrada.
+    async getStatementAccounts() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.statementAccounts).select("*").order("kind").order("name");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        ...snakeToCamel(r),
+        accountType: r.kind
+      }));
+    },
+    async searchFinancialAccounts(query, limit = 20) {
+      const term = query.trim();
+      if (term.length < 2) return [];
+      const { pub } = getClients();
+      const groups = [
+        ["person"],
+        ["bank", "unit"],
+        ["cash_physical", "cash_session"],
+        ["card_receivable_credit", "card_receivable_debit", "card_payable"],
+        ["unidentified", "system"]
+      ];
+      const perGroup = Math.min(Math.max(Math.ceil(limit / groups.length), 4), 12);
+      const answers = await Promise.all(groups.map(async (kinds) => {
+        const { data, error } = await pub.from("plg_financial_accounts").select("*").eq("is_active", true).in("kind", kinds).ilike("name", `%${term}%`).order("name").limit(perGroup);
+        if (error) throw error;
+        return (data ?? []).map((row) => ({
+          ...snakeToCamel(row),
+          accountType: row.kind
+        }));
+      }));
+      const out = [];
+      for (let index = 0; out.length < limit && answers.some((rows) => index < rows.length); index += 1) {
+        for (const rows of answers) {
+          if (rows[index]) out.push(rows[index]);
+          if (out.length === limit) break;
+        }
+      }
+      return out;
+    },
+    /**
+     * Writes where getBankAccounts READS.
+     *
+     * It used to insert into `plg_financial_bank_accounts` while the reader
+     * came from `plg_financial_accounts` — so an account created through the UI
+     * was never seen again by any screen or RPC. The caixa screen's own empty
+     * state says "crie uma conta do tipo Caixa primeiro", and following that
+     * instruction landed the row in a table nothing reads.
+     *
+     * `accountType` carries the canonical `kind` (see getBankAccounts), so it is
+     * written to `kind`; `account_type` keeps the descriptive value the older
+     * rows carry.
+     */
+    async createBankAccount(input) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      const row = camelToSnake(input);
+      const kind = row.account_type;
+      delete row.account_type;
+      delete row.initial_balance;
+      const { data, error } = await pub.from("plg_financial_accounts").insert({
+        ...row,
+        tenant_id: tenantId,
+        kind,
+        account_type: kind,
+        is_active: true
+      }).select().single();
+      if (error) throw error;
+      return { ...snakeToCamel(data), accountType: data.kind };
+    },
+    async updateBankAccount(id, partial) {
+      const { pub } = getClients();
+      const row = camelToSnake(partial);
+      delete row.id;
+      delete row.tenant_id;
+      if (row.account_type) {
+        row.kind = row.account_type;
+      }
+      const { data, error } = await pub.from("plg_financial_accounts").update(row).eq("id", id).select().single();
+      if (error) throw error;
+      return { ...snakeToCamel(data), accountType: data.kind };
+    },
+    // --- Cash Sessions ---
+    /**
+     * Sessions carrying what the caixa SHOULD hold right now.
+     *
+     * The close screen used to compare the counted cash against the OPENING
+     * balance, so every cash sale of the shift read as a surplus. The expected
+     * value comes from the same view the close RPC reads, so the operator
+     * confirms the number the system is about to record.
+     */
+    async getCashSessions(bankAccountId) {
+      const { pub } = getClients();
+      let qb = pub.from(T.cashRegisterSessions).select("*");
+      if (bankAccountId) qb = qb.eq("bank_account_id", bankAccountId);
+      const { data, error } = await qb.order("opened_at", { ascending: false });
+      if (error) throw error;
+      const rows = (data ?? []).map((r) => snakeToCamel(r));
+      if (!rows.length) return rows;
+      const { data: exp } = await pub.from("v_financial_cash_session_expected").select("session_id, expected_cash, received_by_method, payment_count").in("session_id", rows.map((r) => r.id));
+      const by = new Map((exp ?? []).map((e) => [e.session_id, e]));
+      return rows.map((r) => {
+        const e = by.get(r.id);
+        return e ? {
+          ...r,
+          expectedCash: Number(e.expected_cash ?? 0),
+          receivedByMethod: e.received_by_method ?? {},
+          paymentCount: e.payment_count ?? 0
+        } : r;
+      });
+    },
+    async getOpenSession(bankAccountId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.cashRegisterSessions).select("*").eq("bank_account_id", bankAccountId).eq("status", "open").single();
+      if (error) throw error;
+      return data ? snakeToCamel(data) : null;
+    },
+    // Verbo, não INSERT. A escrita direta parecia funcionar e não abria caixa
+    // nenhum: `financial_cash_session_open` cria uma CONTA dedicada para a
+    // caixinha, funda-a com um movimento a partir do cofre, exige
+    // `financial.cash_session`, recusa a segunda sessão aberta do mesmo
+    // operador na mesma unidade, valida que o cofre é `cash_physical` e audita.
+    // A linha inserida à mão não tinha conta — e sem conta nenhum movimento
+    // pode pertencer a ela, então o fechamento contava zero.
+    async openCashSession(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_cash_session_open", {
+        p_cofre_account_id: input.bankAccountId,
+        p_opening_amount: input.openingBalance,
+        p_idempotency_key: null
+      });
+      if (error) throw error;
+      const sessionId = data?.session_id;
+      if (!sessionId) throw new Error("financial_cash_session_open n\xE3o devolveu sess\xE3o");
+      const { data: row, error: readError } = await pub.from(T.cashRegisterSessions).select("*").eq("id", sessionId).single();
+      if (readError) throw readError;
+      return snakeToCamel(row);
+    },
+    // O fechamento é uma CONFERÊNCIA, e o UPDATE à mão não conferia nada: a RPC
+    // calcula o esperado (saldo da conta da caixinha para dinheiro, soma dos
+    // pagamentos em cartão da sessão), compara com o contado, devolve o
+    // dinheiro contado ao cofre e lança a diferença como quebra de caixa —
+    // falta ou sobra — em conta de sistema própria. Depois audita.
+    //
+    // A RPC fecha a sessão aberta DE QUEM CHAMA, e por isso não recebe id:
+    // fecha-se o próprio caixa. `sessionId` continua na entrada pelo contrato
+    // do provider e é conferido aqui, para o erro sair como "não é o seu
+    // caixa" em vez de fechar silenciosamente o caixa errado.
+    async closeCashSession(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_cash_session_close", {
+        p_counted_cash: input.closingBalance,
+        p_counted_card: input.countedCard ?? 0,
+        p_idempotency_key: null,
+        p_notes: input.notes ?? null
+      });
+      if (error) throw error;
+      const closedId = data?.session_id;
+      if (closedId && input.sessionId && closedId !== input.sessionId) {
+        throw new Error("o caixa fechado n\xE3o \xE9 o que a tela pediu \u2014 recarregue a lista");
+      }
+      const { data: row, error: readError } = await pub.from(T.cashRegisterSessions).select("*").eq("id", closedId ?? input.sessionId).single();
+      if (readError) throw readError;
+      return snakeToCamel(row);
+    },
+    async getCashSessionSummary(sessionId) {
+      const { pub } = getClients();
+      const session = (await pub.from(T.cashRegisterSessions).select("*").eq("id", sessionId).single()).data;
+      const { data: movs } = await pub.from(T.movements).select("direction, paid_amount").eq("cash_session_id", sessionId).eq("status", "paid");
+      const flow = sessionCashFlow((movs ?? []).map((m) => ({ direction: m.direction, paidAmount: m.paid_amount })));
+      return { session: snakeToCamel(session), ...flow };
+    },
+    // --- Payment Methods ---
+    async getPaymentMethods() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.paymentMethods).select("*").eq("is_active", true).order("name");
+      if (error) throw error;
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    async getPaymentMethodTypes() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.paymentMethodTypes).select("*").eq("is_active", true).order("name");
+      if (error) throw error;
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    // --- Chart of Accounts ---
+    async getChartOfAccounts() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.chartOfAccounts).select("*").eq("is_active", true).order("code");
+      if (error) throw error;
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    async resolveChartAccountRefs(refs) {
+      const unique = [...new Set(refs.map((ref) => String(ref).trim()).filter(Boolean))];
+      if (unique.length === 0) return {};
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_resolve_chart_account_refs", { p_refs: unique });
+      if (error) throw error;
+      return Object.fromEntries((data ?? []).map((row) => [String(row.source_ref), String(row.chart_account_id)]));
+    },
+    async getCostCenters() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.costCenters).select("*").eq("is_active", true).order("code");
+      if (error) throw error;
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    // --- Card Transactions ---
+    async getCardTransactions(dateRange) {
+      getClients();
+      return [];
+    },
+    // --- Statements (ERP extract: opening balance + realized cash + per-row net/fee) ---
+    async getStatement(query) {
+      const { core, pub } = getClients();
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const { data: acctRows } = await pub.from("plg_financial_accounts").select("id, name, is_active");
+      const allAccounts = acctRows ?? [];
+      const consolidated = !query.bankAccountId;
+      const scopeAccounts = consolidated ? allAccounts.filter((a) => a.is_active) : allAccounts.filter((a) => a.id === query.bankAccountId);
+      const accountIds = scopeAccounts.map((a) => a.id);
+      const accountNameById = new Map(allAccounts.map((a) => [a.id, a.name]));
+      if (!consolidated && accountIds.length === 0) return emptyStatement(query.bankAccountId);
+      const scopeFilter = (qb) => consolidated ? qb : qb.in("bank_account_id", accountIds);
+      const toMovement = (r) => snakeToCamel(r);
+      const { data: priorRows } = await scopeFilter(pub.from(T.cashMovements).select("*").neq("status", "cancelled").lt("payment_date", query.dateRange.from));
+      const openingBalance = ledgerBalance(0, (priorRows ?? []).map(toMovement));
+      const { data: movs } = await scopeFilter(pub.from(T.cashMovements).select("*").neq("status", "cancelled").gte("payment_date", query.dateRange.from).lte("payment_date", query.dateRange.to).order("payment_date").order("created_at"));
+      const invoiceIds = [...new Set((movs ?? []).map((r) => r.invoice_id).filter(Boolean))];
+      const invoiceById = /* @__PURE__ */ new Map();
+      if (invoiceIds.length) {
+        const { data: orders } = await core.from("orders").select("id, party_id, reference_number, metadata").in("id", invoiceIds);
+        for (const o of orders ?? []) {
+          invoiceById.set(o.id, { id: o.id, contactId: o.party_id, contactName: o.metadata?.contactName, fiscalNumber: o.reference_number });
+        }
+      }
+      const statement = buildStatement({
+        openingBalance,
+        movements: (movs ?? []).map(toMovement),
+        consolidated,
+        accountNameOf: (id) => accountNameById.get(id),
+        invoiceOf: (movement) => movement.invoiceId ? invoiceById.get(movement.invoiceId) : void 0
+      });
+      const entries = statement.entries;
+      const matchedIds = [...new Set(entries.map((e) => e.movement.matchedMovementId).filter(Boolean))];
+      if (matchedIds.length) {
+        const { data: matched } = await pub.from(T.movements).select("id, invoice_id, notes").in("id", matchedIds);
+        const matchedById = new Map((matched ?? []).map((m) => [m.id, m]));
+        const matchedInvoiceIds = [...new Set((matched ?? []).map((m) => m.invoice_id).filter(Boolean))];
+        const invById = /* @__PURE__ */ new Map();
+        if (matchedInvoiceIds.length) {
+          const { data: orders } = await core.from("orders").select("id, reference_number, metadata").in("id", matchedInvoiceIds);
+          for (const o of orders ?? []) invById.set(o.id, o);
+        }
+        for (const e of entries) {
+          const mid = e.movement.matchedMovementId;
+          const mm = mid ? matchedById.get(mid) : void 0;
+          if (!mm) continue;
+          const inv = mm.invoice_id ? invById.get(mm.invoice_id) : void 0;
+          e.reconciledWith = {
+            movementId: mm.id,
+            description: mm.notes ?? void 0,
+            invoiceId: mm.invoice_id ?? void 0,
+            fiscalNumber: inv?.reference_number ?? void 0,
+            contactName: inv?.metadata?.contactName ?? void 0
+          };
+        }
+      }
+      const { data: todayRows } = await scopeFilter(pub.from(T.cashMovements).select("*").neq("status", "cancelled").lte("payment_date", today));
+      return {
+        ...statement,
+        accountId: query.bankAccountId,
+        accountCurrentBalance: ledgerBalance(0, (todayRows ?? []).map(toMovement))
+      };
+    },
+    async getDre(query) {
+      const { pub } = getClients();
+      const columns = "unit_id,competence_month,direction,account_id,account_code,account_name,account_type,account_parent_id,statement_code,statement_name,unclassified,line_count,amount,discount";
+      const rpcResult = await pub.rpc("financial_dre", {
+        p_from: `${query.year}-01-01`,
+        p_to: `${query.year}-12-31`,
+        p_unit_id: query.unitId ?? null
+      });
+      if (!rpcResult.error) return (rpcResult.data ?? []).map((row) => ({
+        unitId: row.unit_id ?? void 0,
+        competenceMonth: row.competence_month ?? void 0,
+        accountId: row.account_id ?? void 0,
+        accountCode: row.account_code ?? void 0,
+        accountName: row.account_name ?? void 0,
+        accountType: row.account_type,
+        parentAccountId: row.account_parent_id ?? void 0,
+        statementCode: row.statement_code ?? void 0,
+        statementName: row.statement_name ?? void 0,
+        unclassified: Boolean(row.unclassified),
+        lineCount: Number(row.line_count) || 0,
+        amount: Number(row.amount) || 0,
+        discount: Number(row.discount) || 0
+      }));
+      if (rpcResult.error.code !== "PGRST202" && rpcResult.error.code !== "42883") throw rpcResult.error;
+      const { data, error } = await pub.from("plg_financial_rep_dre").select(columns).or(`competence_month.is.null,and(competence_month.gte.${query.year}-01-01,competence_month.lte.${query.year}-12-31)`).order("account_code", { ascending: true }).order("competence_month", { ascending: true });
+      if (error) throw error;
+      return (data ?? []).filter((row) => !row.competence_month || !query.unitId || row.unit_id === query.unitId).map((row) => ({
+        unitId: row.unit_id ?? void 0,
+        competenceMonth: row.competence_month ?? void 0,
+        accountId: row.account_id ?? void 0,
+        accountCode: row.account_code ?? void 0,
+        accountName: row.account_name ?? void 0,
+        accountType: row.direction === "receivable" ? "revenue" : row.direction === "payable" ? "expense" : row.account_type,
+        parentAccountId: row.account_parent_id ?? void 0,
+        statementCode: row.statement_code ?? void 0,
+        statementName: row.statement_name ?? void 0,
+        unclassified: Boolean(row.unclassified),
+        lineCount: Number(row.line_count) || 0,
+        amount: Number(row.amount) || 0,
+        discount: Number(row.discount) || 0
+      }));
+    },
+    // --- Summary ---
+    // --- Fechamento e prova do livro (006) ---
+    async getPeriods() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.periods).select("*").order("competence_month", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        competenceMonth: r.competence_month,
+        status: r.status,
+        closedAt: r.closed_at,
+        reopenReason: r.reopen_reason
+      }));
+    },
+    async closePeriod(month, notes) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_period_close", { p_month: month, p_notes: notes ?? null });
+      if (error) throw error;
+    },
+    async reopenPeriod(month, reason) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_period_reopen", { p_month: month, p_reason: reason });
+      if (error) throw error;
+    },
+    async getTrialBalance(competenceMonth) {
+      const { pub } = getClients();
+      let qb = pub.from(T.trialBalance).select("*");
+      if (competenceMonth) qb = qb.eq("competence_month", competenceMonth);
+      const { data, error } = await qb.order("account_code");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        accountId: r.account_id,
+        accountCode: r.account_code,
+        accountName: r.account_name,
+        competenceMonth: r.competence_month,
+        totalDebit: Number(r.total_debit) || 0,
+        totalCredit: Number(r.total_credit) || 0,
+        balance: Number(r.balance) || 0
+      }));
+    },
+    // --- Cobrança (016) e margem (015) ---
+    async getAging() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.aging).select("*").eq("direction", "receivable").order("due_date");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        installmentId: r.installment_id,
+        invoiceNumber: r.invoice_number,
+        counterpartyName: r.counterparty_name,
+        dueDate: r.due_date,
+        balance: Number(r.balance) || 0,
+        daysOverdue: Number(r.days_overdue) || 0,
+        bucket: r.bucket
+      }));
+    },
+    async getMarginByMonth() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.marginByMonth).select("*").order("competence_month", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        competenceMonth: r.competence_month,
+        revenue: Number(r.revenue) || 0,
+        cogs: Number(r.cogs) || 0,
+        commission: Number(r.commission) || 0,
+        margin: Number(r.margin) || 0,
+        marginPercent: Number(r.margin_percent) || 0
+      }));
+    },
+    // --- Contas recorrentes (014) ---
+    async getRecurringBills(direction) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.recurringBills).select("*").eq("direction", direction).order("is_active", { ascending: false }).order("description");
+      if (error) throw error;
+      const rows = data ?? [];
+      const personIds = [...new Set(rows.map((row) => row.counterparty_person_id).filter(Boolean))];
+      const names = /* @__PURE__ */ new Map();
+      if (personIds.length > 0) {
+        const { data: people, error: peopleError } = await pub.from("people").select("id,name").in("id", personIds);
+        if (peopleError) throw peopleError;
+        for (const person of people ?? []) names.set(person.id, person.name);
+      }
+      return rows.map((row) => mapRecurringBill(row, names.get(row.counterparty_person_id) ?? null));
+    },
+    // ------------------------------------------------------------------
+    // O PREVISTO, ao lado do LANÇADO.
+    //
+    // A ocorrência provisionada não é conta: não tem fatura, não entra no
+    // razão e não cobra ninguém. Mas ela é o que faz o mês aparecer inteiro na
+    // lista — o V1 injeta essas linhas ao lado das contas de verdade, e é
+    // olhando as duas juntas que alguém decide o que vira dívida.
+    //
+    // Linha VIRTUAL, com `id` prefixado: ela não pode colidir com o id de uma
+    // parcela nem ser aberta como fatura, porque não há fatura.
+    // ------------------------------------------------------------------
+    async getProvisionedOccurrences(query) {
+      const { pub } = getClients();
+      const direcao = query.direction === "debit" ? "payable" : "receivable";
+      let qb = pub.from(T.recurringOccurrences).select(`id, seq, due_date, competence_date, amount, unit_id, recurring_bill_id,
+                 ${T.recurringBills}!inner(id, description, notes, direction, counterparty_person_id,
+                                           chart_account_id, cost_center_id, is_active)`).eq("status", "provisioned").eq(`${T.recurringBills}.direction`, direcao).eq(`${T.recurringBills}.is_active`, true);
+      if (query.contactId) qb = qb.eq(`${T.recurringBills}.counterparty_person_id`, query.contactId);
+      if (query.accountId) qb = qb.eq(`${T.recurringBills}.chart_account_id`, query.accountId);
+      if (query.costCenterId) qb = qb.eq(`${T.recurringBills}.cost_center_id`, query.costCenterId);
+      if (query.unitId) qb = qb.or(`unit_id.is.null,unit_id.eq.${query.unitId}`);
+      if (query.dateRange) {
+        qb = qb.gte("due_date", query.dateRange.from.slice(0, 10)).lte("due_date", query.dateRange.to.slice(0, 10));
+      }
+      const { data, error } = await qb.order("due_date", { ascending: true }).limit(200);
+      if (error) throw error;
+      const linhas = data ?? [];
+      const pessoaIds = [...new Set(linhas.map((row) => row[T.recurringBills]?.counterparty_person_id).filter(Boolean))];
+      const nomes = /* @__PURE__ */ new Map();
+      if (pessoaIds.length > 0) {
+        const { data: people } = await pub.from("people").select("id,name").in("id", pessoaIds);
+        for (const person of people ?? []) nomes.set(person.id, person.name);
+      }
+      const termo = query.search?.trim().toLocaleLowerCase("pt-BR");
+      return linhas.filter((row) => {
+        if (!termo) return true;
+        const regua = row[T.recurringBills] ?? {};
+        const nome = regua.counterparty_person_id ? nomes.get(regua.counterparty_person_id) : "";
+        return [regua.description, regua.notes, nome].some((campo) => (campo ?? "").toLocaleLowerCase("pt-BR").includes(termo));
+      }).map((row) => {
+        const regua = row[T.recurringBills] ?? {};
+        return {
+          id: `occ:${row.id}`,
+          direction: query.direction ?? "debit",
+          invoiceDate: row.competence_date ?? row.due_date,
+          dueDate: row.due_date,
+          totalAmount: Number(row.amount) || 0,
+          paidAmount: 0,
+          status: "provisioned",
+          totalInstallments: 1,
+          installmentNumber: row.seq ?? 1,
+          contactId: regua.counterparty_person_id ?? void 0,
+          contactName: regua.counterparty_person_id ? nomes.get(regua.counterparty_person_id) : void 0,
+          unitId: row.unit_id ?? void 0,
+          itemsSummary: regua.description ?? void 0,
+          isProvisionedOccurrence: true,
+          occurrenceId: row.id,
+          recurringBillId: row.recurring_bill_id,
+          tenantId: "",
+          createdAt: row.due_date,
+          updatedAt: row.due_date
+        };
+      });
+    },
+    async consolidateOccurrence(occurrenceId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_consolidate_occurrence", {
+        p_occurrence_id: occurrenceId
+      });
+      if (error) throw new Error(error.message);
+      return data?.invoice_id ?? null;
+    },
+    async saveRecurringBill(input) {
+      const { pub } = getClients();
+      const row = {
+        direction: input.direction,
+        description: input.description.trim(),
+        counterparty_person_id: input.counterpartyPersonId,
+        amount: round2(input.amount),
+        items: input.items,
+        unit_id: input.unitId || null,
+        chart_account_id: input.chartAccountId || null,
+        cost_center_id: input.costCenterId || null,
+        frequency: input.frequency,
+        due_day: input.dueDay,
+        starts_on: input.startsOn,
+        ends_on: input.endsOn || null,
+        is_active: input.isActive ?? true,
+        notes: input.notes?.trim() || null
+      };
+      const request = input.id ? pub.from(T.recurringBills).update(row).eq("id", input.id) : pub.from(T.recurringBills).insert({ ...row, tenant_id: getActiveTenantId() });
+      const { data, error } = await request.select("*").single();
+      if (error) throw error;
+      return mapRecurringBill(data);
+    },
+    /**
+     * Provisiona os vencimentos futuros de uma régua.
+     *
+     * Chamado logo depois de salvar: sem isto a recorrência cadastrada hoje não
+     * aparece como previsto em lugar nenhum — ela só existiria no dia em que
+     * alguém rodasse a rotina, já como dívida.
+     */
+    async provisionRecurringBill(billId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_recurring_provision", { p_bill_id: billId });
+      if (error) throw new Error(error.message);
+      return data?.provisioned ?? 0;
+    },
+    async updateRecurringBill(id, patch) {
+      const { pub } = getClients();
+      const row = {};
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      if (patch.endsOn !== void 0) row.ends_on = patch.endsOn;
+      const { error } = await pub.from(T.recurringBills).update(row).eq("id", id);
+      if (error) throw error;
+    },
+    async runRecurring(through) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_recurring_run", { p_through: through ?? null });
+      if (error) throw error;
+      return { created: Number(data?.created) || 0, total: Number(data?.total) || 0 };
+    },
+    // --- Commissions (009) ---
+    async getCommissions(query) {
+      const { pub } = getClients();
+      let qb = pub.from(T.commissions).select("*");
+      if (query.periodStart) qb = qb.gte("competence_date", query.periodStart);
+      if (query.periodEnd) qb = qb.lte("competence_date", query.periodEnd);
+      if (query.personId) qb = qb.eq("person_id", query.personId);
+      if (query.status) qb = qb.eq("status", query.status);
+      const { data, error } = await qb.order("competence_date", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        personId: r.person_id,
+        personName: r.person_name,
+        itemId: r.item_id,
+        itemName: r.item_name,
+        orderId: r.order_id,
+        invoiceId: r.invoice_id,
+        invoiceNumber: r.invoice_number,
+        competenceDate: r.competence_date,
+        ruleName: r.rule_name,
+        functionName: r.function_name,
+        baseAmount: Number(r.base_amount) || 0,
+        rate: Number(r.rate) || 0,
+        amount: Number(r.amount) || 0,
+        share: Number(r.share) || 1,
+        role: r.role,
+        status: r.status
+      }));
+    },
+    async generateCommissions(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_commission_generate", {
+        p_period_start: input.periodStart,
+        p_period_end: input.periodEnd,
+        p_unit_id: input.unitId ?? null
+      });
+      if (error) throw error;
+      return {
+        generationId: data?.generation_id,
+        entries: Number(data?.entries) || 0,
+        total: Number(data?.total) || 0
+      };
+    },
+    // ── As regras de comissão: a política que Configurações edita ────────────
+    //
+    // Numa consulta só, com critérios e funções aninhados, como o V1 faz. O
+    // funil da tela simula qual regra venceria para uma combinação, e para isso
+    // precisa de TODAS as regras inteiras em memória — buscar função por regra
+    // seria N+1 a cada troca de filtro.
+    async getCommissionRules() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.commissionRules).select(`*, ${T.commissionRuleCriteria}(*), ${T.commissionFunctions}(*)`).order("priority", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        name: r.name,
+        description: r.description,
+        priority: Number(r.priority) || 0,
+        isDefault: !!r.is_default,
+        isActive: !!r.is_active,
+        unitId: r.unit_id,
+        valueType: r.value_type ?? "percentage",
+        value: Number(r.value) || 0,
+        criteria: (r[T.commissionRuleCriteria] ?? []).map((c) => ({
+          id: c.id,
+          criteriaType: c.criteria_type,
+          criteriaValue: c.criteria_value ?? {}
+        })),
+        functions: (r[T.commissionFunctions] ?? []).slice().sort((a, b) => (a.display_order ?? 0) - (b.display_order ?? 0)).map((f) => ({
+          id: f.id,
+          ruleId: f.rule_id,
+          functionName: f.function_name,
+          accountType: f.account_type,
+          personId: f.person_id,
+          valueType: f.value_type,
+          // numeric(14,4) chega como string no PostgREST; `Number` aqui evita
+          // o "R$ NaN" que já apareceu nos cartões por somar string.
+          valueAmount: Number(f.value_amount) || 0,
+          calculationBase: f.calculation_base,
+          tierMode: f.tier_mode,
+          minGuaranteed: f.min_guaranteed == null ? null : Number(f.min_guaranteed),
+          tiers: Array.isArray(f.tiers) ? f.tiers : [],
+          isVariable: !!f.is_variable,
+          displayOrder: f.display_order ?? 0,
+          isActive: !!f.is_active
+        }))
+      }));
+    },
+    async saveCommissionRule(input) {
+      const { pub } = getClients();
+      const row = {
+        name: input.name,
+        description: input.description ?? null,
+        priority: input.priority,
+        is_default: input.isDefault ?? false,
+        is_active: input.isActive ?? true,
+        unit_id: input.unitId ?? null
+      };
+      let ruleId = input.id;
+      if (ruleId) {
+        const { error } = await pub.from(T.commissionRules).update(row).eq("id", ruleId);
+        if (error) throw error;
+      } else {
+        const { data, error } = await pub.from(T.commissionRules).insert({ ...row, tenant_id: getActiveTenantId() }).select("id").single();
+        if (error) throw error;
+        ruleId = data.id;
+      }
+      if (input.criteria) {
+        const { error: delErr } = await pub.from(T.commissionRuleCriteria).delete().eq("rule_id", ruleId);
+        if (delErr) throw delErr;
+        const rows = input.criteria.filter((c) => hasCriteriaValue(c.criteriaValue)).map((c) => ({ tenant_id: getActiveTenantId(), rule_id: ruleId, criteria_type: c.criteriaType, criteria_value: c.criteriaValue }));
+        if (rows.length) {
+          const { error } = await pub.from(T.commissionRuleCriteria).insert(rows);
+          if (error) throw error;
+        }
+      }
+      return ruleId;
+    },
+    async saveCommissionFunctions(ruleId, functions) {
+      const { pub } = getClients();
+      const { error: delErr } = await pub.from(T.commissionFunctions).delete().eq("rule_id", ruleId);
+      if (delErr) throw delErr;
+      if (!functions.length) return;
+      const rows = functions.map((f, i) => ({
+        tenant_id: getActiveTenantId(),
+        rule_id: ruleId,
+        function_name: f.functionName,
+        account_type: f.accountType,
+        person_id: f.personId ?? null,
+        value_type: f.valueType,
+        value_amount: f.valueAmount,
+        calculation_base: f.calculationBase,
+        tier_mode: f.tierMode,
+        // O piso só existe na faixa que o usa; guardá-lo nas outras deixaria um
+        // número invisível na tela e ativo no cálculo se a faixa mudasse.
+        min_guaranteed: f.tierMode === "guaranteed_min" ? f.minGuaranteed ?? 0 : null,
+        tiers: f.tierMode === "marginal" || f.tierMode === "retroactive" ? f.tiers : [],
+        is_variable: f.isVariable,
+        display_order: i,
+        is_active: f.isActive
+      }));
+      const { error } = await pub.from(T.commissionFunctions).insert(rows);
+      if (error) throw error;
+    },
+    async deleteCommissionRule(id) {
+      const { pub } = getClients();
+      const { error } = await pub.from(T.commissionRules).delete().eq("id", id);
+      if (error) throw error;
+    },
+    async duplicateCommissionRule(id) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.commissionRules).select(`*, ${T.commissionRuleCriteria}(*), ${T.commissionFunctions}(*)`).eq("id", id).single();
+      if (error) throw error;
+      const src = data;
+      const { data: created, error: insErr } = await pub.from(T.commissionRules).insert({
+        tenant_id: getActiveTenantId(),
+        name: `${src.name} (c\xF3pia)`,
+        description: src.description,
+        priority: src.priority,
+        is_default: false,
+        is_active: false,
+        unit_id: src.unit_id,
+        value_type: src.value_type,
+        value: src.value
+      }).select("id").single();
+      if (insErr) throw insErr;
+      const newId = created.id;
+      const crit = (src[T.commissionRuleCriteria] ?? []).map((c) => ({
+        tenant_id: getActiveTenantId(),
+        rule_id: newId,
+        criteria_type: c.criteria_type,
+        criteria_value: c.criteria_value
+      }));
+      if (crit.length) {
+        const { error: e } = await pub.from(T.commissionRuleCriteria).insert(crit);
+        if (e) throw e;
+      }
+      const fns = (src[T.commissionFunctions] ?? []).map((f) => ({
+        tenant_id: getActiveTenantId(),
+        rule_id: newId,
+        function_name: f.function_name,
+        account_type: f.account_type,
+        person_id: f.person_id,
+        value_type: f.value_type,
+        value_amount: f.value_amount,
+        calculation_base: f.calculation_base,
+        tier_mode: f.tier_mode,
+        min_guaranteed: f.min_guaranteed,
+        tiers: f.tiers,
+        is_variable: f.is_variable,
+        display_order: f.display_order,
+        is_active: f.is_active
+      }));
+      if (fns.length) {
+        const { error: e } = await pub.from(T.commissionFunctions).insert(fns);
+        if (e) throw e;
+      }
+      return newId;
+    },
+    async getCommissionCatalogs() {
+      const { pub } = getClients();
+      const [svc, cat, ppl, unt] = await Promise.all([
+        pub.from("products").select("id,name,category_id").eq("is_active", true).order("name"),
+        pub.from("categories").select("id,name").eq("is_active", true).order("name"),
+        // `kind = 'staff'` é quem executa; a lista de critério não é a agenda de
+        // clientes, e oferecer os dois juntos é como se escolhe o errado.
+        pub.from("people").select("id,name").eq("kind", "staff").eq("is_active", true).order("name"),
+        pub.from("v_units").select("id,name").eq("is_active", true).order("name")
+      ]);
+      return {
+        services: (svc.data ?? []).map((r) => ({ id: r.id, name: r.name, categoryId: r.category_id })),
+        categories: (cat.data ?? []).map((r) => ({ id: r.id, name: r.name })),
+        professionals: (ppl.data ?? []).map((r) => ({ id: r.id, name: r.name })),
+        units: (unt.data ?? []).map((r) => ({ id: r.id, name: r.name }))
+      };
+    },
+    // ── O caminho do apurado até o dinheiro sair ────────────────────────────
+    //
+    // São TRÊS passos e três decisões, e o V2 só tinha o primeiro ligado:
+    // apurar (gera os lançamentos), aprovar (autoriza), e o borderô (levanta
+    // uma conta a pagar por pessoa). "Apurar não é autorizar" está no próprio
+    // comentário da 012 — quem confere pode não ser quem manda pagar.
+    async getCommissionGenerations() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.commissionGenerations).select("*").order("created_at", { ascending: false }).limit(20);
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        periodStart: r.period_start,
+        periodEnd: r.period_end,
+        status: r.status,
+        // `total_amount` e `entry_count`, conferidos no schema — não `total`
+        // nem `entries`, que era o palpite pelo nome do campo do resultado.
+        total: Number(r.total_amount) || 0,
+        entries: Number(r.entry_count) || 0
+      }));
+    },
+    async approveCommissions(generationId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_commission_approve", {
+        p_generation_id: generationId
+      });
+      if (error) throw error;
+      return {
+        generationId: data?.generation_id ?? generationId,
+        approved: Number(data?.approved) || 0
+      };
+    },
+    async payRunCommissions(generationId, dueDate) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_commission_pay_run", {
+        p_generation_id: generationId,
+        p_due_date: dueDate ?? null
+      });
+      if (error) throw error;
+      return {
+        generationId: data?.generation_id ?? generationId,
+        payables: Number(data?.payables) || 0,
+        total: Number(data?.total) || 0,
+        dueDate: data?.due_date
+      };
+    },
+    // ── Metas: três degraus por mês, e o realizado vem do livro ─────────────
+    // ── Conferência de caixa ────────────────────────────────────────────────
+    async getCashSessionReviews() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_cash_session_review").select("*").order("closed_at", { ascending: false }).limit(200);
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        sessionId: r.session_id,
+        unitId: r.unit_id,
+        openedAt: r.opened_at,
+        closedAt: r.closed_at,
+        openedByName: r.opened_by_name,
+        closedByName: r.closed_by_name,
+        closedByUserId: r.closed_by_user_id,
+        openingBalance: Number(r.opening_balance) || 0,
+        closingBalance: Number(r.closing_balance) || 0,
+        difference: Number(r.difference) || 0,
+        reviewStatus: r.review_status,
+        reviewedAt: r.reviewed_at,
+        reviewerName: r.reviewer_name,
+        reviewNotes: r.review_notes
+      }));
+    },
+    async reviewCashSession(sessionId, verdict, notes) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_cash_session_review", {
+        p_session_id: sessionId,
+        p_verdict: verdict,
+        p_notes: notes ?? null
+      });
+      if (error) throw error;
+    },
+    async getGoalYear(unitId, year) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("v_financial_goal_year").select("*").eq("unit_id", unitId).eq("year", year).order("month");
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        goalId: r.goal_id,
+        unitId: r.unit_id,
+        year: Number(r.year),
+        month: Number(r.month),
+        targetAmount: Number(r.target_amount) || 0,
+        superAmount: Number(r.super_amount) || 0,
+        hyperAmount: Number(r.hyper_amount) || 0,
+        achievedAmount: Number(r.achieved_amount) || 0,
+        targetPercent: Number(r.target_percent) || 0,
+        superPercent: Number(r.super_percent) || 0,
+        hyperPercent: Number(r.hyper_percent) || 0,
+        notes: r.notes
+      }));
+    },
+    async saveGoal(input) {
+      const { pub } = getClients();
+      const row = {
+        tenant_id: getActiveTenantId(),
+        unit_id: input.unitId,
+        year: input.year,
+        month: input.month,
+        target_amount: input.targetAmount,
+        super_amount: input.superAmount,
+        hyper_amount: input.hyperAmount,
+        notes: input.notes ?? null
+      };
+      const { error } = await pub.from("plg_financial_goals").upsert(row, { onConflict: "tenant_id,unit_id,year,month" });
+      if (error) throw error;
+    },
+    async deleteGoal(id) {
+      const { pub } = getClients();
+      const { error } = await pub.from("plg_financial_goals").delete().eq("id", id);
+      if (error) throw error;
+    },
+    // --- Vales-presente (027) ---
+    // O cartão mora na loja; o Financeiro entra por RPC própria, que filtra por
+    // tenant e permissão. Ler a tabela direto daqui daria de brinde a loja
+    // inteira a quem só tem financial.read.
+    async giftCardsEnabled() {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_gift_cards_enabled");
+      if (error) throw error;
+      return data === true;
+    },
+    async getGiftCards(query) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_gift_cards", {
+        p_search: query?.search?.trim() || null,
+        p_state: query?.state ?? null,
+        p_min: query?.minValue ?? null,
+        p_max: query?.maxValue ?? null,
+        p_from: query?.issuedFrom || null,
+        p_to: query?.issuedTo || null,
+        p_limit: 500
+      });
+      if (error) throw error;
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        code: r.code,
+        faceValue: Number(r.face_value) || 0,
+        // NULL atravessa como NULL: é "nunca ativado", e virar 0 aqui apagaria
+        // a única diferença que esta tela existe para mostrar.
+        balance: r.balance == null ? null : Number(r.balance),
+        state: r.state,
+        currency: r.currency,
+        issuedAt: r.issued_at,
+        expiresAt: r.expires_at,
+        activatedAt: r.activated_at,
+        note: r.note,
+        customerEmail: r.customer_email
+      }));
+    },
+    async findGiftCardByCode(raw) {
+      const code = raw.replace(/[\s.-]/g, "").toUpperCase();
+      if (!code) return null;
+      const { pub } = getClients();
+      let { data, error } = await pub.rpc("financial_gift_card_by_code", { p_code: code });
+      if (error?.code === "PGRST202") {
+        ({ data, error } = await pub.rpc("financial_gift_cards", { p_search: code, p_limit: 5 }));
+      }
+      if (error) throw error;
+      const row = (data ?? []).find((r) => String(r.code).toUpperCase() === code);
+      if (!row) return null;
+      return {
+        id: row.id,
+        code: row.code,
+        faceValue: Number(row.face_value) || 0,
+        balance: row.balance == null ? null : Number(row.balance),
+        state: row.state,
+        currency: row.currency,
+        issuedAt: row.issued_at,
+        expiresAt: row.expires_at,
+        activatedAt: row.activated_at,
+        note: row.note,
+        customerEmail: row.customer_email
+      };
+    },
+    async issueGiftCards(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("financial_issue_gift_cards", {
+        p_quantity: input.quantity,
+        p_amount: input.unitAmount,
+        p_expires_at: input.expiresAt || null,
+        p_note: input.note || null
+      });
+      if (error) throw error;
+      return (data ?? []).map((r) => r.code);
+    },
+    async activateGiftCard(id) {
+      const { pub } = getClients();
+      const { error } = await pub.rpc("financial_activate_gift_card", { p_id: id });
+      if (error) throw error;
+    },
+    async getSummary(dateRange) {
+      const { pub } = getClients();
+      const n = (v) => Number(v) || 0;
+      const args = { p_from: dateRange?.from ?? null, p_to: dateRange?.to ?? null };
+      let split = await pub.rpc("financial_summary_by_currency", args);
+      if (!split.error && Array.isArray(split.data)) {
+        const missing = split.data.filter((r) => r.fx_rate === null || r.fx_rate === void 0);
+        if (missing.length > 0) {
+          const house = String(missing[0].house_currency);
+          const tenantId = getActiveTenantId();
+          if (tenantId && await ensureReferenceRates(pub, tenantId, house, missing.map((r) => String(r.currency)))) {
+            const again = await pub.rpc("financial_summary_by_currency", args);
+            if (!again.error && Array.isArray(again.data)) split = again;
+          }
+        }
+        const total = {
+          totalBalance: 0,
+          totalReceivable: 0,
+          totalPayable: 0,
+          monthlyInflow: 0,
+          monthlyOutflow: 0,
+          overdueReceivableCount: 0,
+          overdueReceivableAmount: 0,
+          overduePayableCount: 0,
+          overduePayableAmount: 0
+        };
+        const excluded = [];
+        for (const r of split.data) {
+          total.overdueReceivableCount += n(r.overdue_receivable_count);
+          total.overduePayableCount += n(r.overdue_payable_count);
+          if (r.fx_rate === null || r.fx_rate === void 0) {
+            const left = {
+              currency: String(r.currency),
+              balance: n(r.total_balance),
+              receivable: n(r.total_receivable),
+              payable: n(r.total_payable),
+              inflow: n(r.monthly_inflow),
+              outflow: n(r.monthly_outflow)
+            };
+            if (left.balance || left.receivable || left.payable || left.inflow || left.outflow) excluded.push(left);
+            continue;
+          }
+          const rate = n(r.fx_rate);
+          total.totalBalance += n(r.total_balance) * rate;
+          total.totalReceivable += n(r.total_receivable) * rate;
+          total.totalPayable += n(r.total_payable) * rate;
+          total.monthlyInflow += n(r.monthly_inflow) * rate;
+          total.monthlyOutflow += n(r.monthly_outflow) * rate;
+          total.overdueReceivableAmount += n(r.overdue_receivable_amount) * rate;
+          total.overduePayableAmount += n(r.overdue_payable_amount) * rate;
+        }
+        const cents = (v) => Math.round(v * 100) / 100;
+        return {
+          totalBalance: cents(total.totalBalance),
+          totalReceivable: cents(total.totalReceivable),
+          totalPayable: cents(total.totalPayable),
+          monthlyInflow: cents(total.monthlyInflow),
+          monthlyOutflow: cents(total.monthlyOutflow),
+          overdueReceivableCount: total.overdueReceivableCount,
+          overdueReceivableAmount: cents(total.overdueReceivableAmount),
+          overduePayableCount: total.overduePayableCount,
+          overduePayableAmount: cents(total.overduePayableAmount),
+          ...excluded.length ? { excluded } : {}
+        };
+      }
+      const { data, error } = await pub.rpc("financial_summary", args);
+      if (error) throw error;
+      const row = (Array.isArray(data) ? data[0] : data) ?? {};
+      return {
+        totalBalance: n(row.total_balance),
+        totalReceivable: n(row.total_receivable),
+        totalPayable: n(row.total_payable),
+        monthlyInflow: n(row.monthly_inflow),
+        monthlyOutflow: n(row.monthly_outflow),
+        overdueReceivableCount: n(row.overdue_receivable_count),
+        overdueReceivableAmount: n(row.overdue_receivable_amount),
+        overduePayableCount: n(row.overdue_payable_count),
+        overduePayableAmount: n(row.overdue_payable_amount)
+      };
+    },
+    // --- Conciliação Bancária ---
+    //
+    // A linha do extrato mora em `plg_financial_bank_statement_lines` e NÃO em
+    // `plg_financial_movements`. A migration 112 conta a história inteira; o
+    // resumo é que uma linha recém-chegada não tem as duas pernas que
+    // `plg_financial_movements_legs_check` exige, porque ainda não se sabe
+    // contra o quê ela lança — e era por isso que todo INSERT do import antigo
+    // era recusado pelo banco enquanto os testes do mock passavam.
+    async importBankTransactions(input) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      const rows = input.lines.map((line) => ({
+        tenant_id: tenantId,
+        bank_account_id: line.bankAccountId ?? input.bankAccountId ?? null,
+        external_id: line.externalId,
+        external_source: line.externalSource,
+        posted_on: line.date,
+        effective_at: line.effectiveAt ?? null,
+        direction: line.direction,
+        amount: Math.abs(line.amount),
+        balance_after: line.balanceAfter ?? null,
+        description: line.description,
+        counterparty_name: line.counterpartyName ?? null,
+        counterparty_document: line.counterpartyDocument ?? null,
+        document: line.document ?? null,
+        code: line.code ?? null,
+        category: line.category ?? null,
+        transaction_type: line.transactionType ?? null,
+        raw_payload: line.rawPayload ?? null
+      }));
+      if (rows.length === 0) return { imported: 0, duplicates: 0 };
+      const { data, error } = await pub.from(T.statementLines).upsert(rows, { onConflict: "tenant_id,external_source,external_id", ignoreDuplicates: true }).select("id");
+      if (error) throw error;
+      const imported = (data ?? []).length;
+      return { imported, duplicates: rows.length - imported };
+    },
+    // A lista da tela. Ela mostra o extrato INTEIRO do período — pendente e
+    // conciliado — porque conferir o que se conciliou ontem é parte do
+    // trabalho, e uma tela que só mostra pendência esconde o próprio resultado.
+    async getStatementLines(query) {
+      const { pub } = getClients();
+      const { page, pageSize } = statementLinesPage(query);
+      const from = (page - 1) * pageSize;
+      let qb = pub.from(T.statementLines).select("*", { count: "exact" }).eq("provider_deleted", false);
+      if (query?.bankAccountId) qb = qb.eq("bank_account_id", query.bankAccountId);
+      if (query?.dateRange) qb = qb.gte("posted_on", query.dateRange.from).lte("posted_on", query.dateRange.to);
+      if (query?.direction) qb = qb.eq("direction", query.direction);
+      if (query?.status === "reconciled") qb = qb.not("reconciled_at", "is", null);
+      else if (query?.status === "pending") qb = qb.is("reconciled_at", null);
+      const term = (query?.search ?? "").trim();
+      if (term) {
+        const safe = term.replace(/[,()*%]/g, " ");
+        qb = qb.or([
+          `description.ilike.%${safe}%`,
+          `counterparty_name.ilike.%${safe}%`,
+          `counterparty_document.ilike.%${safe}%`,
+          `document.ilike.%${safe}%`,
+          `code.ilike.%${safe}%`,
+          `category.ilike.%${safe}%`,
+          `transaction_type.ilike.%${safe}%`,
+          `external_id.ilike.%${safe}%`
+        ].join(","));
+      }
+      if (query?.hideInvestments) qb = qb.or(`code.is.null,code.not.in.(${INVESTMENT_CODES.join(",")})`);
+      const { data, error, count } = await qb.order("posted_on", { ascending: false }).order("id", { ascending: false }).range(from, from + pageSize - 1);
+      if (error) throw error;
+      const rows = (data ?? []).map(toStatementLine);
+      await anexaContraparte(rows);
+      return { rows, total: count ?? 0, page, pageSize, ...pageTotals(rows) };
+    },
+    async getUnreconciled(query) {
+      const { pub } = getClients();
+      let qb = pub.from(T.statementLines).select("*").is("reconciled_at", null).eq("provider_deleted", false);
+      if (query?.bankAccountId) qb = qb.eq("bank_account_id", query.bankAccountId);
+      if (query?.dateRange) qb = qb.gte("posted_on", query.dateRange.from).lte("posted_on", query.dateRange.to);
+      const { data, error } = await qb.order("posted_on", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map(toStatementLine);
+    },
+    async suggestReconciliation(statementLineId) {
+      const { core, pub } = getClients();
+      const { data: line } = await pub.from(T.statementLines).select("*").eq("id", statementLineId).single();
+      if (!line) return [];
+      const amount = Number(line.amount) || 0;
+      const lineDate = line.posted_on;
+      const tol = candidateTolerance(amount);
+      const { data, error } = await pub.from(T.movements).select("*").is("external_source", null).is("reconciled_at", null).eq("direction", line.direction).gte("amount", round2(amount - tol)).lte("amount", round2(amount + tol)).limit(25);
+      if (error) throw error;
+      const candidates = (data ?? []).map((r) => {
+        const movement = snakeToCamel(r);
+        return { movement, score: candidateScore({ amount, date: lineDate }, movement) };
+      }).sort((a, b) => b.score - a.score);
+      const invoiceIds = [...new Set(candidates.map((c) => c.movement.invoiceId).filter(Boolean))];
+      if (invoiceIds.length) {
+        const { data: orders } = await core.from("orders").select("id, reference_number, metadata").in("id", invoiceIds);
+        const byId = new Map((orders ?? []).map((o) => [o.id, o]));
+        for (const c of candidates) {
+          const o = c.movement.invoiceId ? byId.get(c.movement.invoiceId) : void 0;
+          if (o) c.invoice = { id: o.id, contactName: o.metadata?.contactName, fiscalNumber: o.reference_number };
+        }
+      }
+      const linha = { id: line.id, amount, date: lineDate, direction: line.direction, externalSource: line.external_source };
+      const abertas = await searchBillTargets(linha, {
+        status: "open",
+        amountMin: round2(amount - tol),
+        amountMax: round2(amount + tol),
+        pageSize: 25
+      }).catch(() => ({ data: [], hasMore: false }));
+      return [...candidates, ...abertas.data].sort((a, b) => b.score - a.score);
+    },
+    async searchReconciliationTargets(statementLineId, query) {
+      return searchBillTargets(await readStatementLine(statementLineId), query);
+    },
+    // ------------------------------------------------------------------
+    // A SUGESTÃO QUE CHEGA SOZINHA, para a página inteira.
+    //
+    // DUAS perguntas ao banco para cinquenta linhas, e não duas por linha:
+    //
+    //   1. os lançamentos nativos em aberto cujo valor cabe em ALGUMA das
+    //      faixas de ±2% da página (um `or` só, com uma faixa por valor
+    //      distinto — o PostgREST aceita um `or` por consulta);
+    //   2. o nome de quem, para os documentos desses lançamentos.
+    //
+    // O cruzamento é em memória (ver match-statement.ts): valor, nome e data,
+    // e nenhum lançamento oferecido a duas linhas.
+    // ------------------------------------------------------------------
+    async syncStatements(input) {
+      const { pub } = getClients();
+      const { data, error } = await pub.functions.invoke("financial-statement-sync", {
+        body: { accountId: input?.bankAccountId, tenantId: getActiveTenantId() ?? null }
+      });
+      if (error) {
+        let body = null;
+        try {
+          body = await error?.context?.json?.();
+        } catch {
+        }
+        throw new Error(body?.error || error.message || "N\xE3o foi poss\xEDvel buscar o extrato do banco.");
+      }
+      const results = data?.results ?? [];
+      return {
+        imported: Number(data?.imported ?? 0),
+        failed: Number(data?.failed ?? 0),
+        errors: results.map((r) => r.error).filter((e) => Boolean(e))
+      };
+    },
+    async suggestReconciliationBatch(lines) {
+      const { core, pub } = getClients();
+      const abertas = lines.filter((line) => !line.reconciledAt && (Number(line.amount) || 0) > 0);
+      if (abertas.length === 0) return {};
+      const faixas = [...new Set(abertas.map((line) => round2(line.amount)))].map((valor) => {
+        const tol = Math.max(0.01, round2(valor * NAME_AMOUNT_TOLERANCE));
+        return `and(amount.gte.${round2(valor - tol)},amount.lte.${round2(valor + tol)})`;
+      });
+      const direcoes = [...new Set(abertas.map((line) => line.direction))];
+      const { data, error } = await pub.from(T.movements).select("*").is("external_source", null).is("reconciled_at", null).in("direction", direcoes).or(faixas.join(",")).limit(500);
+      if (error) throw error;
+      const movimentos = (data ?? []).map((r) => snakeToCamel(r));
+      const datas = abertas.map((line) => line.date).filter(Boolean).sort();
+      const contexto = /* @__PURE__ */ new Map();
+      if (datas.length) {
+        const { data: billRows } = await pub.from("v_financial_invoice_lines_due").select("installment_id,invoice_id,direction,number,due_date,description,counterparty_name,installment_number,amount,paid,status").in("direction", direcoes.map((d) => d === "debit" ? "payable" : "receivable")).in("status", ["pending", "partial", "overdue"]).gte("due_date", shiftIsoDate(datas[0], -30)).lte("due_date", shiftIsoDate(datas[datas.length - 1], 30)).or(faixas.join(",")).limit(500);
+        for (const r of billRows ?? []) {
+          movimentos.push({
+            id: r.installment_id,
+            invoiceId: r.invoice_id,
+            direction: r.direction === "payable" ? "debit" : "credit",
+            movementKind: "bill",
+            amount: Number(r.amount) || 0,
+            paidAmount: Number(r.paid) || 0,
+            status: r.status,
+            dueDate: r.due_date,
+            installmentNumber: r.installment_number ?? void 0,
+            notes: r.description ?? void 0
+          });
+          contexto.set(r.installment_id, {
+            contactName: r.counterparty_name ?? void 0,
+            invoice: { id: r.invoice_id, contactName: r.counterparty_name ?? void 0, fiscalNumber: r.number ?? void 0 }
+          });
+        }
+      }
+      if (movimentos.length === 0) return {};
+      const invoiceIds = [...new Set(movimentos.filter((m) => !contexto.has(m.id)).map((m) => m.invoiceId).filter(Boolean))];
+      if (invoiceIds.length > 0) {
+        const { data: orders } = await core.from("orders").select("id, reference_number, metadata").in("id", invoiceIds);
+        const byId = new Map((orders ?? []).map((o) => [o.id, o]));
+        for (const movimento of movimentos) {
+          const order = movimento.invoiceId ? byId.get(movimento.invoiceId) : void 0;
+          if (!order) continue;
+          const contactName = order.metadata?.contactName;
+          contexto.set(movimento.id, {
+            contactName,
+            invoice: { id: order.id, contactName, fiscalNumber: order.reference_number }
+          });
+        }
+      }
+      return matchStatementLines(abertas, movimentos, contexto);
+    },
+    async reconcileMovement(input) {
+      if (input.mode === "settle" && input.matchedMovementId) {
+        const line = await readStatementLine(input.bankMovementId);
+        const { data: alvo } = await getClients().pub.from(T.bills).select("amount, paid").eq("installment_id", input.matchedMovementId).maybeSingle();
+        if (!alvo) throw new Error("Lan\xE7amento n\xE3o encontrado");
+        await runReconcileLink(
+          reconcileFacade(),
+          line,
+          {
+            movementId: input.matchedMovementId,
+            mode: "settle",
+            openAmount: round2((Number(alvo.amount) || 0) - (Number(alvo.paid) || 0))
+          },
+          { payment: input.payment, adjustments: input.adjustments, partial: input.partial }
+        );
+        return;
+      }
+      await markReconciled(input.bankMovementId, input.matchedMovementId);
+    },
+    // «Marcar como transferência». A conta do extrato é sempre uma das pontas.
+    // SAÍDA no extrato = o dinheiro deixou aquela conta, logo ela é a ORIGEM;
+    // entrada é o inverso. Mesma convenção do V1 e da sangria de caixa —
+    // inverter faz o saldo consolidado andar duas vezes no sentido errado.
+    async reconcileAsTransfer(input) {
+      const line = await readStatementLine(input.bankMovementId);
+      const transfer = await provider.createTransfer(transferForStatementLine(line, input));
+      await provider.reconcileMovement({ bankMovementId: input.bankMovementId, matchedMovementId: statementLegOf(line, transfer) });
+      return transfer;
+    },
+    // «Lançar como conta». A conta nasce classificada, é quitada contra a conta
+    // do extrato, e a linha passa a ser a prova dela. É o caminho que faz o
+    // extrato BATER: sem ele, uma linha sem contrapartida fica marcada como
+    // conciliada e o dinheiro continua fora do livro.
+    async reconcileAsBill(input) {
+      const line = await readStatementLine(input.bankMovementId);
+      const { invoiceId } = await runReconcileAsBill(reconcileFacade(), line, input);
+      const invoice = await provider.getInvoiceById(invoiceId);
+      if (!invoice) throw new Error("A conta n\xE3o foi criada");
+      return invoice;
+    },
+    async unreconcileMovement(statementLineId) {
+      const { pub } = getClients();
+      const { data: line } = await pub.from(T.statementLines).select("matched_movement_id").eq("id", statementLineId).single();
+      await pub.from(T.statementLines).update({ reconciled_at: null, matched_movement_id: null }).eq("id", statementLineId);
+      if (line?.matched_movement_id) {
+        await pub.from(T.movements).update({ reconciled_at: null }).eq("id", line.matched_movement_id);
+      }
+    },
+    // --- Notas fiscais (NF-e / NFC-e / NFS-e) ---
+    async getNotas(query) {
+      const { pub } = getClients();
+      let qb = pub.from(T.notas).select("*", { count: "exact" });
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status];
+        qb = qb.in("status", statuses);
+      }
+      if (query.model) qb = qb.eq("model", query.model);
+      if (query.orderId) qb = qb.eq("order_id", query.orderId);
+      if (query.search) qb = qb.or(`number.ilike.%${query.search}%,contact_name.ilike.%${query.search}%`);
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      qb = qb.range((page - 1) * pageSize, page * pageSize - 1).order("created_at", { ascending: false });
+      const { data, count } = await qb;
+      return { data: (data ?? []).map((r) => snakeToCamel(r)), total: count ?? 0 };
+    },
+    async getNotaById(id) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.notas).select("*").eq("id", id).maybeSingle();
+      if (error) throw error;
+      return data ? snakeToCamel(data) : null;
+    },
+    async createNota(input) {
+      const { pub } = getClients();
+      const row = {
+        tenant_id: getActiveTenantId(),
+        model: input.model ?? "nfe",
+        status: "draft",
+        series: input.series ?? null,
+        order_id: input.orderId ?? null,
+        contact_id: input.contactId ?? null,
+        contact_name: input.contactName ?? null,
+        total_amount: input.totalAmount,
+        observations: input.observations ?? null
+      };
+      const { data, error } = await pub.from(T.notas).insert(row).select().single();
+      if (error) throw error;
+      return snakeToCamel(data);
+    },
+    async updateNota(id, patch) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.notas).update(camelToSnake(patch)).eq("id", id).select().single();
+      if (error) throw error;
+      return snakeToCamel(data);
+    },
+    // Emission seam: no SEFAZ integration yet, so assign a número/série locally
+    // and mark it issued. An external emissor replaces this body (or overrides
+    // issueNota on a wrapping provider) without any UI change.
+    async issueNota(id) {
+      const { pub } = getClients();
+      const { data: current } = await pub.from(T.notas).select("series").eq("id", id).single();
+      const { count } = await pub.from(T.notas).select("id", { count: "exact", head: true }).eq("status", "issued");
+      const patch = {
+        status: "issued",
+        number: String((count ?? 0) + 1).padStart(6, "0"),
+        series: current?.series ?? "1",
+        issued_at: (/* @__PURE__ */ new Date()).toISOString(),
+        emissor: "manual"
+      };
+      const { data, error } = await pub.from(T.notas).update(patch).eq("id", id).select().single();
+      if (error) throw error;
+      return snakeToCamel(data);
+    },
+    async cancelNota(id, reason) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.notas).update({ status: "cancelled", error_message: reason ?? null }).eq("id", id).select().single();
+      if (error) throw error;
+      return snakeToCamel(data);
+    },
+    // --- Remessa CNAB 240 (080) ---
+    /**
+     * The Bacen registry, by COMPE code or by name.
+     *
+     * A bank is the country's, not the tenant's, so `public.banks` is global and
+     * read-only. A pool where migration 167 has not run yet answers with an
+     * empty list, and the caller falls back to the static catalogue — a missing
+     * table costs a longer list, never the screen.
+     */
+    async searchBanks(query, limit = 12) {
+      const term = query.trim();
+      const { pub } = getClients();
+      let qb = pub.from("banks").select("ispb,compe,name,legal_name,brand_color,logo_url").eq("is_active", true);
+      if (term) {
+        const digits = term.replace(/\D/g, "");
+        qb = digits.length >= 2 && digits.length <= 3 ? qb.like("compe", `${digits}%`) : qb.or(`name.ilike.%${term}%,legal_name.ilike.%${term}%`);
+      }
+      const { data, error } = await qb.order("compe", { nullsFirst: false }).limit(limit);
+      if (error) return [];
+      return (data ?? []).map((row) => ({
+        ispb: row.ispb,
+        compe: row.compe ?? void 0,
+        name: row.name,
+        legalName: row.legal_name ?? void 0,
+        brandColor: row.brand_color ?? void 0,
+        logoUrl: row.logo_url ?? void 0
+      }));
+    },
+    /**
+     * Who gets paid, who pays, and which file number is next.
+     *
+     * The payee's document lives on `people`, the account on `payee_accounts`
+     * and the address on `addresses` — three tables because each answers a
+     * different question, and the CNPJ of the paying company is a fourth. The
+     * wizard asks once and gets all of it, so step 3 can show a form with the
+     * blanks already filled instead of a sentence saying data is missing.
+     */
+    async getCnabContext({ contactIds, bankAccountId, unitId }) {
+      const { pub } = getClients();
+      const ids = [...new Set(contactIds.filter(Boolean))];
+      const [peopleRes, accountsRes, addressRes, companyRes, unitRes, seqRes] = await Promise.all([
+        ids.length ? pub.from("people").select("id,name,document_number").in("id", ids) : Promise.resolve({ data: [], error: null }),
+        ids.length ? pub.from(T.payeeAccounts).select("*").eq("owner_type", "person").in("owner_id", ids).order("is_default", { ascending: false }).order("created_at") : Promise.resolve({ data: [], error: null }),
+        ids.length ? pub.from("addresses").select("*").eq("owner_type", "person").in("owner_id", ids) : Promise.resolve({ data: [], error: null }),
+        // As empresas do tenant. São unidades de linhas, então vêm todas e a
+        // escolha é feita aqui — a da unidade da conta, senão a sem unidade,
+        // senão a única que existe.
+        pub.from("company_legal_entities").select("id,unit_id,kind,legal_name,trade_name,document_number").eq("is_active", true).limit(20),
+        // O nome da unidade é o que a tela escreve enquanto não há empresa
+        // cadastrada — melhor que um campo em branco pedindo razão social.
+        unitId ? pub.from(T.unitCompanies).select("unit_id,unit_name").eq("unit_id", unitId).maybeSingle() : Promise.resolve({ data: null, error: null }),
+        pub.from(T.cnabBatches).select("sequence_number").eq("bank_account_id", bankAccountId).order("sequence_number", { ascending: false }).limit(1).maybeSingle()
+      ]);
+      if (peopleRes.error) throw peopleRes.error;
+      if (accountsRes.error) throw accountsRes.error;
+      const accountOf = /* @__PURE__ */ new Map();
+      for (const row of accountsRes.data ?? []) {
+        if (!accountOf.has(row.owner_id)) accountOf.set(row.owner_id, row);
+      }
+      const addressOf = /* @__PURE__ */ new Map();
+      for (const row of addressRes.data ?? []) {
+        if (!addressOf.has(row.owner_id)) addressOf.set(row.owner_id, row);
+      }
+      const payees = (peopleRes.data ?? []).map((person) => {
+        const account = accountOf.get(person.id);
+        const address = addressOf.get(person.id);
+        return {
+          contactId: person.id,
+          name: person.name ?? "",
+          document: person.document_number ?? "",
+          payeeAccountId: account?.id,
+          bankCode: account?.bank_code ?? "",
+          bankName: account?.bank_name ?? "",
+          agencyNumber: account?.agency_number ?? "",
+          agencyDigit: account?.agency_digit ?? "",
+          accountNumber: account?.account_number ?? "",
+          accountDigit: account?.account_digit ?? "",
+          accountType: account?.account_type ?? "",
+          pixKey: account?.pix_key ?? "",
+          pixKeyType: account?.pix_key_type ?? "",
+          street: address?.street ?? "",
+          number: address?.number ?? "",
+          complement: address?.complement ?? "",
+          district: address?.district ?? "",
+          city: address?.city ?? "",
+          state: address?.state ?? "",
+          postalCode: address?.postal_code ?? ""
+        };
+      });
+      const companies = companyRes.data ?? [];
+      const companyRow = companies.find((row) => unitId && row.unit_id === unitId) ?? companies.find((row) => !row.unit_id) ?? companies[0];
+      const unitName = unitRes.data?.unit_name ?? "";
+      const company = {
+        id: companyRow?.id ?? void 0,
+        unitId,
+        name: companyRow?.trade_name || companyRow?.legal_name || unitName,
+        document: companyRow?.document_number || ""
+      };
+      return {
+        company,
+        nextSequence: Number(seqRes.data?.sequence_number ?? 0) + 1,
+        payees
+      };
+    },
+    /**
+     * A empresa pagadora, cadastrada de dentro da remessa.
+     *
+     * `company_legal_entities` nasceu sem tela: nenhuma superfície do SDK
+     * escreve nela, e o resultado é um pool com treze unidades e zero empresas.
+     * Como o CNPJ é obrigatório no cabeçalho do CNAB, é aqui que a pessoa o
+     * digita — e gravá-lo é o que faz a PRÓXIMA remessa já vir preenchida.
+     *
+     * `unit_id` na linha é o que recorta a empresa por unidade. O elo inverso
+     * (`app.units.company_legal_entity_id`) fica para quem tiver a RPC: o schema
+     * `app` não é alcançável por aqui, e a leitura já resolve pelos dois lados.
+     */
+    async saveCompany(input) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      const digits = (input.document || "").replace(/\D/g, "");
+      const name = input.name.trim();
+      if (!name) throw new Error("A empresa precisa de um nome.");
+      if (digits.length !== 11 && digits.length !== 14) {
+        throw new Error("CNPJ com 14 d\xEDgitos ou CPF com 11 \u2014 o cabe\xE7alho do CNAB n\xE3o aceita outro.");
+      }
+      const row = {
+        kind: digits.length === 14 ? "company" : "individual",
+        legal_name: name,
+        trade_name: name,
+        document_number: digits
+      };
+      if (input.id) {
+        const { error: error2 } = await pub.from("company_legal_entities").update(row).eq("id", input.id);
+        if (error2) throw error2;
+        return { id: input.id };
+      }
+      const { data, error } = await pub.from("company_legal_entities").insert({ ...row, tenant_id: tenantId, unit_id: input.unitId ?? null, is_active: true }).select("id").single();
+      if (error) throw error;
+      return { id: data.id };
+    },
+    /**
+     * What the wizard collected goes back to the cadastro, not to the file only.
+     * Otherwise the same CPF is typed again on the next remittance, and the two
+     * typings disagree.
+     */
+    async saveCnabPayees(payees) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      const text = (v) => {
+        const s = (v ?? "").trim();
+        return s === "" ? null : s;
+      };
+      for (const payee of payees) {
+        if (text(payee.document)) {
+          const { error: error2 } = await pub.from("people").update({ document_number: text(payee.document) }).eq("id", payee.contactId);
+          if (error2) throw error2;
+        }
+        const row = {
+          bank_code: text(payee.bankCode),
+          bank_name: text(payee.bankName),
+          agency_number: text(payee.agencyNumber),
+          agency_digit: text(payee.agencyDigit),
+          account_number: text(payee.accountNumber),
+          account_digit: text(payee.accountDigit),
+          account_type: text(payee.accountType),
+          pix_key: text(payee.pixKey),
+          pix_key_type: text(payee.pixKeyType)
+        };
+        if (!row.account_number && !row.pix_key) continue;
+        let targetId = payee.payeeAccountId;
+        if (!targetId) {
+          const { data: existing } = await pub.from(T.payeeAccounts).select("id").eq("owner_type", "person").eq("owner_id", payee.contactId).order("is_default", { ascending: false }).order("created_at").limit(1).maybeSingle();
+          targetId = existing?.id;
+        }
+        const { data: written, error } = targetId ? await pub.from(T.payeeAccounts).update(row).eq("id", targetId).select("id") : await pub.from(T.payeeAccounts).insert({
+          ...row,
+          tenant_id: tenantId,
+          owner_type: "person",
+          owner_id: payee.contactId,
+          label: "Principal",
+          is_default: true
+        }).select("id");
+        if (error) throw error;
+        if (!written?.length) throw new Error("payee account was not saved (no financial edit permission?)");
+      }
+    },
+    /**
+     * The file that already left for the bank. `sequence_number` is the bank's
+     * count, not the file's — two remittances carrying the same one is a
+     * rejected remittance, so it is written with the batch and never derived
+     * again.
+     */
+    async recordCnabBatch(input) {
+      const { pub } = getClients();
+      const tenantId = getActiveTenantId();
+      const { data, error } = await pub.from(T.cnabBatches).insert({
+        tenant_id: tenantId,
+        unit_id: input.unitId ?? null,
+        bank_account_id: input.bankAccountId,
+        layout: input.layout,
+        sequence_number: input.sequenceNumber,
+        total_amount: input.totalAmount,
+        items_count: input.items.length,
+        file_name: input.fileName,
+        // The file's home is `public.documents` through `document_id`; until the
+        // upload path exists it rides in metadata, which keeps a generated
+        // remittance downloadable instead of gone.
+        metadata: { file_content: input.fileContent }
+      }).select("id").single();
+      if (error) throw error;
+      const batchId = data.id;
+      if (input.items.length) {
+        const ids = [...new Set(input.items.map((item) => item.movementId))];
+        const { data: movementRows } = await pub.from(T.movements).select("id").in("id", ids);
+        const isMovement = new Set((movementRows ?? []).map((row) => row.id));
+        const { error: itemsError } = await pub.from(T.cnabItems).insert(
+          input.items.map((item) => ({
+            tenant_id: tenantId,
+            batch_id: batchId,
+            installment_id: item.movementId,
+            movement_id: isMovement.has(item.movementId) ? item.movementId : null,
+            payment_form: item.paymentForm,
+            payment_date: item.paymentDate,
+            amount: item.amount
+          }))
+        );
+        if (itemsError) throw itemsError;
+      }
+      return { id: batchId };
+    }
+  };
+  return provider;
+}
+
+export { createSupabaseFinancialProvider };
+//# sourceMappingURL=chunk-2XWEZXFT.js.map
+//# sourceMappingURL=chunk-2XWEZXFT.js.map