@fayz-ai/inventory 0.0.0-stage → 0.1.0

package/dist/chunk-2FXO63QV.js

@@ -0,0 +1,1732 @@
+import { productImageProblem, derivedProductType, isNewBarcodePrimary } from './chunk-JN5AZ656.js';
+import { createIdempotencyKey, randomId } from './chunk-JX7NCXJQ.js';
+import { explodeRecipe } from './chunk-EF5LVTOC.js';
+import { getDuplicateDefaultUnitIds, getMissingMeasurementUnits, getDuplicateAutoCreatedLocationIds, DEFAULT_STOCK_LOCATION } from './chunk-YZDGJBJD.js';
+import { categoryCounts, pickRestock, recentMovementCutoff, summarizeStock, expiryWindow, toPanelRow, hasHealth } from './chunk-52AJ7H2W.js';
+import { T, PRODUCT_CATEGORY_KIND } from './chunk-RUOX7OOY.js';
+import { assertReversible, consumptionKey, skippedConsumption, assertConsumable } from './chunk-GBIFZCEN.js';
+import { countProgress } from './chunk-W36J5END.js';
+import { reversedSourceDelta, ledgerKind, signedLedgerQuantity } from './chunk-AFUR3HLA.js';
+import { getActiveUnitId, getActiveTenantId, getSupabaseClientOptional, emitDataChanged } from '@fayz-ai/core';
+
+var PRODUCT_SELECT = `*, ${T.productDetails}(*)`;
+var PRODUCTS_READ = "v_inventory_products";
+var USAGE_AUDIT_READ = "v_inventory_consumption_audit";
+var COUNT_SESSION_SELECT = `*, ${T.stockLocations}(name), ${T.productCategories}(name)`;
+var referenceDataPromises = /* @__PURE__ */ new Map();
+function client() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase not initialized");
+  return supabase;
+}
+function goods(sb, columns, options) {
+  return sb.from(PRODUCTS_READ).select(columns, options).neq("kind", "service");
+}
+function fail(operation, error) {
+  if (error) throw new Error(`${operation}: ${error.message ?? "Supabase request failed"}`);
+}
+var PAGE_ROWS = 1e3;
+var IN_CHUNK = 200;
+async function selectAllRows(page, operation) {
+  const out = [];
+  for (let from = 0; ; from += PAGE_ROWS) {
+    const { data, error } = await page(from, from + PAGE_ROWS - 1);
+    fail(operation, error);
+    out.push(...data ?? []);
+    if (!data || data.length < PAGE_ROWS) return out;
+  }
+}
+async function selectInChunks(ids, page, operation) {
+  const chunks = [];
+  for (let i = 0; i < ids.length; i += IN_CHUNK) chunks.push(ids.slice(i, i + IN_CHUNK));
+  const parts = await Promise.all(chunks.map((chunk) => selectAllRows((from, to) => page(chunk, from, to), operation)));
+  return parts.flat();
+}
+function announceWrites(provider) {
+  const announce = (name, payloads) => {
+    const original = provider[name];
+    if (!original) return;
+    provider[name] = async (...args) => {
+      const result = await original.apply(provider, args);
+      for (const p of payloads(args, result)) emitDataChanged({ source: "ui", ...p });
+      return result;
+    };
+  };
+  announce("createProduct", (_a, r) => [{ table: "products", op: "create", id: r?.id }]);
+  announce("updateProduct", ([id]) => [{ table: "products", op: "update", id }]);
+  announce("setIngredientCost", ([id]) => [{ table: "products", op: "update", id }]);
+  announce("saveRecipeSheet", ([sheet], recipeId) => [
+    { table: T.recipes, op: sheet?.id ? "update" : "create", id: recipeId },
+    { table: "products", op: "update", id: sheet?.productId }
+  ]);
+}
+function mapRecipeOutput(o) {
+  return {
+    id: o.id,
+    productId: o.product_id,
+    outputType: o.output_type,
+    expectedQuantity: Number(o.expected_quantity) || 0,
+    measurementUnitId: o.measurement_unit_id ?? void 0,
+    costShare: o.cost_share != null ? Number(o.cost_share) : null
+  };
+}
+async function recipeListInOneQuery(pub, productId) {
+  const select = [
+    "id, name, price, image_url, category_id",
+    `details:${T.productDetails}!inner(is_for_sale, is_intermediate)`,
+    `category:${T.productCategories}!category_id(name)`,
+    `recipes:${T.recipes}!product_id(id, description, yield_quantity, preparation_time_minutes, updated_at, is_active, unit:${T.measurementUnits}!yield_unit_id(abbreviation), lines:${T.recipeIngredients}!recipe_id(quantity, ingredient:products!product_id(cost)))`
+  ].join(", ");
+  let rows;
+  try {
+    rows = await selectAllRows((from, to) => {
+      let q = pub.from("products").select(select).eq("is_active", true).eq(`${T.productDetails}.is_produced`, true);
+      if (productId) q = q.eq("id", productId);
+      return q.order("id").range(from, to);
+    }, "Could not read recipe list");
+  } catch {
+    return null;
+  }
+  rows.sort((a, b) => String(a.name ?? "").localeCompare(String(b.name ?? "")));
+  return rows.map((p) => {
+    const details = Array.isArray(p.details) ? p.details[0] : p.details;
+    const r = (p.recipes ?? []).filter((x) => x.is_active).sort((a, b) => String(b.updated_at ?? "").localeCompare(String(a.updated_at ?? "")))[0];
+    const lines = r?.lines ?? [];
+    return {
+      productId: p.id,
+      productName: p.name,
+      imageUrl: p.image_url ?? void 0,
+      categoryName: p.category?.name ?? void 0,
+      isForSale: Boolean(details?.is_for_sale),
+      isIntermediate: Boolean(details?.is_intermediate),
+      recipeId: r?.id,
+      description: r?.description ?? void 0,
+      ingredientCount: lines.length,
+      yieldQuantity: r?.yield_quantity != null ? Number(r.yield_quantity) : void 0,
+      yieldUnitAbbr: r?.unit?.abbreviation ?? void 0,
+      preparationTimeMinutes: r?.preparation_time_minutes ?? void 0,
+      cost: lines.reduce((sum, l) => sum + (Number(l.quantity) || 0) * (Number(l.ingredient?.cost) || 0), 0),
+      salePrice: Number(p.price) || 0
+    };
+  });
+}
+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 embedded(value) {
+  const one = Array.isArray(value) ? value[0] : value;
+  return one && typeof one === "object" ? one : void 0;
+}
+function withoutEmbeds(row, keys) {
+  const copy = { ...row };
+  for (const key of keys) delete copy[key];
+  return copy;
+}
+function idsOf(rows, key) {
+  return [...new Set(rows.map((row) => row[key]).filter(Boolean))];
+}
+async function namesById(sb, table, ids) {
+  const names = /* @__PURE__ */ new Map();
+  if (ids.length === 0) return names;
+  const { data } = await sb.from(table).select("id, name").in("id", ids);
+  for (const row of data ?? []) names.set(row.id, row.name);
+  return names;
+}
+function toRecipe(row) {
+  const recipe = snakeToCamel(withoutEmbeds(row, ["products"]));
+  const product = embedded(row.products);
+  if (product) {
+    recipe.productName = product.name ?? recipe.productName;
+    recipe.productSalePrice = product.price ?? void 0;
+  }
+  return recipe;
+}
+function toRecipeIngredient(row) {
+  const ingredient = snakeToCamel(withoutEmbeds(row, ["products", T.recipeGroups]));
+  const group = embedded(row[T.recipeGroups]);
+  if (group) ingredient.groupName = group.name;
+  const product = embedded(row.products);
+  if (product) {
+    const details = embedded(product[T.productDetails]);
+    ingredient.productName = product.name ?? ingredient.productName;
+    ingredient.costBasis = {
+      cost: Number(product.cost) || 0,
+      conversionFactor: details?.conversion_factor ?? void 0,
+      purchaseUnitId: details?.purchase_unit_id ?? void 0
+    };
+  }
+  return ingredient;
+}
+function toCountSession(row) {
+  const session = snakeToCamel(withoutEmbeds(row, [T.stockLocations, T.productCategories]));
+  session.stockLocationName = embedded(row[T.stockLocations])?.name;
+  session.categoryName = embedded(row[T.productCategories])?.name;
+  session.blind = row.blind ?? true;
+  return session;
+}
+function toCountItem(row) {
+  const item = snakeToCamel(withoutEmbeds(row, ["products"]));
+  const product = embedded(row.products);
+  if (product) {
+    item.productName = product.name;
+    item.productSku = product.sku ?? void 0;
+  }
+  item.systemQuantity = Number(row.system_quantity) || 0;
+  item.countedQuantity = row.counted_quantity == null ? void 0 : Number(row.counted_quantity);
+  item.unitCost = Number(row.unit_cost) || 0;
+  return item;
+}
+function toClassification(d) {
+  return {
+    isIngredient: d.is_ingredient ?? false,
+    isForSale: d.is_for_sale ?? false,
+    isIntermediate: d.is_intermediate ?? false,
+    isAsset: d.is_asset ?? false,
+    isProduced: d.is_produced ?? false,
+    isResale: d.is_resale ?? false,
+    trackByUnitLabel: d.track_by_unit_label ?? false
+  };
+}
+function toGeneralExtras(d) {
+  return {
+    commissionPercent: d.commission_percent ?? void 0,
+    chartAccountId: d.chart_account_id ?? void 0,
+    contentPerUnit: d.content_per_unit ?? void 0,
+    contentUnitId: d.content_unit_id ?? void 0,
+    avgPurchasePrice: d.avg_purchase_price ?? void 0,
+    avgPurchasePriceUpdatedAt: d.avg_purchase_price_updated_at ?? void 0,
+    professionalResalePrice: d.professional_resale_price ?? void 0,
+    requireBatchForStock: d.require_batch_for_stock ?? false,
+    requireExpiryForStock: d.require_expiry_for_stock ?? false
+  };
+}
+function toProduct(row) {
+  const meta = row.metadata ?? {};
+  const d = embedded(row[T.productDetails]) ?? {};
+  const classification = toClassification(d);
+  return {
+    classification,
+    extras: toGeneralExtras(d),
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    sku: row.sku,
+    barcode: meta.barcode,
+    brand: meta.brand,
+    productType: derivedProductType(classification, meta.productType),
+    currentQuantity: row.stock ?? 0,
+    minQuantity: row.min_stock ?? 0,
+    maxQuantity: meta.maxQuantity,
+    costPrice: row.cost ?? 0,
+    salePrice: row.price,
+    categoryId: row.category_id ?? void 0,
+    measurementUnitId: d.measurement_unit_id ?? void 0,
+    purchaseUnitId: d.purchase_unit_id ?? void 0,
+    conversionFactor: d.conversion_factor ?? void 0,
+    supplierId: d.supplier_id ?? void 0,
+    defaultLocationId: d.default_location_id ?? void 0,
+    purpose: d.purpose ?? void 0,
+    isActive: row.is_active ?? true,
+    imageUrl: row.image_url,
+    metadata: meta,
+    tenantId: row.tenant_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+async function fillCoverFromShopGallery(core, products) {
+  const missing = products.filter((p) => !p.imageUrl).map((p) => p.id);
+  if (missing.length === 0) return;
+  const { data, error } = await core.from("plg_shop_products").select("product_id, images:plg_shop_product_images(url, is_primary, sort_order)").in("product_id", missing);
+  if (error || !data?.length) return;
+  const cover = /* @__PURE__ */ new Map();
+  for (const listing of data) {
+    for (const img of listing.images ?? []) {
+      const rank = (img.is_primary ? 0 : 1e6) + (img.sort_order ?? 0);
+      const current = cover.get(listing.product_id);
+      if (img.url && (!current || rank < current.rank)) cover.set(listing.product_id, { url: img.url, rank });
+    }
+  }
+  for (const p of products) {
+    if (!p.imageUrl) p.imageUrl = cover.get(p.id)?.url;
+  }
+}
+function productDetailsRow(input) {
+  const row = {};
+  if (input.measurementUnitId !== void 0) row.measurement_unit_id = input.measurementUnitId || null;
+  if (input.purchaseUnitId !== void 0) row.purchase_unit_id = input.purchaseUnitId || null;
+  if (input.conversionFactor !== void 0) row.conversion_factor = input.conversionFactor ?? 1;
+  if (input.supplierId !== void 0) row.supplier_id = input.supplierId || null;
+  if (input.defaultLocationId !== void 0) row.default_location_id = input.defaultLocationId || null;
+  if (input.purpose !== void 0) row.purpose = input.purpose || null;
+  const c = input.classification;
+  if (c) {
+    if (c.isIngredient !== void 0) row.is_ingredient = c.isIngredient;
+    if (c.isForSale !== void 0) row.is_for_sale = c.isForSale;
+    if (c.isIntermediate !== void 0) row.is_intermediate = c.isIntermediate;
+    if (c.isAsset !== void 0) row.is_asset = c.isAsset;
+    if (c.isProduced !== void 0) row.is_produced = c.isProduced;
+    if (c.isResale !== void 0) row.is_resale = c.isResale;
+    if (c.trackByUnitLabel !== void 0) row.track_by_unit_label = c.trackByUnitLabel;
+  }
+  const e = input.extras;
+  if (e) {
+    if (e.commissionPercent !== void 0) row.commission_percent = e.commissionPercent ?? 0;
+    if (e.chartAccountId !== void 0) row.chart_account_id = e.chartAccountId || null;
+    if (e.contentPerUnit !== void 0) row.content_per_unit = e.contentPerUnit ?? null;
+    if (e.contentUnitId !== void 0) row.content_unit_id = e.contentUnitId || null;
+    if (e.avgPurchasePrice !== void 0) row.avg_purchase_price = e.avgPurchasePrice ?? null;
+    if (e.professionalResalePrice !== void 0) row.professional_resale_price = e.professionalResalePrice ?? null;
+    if (e.requireBatchForStock !== void 0) row.require_batch_for_stock = e.requireBatchForStock;
+    if (e.requireExpiryForStock !== void 0) row.require_expiry_for_stock = e.requireExpiryForStock;
+  }
+  return Object.keys(row).length > 0 ? row : null;
+}
+var ingredientInfo = {
+  table: T.productIngredientInfo,
+  toRow: (v) => ({
+    minimum_quantity: v.minimumQuantity ?? 0,
+    maximum_quantity: v.maximumQuantity ?? null,
+    reorder_point: v.reorderPoint ?? null,
+    lead_time_days: v.leadTimeDays ?? null,
+    shelf_life_days: v.shelfLifeDays ?? null,
+    storage_temperature: v.storageTemperature || null,
+    allowed_supplier_ids: v.allowedSupplierIds?.length ? v.allowedSupplierIds : null,
+    notes: v.notes || null
+  }),
+  fromRow: (r) => ({
+    minimumQuantity: r.minimum_quantity ?? void 0,
+    maximumQuantity: r.maximum_quantity ?? void 0,
+    reorderPoint: r.reorder_point ?? void 0,
+    leadTimeDays: r.lead_time_days ?? void 0,
+    shelfLifeDays: r.shelf_life_days ?? void 0,
+    storageTemperature: r.storage_temperature ?? void 0,
+    allowedSupplierIds: r.allowed_supplier_ids ?? void 0,
+    notes: r.notes ?? void 0
+  })
+};
+var saleInfo = {
+  table: T.productSaleInfo,
+  toRow: (v) => ({
+    menu_description: v.menuDescription || null,
+    allergens: v.allergens || null,
+    preparation_time_minutes: v.preparationTimeMinutes ?? null,
+    serves_quantity: v.servesQuantity ?? null,
+    calories: v.calories ?? null,
+    sold_by_weight: v.soldByWeight ?? false,
+    highlight_delivery: v.highlightDelivery ?? false,
+    available_for_delivery: v.availableForDelivery ?? true,
+    available_for_counter: v.availableForCounter ?? true,
+    notes: v.notes || null
+  }),
+  fromRow: (r) => ({
+    menuDescription: r.menu_description ?? void 0,
+    allergens: r.allergens ?? void 0,
+    preparationTimeMinutes: r.preparation_time_minutes ?? void 0,
+    servesQuantity: r.serves_quantity ?? void 0,
+    calories: r.calories ?? void 0,
+    soldByWeight: r.sold_by_weight ?? false,
+    highlightDelivery: r.highlight_delivery ?? false,
+    availableForDelivery: r.available_for_delivery ?? true,
+    availableForCounter: r.available_for_counter ?? true,
+    notes: r.notes ?? void 0
+  })
+};
+var intermediateInfo = {
+  table: T.productIntermediateInfo,
+  toRow: (v) => ({
+    yield_percentage: v.yieldPercentage ?? null,
+    preparation_time_minutes: v.preparationTimeMinutes ?? null,
+    shelf_life_hours: v.shelfLifeHours ?? null,
+    batch_size: v.batchSize ?? null,
+    batch_unit_id: v.batchUnitId || null,
+    storage_instructions: v.storageInstructions || null,
+    notes: v.notes || null
+  }),
+  fromRow: (r) => ({
+    yieldPercentage: r.yield_percentage ?? void 0,
+    preparationTimeMinutes: r.preparation_time_minutes ?? void 0,
+    shelfLifeHours: r.shelf_life_hours ?? void 0,
+    batchSize: r.batch_size ?? void 0,
+    batchUnitId: r.batch_unit_id ?? void 0,
+    storageInstructions: r.storage_instructions ?? void 0,
+    notes: r.notes ?? void 0
+  })
+};
+var assetInfo = {
+  table: T.productAssetInfo,
+  toRow: (v) => ({
+    asset_value: v.assetValue ?? 0,
+    residual_value: v.residualValue ?? 0,
+    useful_life_months: v.usefulLifeMonths ?? null,
+    depreciation_rate: v.depreciationRate ?? null,
+    serial_number: v.serialNumber || null,
+    acquisition_date: v.acquisitionDate || null,
+    warranty_expiry_date: v.warrantyExpiryDate || null,
+    asset_status: v.assetStatus || "active",
+    asset_location: v.assetLocation || null,
+    responsible_person_id: v.responsiblePersonId || null,
+    insurance_policy: v.insurancePolicy || null,
+    last_maintenance_date: v.lastMaintenanceDate || null,
+    next_maintenance_date: v.nextMaintenanceDate || null,
+    notes: v.notes || null
+  }),
+  fromRow: (r) => ({
+    assetValue: r.asset_value ?? void 0,
+    residualValue: r.residual_value ?? void 0,
+    usefulLifeMonths: r.useful_life_months ?? void 0,
+    depreciationRate: r.depreciation_rate ?? void 0,
+    serialNumber: r.serial_number ?? void 0,
+    acquisitionDate: r.acquisition_date ?? void 0,
+    warrantyExpiryDate: r.warranty_expiry_date ?? void 0,
+    assetStatus: r.asset_status ?? void 0,
+    assetLocation: r.asset_location ?? void 0,
+    responsiblePersonId: r.responsible_person_id ?? void 0,
+    insurancePolicy: r.insurance_policy ?? void 0,
+    lastMaintenanceDate: r.last_maintenance_date ?? void 0,
+    nextMaintenanceDate: r.next_maintenance_date ?? void 0,
+    notes: r.notes ?? void 0
+  })
+};
+var taxInfo = {
+  table: T.productTaxInfo,
+  toRow: (v) => ({
+    tax_group_id: v.taxGroupId || null,
+    ncm: v.ncm || null,
+    cest: v.cest || null,
+    icms_origin: v.icmsOrigin || null,
+    icms_rate: v.icmsRate ?? null,
+    cfop: v.cfop || null,
+    cst: v.cst || null,
+    pis_situation: v.pisSituation || null,
+    pis_rate: v.pisRate ?? null,
+    cofins_situation: v.cofinsSituation || null,
+    cofins_rate: v.cofinsRate ?? null,
+    base_calculation_mode: v.baseCalculationMode || null,
+    benefit_code: v.benefitCode || null,
+    poverty_fund_rate: v.povertyFundRate ?? null,
+    ibs_cbs_situation: v.ibsCbsSituation || null,
+    ibs_cbs_classification: v.ibsCbsClassification || null
+  }),
+  fromRow: (r) => ({
+    taxGroupId: r.tax_group_id ?? void 0,
+    ncm: r.ncm ?? void 0,
+    cest: r.cest ?? void 0,
+    icmsOrigin: r.icms_origin ?? void 0,
+    icmsRate: r.icms_rate ?? void 0,
+    cfop: r.cfop ?? void 0,
+    cst: r.cst ?? void 0,
+    pisSituation: r.pis_situation ?? void 0,
+    pisRate: r.pis_rate ?? void 0,
+    cofinsSituation: r.cofins_situation ?? void 0,
+    cofinsRate: r.cofins_rate ?? void 0,
+    baseCalculationMode: r.base_calculation_mode ?? void 0,
+    benefitCode: r.benefit_code ?? void 0,
+    povertyFundRate: r.poverty_fund_rate ?? void 0,
+    ibsCbsSituation: r.ibs_cbs_situation ?? void 0,
+    ibsCbsClassification: r.ibs_cbs_classification ?? void 0
+  })
+};
+var INFO_TABLES = { ingredientInfo, saleInfo, intermediateInfo, assetInfo, taxInfo };
+var INFO_KEYS = Object.keys(INFO_TABLES);
+async function saveProductInfos(sb, tenantId, productId, input) {
+  const failures = [];
+  for (const key of INFO_KEYS) {
+    const value = input[key];
+    if (!value) continue;
+    const def = INFO_TABLES[key];
+    const row = { ...def.toRow(value), product_id: productId, tenant_id: tenantId };
+    const { error } = await sb.from(def.table).upsert(row, { onConflict: "product_id" });
+    if (error) failures.push(`${def.table}: ${error.message}`);
+  }
+  for (const ch of input.saleChannels ?? []) {
+    const { error } = await sb.from(T.productSaleChannels).upsert(
+      { tenant_id: tenantId, product_id: productId, channel: ch.channel, price: ch.price ?? 0, active: ch.active ?? true },
+      { onConflict: "product_id,channel" }
+    );
+    if (error) failures.push(`${T.productSaleChannels}: ${error.message}`);
+  }
+  return failures;
+}
+async function hydrateRecipes(sb, rows) {
+  const productIds = idsOf(rows, "product_id");
+  const productsById = /* @__PURE__ */ new Map();
+  if (productIds.length > 0) {
+    const { data, error } = await sb.from("products").select("id, name, price").in("id", productIds);
+    fail("Could not read recipe products", error);
+    for (const product of data ?? []) productsById.set(product.id, product);
+  }
+  return rows.map((row) => toRecipe({ ...row, products: productsById.get(row.product_id) }));
+}
+async function hydrateRecipeIngredients(sb, rows, includeGroups) {
+  const productIds = idsOf(rows, "product_id");
+  const productsById = /* @__PURE__ */ new Map();
+  const detailsByProductId = /* @__PURE__ */ new Map();
+  const unitsById = /* @__PURE__ */ new Map();
+  if (productIds.length > 0) {
+    const [{ data: products, error: productsError }, { data: details, error: detailsError }] = await Promise.all([
+      sb.from("products").select("id, name, cost").in("id", productIds),
+      sb.from(T.productDetails).select("product_id, conversion_factor, measurement_unit_id, purchase_unit_id").in("product_id", productIds)
+    ]);
+    fail("Could not read recipe ingredient products", productsError);
+    fail("Could not read recipe ingredient details", detailsError);
+    for (const product of products ?? []) productsById.set(product.id, product);
+    for (const detail of details ?? []) detailsByProductId.set(detail.product_id, detail);
+    const unitIds = [...new Set([
+      ...rows.map((row) => row.unit_id),
+      ...(details ?? []).map((detail) => detail.measurement_unit_id)
+    ].filter(Boolean))];
+    if (unitIds.length > 0) {
+      const { data: units, error: unitsError } = await sb.from(T.measurementUnits).select("id, name, abbreviation").in("id", unitIds);
+      fail("Could not read recipe ingredient units", unitsError);
+      for (const unit of units ?? []) unitsById.set(unit.id, unit);
+    }
+  }
+  const groupsById = /* @__PURE__ */ new Map();
+  const groupIds = includeGroups ? idsOf(rows, "group_id") : [];
+  if (groupIds.length > 0) {
+    const { data, error } = await sb.from(T.recipeGroups).select("id, name").in("id", groupIds);
+    fail("Could not read recipe groups", error);
+    for (const group of data ?? []) groupsById.set(group.id, group);
+  }
+  return rows.map((row) => {
+    const product = productsById.get(row.product_id);
+    const details = detailsByProductId.get(row.product_id);
+    const ingredient = toRecipeIngredient({
+      ...row,
+      products: product ? { ...product, [T.productDetails]: details } : void 0,
+      [T.recipeGroups]: groupsById.get(row.group_id)
+    });
+    const unitId = row.unit_id ?? details?.measurement_unit_id;
+    const unit = unitId ? unitsById.get(unitId) : void 0;
+    ingredient.unitId = unitId ?? ingredient.unitId;
+    ingredient.unitName = unit?.abbreviation ?? unit?.name ?? ingredient.unitName;
+    return ingredient;
+  });
+}
+async function defaultLocationId(sb, tenantId) {
+  if (!tenantId) return void 0;
+  const { data } = await sb.from(T.stockLocations).select("id").eq("tenant_id", tenantId).eq("is_active", true).order("created_at").limit(1);
+  return data?.[0]?.id;
+}
+async function defaultUnitId(sb, tenantId) {
+  const { data } = await sb.from("v_units").select("id, kind").eq("tenant_id", tenantId).order("kind", { ascending: true }).limit(50);
+  const rows = data ?? [];
+  return (rows.find((r) => r.kind === "hq") ?? rows[0])?.id;
+}
+async function applyPositionDelta(sb, tenantId, slot, locationId, amount) {
+  const bump = async () => {
+    const { data: existing, error } = await sb.from(T.stockPositions).select("id, quantity").eq("product_id", slot.productId).eq("stock_location_id", locationId).is("batch_number", slot.batchNumber ?? null).is("expiration_date", slot.expirationDate ?? null).maybeSingle();
+    if (error) throw new Error(error.message);
+    if (!existing) return null;
+    const current = Number(existing.quantity) || 0;
+    const { error: updateError } = await sb.from(T.stockPositions).update({ quantity: current + amount, unit_cost: slot.unitCost ?? 0 }).eq("id", existing.id);
+    if (updateError) throw new Error(updateError.message);
+    return amount;
+  };
+  const bumped = await bump();
+  if (bumped !== null) return bumped;
+  const { error: insertError } = await sb.from(T.stockPositions).insert({
+    tenant_id: tenantId,
+    product_id: slot.productId,
+    stock_location_id: locationId,
+    quantity: amount,
+    unit_cost: slot.unitCost ?? 0,
+    batch_number: slot.batchNumber ?? null,
+    expiration_date: slot.expirationDate ?? null
+  });
+  if (!insertError) return amount;
+  if (insertError.code === "23505") {
+    const retried = await bump();
+    if (retried !== null) return retried;
+  }
+  throw new Error(insertError.message);
+}
+function toUsageAuditEntry(r, names) {
+  return {
+    itemId: r.item_id,
+    productId: r.product_id,
+    productName: r.product_name ?? void 0,
+    productSku: r.product_sku ?? void 0,
+    usedAt: r.used_at,
+    movementDate: r.movement_date,
+    postedQuantity: Number(r.posted_quantity ?? 0),
+    netQuantity: Number(r.net_quantity ?? 0),
+    // Null is "no standard to compare to"; 0 is a standard of zero.
+    standardQuantity: r.standard_quantity == null ? null : Number(r.standard_quantity),
+    variance: r.variance == null ? null : Number(r.variance),
+    unitAbbreviation: r.unit_abbreviation ?? void 0,
+    totalCost: Number(r.total_cost ?? 0),
+    stockLocationId: r.stock_location_id ?? void 0,
+    stockLocationName: r.stock_location_name ?? void 0,
+    locationCount: Number(r.location_count ?? 1),
+    recipeId: r.recipe_id ?? void 0,
+    recipeName: r.recipe_name ?? void 0,
+    orderId: r.order_id ?? void 0,
+    itemName: r.item_name ?? void 0,
+    orderReference: r.order_reference ?? void 0,
+    performedById: r.performed_by_id ?? void 0,
+    performedByName: r.performed_by_name ?? names.get(r.performed_by_id) ?? void 0,
+    customerId: r.customer_id ?? void 0,
+    customerName: r.customer_name ?? names.get(r.customer_id) ?? void 0,
+    correctedAt: r.corrected_at ?? void 0,
+    correctionReason: r.correction_reason ?? void 0,
+    isCorrected: Boolean(r.is_corrected),
+    source: r.source ?? void 0,
+    stockPosted: r.stock_posted == null ? void 0 : Boolean(r.stock_posted)
+  };
+}
+async function invokeFunction(pub, name, body) {
+  const { data, error } = await pub.functions.invoke(name, { body: { ...body, tenantId: getActiveTenantId() ?? null } });
+  if (error) {
+    const payload = await error.context?.json?.().catch(() => null);
+    throw new Error(payload?.error ?? error.message);
+  }
+  const res = data ?? {};
+  if (res.ok === false || typeof res.error === "string") throw new Error(String(res.error ?? "A IA n\xE3o respondeu."));
+  return res;
+}
+async function resolveBaseUnits(pub, productIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (productIds.length === 0) return out;
+  const { data: details, error } = await pub.from(T.productDetails).select("product_id, measurement_unit_id").in("product_id", productIds);
+  fail("Could not read product units", error);
+  for (const d of details ?? []) if (d.measurement_unit_id) out.set(d.product_id, d.measurement_unit_id);
+  const missing = productIds.filter((id) => !out.has(id));
+  if (missing.length > 0) {
+    const { data: lines, error: linesError } = await pub.from(T.recipeIngredients).select("product_id, unit_id, created_at").in("product_id", missing).not("unit_id", "is", null).order("created_at", { ascending: false });
+    fail("Could not read sheet units", linesError);
+    for (const l of lines ?? []) if (!out.has(l.product_id)) out.set(l.product_id, l.unit_id);
+  }
+  return out;
+}
+async function readIngredientInfo(pub, productIds) {
+  const ids = [...new Set(productIds.filter(Boolean))];
+  if (ids.length === 0) return [];
+  const [{ data, error }, units] = await Promise.all([
+    pub.from("products").select("id, name, cost").in("id", ids),
+    resolveBaseUnits(pub, ids)
+  ]);
+  fail("Could not read ingredients", error);
+  return (data ?? []).map((p) => ({
+    productId: p.id,
+    name: p.name,
+    cost: Number(p.cost) || 0,
+    baseUnitId: units.get(p.id)
+  }));
+}
+function createSupabaseInventoryProvider() {
+  const getClients = () => {
+    const sb = client();
+    return { core: sb, pub: sb };
+  };
+  const provider = {
+    async ensureReferenceData() {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      if (!tenantId) return;
+      const running = referenceDataPromises.get(tenantId);
+      if (running) return running;
+      const prepare = (async () => {
+        const { data: units, error: unitsError } = await sb.from(T.measurementUnits).select("id, abbreviation, created_at").eq("tenant_id", tenantId);
+        if (unitsError) throw new Error(unitsError.message);
+        const duplicateIds = getDuplicateDefaultUnitIds(units ?? []);
+        if (duplicateIds.length > 0) {
+          const { error } = await sb.from(T.measurementUnits).delete().in("id", duplicateIds);
+          if (error) throw new Error(error.message);
+        }
+        const missing = getMissingMeasurementUnits(units ?? []);
+        if (missing.length > 0) {
+          const { error } = await sb.from(T.measurementUnits).insert(
+            missing.map((unit) => ({ ...unit, tenant_id: tenantId, is_active: true }))
+          );
+          if (error) throw new Error(error.message);
+        }
+        const { data: locations, error: locationError } = await sb.from(T.stockLocations).select("id, name, created_at").eq("tenant_id", tenantId);
+        if (locationError) throw new Error(locationError.message);
+        const duplicateLocationIds = getDuplicateAutoCreatedLocationIds(locations ?? []);
+        if (duplicateLocationIds.length > 0) {
+          const { error } = await sb.from(T.stockLocations).delete().in("id", duplicateLocationIds);
+          if (error) throw new Error(error.message);
+        }
+        if (!locations || locations.length === 0) {
+          const unitId = getActiveUnitId() ?? await defaultUnitId(sb, tenantId);
+          if (!unitId) throw new Error("inventory: the tenant has no unit to attach the default stock location to");
+          const { error } = await sb.from(T.stockLocations).insert({
+            tenant_id: tenantId,
+            unit_id: unitId,
+            ...DEFAULT_STOCK_LOCATION,
+            is_active: true
+          });
+          if (error) throw new Error(error.message);
+        }
+      })();
+      referenceDataPromises.set(tenantId, prepare);
+      try {
+        await prepare;
+      } finally {
+        if (referenceDataPromises.get(tenantId) === prepare) referenceDataPromises.delete(tenantId);
+      }
+    },
+    async getProducts(query) {
+      const sb = client();
+      let qb = goods(sb, PRODUCT_SELECT, { count: "exact" });
+      if (query.search) qb = qb.ilike("name", `%${query.search}%`);
+      if (query.productType) qb = qb.eq("metadata->>productType", query.productType);
+      if (query.categoryId) qb = qb.eq("category_id", query.categoryId);
+      if (query.isActive !== void 0) qb = qb.eq("is_active", query.isActive);
+      if (query.lowStockOnly) qb = qb.lte("stock", 0);
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const { data, count } = await qb.range((page - 1) * pageSize, page * pageSize - 1).order("created_at", { ascending: false });
+      const products = (data ?? []).map(toProduct);
+      await fillCoverFromShopGallery(sb, products);
+      return { data: products, total: count ?? 0 };
+    },
+    async getProductById(id) {
+      const sb = client();
+      const { data } = await sb.from(PRODUCTS_READ).select(PRODUCT_SELECT).eq("id", id).single();
+      if (!data) return null;
+      const product = toProduct(data);
+      const infos = await Promise.all(INFO_KEYS.map(async (key) => {
+        const def = INFO_TABLES[key];
+        const { data: row, error } = await sb.from(def.table).select("*").eq("product_id", id).maybeSingle();
+        return [key, error || !row ? void 0 : def.fromRow(row)];
+      }));
+      for (const [key, value] of infos) {
+        if (value) Object.assign(product, { [key]: value });
+      }
+      const { data: channels } = await sb.from(T.productSaleChannels).select("channel, price, active").eq("product_id", id);
+      if (channels?.length) {
+        product.saleChannels = channels.map((c) => ({
+          channel: c.channel,
+          price: Number(c.price) || 0,
+          active: c.active ?? true
+        }));
+      }
+      await fillCoverFromShopGallery(sb, [product]);
+      return product;
+    },
+    async createProduct(input) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      const { data, error } = await sb.from("products").insert({
+        tenant_id: tenantId,
+        name: input.name,
+        description: input.description,
+        sku: input.sku,
+        price: input.salePrice ?? 0,
+        cost: input.costPrice ?? 0,
+        is_active: true,
+        image_url: input.imageUrl,
+        category_id: input.categoryId || null,
+        metadata: {
+          productType: derivedProductType(input.classification, input.productType),
+          barcode: input.barcode,
+          brand: input.brand,
+          maxQuantity: input.maxQuantity
+        }
+      }).select().single();
+      if (error) throw new Error(error.message);
+      const productId = data.id;
+      if (input.minQuantity !== void 0 || input.maxQuantity !== void 0) {
+        await sb.from(T.productSettings).upsert(
+          { tenant_id: tenantId, product_id: productId, min_quantity: input.minQuantity ?? 0, max_quantity: input.maxQuantity ?? null },
+          { onConflict: "tenant_id,product_id,unit_id" }
+        );
+      }
+      const details = productDetailsRow(input);
+      if (details) {
+        const { error: detailsError } = await sb.from(T.productDetails).upsert({ ...details, product_id: productId, tenant_id: tenantId }, { onConflict: "product_id" });
+        if (detailsError) throw new Error(detailsError.message);
+      }
+      const failures = await saveProductInfos(sb, tenantId, productId, input);
+      if (failures.length) console.warn("[inventory] product fichas not saved:", failures);
+      return await provider.getProductById(productId) ?? toProduct(data);
+    },
+    async getProductBarcodes(productId) {
+      const { data } = await client().from(T.productBarcodes).select("id, barcode, barcode_type, description, is_primary").eq("product_id", productId).order("is_primary", { ascending: false }).order("created_at", { ascending: true });
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        barcode: r.barcode,
+        barcodeType: r.barcode_type ?? void 0,
+        description: r.description ?? void 0,
+        isPrimary: r.is_primary ?? false
+      }));
+    },
+    async addProductBarcode(productId, input) {
+      const existing = await provider.getProductBarcodes(productId);
+      const { error } = await client().from(T.productBarcodes).insert({
+        tenant_id: getActiveTenantId(),
+        product_id: productId,
+        barcode: input.barcode.trim(),
+        barcode_type: input.barcodeType || "EAN-13",
+        description: input.description || null,
+        is_primary: isNewBarcodePrimary(input, existing.length)
+      });
+      if (error) throw new Error(error.message);
+    },
+    async getProductVariants(productId) {
+      const { data } = await client().from("product_variants").select("id, name, sku, is_default, is_active, sort_order").eq("product_id", productId).order("sort_order", { ascending: true }).order("created_at", { ascending: true });
+      const rows = data ?? [];
+      if (rows.length === 0) return [];
+      const balances = await client().from("stock_balances").select("variant_id, on_hand").in("variant_id", rows.map((r) => r.id));
+      const onHand = /* @__PURE__ */ new Map();
+      for (const b of balances.data ?? []) {
+        onHand.set(b.variant_id, (onHand.get(b.variant_id) ?? 0) + (Number(b.on_hand) || 0));
+      }
+      return rows.map((r) => ({
+        id: r.id,
+        name: r.name,
+        sku: r.sku ?? void 0,
+        isDefault: !!r.is_default,
+        isActive: r.is_active !== false,
+        onHand: onHand.get(r.id) ?? 0
+      }));
+    },
+    async addProductVariant(productId, input) {
+      const existing = await provider.getProductVariants(productId);
+      const { error } = await client().from("product_variants").insert({
+        tenant_id: getActiveTenantId(),
+        product_id: productId,
+        name: input.name.trim(),
+        sku: input.sku?.trim() || null,
+        sort_order: existing.length
+      });
+      if (error) throw new Error(error.message);
+    },
+    async setProductVariantActive(id, active) {
+      const { error } = await client().from("product_variants").update({ is_active: active }).eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async removeProductBarcode(id) {
+      const { error } = await client().from(T.productBarcodes).delete().eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async setPrimaryProductBarcode(productId, id) {
+      const sb = client();
+      await sb.from(T.productBarcodes).update({ is_primary: false }).eq("product_id", productId);
+      const { error } = await sb.from(T.productBarcodes).update({ is_primary: true }).eq("id", id);
+      if (error) throw new Error(error.message);
+    },
+    async updateProduct(id, partial) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      const row = {};
+      if (partial.name !== void 0) row.name = partial.name;
+      if (partial.description !== void 0) row.description = partial.description;
+      if (partial.sku !== void 0) row.sku = partial.sku;
+      if (partial.salePrice !== void 0) row.price = partial.salePrice;
+      if (partial.costPrice !== void 0) row.cost = partial.costPrice;
+      if (partial.isActive !== void 0) row.is_active = partial.isActive;
+      if (partial.imageUrl !== void 0) row.image_url = partial.imageUrl;
+      if (partial.categoryId !== void 0) row.category_id = partial.categoryId || null;
+      const metaPatch = {};
+      if (partial.classification) metaPatch.productType = derivedProductType(partial.classification, partial.productType);
+      else if (partial.productType !== void 0) metaPatch.productType = partial.productType;
+      if (partial.barcode !== void 0) metaPatch.barcode = partial.barcode;
+      if (partial.brand !== void 0) metaPatch.brand = partial.brand;
+      if (partial.maxQuantity !== void 0) metaPatch.maxQuantity = partial.maxQuantity;
+      if (Object.keys(metaPatch).length > 0) {
+        const { data: current } = await sb.from("products").select("metadata").eq("id", id).single();
+        row.metadata = { ...current?.metadata ?? {}, ...metaPatch };
+      }
+      if (Object.keys(row).length > 0) {
+        const { error } = await sb.from("products").update(row).eq("id", id);
+        if (error) throw new Error(error.message);
+      }
+      if (partial.minQuantity !== void 0) {
+        await sb.from(T.productSettings).upsert(
+          { tenant_id: tenantId, product_id: id, min_quantity: partial.minQuantity },
+          { onConflict: "tenant_id,product_id,unit_id" }
+        );
+      }
+      const details = productDetailsRow(partial);
+      if (details) {
+        const { error: detailsError } = await sb.from(T.productDetails).upsert({ ...details, product_id: id, tenant_id: tenantId }, { onConflict: "product_id" });
+        if (detailsError) throw new Error(detailsError.message);
+      }
+      const failures = await saveProductInfos(sb, tenantId, id, partial);
+      if (failures.length) console.warn("[inventory] product fichas not saved:", failures);
+      const updated = await provider.getProductById(id);
+      if (!updated) throw new Error(`Product ${id} not found after update`);
+      return updated;
+    },
+    async uploadProductImage(productId, file) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      if (!tenantId) throw new Error("Nenhum estabelecimento ativo para enviar a foto.");
+      const problem = productImageProblem(file);
+      if (problem) throw new Error(problem);
+      const extension = file.name.split(".").pop()?.toLowerCase().replace(/[^a-z0-9]/g, "") || "jpg";
+      const path = `${tenantId}/products/${productId}/${randomId()}.${extension}`;
+      const bucket = sb.storage.from("inventory-images");
+      const { error: uploadError } = await bucket.upload(path, file, { cacheControl: "31536000", contentType: file.type, upsert: false });
+      if (uploadError) throw new Error(uploadError.message);
+      const { data: { publicUrl } } = bucket.getPublicUrl(path);
+      const { error: registerError } = await sb.rpc("inventory_register_product_image", {
+        p_product: productId,
+        p_storage_path: path,
+        p_public_url: publicUrl,
+        p_file_name: file.name,
+        p_file_size: file.size,
+        p_mime_type: file.type
+      });
+      if (registerError) {
+        await bucket.remove([path]);
+        throw new Error(registerError.message);
+      }
+      return publicUrl;
+    },
+    async getMovements(query) {
+      const sb = client();
+      let qb = sb.from("v_stock_movements").select("*", { count: "exact" });
+      if (query.productId) qb = qb.eq("product_id", query.productId);
+      if (query.movementType) {
+        qb = qb.in("movement_type", Array.isArray(query.movementType) ? query.movementType : [query.movementType]);
+      }
+      if (query.stockLocationId) qb = qb.eq("stock_location_id", query.stockLocationId);
+      if (query.dateRange) qb = qb.gte("movement_date", query.dateRange.from).lte("movement_date", query.dateRange.to);
+      if (query.search) qb = qb.ilike("product_name", `%${query.search}%`);
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const { data, count } = await qb.range((page - 1) * pageSize, page * pageSize - 1).order("movement_date", { ascending: false });
+      const movements = (data ?? []).map((r) => {
+        const movement = snakeToCamel(r);
+        movement.productName = r.product_name ?? movement.productName;
+        movement.productSku = r.product_sku ?? movement.productSku;
+        movement.stockLocationName = r.stock_location_name ?? movement.stockLocationName;
+        movement.destinationLocationName = r.destination_location_name ?? movement.destinationLocationName;
+        return movement;
+      });
+      const unnamed = /* @__PURE__ */ new Set();
+      for (const m of movements) {
+        if (m.stockLocationId && !m.stockLocationName) unnamed.add(m.stockLocationId);
+        if (m.destinationLocationId && !m.destinationLocationName) unnamed.add(m.destinationLocationId);
+      }
+      if (unnamed.size > 0) {
+        const names = await namesById(sb, T.stockLocations, [...unnamed]);
+        for (const m of movements) {
+          if (m.stockLocationId && !m.stockLocationName) m.stockLocationName = names.get(m.stockLocationId);
+          if (m.destinationLocationId && !m.destinationLocationName) m.destinationLocationName = names.get(m.destinationLocationId);
+        }
+      }
+      return { data: movements, total: count ?? 0 };
+    },
+    async createMovement(input) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      const kind = ledgerKind(input.movementType);
+      const line = {
+        product_id: input.productId,
+        quantity: signedLedgerQuantity(kind, input.quantity),
+        ...input.unitCost != null ? { unit_cost: input.unitCost } : {},
+        ...input.batchNumber ? { batch_number: input.batchNumber } : {},
+        ...input.expirationDate ? { expiration_date: input.expirationDate } : {},
+        ...input.notes ? { notes: input.notes } : {}
+      };
+      const locationId = input.stockLocationId ?? await defaultLocationId(sb, tenantId);
+      if (!locationId) throw new Error("inventory: this tenant has no stock location to record the movement against");
+      const idempotencyKey = input.idempotencyKey ?? createIdempotencyKey(`inventory:${kind}`);
+      const { data: operation, error } = kind === "in" ? await sb.rpc("inventory_receive", {
+        p_location: locationId,
+        p_lines: [line],
+        p_document: {
+          type: "manual",
+          ...input.documentNumber ? { ref: input.documentNumber } : {},
+          ...input.supplierId ? { supplier_id: input.supplierId } : {},
+          ...input.movementDate ? { date: input.movementDate } : {}
+        },
+        p_idempotency_key: idempotencyKey
+      }) : await sb.rpc("inventory_adjust", {
+        p_location: locationId,
+        p_lines: [line],
+        p_reason: input.reason ?? input.movementType,
+        p_idempotency_key: idempotencyKey
+      });
+      if (error) throw error;
+      const written = operation?.movements?.[0];
+      if (!written) throw new Error("inventory: the ledger accepted the operation but returned no movement");
+      const movement = snakeToCamel({ ...written, tenant_id: tenantId, movement_type: input.movementType });
+      try {
+        const { data: product } = await sb.from(PRODUCTS_READ).select("id, name, stock").eq("id", input.productId).single();
+        movement.productName = product?.name;
+        if (input.stockLocationId) {
+          const { data: loc } = await sb.from(T.stockLocations).select("name").eq("id", input.stockLocationId).single();
+          movement.stockLocationName = loc?.name;
+        }
+        if (input.destinationLocationId) {
+          const { data: loc } = await sb.from(T.stockLocations).select("name").eq("id", input.destinationLocationId).single();
+          movement.destinationLocationName = loc?.name;
+        }
+        if (input.supplierId) {
+          const { data: supplier } = await sb.from("people").select("name").eq("id", input.supplierId).single();
+          movement.supplierName = supplier?.name;
+        }
+      } catch {
+      }
+      return movement;
+    },
+    async reverseMovement(movementId) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      const { data: row, error } = await sb.from(T.stockMovements).select("*").eq("id", movementId).single();
+      if (error) throw new Error(error.message);
+      if (!row) throw new Error(`Movement ${movementId} not found`);
+      const movementType = row.movement_type;
+      const quantity = Number(row.quantity) || 0;
+      const slot = {
+        productId: row.product_id,
+        unitCost: row.unit_cost ?? 0,
+        batchNumber: row.batch_number ?? void 0,
+        expirationDate: row.expiration_date ?? void 0
+      };
+      const { data: deleted, error: deleteError } = await sb.from(T.stockMovements).delete().eq("id", movementId).select("id");
+      if (deleteError) throw new Error(deleteError.message);
+      if (!deleted || deleted.length === 0) throw new Error(`Movement ${movementId} could not be deleted`);
+      if (row.stock_location_id) {
+        await applyPositionDelta(sb, tenantId, slot, row.stock_location_id, reversedSourceDelta(movementType, quantity));
+        if (movementType === "transfer" && row.destination_location_id) {
+          await applyPositionDelta(sb, tenantId, slot, row.destination_location_id, -quantity);
+        }
+      }
+    },
+    async getPositions(productId) {
+      const sb = client();
+      const { data } = await sb.from(T.stockPositions).select("*").eq("product_id", productId);
+      const positions = (data ?? []).map((r) => snakeToCamel(r));
+      const names = await namesById(sb, T.stockLocations, [...new Set(positions.map((p) => p.stockLocationId).filter(Boolean))]);
+      for (const p of positions) {
+        if (p.stockLocationId) p.stockLocationName = names.get(p.stockLocationId);
+      }
+      return positions;
+    },
+    /** One line per slot; product and category narrow first so pagination never returns half pages. */
+    async getStockPanel(query) {
+      const sb = client();
+      const narrowsProducts = Boolean(query.productSearch || query.categoryId);
+      const productSelect = PRODUCT_SELECT;
+      let qp = goods(sb, productSelect);
+      if (query.productSearch) qp = qp.ilike("name", `%${query.productSearch}%`);
+      if (query.categoryId) qp = qp.eq("category_id", query.categoryId);
+      const { data: productRows } = await qp.limit(narrowsProducts ? 1e3 : 5e3);
+      const productsById = new Map((productRows ?? []).map(toProduct).map((p) => [p.id, p]));
+      if (narrowsProducts && productsById.size === 0) return [];
+      let qb = sb.from(T.stockPositions).select("*");
+      if (narrowsProducts) qb = qb.in("product_id", [...productsById.keys()]);
+      if (query.stockLocationId) qb = qb.eq("stock_location_id", query.stockLocationId);
+      if (query.batch) qb = qb.ilike("batch_number", `%${query.batch}%`);
+      const window = expiryWindow(query.expiry, /* @__PURE__ */ new Date());
+      if (window?.kind === "expired") qb = qb.lt("expiration_date", window.before);
+      else if (window?.kind === "none") qb = qb.is("expiration_date", null);
+      else if (window?.kind === "within") qb = qb.gte("expiration_date", window.from).lte("expiration_date", window.to);
+      const { data: positionRows } = await qb.limit(query.limit ?? 500);
+      const positions = positionRows ?? [];
+      const locationNames = await namesById(sb, T.stockLocations, idsOf(positions, "stock_location_id"));
+      return positions.map((r) => toPanelRow(
+        {
+          id: r.id,
+          productId: r.product_id,
+          quantity: r.quantity,
+          unitCost: r.unit_cost,
+          stockLocationId: r.stock_location_id ?? void 0,
+          batchNumber: r.batch_number ?? void 0,
+          expirationDate: r.expiration_date ?? void 0
+        },
+        productsById.get(r.product_id),
+        r.stock_location_id ? locationNames.get(r.stock_location_id) : void 0
+      )).filter((row) => hasHealth(row, query.status)).sort((a, b) => a.productName.localeCompare(b.productName, "pt-BR"));
+    },
+    async getLocations() {
+      const { data } = await client().from(T.stockLocations).select("*").eq("is_active", true).order("name");
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    async createLocation(input) {
+      const { data } = await client().from(T.stockLocations).insert({ ...camelToSnake(input), tenant_id: getActiveTenantId() }).select().single();
+      return snakeToCamel(data ?? {});
+    },
+    async getSuppliers() {
+      const { data } = await client().from("people").select("id, name, document_number, phone").eq("kind", "supplier").eq("is_active", true).order("name").limit(200);
+      return (data ?? []).map((r) => ({
+        id: r.id,
+        name: r.name,
+        documentNumber: r.document_number ?? void 0,
+        phone: r.phone ?? void 0
+      }));
+    },
+    async getCategories() {
+      const { data } = await client().from(T.productCategories).select("*").eq("kind", PRODUCT_CATEGORY_KIND).eq("is_active", true).order("name");
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    async getCountSessions() {
+      const sb = client();
+      const { data } = await sb.from(T.countSessions).select(COUNT_SESSION_SELECT).order("opened_at", { ascending: false }).limit(100);
+      const sessions = (data ?? []).map(toCountSession);
+      if (sessions.length === 0) return sessions;
+      const { data: lines } = await sb.from(T.countItems).select("session_id, system_quantity, counted_quantity").in("session_id", sessions.map((s) => s.id));
+      const bySession = /* @__PURE__ */ new Map();
+      for (const line of lines ?? []) {
+        const items = bySession.get(line.session_id) ?? [];
+        items.push({
+          systemQuantity: Number(line.system_quantity) || 0,
+          countedQuantity: line.counted_quantity == null ? void 0 : Number(line.counted_quantity)
+        });
+        bySession.set(line.session_id, items);
+      }
+      return sessions.map((session) => ({ ...session, ...countProgress(bySession.get(session.id) ?? []) }));
+    },
+    async getCountSession(id) {
+      const { data } = await client().from(T.countSessions).select(COUNT_SESSION_SELECT).eq("id", id).maybeSingle();
+      return data ? toCountSession(data) : null;
+    },
+    async getCountItems(sessionId) {
+      const { data } = await client().from(T.countItems).select("*, products(name, sku)").eq("session_id", sessionId);
+      return (data ?? []).map(toCountItem).sort((a, b) => (a.productName ?? "").localeCompare(b.productName ?? ""));
+    },
+    async openCountSession(input) {
+      const { data, error } = await client().rpc("inventory_open_count_session", {
+        p_stock_location_id: input.stockLocationId,
+        p_category_id: input.categoryId ?? null,
+        p_reference: input.reference ?? null,
+        p_blind: input.blind ?? true,
+        p_notes: input.notes ?? null
+      });
+      if (error) throw new Error(error.message);
+      const session = await provider.getCountSession(data);
+      if (!session) throw new Error("Count session could not be read after opening");
+      return session;
+    },
+    async saveCountEntry(itemId, quantity, notes) {
+      const sb = client();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const row = { counted_quantity: quantity, counted_at: quantity == null ? null : now, updated_at: now };
+      if (notes !== void 0) row.notes = notes || null;
+      const { data, error } = await sb.from(T.countItems).update(row).eq("id", itemId).select("*, products(name, sku)").single();
+      if (error) throw new Error(error.message);
+      await sb.from(T.countSessions).update({ status: "counting", updated_at: now }).eq("id", data.session_id).eq("status", "open");
+      return toCountItem(data);
+    },
+    async closeCountSession(sessionId, reason) {
+      const { data, error } = await client().rpc("inventory_close_count_session", { p_session_id: sessionId, p_reason: reason ?? null });
+      if (error) throw new Error(error.message);
+      const result = data ?? {};
+      if (result.ok === false) throw new Error(result.error ?? "Could not close the count");
+      return {
+        sessionId,
+        adjustmentsCreated: Number(result.adjustments_created) || 0,
+        alreadyClosed: result.already_closed === true
+      };
+    },
+    async cancelCountSession(sessionId) {
+      const { error } = await client().from(T.countSessions).update({ status: "cancelled", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", sessionId).neq("status", "closed");
+      if (error) throw new Error(error.message);
+      const session = await provider.getCountSession(sessionId);
+      if (!session) throw new Error(`Count session ${sessionId} not found`);
+      return session;
+    },
+    async getRecipes() {
+      const sb = client();
+      const { data, error } = await sb.from(T.recipes).select("*").eq("is_active", true).order("name");
+      fail("Could not read recipes", error);
+      return hydrateRecipes(sb, data ?? []);
+    },
+    async getRecipeById(id) {
+      const sb = client();
+      const { data, error } = await sb.from(T.recipes).select("*").eq("id", id).maybeSingle();
+      fail("Could not read recipe", error);
+      if (!data) return null;
+      return (await hydrateRecipes(sb, [data]))[0] ?? null;
+    },
+    async getRecipeIngredients(recipeId) {
+      const sb = client();
+      const { data, error } = await sb.from(T.recipeIngredients).select("*").eq("recipe_id", recipeId).order("display_order");
+      fail("Could not read recipe ingredients", error);
+      return hydrateRecipeIngredients(sb, data ?? [], true);
+    },
+    async getAllRecipeIngredients() {
+      const sb = client();
+      const { data, error } = await sb.from(T.recipeIngredients).select("*").order("display_order");
+      fail("Could not read recipe ingredients", error);
+      return hydrateRecipeIngredients(sb, data ?? [], false);
+    },
+    async getRecipeGroups(recipeId) {
+      const { data, error } = await client().from(T.recipeGroups).select("*").eq("recipe_id", recipeId).order("display_order");
+      fail("Could not read recipe groups", error);
+      return (data ?? []).map((r) => snakeToCamel(r));
+    },
+    async createRecipe(input) {
+      const sb = client();
+      const tenantId = getActiveTenantId();
+      const { ingredients, ...recipeData } = input;
+      const { data: recipe, error: recipeError } = await sb.from(T.recipes).insert({ ...camelToSnake(recipeData), tenant_id: tenantId }).select().single();
+      fail("Could not create recipe", recipeError);
+      if (!recipe) throw new Error("Could not create recipe: Supabase returned no row");
+      if (ingredients.length > 0) {
+        const { error: ingredientsError } = await sb.from(T.recipeIngredients).insert(
+          ingredients.map((ing) => ({ ...camelToSnake(ing), recipe_id: recipe.id, tenant_id: tenantId }))
+        );
+        if (ingredientsError) {
+          await sb.from(T.recipes).delete().eq("id", recipe.id);
+          fail("Could not create recipe ingredients", ingredientsError);
+        }
+      }
+      if (recipeData.productId) {
+        const { error: retireError } = await sb.from(T.recipes).update({ is_active: false }).eq("product_id", recipeData.productId).eq("is_active", true).neq("id", recipe.id);
+        if (retireError) console.warn("Could not retire previous recipes", retireError.message);
+      }
+      return snakeToCamel(recipe);
+    },
+    async updateRecipe(id, patch) {
+      const row = {};
+      if (patch.name !== void 0) row.name = patch.name;
+      if (patch.description !== void 0) row.description = patch.description;
+      if (patch.productId !== void 0) row.product_id = patch.productId || null;
+      if (patch.yieldQuantity !== void 0) row.yield_quantity = patch.yieldQuantity;
+      if (patch.preparationTimeMinutes !== void 0) row.preparation_time_minutes = patch.preparationTimeMinutes;
+      if (patch.instructions !== void 0) row.instructions = patch.instructions;
+      if (patch.isActive !== void 0) row.is_active = patch.isActive;
+      if (patch.metadata !== void 0) row.metadata = patch.metadata;
+      if (Object.keys(row).length > 0) {
+        row.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        const { error } = await client().from(T.recipes).update(row).eq("id", id);
+        if (error) throw new Error(error.message);
+      }
+      const updated = await provider.getRecipeById(id);
+      if (!updated) throw new Error(`Recipe ${id} not found after update`);
+      return updated;
+    },
+    async addRecipeIngredient(recipeId, input) {
+      const sb = client();
+      const { data, error } = await sb.from(T.recipeIngredients).insert({ ...camelToSnake(input), recipe_id: recipeId, tenant_id: getActiveTenantId() }).select("*").single();
+      fail("Could not add recipe ingredient", error);
+      if (!data) throw new Error("Could not add recipe ingredient: Supabase returned no row");
+      return (await hydrateRecipeIngredients(sb, [data], true))[0];
+    },
+    // --- Ficha Técnica -----------------------------------------------------
+    async getRecipeExport() {
+      const { pub } = getClients();
+      const select = [
+        "id, name, price",
+        `details:${T.productDetails}!inner(is_produced)`,
+        `category:${T.productCategories}!category_id(name)`,
+        `recipes:${T.recipes}!product_id(id, yield_quantity, yield_unit_id, preparation_time_minutes, updated_at, is_active, groups:${T.recipeGroups}!recipe_id(id, name, display_order), lines:${T.recipeIngredients}!recipe_id(quantity, unit_id, group_id, display_order, ingredient:products!product_id(id, name, sku, cost)))`
+      ].join(", ");
+      const [rows, { data: units }] = await Promise.all([
+        selectAllRows((from, to) => pub.from("products").select(select).eq("is_active", true).eq(`${T.productDetails}.is_produced`, true).order("id").range(from, to), "Could not read recipes for export"),
+        pub.from(T.measurementUnits).select("id, abbreviation")
+      ]);
+      const abbr = new Map((units ?? []).map((u) => [u.id, u.abbreviation]));
+      const byOrder = (a, b) => (a.display_order ?? 0) - (b.display_order ?? 0);
+      return rows.sort((a, b) => String(a.name ?? "").localeCompare(String(b.name ?? ""))).map((p) => {
+        const r = (p.recipes ?? []).filter((x) => x.is_active).sort((a, b) => String(b.updated_at ?? "").localeCompare(String(a.updated_at ?? "")))[0];
+        const toLine = (l) => ({
+          ingredientId: l.ingredient?.id ?? "",
+          ingredientName: l.ingredient?.name ?? "\u2014",
+          ingredientSku: l.ingredient?.sku ?? void 0,
+          unitAbbr: l.unit_id ? abbr.get(l.unit_id) : void 0,
+          quantity: Number(l.quantity) || 0,
+          unitCost: Number(l.ingredient?.cost) || 0
+        });
+        const lines = [...r?.lines ?? []].sort(byOrder);
+        const groups = [...r?.groups ?? []].sort(byOrder).map((g) => ({
+          name: g.name ?? "",
+          lines: lines.filter((l) => l.group_id === g.id).map(toLine)
+        }));
+        const loose = lines.filter((l) => !l.group_id || !groups.length);
+        if (loose.length) groups.push({ name: "", lines: loose.map(toLine) });
+        return {
+          productId: p.id,
+          productName: p.name,
+          categoryName: p.category?.name ?? void 0,
+          salePrice: Number(p.price) || 0,
+          hasSheet: Boolean(r),
+          yieldQuantity: r?.yield_quantity != null ? Number(r.yield_quantity) : void 0,
+          yieldUnitAbbr: r?.yield_unit_id ? abbr.get(r.yield_unit_id) : void 0,
+          preparationTimeMinutes: r?.preparation_time_minutes ?? void 0,
+          groups: groups.filter((g) => g.lines.length)
+        };
+      });
+    },
+    async getRecipeListRow(productId) {
+      const rows = await recipeListInOneQuery(getClients().pub, productId);
+      if (!rows) throw new Error("Could not read recipe list row");
+      return rows[0] ?? null;
+    },
+    async getRecipeList() {
+      const { pub } = getClients();
+      const nested = await recipeListInOneQuery(pub);
+      if (nested) return nested;
+      const produced = await selectAllRows((from, to) => pub.from(T.productDetails).select("product_id, is_for_sale, is_intermediate").eq("is_produced", true).order("product_id").range(from, to), "Could not read produced products");
+      const ids = produced.map((r) => r.product_id);
+      const flagsOf = new Map(produced.map((r) => [r.product_id, r]));
+      if (ids.length === 0) return [];
+      const [products, recipes] = await Promise.all([
+        selectInChunks(ids, (chunk, from, to) => pub.from("products").select("id, name, price, image_url, is_active, category_id").in("id", chunk).eq("is_active", true).order("id").range(from, to), "Could not read products"),
+        selectInChunks(ids, (chunk, from, to) => pub.from(T.recipes).select("id, product_id, description, yield_quantity, yield_unit_id, preparation_time_minutes, updated_at").in("product_id", chunk).eq("is_active", true).order("id").range(from, to), "Could not read recipes")
+      ]);
+      products.sort((a, b) => String(a.name ?? "").localeCompare(String(b.name ?? "")));
+      recipes.sort((a, b) => String(b.updated_at ?? "").localeCompare(String(a.updated_at ?? "")));
+      const recipeByProduct = /* @__PURE__ */ new Map();
+      for (const r of recipes) if (!recipeByProduct.has(r.product_id)) recipeByProduct.set(r.product_id, r);
+      const recipeIds = [...recipeByProduct.values()].map((r) => r.id);
+      const unitIds = [...new Set([...recipeByProduct.values()].map((r) => r.yield_unit_id).filter(Boolean))];
+      const categoryIds = [...new Set(products.map((p) => p.category_id).filter(Boolean))];
+      const [lines, { data: units }, { data: categories }] = await Promise.all([
+        selectInChunks(
+          recipeIds,
+          (chunk, from, to) => pub.from(T.recipeIngredients).select("id, recipe_id, product_id, quantity").in("recipe_id", chunk).order("id").range(from, to),
+          "Could not read recipe lines"
+        ),
+        unitIds.length ? pub.from(T.measurementUnits).select("id, abbreviation").in("id", unitIds) : Promise.resolve({ data: [] }),
+        categoryIds.length ? pub.from(T.productCategories).select("id, name").in("id", categoryIds) : Promise.resolve({ data: [] })
+      ]);
+      const categoryName = new Map((categories ?? []).map((c) => [c.id, c.name]));
+      const costIds = [...new Set(lines.map((l) => l.product_id))];
+      const costRows = await selectInChunks(costIds, (chunk, from, to) => pub.from("products").select("id, cost").in("id", chunk).order("id").range(from, to), "Could not read ingredient costs");
+      const costOf = new Map((costRows ?? []).map((p) => [p.id, Number(p.cost) || 0]));
+      const unitAbbr = new Map((units ?? []).map((u) => [u.id, u.abbreviation]));
+      const count = /* @__PURE__ */ new Map();
+      const cost = /* @__PURE__ */ new Map();
+      for (const l of lines ?? []) {
+        count.set(l.recipe_id, (count.get(l.recipe_id) ?? 0) + 1);
+        cost.set(l.recipe_id, (cost.get(l.recipe_id) ?? 0) + (Number(l.quantity) || 0) * (costOf.get(l.product_id) ?? 0));
+      }
+      return (products ?? []).map((p) => {
+        const r = recipeByProduct.get(p.id);
+        return {
+          productId: p.id,
+          productName: p.name,
+          imageUrl: p.image_url ?? void 0,
+          categoryName: p.category_id ? categoryName.get(p.category_id) : void 0,
+          isForSale: Boolean(flagsOf.get(p.id)?.is_for_sale),
+          isIntermediate: Boolean(flagsOf.get(p.id)?.is_intermediate),
+          recipeId: r?.id,
+          description: r?.description ?? void 0,
+          ingredientCount: r ? count.get(r.id) ?? 0 : 0,
+          yieldQuantity: r?.yield_quantity != null ? Number(r.yield_quantity) : void 0,
+          yieldUnitAbbr: r?.yield_unit_id ? unitAbbr.get(r.yield_unit_id) : void 0,
+          preparationTimeMinutes: r?.preparation_time_minutes ?? void 0,
+          cost: r ? cost.get(r.id) ?? 0 : 0,
+          salePrice: Number(p.price) || 0
+        };
+      });
+    },
+    async searchRecipeCandidates(query, kind) {
+      const { pub } = getClients();
+      let flags = pub.from(T.productDetails).select("product_id, is_for_sale, is_intermediate, is_produced, category_id");
+      flags = kind === "sale" ? flags.eq("is_for_sale", true) : kind === "intermediate" ? flags.eq("is_intermediate", true) : flags.or("is_for_sale.eq.true,is_intermediate.eq.true,is_produced.eq.true");
+      const { data: details, error: dErr } = await flags;
+      fail("Could not read products", dErr);
+      const byId = new Map((details ?? []).map((d) => [d.product_id, d]));
+      if (byId.size === 0) return [];
+      let q = pub.from("products").select("id, name, image_url, price").in("id", [...byId.keys()]).eq("is_active", true).order("name").limit(60);
+      if (query.trim()) q = q.ilike("name", `%${query.trim()}%`);
+      const { data: products, error } = await q;
+      fail("Could not search products", error);
+      const ids = (products ?? []).map((p) => p.id);
+      const catIds = [...new Set((products ?? []).map((p) => byId.get(p.id)?.category_id).filter(Boolean))];
+      const [{ data: recipes }, { data: cats }] = await Promise.all([
+        ids.length ? pub.from(T.recipes).select("product_id").in("product_id", ids).eq("is_active", true) : Promise.resolve({ data: [] }),
+        catIds.length ? pub.from(T.productCategories).select("id, name").in("id", catIds) : Promise.resolve({ data: [] })
+      ]);
+      const withRecipe = new Set((recipes ?? []).map((r) => r.product_id));
+      const catName = new Map((cats ?? []).map((c) => [c.id, c.name]));
+      return (products ?? []).map((p) => {
+        const d = byId.get(p.id);
+        return {
+          productId: p.id,
+          name: p.name,
+          imageUrl: p.image_url ?? void 0,
+          categoryName: d?.category_id ? catName.get(d.category_id) : void 0,
+          salePrice: Number(p.price) || 0,
+          kind: d?.is_for_sale ? "sale" : d?.is_intermediate ? "intermediate" : "produced",
+          hasRecipe: withRecipe.has(p.id)
+        };
+      });
+    },
+    async getRecipeSheet(productId) {
+      const { pub } = getClients();
+      const recipeQuery = (select) => pub.from(T.recipes).select(select).eq("product_id", productId).eq("is_active", true).order("updated_at", { ascending: false }).limit(1).maybeSingle();
+      const nested = await recipeQuery(`*, groups:${T.recipeGroups}(*), lines:${T.recipeIngredients}(*), outputs:plg_inventory_recipe_outputs(*)`);
+      let r = nested.data;
+      let groups;
+      let lines;
+      let outputs;
+      if (!nested.error) {
+        if (!r) return null;
+        const byOrder = (a, b) => (a.display_order ?? 0) - (b.display_order ?? 0);
+        groups = [...r.groups ?? []].sort(byOrder);
+        lines = [...r.lines ?? []].sort(byOrder);
+        outputs = [...r.outputs ?? []].sort(byOrder).map(mapRecipeOutput);
+      } else {
+        const plain = await recipeQuery("*");
+        fail("Could not read recipe", plain.error);
+        r = plain.data;
+        if (!r) return null;
+        const [{ data: g, error: gErr }, { data: l, error: lErr }, o] = await Promise.all([
+          pub.from(T.recipeGroups).select("*").eq("recipe_id", r.id).order("display_order"),
+          pub.from(T.recipeIngredients).select("*").eq("recipe_id", r.id).order("display_order"),
+          provider.getRecipeOutputs(r.id)
+        ]);
+        fail("Could not read recipe groups", gErr);
+        fail("Could not read recipe lines", lErr);
+        groups = g;
+        lines = l;
+        outputs = o;
+      }
+      const toLine = (l) => ({
+        productId: l.product_id,
+        quantity: Number(l.quantity) || 0,
+        unitId: l.unit_id ?? void 0,
+        displayUnitId: l.display_unit_id ?? void 0,
+        notes: l.notes ?? void 0
+      });
+      const sheetGroups = (groups ?? []).map((g) => ({
+        name: g.name ?? "",
+        stationId: g.station_id ?? void 0,
+        preparationNotes: g.preparation_notes ?? void 0,
+        estimatedMinutes: g.estimated_minutes ?? void 0,
+        ingredients: (lines ?? []).filter((l) => l.group_id === g.id).map(toLine)
+      }));
+      const orphans = (lines ?? []).filter((l) => !l.group_id);
+      if (orphans.length > 0) sheetGroups.push({ name: "Componentes", stationId: void 0, preparationNotes: void 0, estimatedMinutes: void 0, ingredients: orphans.map(toLine) });
+      return {
+        id: r.id,
+        productId: r.product_id,
+        name: r.name ?? "",
+        description: r.description ?? void 0,
+        yieldQuantity: Number(r.yield_quantity) || 1,
+        yieldUnitId: r.yield_unit_id ?? void 0,
+        yieldMode: r.yield_mode === "batch" ? "batch" : "portion",
+        preparationTimeMinutes: r.preparation_time_minutes ?? void 0,
+        instructions: r.instructions ?? void 0,
+        groups: sheetGroups,
+        outputs
+      };
+    },
+    async getRecipeOutputs(recipeId) {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_inventory_recipe_outputs").select("*").eq("recipe_id", recipeId).order("display_order");
+      fail("Could not read recipe outputs", error);
+      return (data ?? []).map(mapRecipeOutput);
+    },
+    async getMeasurementUnitList() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from(T.measurementUnits).select("id, name, abbreviation").eq("is_active", true).order("name");
+      fail("Could not read measurement units", error);
+      return data ?? [];
+    },
+    async getProductionStations() {
+      const { pub } = getClients();
+      const { data, error } = await pub.from("plg_inventory_production_stations").select("id, name, unit_id").eq("is_active", true).order("sort_order").order("name");
+      fail("Could not read production stations", error);
+      return (data ?? []).map((s) => ({ id: s.id, name: s.name, unitId: s.unit_id ?? void 0 }));
+    },
+    async getIngredientInfo(productIds) {
+      return readIngredientInfo(getClients().pub, productIds);
+    },
+    async searchIngredients(query) {
+      const { pub } = getClients();
+      const { data: flagged, error: flagError } = await pub.from(T.productDetails).select("product_id").or("is_ingredient.eq.true,is_intermediate.eq.true");
+      fail("Could not read ingredients", flagError);
+      const ids = (flagged ?? []).map((r) => r.product_id);
+      if (ids.length === 0) return [];
+      let q = pub.from("products").select("id").in("id", ids).eq("is_active", true).order("name").limit(25);
+      if (query.trim()) q = q.ilike("name", `%${query.trim()}%`);
+      const { data, error } = await q;
+      fail("Could not search ingredients", error);
+      const info = await readIngredientInfo(pub, (data ?? []).map((p) => p.id));
+      return info.sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+    },
+    async saveRecipeSheet(sheet, unitCost) {
+      const { pub } = getClients();
+      const payload = {
+        id: sheet.id ?? null,
+        productId: sheet.productId,
+        name: sheet.name,
+        description: sheet.description ?? "",
+        yieldQuantity: sheet.yieldQuantity,
+        yieldUnitId: sheet.yieldUnitId ?? "",
+        yieldMode: sheet.yieldMode,
+        preparationTimeMinutes: sheet.preparationTimeMinutes ?? "",
+        instructions: sheet.instructions ?? "",
+        unitId: getActiveUnitId() ?? "",
+        unitCost: unitCost ?? "",
+        groups: sheet.groups,
+        outputs: sheet.outputs
+      };
+      const { data, error } = await pub.rpc("inventory_save_recipe", { p_recipe: payload });
+      if (error) throw new Error(error.message);
+      return data;
+    },
+    async setIngredientCost(productId, cost) {
+      const { pub } = getClients();
+      const { error } = await pub.from("products").update({ cost }).eq("id", productId);
+      if (error) throw new Error(error.message);
+      const { error: detailError } = await pub.from(T.productDetails).update({ avg_purchase_price: cost, avg_purchase_price_updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("product_id", productId);
+      if (detailError) throw new Error(detailError.message);
+    },
+    async suggestRecipe(input) {
+      return invokeFunction(getClients().pub, "inventory-recipe-ai", { action: "suggest-recipe", ...input });
+    },
+    async suggestIngredientCost(productId, name) {
+      return invokeFunction(getClients().pub, "inventory-recipe-ai", { action: "suggest-cost", productId, name });
+    },
+    async uploadAiReference(file) {
+      const { core } = getClients();
+      const tenantId = getActiveTenantId();
+      if (!tenantId) throw new Error("Nenhum estabelecimento ativo para enviar a foto.");
+      if (!file.type.startsWith("image/")) throw new Error("Selecione um arquivo de imagem.");
+      const extension = file.name.split(".").pop()?.toLowerCase().replace(/[^a-z0-9]/g, "") || "jpg";
+      const path = `${tenantId}/ai-references/${crypto.randomUUID()}.${extension}`;
+      const bucket = core.storage.from("inventory-images");
+      const { error } = await bucket.upload(path, file, { contentType: file.type, upsert: false });
+      if (error) throw new Error(error.message);
+      return bucket.getPublicUrl(path).data.publicUrl;
+    },
+    async generateProductImage(input) {
+      const res = await invokeFunction(getClients().pub, "inventory-recipe-ai", { action: "generate-image", ...input });
+      if (!res.imageBase64) throw new Error("A IA n\xE3o devolveu imagem.");
+      return res.imageBase64;
+    },
+    // --- Complementos ------------------------------------------------------
+    // Written to the menu's modifier tables, linked to the product: the same
+    // rows the menu reads. Each product owns its groups, as in V1.
+    async getProductOptionGroups(productId) {
+      const { pub } = getClients();
+      const { data: links, error } = await pub.from("plg_menu_item_modifier_groups").select("group_id, sort_order").eq("product_id", productId).order("sort_order");
+      fail("Could not read option groups", error);
+      const groupIds = (links ?? []).map((l) => l.group_id);
+      if (groupIds.length === 0) return [];
+      const [{ data: groups, error: gErr }, { data: items, error: iErr }] = await Promise.all([
+        pub.from("plg_menu_modifier_groups").select("*").in("id", groupIds),
+        pub.from("plg_menu_modifiers").select("*").in("group_id", groupIds).order("sort_order")
+      ]);
+      fail("Could not read option groups", gErr);
+      fail("Could not read options", iErr);
+      const byId = new Map((groups ?? []).map((g) => [g.id, g]));
+      return groupIds.map((id) => byId.get(id)).filter(Boolean).map((g) => ({
+        id: g.id,
+        name: g.name,
+        isActive: g.is_active !== false,
+        isRequired: !!g.is_required,
+        minSelections: Number(g.min_selections) || 0,
+        maxSelections: Number(g.max_selections) || 1,
+        items: (items ?? []).filter((i) => i.group_id === g.id).map((i) => ({
+          id: i.id,
+          name: i.name,
+          priceAdjustment: Number(i.price_adjustment) || 0,
+          isActive: i.is_active !== false
+        }))
+      }));
+    },
+    async saveProductOptionGroups(productId, groups) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("menu_save_product_option_groups", {
+        p_product: productId,
+        p_groups: groups.map((g, gi) => ({
+          id: g.id ?? null,
+          name: g.name.trim(),
+          isActive: g.isActive,
+          isRequired: g.isRequired,
+          minSelections: g.minSelections,
+          maxSelections: g.maxSelections,
+          sortOrder: gi,
+          items: g.items.map((i, ii) => ({
+            id: i.id ?? null,
+            name: i.name.trim(),
+            priceAdjustment: i.priceAdjustment,
+            isActive: i.isActive,
+            sortOrder: ii
+          }))
+        }))
+      });
+      if (error) throw new Error(error.message);
+      return provider.getProductOptionGroups(productId);
+    },
+    async consumeRecipeForSource(input) {
+      assertConsumable(input);
+      const sb = client();
+      const idempotencyKey = consumptionKey(input.sourceType, input.sourceId);
+      const { data: recipeRow, error: recipeError } = await sb.from(T.recipes).select("*").eq("product_id", input.productId).eq("is_active", true).order("updated_at", { ascending: false }).limit(1).maybeSingle();
+      if (recipeError) throw new Error(recipeError.message);
+      if (!recipeRow) return skippedConsumption(input, "no_active_recipe");
+      const recipe = toRecipe(recipeRow);
+      const { data: ingredientRows, error: ingredientError } = await sb.from(T.recipeIngredients).select("*").eq("recipe_id", recipe.id).order("display_order");
+      if (ingredientError) throw new Error(ingredientError.message);
+      const rows = ingredientRows ?? [];
+      const productIds = [...new Set(rows.map((row) => String(row.product_id)))];
+      const [{ data: settingsRows, error: settingsError }, { data: detailRows, error: detailsError }] = await Promise.all([
+        sb.from(T.productSettings).select("product_id, unit_id, measurement_unit_id, default_location_id").in("product_id", productIds).is("unit_id", null),
+        sb.from(T.productDetails).select("product_id, measurement_unit_id, default_location_id").in("product_id", productIds)
+      ]);
+      if (settingsError) throw new Error(settingsError.message);
+      if (detailsError) throw new Error(detailsError.message);
+      const settingsByProduct = new Map((settingsRows ?? []).map((row) => [String(row.product_id), row]));
+      const detailsByProduct = new Map((detailRows ?? []).map((row) => [String(row.product_id), row]));
+      const lines = explodeRecipe(recipe, rows.map((row) => {
+        const productId = String(row.product_id);
+        const settings = settingsByProduct.get(productId);
+        const details = detailsByProduct.get(productId);
+        return {
+          productId,
+          quantity: Number(row.quantity),
+          locationId: settings?.default_location_id ?? details?.default_location_id,
+          unitId: row.unit_id ?? settings?.measurement_unit_id ?? details?.measurement_unit_id ?? void 0
+        };
+      }), input.quantity);
+      const { error: reserveError } = await sb.rpc("inventory_reserve", {
+        p_source_type: input.sourceType,
+        p_source_id: input.sourceId,
+        p_lines: lines.map((line) => ({
+          product_id: line.productId,
+          location_id: line.locationId,
+          quantity: line.quantity,
+          ...line.unitId ? { measurement_unit_id: line.unitId } : {},
+          notes: `Recipe ${recipe.id}`
+        })),
+        p_idempotency_key: idempotencyKey
+      });
+      if (reserveError) throw new Error(reserveError.message);
+      const { error: confirmError } = await sb.rpc("inventory_confirm", { p_idempotency_key: idempotencyKey });
+      if (confirmError) throw new Error(confirmError.message);
+      return {
+        sourceType: input.sourceType,
+        sourceId: input.sourceId,
+        idempotencyKey,
+        status: "confirmed",
+        recipeId: recipe.id,
+        lineCount: lines.length
+      };
+    },
+    async reverseRecipeConsumption(input) {
+      assertReversible(input);
+      const sb = client();
+      const idempotencyKey = consumptionKey(input.sourceType, input.sourceId);
+      const { count, error: lookupError } = await sb.from(T.reservations).select("id", { count: "exact", head: true }).eq("source_type", input.sourceType).eq("source_id", input.sourceId);
+      if (lookupError) throw new Error(lookupError.message);
+      if (!count) return skippedConsumption(input, "nothing_to_reverse");
+      const { data, error } = await sb.rpc("inventory_reverse", { p_idempotency_key: idempotencyKey, p_reason: input.reason });
+      if (error) throw new Error(error.message);
+      return {
+        sourceType: input.sourceType,
+        sourceId: input.sourceId,
+        idempotencyKey,
+        status: "reversed",
+        lineCount: Number(data?.reversed_lines) || count
+      };
+    },
+    async getUsageAudit(query) {
+      const sb = client();
+      let qb = sb.from(USAGE_AUDIT_READ).select("*", { count: "planned" });
+      if (query.divergentOnly) qb = qb.not("variance", "is", null).neq("variance", 0);
+      if (query.pendingOnly) qb = qb.eq("is_corrected", false);
+      const unitId = getActiveUnitId();
+      if (unitId) qb = qb.eq("unit_id", unitId);
+      if (query.from) qb = qb.gte("used_at", query.from);
+      if (query.search) {
+        const like = `%${query.search.replace(/[(),]/g, " ").trim()}%`;
+        qb = qb.or(`product_name.ilike.${like},performed_by_name.ilike.${like},customer_name.ilike.${like},item_name.ilike.${like}`);
+      }
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const { data, count, error } = await qb.range((page - 1) * pageSize, page * pageSize - 1).order("used_at", { ascending: false });
+      if (error) throw new Error(error.message);
+      const rows = data ?? [];
+      const personIds = [...new Set(rows.flatMap((r) => [r.performed_by_id, r.customer_id]).filter(Boolean))];
+      const names = await namesById(sb, "people", personIds);
+      return { data: rows.map((r) => toUsageAuditEntry(r, names)), total: count ?? 0 };
+    },
+    async correctUsage(input) {
+      const { error } = await client().rpc("inventory_correct_usage", {
+        p_item_id: input.itemId,
+        p_product_id: input.productId,
+        p_quantity: input.quantity,
+        p_reason: input.reason
+      });
+      if (error) throw new Error(error.message);
+    },
+    async approveUsageBatch(input) {
+      const { data, error } = await client().rpc("inventory_approve_usage_batch", {
+        p_lines: input.lines.map((l) => ({ item_id: l.itemId, product_id: l.productId })),
+        p_post: input.post,
+        p_reason: input.reason ?? null
+      });
+      if (error) throw new Error(error.message);
+      const r = data ?? {};
+      return {
+        linesApproved: Number(r.lines_approved ?? 0),
+        linesPosted: Number(r.lines_posted ?? 0),
+        linesSkipped: Number(r.lines_skipped ?? 0),
+        linesNoStock: Number(r.lines_no_stock ?? 0),
+        missing: (r.missing ?? []).map((m) => ({
+          product: String(m.product),
+          needed: Number(m.needed ?? 0),
+          available: Number(m.available ?? 0)
+        }))
+      };
+    },
+    async correctUsageBatch(input) {
+      const { data, error } = await client().rpc("inventory_correct_usage_batch", {
+        p_reason: input.reason,
+        // The RPC stores the order as line_no, so the batch reads back as it was typed.
+        p_lines: input.lines.map((l) => ({ item_id: l.itemId, product_id: l.productId, quantity: l.quantity }))
+      });
+      if (error) throw new Error(error.message);
+      const r = data ?? {};
+      return {
+        operationId: r.operation_id ?? void 0,
+        linesApplied: Number(r.lines_applied ?? 0),
+        linesUnchanged: Number(r.lines_unchanged ?? 0)
+      };
+    },
+    async getSummary() {
+      const sb = client();
+      const { data: products } = await goods(sb, "stock, min_stock, price, is_active").eq("is_active", true);
+      const { data: movements } = await sb.from(T.stockMovements).select("movement_type").gte("movement_date", recentMovementCutoff(/* @__PURE__ */ new Date()));
+      return summarizeStock(
+        (products ?? []).map((p) => ({ quantity: p.stock ?? 0, minQuantity: p.min_stock ?? 0, unitValue: p.price ?? 0 })),
+        (movements ?? []).map((m) => m.movement_type)
+      );
+    },
+    async getRestockList(limit = 50) {
+      const sb = client();
+      const { data } = await goods(sb, "id, name, category_id, stock, min_stock, unit").eq("is_active", true);
+      const needs = pickRestock((data ?? []).map((r) => ({
+        productId: r.id,
+        name: r.name,
+        categoryId: r.category_id,
+        currentQuantity: Number(r.stock) || 0,
+        minQuantity: Number(r.min_stock) || 0,
+        unit: r.unit ?? void 0
+      })), limit);
+      const names = await namesById(sb, "categories", [...new Set(needs.map((n) => n.categoryId).filter(Boolean))]);
+      return needs.map(({ categoryId, ...rest }) => ({ ...rest, categoryName: categoryId ? names.get(categoryId) : void 0 }));
+    },
+    async getCategoryDistribution() {
+      const sb = client();
+      const { data } = await goods(sb, "category_id").eq("is_active", true);
+      const categoryIds = (data ?? []).map((r) => r.category_id);
+      const names = await namesById(sb, "categories", [...new Set(categoryIds.filter(Boolean))]);
+      return categoryCounts(categoryIds, (id) => names.get(id));
+    }
+  };
+  announceWrites(provider);
+  return provider;
+}
+
+export { createSupabaseInventoryProvider };
+//# sourceMappingURL=chunk-2FXO63QV.js.map
+//# sourceMappingURL=chunk-2FXO63QV.js.map