@fayz-ai/shop 0.9.0-next.1 → 0.10.0

package/dist/chunk-XERLK5LD.js

@@ -0,0 +1,1415 @@
+import { getShopTenantId } from './chunk-KLDS7IPU.js';
+import { Registry, getSupabaseClientOptional } from '@fayz-ai/core';
+
+// src/inventory/stock-store.ts
+var StockMovementError = class extends Error {
+  constructor(message, input) {
+    super(message);
+    this.input = input;
+    this.name = "StockMovementError";
+  }
+};
+function stockBalanceKey(variantId, locationId, lotId) {
+  return `${variantId}::${locationId}::${lotId ?? "-"}`;
+}
+function replayStockLedger(movements, reservations = []) {
+  const balances = /* @__PURE__ */ new Map();
+  for (const movement of movements) {
+    if (!movement.variantId) continue;
+    const key = stockBalanceKey(movement.variantId, movement.locationId, movement.lotId);
+    const row = balances.get(key) ?? {
+      tenantId: movement.tenantId,
+      variantId: movement.variantId,
+      locationId: movement.locationId,
+      lotId: movement.lotId,
+      onHand: 0,
+      reserved: 0
+    };
+    row.onHand += movement.quantity;
+    balances.set(key, row);
+  }
+  for (const reservation of reservations) {
+    if (reservation.status !== "held") continue;
+    const key = stockBalanceKey(reservation.variantId, reservation.locationId, reservation.lotId);
+    const row = balances.get(key);
+    if (row) {
+      row.reserved += reservation.quantity;
+      continue;
+    }
+    balances.set(key, {
+      tenantId: "",
+      variantId: reservation.variantId,
+      locationId: reservation.locationId,
+      lotId: reservation.lotId,
+      onHand: 0,
+      reserved: reservation.quantity
+    });
+  }
+  return balances;
+}
+function mirroredInventoryCount(balances, sellableLocationIds) {
+  let total = 0;
+  for (const balance of balances) {
+    if (!sellableLocationIds.has(balance.locationId)) continue;
+    total += Math.max(balance.onHand - balance.reserved, 0);
+  }
+  return Math.max(total, 0);
+}
+var storeOverrides = /* @__PURE__ */ new Map();
+function registerStockStore(tenantId, store) {
+  storeOverrides.set(tenantId, store);
+}
+function getRegisteredStockStore(tenantId) {
+  return storeOverrides.get(tenantId);
+}
+function resolveStockStore(tenantId, fallback) {
+  return storeOverrides.get(tenantId) ?? fallback();
+}
+function clearStockStores() {
+  storeOverrides.clear();
+}
+
+// src/inventory/stock-types.ts
+var STOCK_TRACKING_MODES = ["none", "quantity", "lot", "serial"];
+var DEFAULT_STOCK_TRACKING = "quantity";
+var STOCK_LOCATION_KINDS = ["store", "warehouse", "transit", "virtual"];
+var STOCK_RESERVATION_STATUSES = ["held", "consumed", "released"];
+var STOCK_LOT_STATUSES = ["active", "quarantined", "expired", "consumed"];
+var STOCK_MOVEMENT_DIRECTIONS = ["in", "out", "either"];
+var CORE_STOCK_MOVEMENT_KINDS = [
+  { key: "receipt", label: "Entrada", direction: "in" },
+  { key: "sale", label: "Venda", direction: "out" },
+  { key: "return", label: "Devolu\xE7\xE3o", direction: "in" },
+  { key: "adjustment", label: "Ajuste", direction: "either" },
+  { key: "transfer_in", label: "Transfer\xEAncia (entrada)", direction: "in" },
+  { key: "transfer_out", label: "Transfer\xEAncia (sa\xEDda)", direction: "out" },
+  { key: "loss", label: "Perda", direction: "out" },
+  { key: "count", label: "Contagem", direction: "either" }
+];
+var CORE_STOCK_REASON_CODES = [
+  // --- 0034 -----------------------------------------------------------------
+  { key: "opening_balance", label: "Saldo inicial", movementKind: "receipt" },
+  { key: "purchase", label: "Compra", movementKind: "receipt" },
+  { key: "production", label: "Produ\xE7\xE3o", movementKind: "receipt" },
+  { key: "customer_order", label: "Pedido do cliente", movementKind: "sale" },
+  { key: "customer_return", label: "Devolu\xE7\xE3o do cliente", movementKind: "return" },
+  { key: "cycle_count", label: "Contagem de estoque", movementKind: "count" },
+  { key: "breakage", label: "Quebra", movementKind: "loss" },
+  { key: "expiry", label: "Vencimento", movementKind: "loss" },
+  { key: "theft", label: "Furto", movementKind: "loss" },
+  { key: "correction", label: "Corre\xE7\xE3o", movementKind: "adjustment" },
+  { key: "legacy_write", label: "Escrita direta em inventory_count", movementKind: "adjustment" },
+  { key: "transfer", label: "Transfer\xEAncia entre locais", movementKind: null },
+  // --- 0038, for Shopify parity ---------------------------------------------
+  // `received` is wider than our `purchase`: stock can arrive from a transfer,
+  // a production run or a supplier, and Shopify does not distinguish.
+  { key: "received", label: "Recebimento", movementKind: "receipt" },
+  // Distinct from our `breakage`: Shopify's `damaged` covers arriving damaged,
+  // not only breaking in the shop. Both are kept — a merchant who already uses
+  // `breakage` is not renamed.
+  { key: "damaged", label: "Avariado", movementKind: "loss" },
+  { key: "quality_control", label: "Controle de qualidade", movementKind: "adjustment" },
+  { key: "promotion", label: "Promo\xE7\xE3o / brinde", movementKind: "loss" },
+  { key: "other", label: "Outro", movementKind: null }
+];
+var OPENING_BALANCE_REASON = "opening_balance";
+var LEGACY_WRITE_REASON = "legacy_write";
+var stockMovementKindRegistry = new Registry("stockMovementKind");
+var stockReasonCodeRegistry = new Registry("stockReasonCode");
+var coreRegistered = false;
+function registerCoreStockVocabulary() {
+  if (coreRegistered && stockMovementKindRegistry.has("receipt")) return;
+  for (const kind of CORE_STOCK_MOVEMENT_KINDS) {
+    stockMovementKindRegistry.register(kind.key, kind, {
+      title: kind.label,
+      description: `Stock movement kind (${kind.direction})`,
+      source: "sdk"
+    });
+  }
+  for (const reason of CORE_STOCK_REASON_CODES) {
+    stockReasonCodeRegistry.register(reason.key, reason, {
+      title: reason.label,
+      description: reason.movementKind ? `Stock reason code for "${reason.movementKind}" movements` : "Stock reason code (any movement kind)",
+      source: "sdk"
+    });
+  }
+  coreRegistered = true;
+}
+function registerStockMovementKind(kind, options = {}) {
+  registerCoreStockVocabulary();
+  if (!kind.key) throw new Error("registerStockMovementKind: kind.key is required");
+  if (!["in", "out", "either"].includes(kind.direction)) {
+    throw new Error(
+      `registerStockMovementKind: "${kind.key}" has unknown direction "${kind.direction}". Valid directions: in, out, either`
+    );
+  }
+  if (stockMovementKindRegistry.has(kind.key) && !options.replace) {
+    throw new Error(
+      `registerStockMovementKind: kind "${kind.key}" is already registered. Registered kinds: ${listStockMovementKindKeys().join(", ")}`
+    );
+  }
+  stockMovementKindRegistry.register(kind.key, kind, {
+    title: kind.label,
+    description: `Stock movement kind (${kind.direction})`,
+    source: "app",
+    ...options.meta
+  });
+}
+function registerStockReasonCode(reason, options = {}) {
+  registerCoreStockVocabulary();
+  if (!reason.key) throw new Error("registerStockReasonCode: reason.key is required");
+  if (reason.movementKind && !stockMovementKindRegistry.has(reason.movementKind)) {
+    throw new Error(
+      `registerStockReasonCode: "${reason.key}" names unknown movement kind "${reason.movementKind}". Registered kinds: ${listStockMovementKindKeys().join(", ")}`
+    );
+  }
+  if (stockReasonCodeRegistry.has(reason.key) && !options.replace) {
+    throw new Error(
+      `registerStockReasonCode: reason "${reason.key}" is already registered. Registered reason codes: ${listStockReasonCodeKeys().join(", ")}`
+    );
+  }
+  stockReasonCodeRegistry.register(reason.key, reason, {
+    title: reason.label,
+    description: reason.movementKind ? `Stock reason code for "${reason.movementKind}" movements` : "Stock reason code (any movement kind)",
+    source: "app",
+    ...options.meta
+  });
+}
+function resolveStockMovementKind(key) {
+  registerCoreStockVocabulary();
+  const kind = stockMovementKindRegistry.get(key);
+  if (!kind) {
+    throw new Error(
+      `Unknown stock movement kind "${key}". Registered kinds: ${listStockMovementKindKeys().join(", ")}`
+    );
+  }
+  return kind;
+}
+function resolveStockReasonCode(key) {
+  registerCoreStockVocabulary();
+  const reason = stockReasonCodeRegistry.get(key);
+  if (!reason) {
+    throw new Error(
+      `Unknown stock reason code "${key}". Registered reason codes: ${listStockReasonCodeKeys().join(", ")}`
+    );
+  }
+  return reason;
+}
+function listStockMovementKindKeys() {
+  registerCoreStockVocabulary();
+  return stockMovementKindRegistry.ids().sort();
+}
+function listStockReasonCodeKeys() {
+  registerCoreStockVocabulary();
+  return stockReasonCodeRegistry.ids().sort();
+}
+function listStockMovementKinds() {
+  registerCoreStockVocabulary();
+  return stockMovementKindRegistry.list().map((entry) => entry.value).sort((a, b) => a.key.localeCompare(b.key));
+}
+function listStockReasonCodes(movementKind) {
+  registerCoreStockVocabulary();
+  const all = stockReasonCodeRegistry.list().map((entry) => entry.value).sort((a, b) => a.key.localeCompare(b.key));
+  if (!movementKind) return all;
+  return all.filter((reason) => reason.movementKind === null || reason.movementKind === movementKind);
+}
+function clearStockVocabulary() {
+  stockMovementKindRegistry.clear();
+  stockReasonCodeRegistry.clear();
+  coreRegistered = false;
+}
+function validateStockMovement(input, facts) {
+  registerCoreStockVocabulary();
+  if (!input.variantId) {
+    throw new Error("stock movement: variantId is required (the ledger is keyed on the sellable unit)");
+  }
+  if (!Number.isInteger(input.quantity)) {
+    throw new Error(`stock movement: quantity must be a whole number (got ${input.quantity})`);
+  }
+  if (input.quantity === 0) {
+    throw new Error("stock movement: quantity must not be zero \u2014 a movement that moves nothing is not a movement");
+  }
+  const kind = resolveStockMovementKind(input.kind);
+  if (kind.direction === "in" && input.quantity < 0) {
+    throw new Error(
+      `stock movement: kind "${kind.key}" is an inbound movement and needs a positive quantity (got ${input.quantity})`
+    );
+  }
+  if (kind.direction === "out" && input.quantity > 0) {
+    throw new Error(
+      `stock movement: kind "${kind.key}" is an outbound movement and needs a negative quantity (got ${input.quantity})`
+    );
+  }
+  if (input.reasonCode) {
+    const reason = resolveStockReasonCode(input.reasonCode);
+    if (reason.movementKind !== null && reason.movementKind !== kind.key) {
+      throw new Error(
+        `stock movement: reason "${reason.key}" belongs to kind "${reason.movementKind}", not "${kind.key}"`
+      );
+    }
+  }
+  if (facts.tracking === "none") {
+    throw new Error(`stock movement: variant ${input.variantId} is tracking=none and holds no stock`);
+  }
+  if (facts.tracking === "quantity") {
+    if (input.lotId) {
+      throw new Error(
+        `stock movement: variant ${input.variantId} is tracking=quantity; it has one implicit lot, so lotId must be null`
+      );
+    }
+    return;
+  }
+  if (!input.lotId) {
+    throw new Error(`stock movement: variant ${input.variantId} is tracking=${facts.tracking}; lotId is required`);
+  }
+  const lot = facts.lot;
+  if (!lot) {
+    throw new Error(`stock movement: lot ${input.lotId} not found`);
+  }
+  if (lot.variantId !== input.variantId) {
+    throw new Error(
+      `stock movement: lot ${lot.id} belongs to variant ${lot.variantId}, not ${input.variantId}`
+    );
+  }
+  if (facts.tracking === "serial") {
+    if (!lot.serial) {
+      throw new Error(
+        `stock movement: variant ${input.variantId} is tracking=serial; lot ${lot.id} carries no serial`
+      );
+    }
+    if (Math.abs(input.quantity) !== 1) {
+      throw new Error(
+        `stock movement: variant ${input.variantId} is tracking=serial; quantity must be 1 or -1 (got ${input.quantity})`
+      );
+    }
+    if (facts.lotOnHand !== void 0) {
+      const next = facts.lotOnHand + input.quantity;
+      if (next > 1 || next < 0) {
+        throw new Error(
+          `stock movement: variant ${input.variantId} is tracking=serial; lot ${lot.id} would go to ${next} on hand (from ${facts.lotOnHand}). A serial is one unit: its balance may only be 0 or 1.`
+        );
+      }
+    }
+  }
+}
+var CORE_STOCK_ALLOCATION_STRATEGIES = [
+  {
+    key: "fefo",
+    label: "Vence primeiro (FEFO)",
+    expiresFirst: true,
+    receivedOrder: "asc",
+    isManual: false
+  },
+  {
+    key: "fifo",
+    label: "Entrou primeiro (FIFO)",
+    expiresFirst: false,
+    receivedOrder: "asc",
+    isManual: false
+  },
+  {
+    key: "lifo",
+    label: "Entrou por ultimo (LIFO)",
+    expiresFirst: false,
+    receivedOrder: "desc",
+    isManual: false
+  },
+  { key: "manual", label: "Manual", expiresFirst: false, receivedOrder: "asc", isManual: true }
+];
+var stockAllocationStrategyRegistry = new Registry(
+  "stockAllocationStrategy"
+);
+var coreRegistered2 = false;
+function registerCoreStockAllocationStrategies() {
+  if (coreRegistered2 && stockAllocationStrategyRegistry.has("fefo")) return;
+  for (const strategy of CORE_STOCK_ALLOCATION_STRATEGIES) {
+    stockAllocationStrategyRegistry.register(strategy.key, strategy, {
+      title: strategy.label,
+      description: describeStrategy(strategy),
+      source: "sdk"
+    });
+  }
+  coreRegistered2 = true;
+}
+function describeStrategy(strategy) {
+  if (strategy.isManual) return "Manual \u2014 the caller names the lot";
+  const parts = [strategy.expiresFirst ? "soonest expiry first" : "ignores expiry"];
+  parts.push(strategy.receivedOrder === "asc" ? "oldest receipt first" : "newest receipt first");
+  return parts.join(", ");
+}
+function registerStockAllocationStrategy(strategy, options = {}) {
+  registerCoreStockAllocationStrategies();
+  if (!strategy.key) throw new Error("registerStockAllocationStrategy: strategy.key is required");
+  if (strategy.receivedOrder !== "asc" && strategy.receivedOrder !== "desc") {
+    throw new Error(
+      `registerStockAllocationStrategy: "${strategy.key}" has unknown receivedOrder "${strategy.receivedOrder}". Valid values: asc, desc`
+    );
+  }
+  if (stockAllocationStrategyRegistry.has(strategy.key) && !options.replace) {
+    throw new Error(
+      `registerStockAllocationStrategy: strategy "${strategy.key}" is already registered. Registered strategies: ${listStockAllocationStrategyKeys().join(", ")}`
+    );
+  }
+  stockAllocationStrategyRegistry.register(strategy.key, strategy, {
+    title: strategy.label,
+    description: describeStrategy(strategy),
+    source: "app",
+    ...options.meta
+  });
+}
+function resolveStockAllocationStrategy(key) {
+  registerCoreStockAllocationStrategies();
+  const strategy = stockAllocationStrategyRegistry.get(key);
+  if (!strategy) {
+    throw new Error(
+      `shop_allocate_stock: unknown allocation strategy "${key}". Valid strategies: ${listStockAllocationStrategyKeys().join(", ")}`
+    );
+  }
+  return strategy;
+}
+function listStockAllocationStrategyKeys() {
+  registerCoreStockAllocationStrategies();
+  return stockAllocationStrategyRegistry.ids().sort();
+}
+function listStockAllocationStrategies() {
+  registerCoreStockAllocationStrategies();
+  return stockAllocationStrategyRegistry.list().map((entry) => entry.value).sort((a, b) => a.key.localeCompare(b.key));
+}
+function clearStockAllocationStrategies() {
+  stockAllocationStrategyRegistry.clear();
+  coreRegistered2 = false;
+}
+function resolveAllocationStrategyKey(input) {
+  const named = trimmed(input.explicit) ?? trimmed(input.variantDefault) ?? trimmed(input.tenantDefault);
+  if (named) {
+    resolveStockAllocationStrategy(named);
+    return named;
+  }
+  const hasExpiry = (input.candidates ?? []).some((candidate) => candidate.expiresAt != null);
+  return hasExpiry ? "fefo" : "fifo";
+}
+function trimmed(value) {
+  if (typeof value !== "string") return null;
+  const next = value.trim();
+  return next.length > 0 ? next : null;
+}
+function compareStockAllocationCandidates(strategy, a, b) {
+  if (strategy.expiresFirst) {
+    const aNull = a.expiresAt == null ? 1 : 0;
+    const bNull = b.expiresAt == null ? 1 : 0;
+    if (aNull !== bNull) return aNull - bNull;
+    if (a.expiresAt != null && b.expiresAt != null && a.expiresAt !== b.expiresAt) {
+      return a.expiresAt < b.expiresAt ? -1 : 1;
+    }
+  }
+  if (a.receivedAt !== b.receivedAt) {
+    const older = a.receivedAt < b.receivedAt ? -1 : 1;
+    return strategy.receivedOrder === "asc" ? older : -older;
+  }
+  const aDefault = a.isDefaultLocation ? 0 : 1;
+  const bDefault = b.isDefaultLocation ? 0 : 1;
+  if (aDefault !== bDefault) return aDefault - bDefault;
+  return String(a.lotId ?? "").localeCompare(String(b.lotId ?? ""));
+}
+var StockAllocationError = class extends Error {
+  constructor(message, requested, available) {
+    super(message);
+    this.requested = requested;
+    this.available = available;
+    this.name = "StockAllocationError";
+  }
+};
+function allocateStock(request, candidates) {
+  if (!Number.isInteger(request.quantity) || request.quantity <= 0) {
+    throw new Error(`shop_allocate_stock: quantity must be positive (got ${request.quantity})`);
+  }
+  if (request.tracking === "none") return [];
+  const strategy = resolveStockAllocationStrategy(
+    resolveAllocationStrategyKey({
+      explicit: request.strategy,
+      variantDefault: request.variantStrategy,
+      tenantDefault: request.tenantStrategy,
+      candidates
+    })
+  );
+  if (request.tracking === "quantity" && request.lotId) {
+    throw new Error(
+      `shop_allocate_stock: variant ${request.variantId} is tracking=quantity; it has one implicit lot, so lotId must be null`
+    );
+  }
+  if (request.tracking !== "quantity" && strategy.isManual && !request.lotId) {
+    throw new Error(
+      `shop_allocate_stock: variant ${request.variantId} uses the "manual" strategy; name the lot to allocate from (lotId)`
+    );
+  }
+  const eligible = candidates.filter((candidate) => candidate.available > 0).filter((candidate) => request.locationId ? candidate.locationId === request.locationId : true).filter((candidate) => request.lotId ? candidate.lotId === request.lotId : true).filter((candidate) => candidate.isSellableLocation !== false).filter(
+    (candidate) => request.tracking === "quantity" ? candidate.lotId == null : candidate.lotId != null
+  ).slice().sort((a, b) => compareStockAllocationCandidates(strategy, a, b));
+  const chosen = [];
+  let remaining = request.quantity;
+  for (const candidate of eligible) {
+    if (remaining <= 0) break;
+    const take = Math.min(remaining, candidate.available);
+    if (request.tracking === "serial" && take !== 1) {
+      throw new Error(
+        `shop_allocate_stock: variant ${request.variantId} is tracking=serial; lot ${candidate.lotId} offered ${candidate.available} units and a serial is one unit`
+      );
+    }
+    chosen.push({ lotId: candidate.lotId, locationId: candidate.locationId, quantity: take });
+    remaining -= take;
+  }
+  if (remaining > 0) {
+    const available = candidates.filter((candidate) => candidate.isSellableLocation !== false).reduce((sum, candidate) => sum + Math.max(candidate.available, 0), 0);
+    throw new StockAllocationError(
+      `shop_allocate_stock: variant ${request.variantId} cannot cover ${request.quantity} unit(s); ${available} available`,
+      request.quantity,
+      available
+    );
+  }
+  return chosen;
+}
+var CORE_RESERVATION_TTL_MINUTES = [
+  { paymentMethod: null, minutes: 30 },
+  { paymentMethod: "pix", minutes: 30 },
+  { paymentMethod: "credit_card", minutes: 30 },
+  { paymentMethod: "debit_card", minutes: 30 },
+  { paymentMethod: "cash", minutes: 30 },
+  { paymentMethod: "other", minutes: 30 },
+  { paymentMethod: "boleto", minutes: 4320 }
+];
+function resolveReservationTtlMinutes(paymentMethod, overrides = []) {
+  const rows = [...overrides, ...CORE_RESERVATION_TTL_MINUTES];
+  const named = rows.find((row) => row.paymentMethod != null && row.paymentMethod === paymentMethod);
+  if (named) return named.minutes;
+  const fallback = rows.find((row) => row.paymentMethod == null);
+  return fallback?.minutes ?? 30;
+}
+
+// src/inventory/shopify-mapping.ts
+var SHOPIFY_DEFAULT_OPTION_NAME = "Title";
+var SHOPIFY_DEFAULT_VARIANT_TITLE = "Default Title";
+function toShopifyVariantTitle(isDefaultVariant, optionsLabel) {
+  return isDefaultVariant || !optionsLabel ? SHOPIFY_DEFAULT_VARIANT_TITLE : optionsLabel;
+}
+function shopifyDefaultOptions() {
+  return [{ name: SHOPIFY_DEFAULT_OPTION_NAME, values: [SHOPIFY_DEFAULT_VARIANT_TITLE] }];
+}
+var SHOPIFY_QUANTITY_STATES = [
+  { shopify: "available", ours: "available", note: "identical (on_hand \u2212 reserved)" },
+  { shopify: "on_hand", ours: "on_hand", note: "identical" },
+  {
+    shopify: "committed",
+    ours: "reserved",
+    note: "same concept; plg_shop_stock_levels publishes both names"
+  },
+  {
+    shopify: "incoming",
+    ours: null,
+    note: 'modelled as a PLACE \u2014 a balance in a location with is_sellable = false (kind "transit") \u2014 which is strictly more expressive than one number'
+  },
+  {
+    shopify: "damaged",
+    ours: null,
+    note: 'modelled as a `loss` movement with reason_code "damaged": carries when, who and how many, where Shopify has a bucket'
+  },
+  {
+    shopify: "quality_control",
+    ours: null,
+    note: 'modelled as a lot with status "quarantined" \u2014 a BATCH under inspection, not a quantity'
+  },
+  {
+    shopify: "safety_stock",
+    ours: null,
+    note: "NOT MODELLED. Reorder point and low-stock threshold are forecasting, which inventory-model.md \xA78 puts out of scope on purpose"
+  }
+];
+var SHOPIFY_ADJUSTMENT_REASONS = [
+  { shopify: "correction", reasonCode: "correction", movementKind: "adjustment" },
+  { shopify: "cycle_count_available", reasonCode: "cycle_count", movementKind: "count" },
+  { shopify: "received", reasonCode: "received", movementKind: "receipt" },
+  { shopify: "damaged", reasonCode: "damaged", movementKind: "loss" },
+  { shopify: "quality_control", reasonCode: "quality_control", movementKind: "adjustment" },
+  { shopify: "promotion", reasonCode: "promotion", movementKind: "loss" },
+  { shopify: "movement_created", reasonCode: "transfer", movementKind: "transfer_out" },
+  { shopify: "movement_received", reasonCode: "transfer", movementKind: "transfer_in" },
+  { shopify: "movement_updated", reasonCode: "transfer", movementKind: "transfer_in" },
+  { shopify: "movement_canceled", reasonCode: "correction", movementKind: "adjustment" },
+  { shopify: "other", reasonCode: "other", movementKind: null },
+  {
+    shopify: "reservation_created",
+    reasonCode: null,
+    movementKind: null,
+    note: "NOT a movement. A hold is a row in plg_shop_stock_reservations with a status and a TTL \u2014 a lifecycle, not an entry in an append-only ledger. Recording it as a movement is what forces Shopify to have a reason code for it at all."
+  }
+];
+function shopifyReasonToStockReason(shopifyReason) {
+  const row = SHOPIFY_ADJUSTMENT_REASONS.find((entry) => entry.shopify === shopifyReason);
+  if (!row) {
+    throw new Error(
+      `shopifyReasonToStockReason: unknown Shopify reason "${shopifyReason}". Known reasons: ${SHOPIFY_ADJUSTMENT_REASONS.map((entry) => entry.shopify).join(", ")}`
+    );
+  }
+  return row.reasonCode;
+}
+var BEYOND_SHOPIFY = [
+  {
+    feature: "lot / batch tracking with expires_at",
+    why: "artorious sells smoked meat: FEFO picking and an answerable recall are regulatory, not optional. Shopify has no native lots."
+  },
+  {
+    feature: "FEFO / FIFO / LIFO / manual allocation as data",
+    why: "Shopify allocates per location only. Which BATCH leaves the shelf is the question a food store actually asks."
+  },
+  {
+    feature: "serial tracking bounded to {0,1} per lot",
+    why: "cristinarotondaro: every piece is one-of-one. Shopify has no native serials."
+  },
+  {
+    feature: "per-variant tracking policy (none | quantity | lot | serial)",
+    why: "One model has to express all six fleet stores without a code fork, and the default must cost a simple store nothing."
+  },
+  {
+    feature: "unit_cost on the lot and on the movement",
+    why: "Margin and CMV are derivable. Shopify keeps cost on the InventoryItem only, with no history."
+  }
+];
+var TRACKING_MODES_BEYOND_SHOPIFY = ["lot", "serial"];
+
+// src/data/tables.ts
+var T = {
+  products: "plg_shop_products",
+  productImages: "plg_shop_product_images",
+  productOptions: "plg_shop_product_options",
+  productVariants: "plg_shop_product_variants",
+  categories: "plg_shop_categories",
+  orders: "plg_shop_orders",
+  orderItems: "plg_shop_order_items",
+  customers: "plg_shop_customers",
+  discounts: "plg_shop_discounts",
+  salesChannels: "plg_shop_channels",
+  // Collections, gift cards and customer groups/segments (migrations 0040-0043).
+  // None of them touch the stock ledger or variants.
+  collections: "plg_shop_collections",
+  collectionProducts: "plg_shop_collection_products",
+  giftCards: "plg_shop_gift_cards",
+  // Message customisations live in the automations table, not a shop-owned one:
+  // the store's emails are events in the same catalog every other module writes
+  // to. `plg_shop_email_templates` (0042) is the retired shape — plugin-automations
+  // migration 0001 copied its rows over and nothing writes to it anymore.
+  messageTemplates: "plg_automations_templates",
+  customerGroups: "plg_shop_customer_groups",
+  customerGroupMembers: "plg_shop_customer_group_members",
+  customerSegments: "plg_shop_customer_segments",
+  /** Public bucket the media library and product photos both live in. */
+  mediaBucket: "shop-images",
+  // The inventory ledger (migrations 0034-0036). stockBalances is DERIVED: it is
+  // read here and never written, because the only legitimate writers are 0034's
+  // SECURITY DEFINER triggers — which is why that table deliberately has no RLS
+  // write policy at all.
+  stockMovementKinds: "plg_shop_stock_movement_kinds",
+  stockReasonCodes: "plg_shop_stock_reason_codes",
+  stockLocations: "plg_shop_stock_locations",
+  stockLots: "plg_shop_stock_lots",
+  stockMovements: "plg_shop_stock_movements",
+  stockReservations: "plg_shop_stock_reservations",
+  stockBalances: "plg_shop_stock_balances",
+  // Allocation and the reservation lifecycle (0038). The strategies and TTLs are
+  // VOCABULARY — rows, not enums (I9) — so an agency widens either with an
+  // INSERT. stockLevels is a VIEW: our (variant, lot, location) balances
+  // projected to (variant, location), which is Shopify's InventoryLevel shape
+  // and what a connector syncs.
+  stockAllocationStrategies: "plg_shop_stock_allocation_strategies",
+  stockReservationTtls: "plg_shop_stock_reservation_ttls",
+  stockLevels: "plg_shop_stock_levels",
+  // Traceability (0039): which lot filled which order line. A join table, not a
+  // jsonb column, because the query that matters runs BACKWARDS.
+  orderItemLots: "plg_shop_order_item_lots",
+  // Tenant-level shop settings (0029). stock_ownership = 'external' means an
+  // ERP owns the numbers and our ledger is not authoritative for that store.
+  settings: "plg_shop_settings",
+  // Core, not plg_shop_*: a delivery zone is a fact about the business, and
+  // fulfilment and financial read it too. Same reasoning as addresses and
+  // orders — see migration 0021.
+  shippingZones: "shipping_zones"
+};
+
+// src/inventory/supabase-stock-store.ts
+function getDb() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("@fayz-ai/shop: Supabase client not initialized. Call setGlobalSupabaseClient() first.");
+  return supabase;
+}
+function rowToLocation(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    code: row.code,
+    name: row.name,
+    kind: row.kind ?? "store",
+    isSellable: row.is_sellable ?? true,
+    isDefault: row.is_default ?? false,
+    status: row.status ?? "active",
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToLot(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    variantId: row.variant_id,
+    lotCode: row.lot_code,
+    serial: row.serial ?? null,
+    manufacturedAt: row.manufactured_at ?? null,
+    expiresAt: row.expires_at ?? null,
+    receivedAt: row.received_at,
+    // numeric(12,4) arrives as a string on the wire; Number() once, here, so no
+    // caller ever adds a cost to a string and gets concatenation.
+    unitCost: row.unit_cost == null ? null : Number(row.unit_cost),
+    supplierRef: row.supplier_ref ?? null,
+    status: row.status ?? "active",
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToMovement(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    variantId: row.variant_id ?? null,
+    productId: row.product_id ?? null,
+    locationId: row.location_id,
+    lotId: row.lot_id ?? null,
+    kind: row.kind,
+    reasonCode: row.reason_code ?? null,
+    quantity: Number(row.quantity),
+    unitCost: row.unit_cost == null ? null : Number(row.unit_cost),
+    orderId: row.order_id ?? null,
+    reservationId: row.reservation_id ?? null,
+    idempotencyKey: row.idempotency_key ?? null,
+    occurredAt: row.occurred_at,
+    createdBy: row.created_by ?? null,
+    note: row.note ?? null,
+    createdAt: row.created_at
+  };
+}
+function rowToBalance(row) {
+  const onHand = Number(row.on_hand ?? 0);
+  const reserved = Number(row.reserved ?? 0);
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    variantId: row.variant_id,
+    locationId: row.location_id,
+    lotId: row.lot_id ?? null,
+    onHand,
+    reserved,
+    // `available` is a STORED generated column in 0034. It is recomputed here
+    // rather than trusted, so a projection that omitted the column cannot make
+    // `available` silently read 0 — the one number the storefront depends on.
+    available: row.available == null ? onHand - reserved : Number(row.available),
+    updatedAt: row.updated_at
+  };
+}
+function rowToReservation(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    variantId: row.variant_id,
+    locationId: row.location_id,
+    lotId: row.lot_id ?? null,
+    quantity: Number(row.quantity),
+    status: row.status ?? "held",
+    orderId: row.order_id ?? null,
+    cartToken: row.cart_token ?? null,
+    expiresAt: row.expires_at ?? null,
+    idempotencyKey: row.idempotency_key ?? null,
+    createdBy: row.created_by ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var UNIQUE_VIOLATION = "23505";
+var SupabaseStockStore = class {
+  /**
+   * An explicit tenant pins the store to one pool (what an ERP connector or a
+   * background job needs); omitted, it resolves per call through the same
+   * resolver every other plg_shop_* read uses.
+   */
+  constructor(explicitTenantId) {
+    this.explicitTenantId = explicitTenantId;
+  }
+  tenantId() {
+    return this.explicitTenantId ?? getShopTenantId();
+  }
+  requireTenantId(operation) {
+    const tenantId = this.tenantId();
+    if (!tenantId) {
+      throw new Error(
+        `@fayz-ai/shop: ${operation} requires a tenant id (configure the shop tenant resolver, or construct SupabaseStockStore with one).`
+      );
+    }
+    return tenantId;
+  }
+  // --- reads ------------------------------------------------------------------
+  async listLocations() {
+    const db = getDb();
+    let q = db.from(T.stockLocations).select("*");
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    q = q.order("is_default", { ascending: false }).order("code", { ascending: true });
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data ?? []).map(rowToLocation);
+  }
+  async getDefaultLocation() {
+    const db = getDb();
+    let q = db.from(T.stockLocations).select("*").eq("is_default", true);
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    const { data, error } = await q.maybeSingle();
+    if (error) throw error;
+    return data ? rowToLocation(data) : null;
+  }
+  /**
+   * `sellableOnly` filters by an id set read from the locations table rather
+   * than by an embedded `!inner` join. Locations are a handful of rows per
+   * tenant, and the set is the same one mirroredInventoryCount() takes — so the
+   * mock, this store and 0036's mirror all narrow "sellable" through one
+   * definition instead of three query dialects.
+   */
+  async listBalances(options = {}) {
+    const db = getDb();
+    let q = db.from(T.stockBalances).select("*");
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    if (options.variantId) q = q.eq("variant_id", options.variantId);
+    if (options.variantIds) q = q.in("variant_id", options.variantIds);
+    if (options.locationId) q = q.eq("location_id", options.locationId);
+    if (options.lotId) q = q.eq("lot_id", options.lotId);
+    if (options.sellableOnly) {
+      const sellable = await this.sellableLocationIds();
+      if (sellable.size === 0) return [];
+      q = q.in("location_id", [...sellable]);
+    }
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data ?? []).map(rowToBalance);
+  }
+  async getAvailable(variantId) {
+    const [balances, sellable] = await Promise.all([
+      this.listBalances({ variantId }),
+      this.sellableLocationIds()
+    ]);
+    return mirroredInventoryCount(balances, sellable);
+  }
+  async listLots(options = {}) {
+    const db = getDb();
+    let q = db.from(T.stockLots).select("*");
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    if (options.variantId) q = q.eq("variant_id", options.variantId);
+    if (options.status) q = q.eq("status", options.status);
+    if (options.expiresBefore) q = q.lte("expires_at", options.expiresBefore);
+    if (options.fefo !== false) {
+      q = q.order("expires_at", { ascending: true, nullsFirst: false }).order("received_at", { ascending: true });
+    }
+    if (options.limit != null) q = q.limit(options.limit);
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data ?? []).map(rowToLot);
+  }
+  async listMovements(options = {}) {
+    const db = getDb();
+    let q = db.from(T.stockMovements).select("*");
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    if (options.variantId) q = q.eq("variant_id", options.variantId);
+    if (options.lotId) q = q.eq("lot_id", options.lotId);
+    if (options.orderId) q = q.eq("order_id", options.orderId);
+    if (options.kind) q = q.eq("kind", options.kind);
+    if (options.reasonCode) q = q.eq("reason_code", options.reasonCode);
+    const ascending = options.newestFirst === false;
+    q = q.order("occurred_at", { ascending }).order("created_at", { ascending });
+    if (options.limit != null) q = q.limit(options.limit);
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data ?? []).map(rowToMovement);
+  }
+  async listReservations(variantId) {
+    const db = getDb();
+    let q = db.from(T.stockReservations).select("*");
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    if (variantId) q = q.eq("variant_id", variantId);
+    q = q.order("created_at", { ascending: true });
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data ?? []).map(rowToReservation);
+  }
+  // --- append -----------------------------------------------------------------
+  /**
+   * Append to the ledger. Never an update — a mistake is corrected by an
+   * opposing movement.
+   *
+   * IDEMPOTENCY IS TWO MECHANISMS, not one, and the second is the real one:
+   *
+   *   1. A pre-read on (tenant_id, idempotency_key) returns the existing
+   *      movement. This is the ordinary retry — same caller, seconds later —
+   *      and it costs one cheap indexed SELECT.
+   *   2. A `23505` on the INSERT is caught and re-read. This is the race the
+   *      pre-read cannot cover: two retries in flight at once both miss the
+   *      SELECT and both attempt the INSERT. 0034's partial unique index
+   *      plg_shop_stock_movements_idempotency_key is what turns the loser into
+   *      an error we can recognise instead of a second decrement.
+   *
+   * Without (2) a retried place_order under load decrements twice, which is
+   * precisely the failure the idempotency key exists to prevent.
+   */
+  async recordMovement(input) {
+    const db = getDb();
+    const tenantId = this.requireTenantId("recordMovement");
+    if (input.idempotencyKey) {
+      const existing = await this.findByIdempotencyKey(input.idempotencyKey);
+      if (existing) return existing;
+    }
+    const variant = await this.readVariant(input.variantId);
+    if (!variant) {
+      throw new StockMovementError(`stock movement: variant ${input.variantId} not found`, input);
+    }
+    if (variant.tenantId !== tenantId) {
+      throw new StockMovementError(
+        `stock movement: variant ${input.variantId} belongs to another store`,
+        input
+      );
+    }
+    const lot = input.lotId ? await this.readLot(input.lotId) : null;
+    try {
+      validateStockMovement(input, {
+        tracking: variant.tracking,
+        lot,
+        // Summed over EVERY location: a serial is one physical unit in the whole
+        // store, so moving it between locations must not let a second copy
+        // appear. Same predicate as 0034's SELECT, and read only when it can
+        // matter, so the quantity-tracked common case costs nothing.
+        lotOnHand: lot && variant.tracking === "serial" ? await this.lotOnHand(lot.id) : void 0
+      });
+    } catch (error2) {
+      throw new StockMovementError(error2.message, input);
+    }
+    let locationId = input.locationId ?? null;
+    if (locationId) {
+      const known = await this.listLocations();
+      if (!known.some((location) => location.id === locationId)) {
+        throw new StockMovementError(
+          `stock movement: location ${locationId} does not belong to store ${tenantId}`,
+          input
+        );
+      }
+    } else {
+      locationId = (await this.getDefaultLocation())?.id ?? null;
+    }
+    const payload = {
+      tenant_id: tenantId,
+      variant_id: input.variantId,
+      location_id: locationId,
+      lot_id: input.lotId ?? null,
+      kind: input.kind,
+      reason_code: input.reasonCode ?? null,
+      quantity: input.quantity,
+      unit_cost: input.unitCost ?? null,
+      order_id: input.orderId ?? null,
+      reservation_id: input.reservationId ?? null,
+      idempotency_key: input.idempotencyKey ?? null,
+      ...input.occurredAt !== void 0 ? { occurred_at: input.occurredAt } : {},
+      note: input.note ?? null
+      // product_id is denormalised by the validator trigger from the variant,
+      // so the ledger row still names its product after an ON DELETE SET NULL.
+    };
+    const { data, error } = await db.from(T.stockMovements).insert(payload).select().single();
+    if (error) {
+      if (error.code === UNIQUE_VIOLATION && input.idempotencyKey) {
+        const winner = await this.findByIdempotencyKey(input.idempotencyKey);
+        if (winner) return winner;
+      }
+      throw new StockMovementError(error.message ?? String(error), input);
+    }
+    return rowToMovement(data);
+  }
+  // --- allocation and the reservation lifecycle (§9 step 4) ---------------------
+  //
+  // All three go through an RPC rather than being computed here, and that is the
+  // whole design rather than a shortcut. §4: allocation runs IN POSTGRES, inside
+  // the SECURITY DEFINER trust boundary, because "stock that can be allocated
+  // from the client is stock that can be lied about". A TypeScript
+  // implementation that read balances and picked lots itself would be a second
+  // allocator racing the first — two answers to "which batch leaves the shelf",
+  // with no lock between them.
+  //
+  // The pure ordering in allocation.ts is the SPECIFICATION both sides share and
+  // what the mock executes; this class calls the authority.
+  async allocate(request) {
+    const db = getDb();
+    const tenantId = this.requireTenantId("allocate");
+    const { data, error } = await db.rpc("shop_allocate_stock", {
+      p_tenant_id: tenantId,
+      p_variant_id: request.variantId,
+      p_quantity: request.quantity,
+      p_location_id: request.locationId ?? null,
+      p_strategy: request.strategy ?? null,
+      p_lot_id: request.lotId ?? null
+    });
+    if (error) throw new Error(error.message ?? String(error));
+    return (data ?? []).map((row) => ({
+      lotId: row.lot_id ?? null,
+      locationId: row.location_id,
+      quantity: Number(row.quantity)
+    }));
+  }
+  async reserve(input) {
+    const db = getDb();
+    const tenantId = this.requireTenantId("reserve");
+    const { data, error } = await db.rpc("shop_reserve_stock", {
+      p_tenant_id: tenantId,
+      p_variant_id: input.variantId,
+      p_quantity: input.quantity,
+      p_location_id: input.locationId,
+      p_lot_id: input.lotId ?? null,
+      p_order_id: input.orderId ?? null,
+      p_cart_token: input.cartToken ?? null,
+      // Postgres parses an ISO-8601 interval literal; minutes keeps the port's
+      // surface a number rather than a Postgres dialect.
+      p_ttl: input.ttlMinutes == null ? null : `${input.ttlMinutes} minutes`,
+      p_idempotency_key: input.idempotencyKey ?? null
+    });
+    if (error) throw new Error(error.message ?? String(error));
+    const id = typeof data === "string" ? data : data?.[0];
+    const rows = await this.listReservations(input.variantId);
+    const created = rows.find((row) => row.id === id);
+    if (!created) throw new Error(`shop_reserve_stock: reservation ${id} could not be read back`);
+    return created;
+  }
+  async setReservationStatus(reservationId, status) {
+    const db = getDb();
+    let q = db.from(T.stockReservations).update({ status }).eq("id", reservationId);
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    const { error } = await q;
+    if (error) throw error;
+  }
+  async sweepExpiredReservations(variantId) {
+    const db = getDb();
+    const tenantId = this.requireTenantId("sweepExpiredReservations");
+    const { data, error } = await db.rpc("shop_sweep_stock_reservations", {
+      p_tenant_id: tenantId,
+      p_variant_id: variantId ?? null
+    });
+    if (error) throw new Error(error.message ?? String(error));
+    return Number(Array.isArray(data) ? data[0] ?? 0 : data ?? 0);
+  }
+  // --- helpers ------------------------------------------------------------------
+  async findByIdempotencyKey(key) {
+    const db = getDb();
+    let q = db.from(T.stockMovements).select("*").eq("idempotency_key", key);
+    const tenantId = this.tenantId();
+    if (tenantId) q = q.eq("tenant_id", tenantId);
+    const { data, error } = await q.maybeSingle();
+    if (error) throw error;
+    return data ? rowToMovement(data) : null;
+  }
+  /** The variant facts the validator needs — tracking is 0034's new column. */
+  async readVariant(variantId) {
+    const { data, error } = await getDb().from(T.productVariants).select("id,tenant_id,product_id,tracking").eq("id", variantId).maybeSingle();
+    if (error) throw error;
+    if (!data) return null;
+    return {
+      id: data.id,
+      tenantId: data.tenant_id,
+      productId: data.product_id ?? null,
+      tracking: data.tracking ?? "quantity"
+    };
+  }
+  async readLot(lotId) {
+    const { data, error } = await getDb().from(T.stockLots).select("id,variant_id,serial").eq("id", lotId).maybeSingle();
+    if (error) throw error;
+    if (!data) return null;
+    return { id: data.id, variantId: data.variant_id, serial: data.serial ?? null };
+  }
+  /** on_hand for one lot across every location — the serial-bound predicate. */
+  async lotOnHand(lotId) {
+    const rows = await this.listBalances({ lotId });
+    return rows.reduce((sum, row) => sum + row.onHand, 0);
+  }
+  async sellableLocationIds() {
+    const locations = await this.listLocations();
+    return new Set(
+      locations.filter((location) => location.isSellable && location.status === "active").map((l) => l.id)
+    );
+  }
+};
+function createSupabaseStockStore(tenantId) {
+  return new SupabaseStockStore(tenantId);
+}
+
+// src/inventory/mock-stock-store.ts
+var TENANT = "mock-tenant";
+var counter = 0;
+function nextId(prefix) {
+  counter += 1;
+  return `${prefix}-${String(counter).padStart(4, "0")}`;
+}
+var ISO = "2026-01-01T00:00:00.000Z";
+var MockStockStore = class {
+  constructor(seed = {}) {
+    this.locations = [];
+    this.lots = [];
+    this.movements = [];
+    this.reservations = [];
+    this.variants = /* @__PURE__ */ new Map();
+    this.tenantId = seed.tenantId ?? TENANT;
+    const seededLocations = seed.locations ?? [];
+    if (!seededLocations.some((l) => l.isDefault)) {
+      this.locations.push(this.makeLocation({ code: "default", name: "Estoque principal", isDefault: true }));
+    }
+    for (const location of seededLocations) this.locations.push(this.makeLocation(location));
+    for (const variant of seed.variants ?? []) {
+      this.variants.set(variant.id, {
+        id: variant.id,
+        tenantId: variant.tenantId ?? this.tenantId,
+        productId: variant.productId ?? null,
+        tracking: variant.tracking ?? DEFAULT_STOCK_TRACKING,
+        inventoryCount: variant.inventoryCount ?? 0
+      });
+    }
+    for (const lot of seed.lots ?? []) {
+      this.lots.push({
+        id: lot.id ?? nextId("lot"),
+        tenantId: lot.tenantId ?? this.tenantId,
+        variantId: lot.variantId ?? "",
+        lotCode: lot.lotCode ?? nextId("LOT"),
+        serial: lot.serial ?? null,
+        manufacturedAt: lot.manufacturedAt ?? null,
+        expiresAt: lot.expiresAt ?? null,
+        receivedAt: lot.receivedAt ?? ISO,
+        unitCost: lot.unitCost ?? null,
+        supplierRef: lot.supplierRef ?? null,
+        status: lot.status ?? "active",
+        createdAt: ISO,
+        updatedAt: ISO
+      });
+    }
+  }
+  makeLocation(partial) {
+    return {
+      id: partial.id ?? nextId("loc"),
+      tenantId: partial.tenantId ?? this.tenantId,
+      code: partial.code ?? nextId("code"),
+      name: partial.name ?? "Local",
+      kind: partial.kind ?? "store",
+      isSellable: partial.isSellable ?? true,
+      isDefault: partial.isDefault ?? false,
+      status: partial.status ?? "active",
+      createdAt: ISO,
+      updatedAt: ISO
+    };
+  }
+  // --- reads ------------------------------------------------------------------
+  async listLocations() {
+    return [...this.locations].sort((a, b) => Number(b.isDefault) - Number(a.isDefault));
+  }
+  async getDefaultLocation() {
+    return this.locations.find((l) => l.isDefault) ?? null;
+  }
+  async listBalances(options = {}) {
+    const replayed = replayStockLedger(this.movements, this.reservations);
+    const sellable = new Set(this.locations.filter((l) => l.isSellable && l.status === "active").map((l) => l.id));
+    const rows = [];
+    for (const [key, row] of replayed) {
+      if (options.variantId && row.variantId !== options.variantId) continue;
+      if (options.variantIds && !options.variantIds.includes(row.variantId)) continue;
+      if (options.locationId && row.locationId !== options.locationId) continue;
+      if (options.lotId && row.lotId !== options.lotId) continue;
+      if (options.sellableOnly && !sellable.has(row.locationId)) continue;
+      rows.push({
+        id: key,
+        tenantId: row.tenantId || this.tenantId,
+        variantId: row.variantId,
+        locationId: row.locationId,
+        lotId: row.lotId,
+        onHand: row.onHand,
+        reserved: row.reserved,
+        available: row.onHand - row.reserved,
+        updatedAt: ISO
+      });
+    }
+    return rows.sort((a, b) => a.id.localeCompare(b.id));
+  }
+  async getAvailable(variantId) {
+    const balances = await this.listBalances({ variantId });
+    return mirroredInventoryCount(balances, this.sellableLocationIds());
+  }
+  async listLots(options = {}) {
+    let rows = [...this.lots];
+    if (options.variantId) rows = rows.filter((l) => l.variantId === options.variantId);
+    if (options.status) rows = rows.filter((l) => l.status === options.status);
+    if (options.expiresBefore) {
+      rows = rows.filter((l) => l.expiresAt !== null && l.expiresAt <= options.expiresBefore);
+    }
+    if (options.fefo !== false) {
+      rows.sort((a, b) => {
+        if (a.expiresAt === b.expiresAt) return a.receivedAt.localeCompare(b.receivedAt);
+        if (a.expiresAt === null) return 1;
+        if (b.expiresAt === null) return -1;
+        return a.expiresAt.localeCompare(b.expiresAt);
+      });
+    }
+    return options.limit != null ? rows.slice(0, options.limit) : rows;
+  }
+  async listMovements(options = {}) {
+    let rows = [...this.movements];
+    if (options.variantId) rows = rows.filter((m) => m.variantId === options.variantId);
+    if (options.lotId) rows = rows.filter((m) => m.lotId === options.lotId);
+    if (options.orderId) rows = rows.filter((m) => m.orderId === options.orderId);
+    if (options.kind) rows = rows.filter((m) => m.kind === options.kind);
+    if (options.reasonCode) rows = rows.filter((m) => m.reasonCode === options.reasonCode);
+    if (options.newestFirst !== false) rows.reverse();
+    return options.limit != null ? rows.slice(0, options.limit) : rows;
+  }
+  async listReservations(variantId) {
+    return variantId ? this.reservations.filter((r) => r.variantId === variantId) : [...this.reservations];
+  }
+  // --- append -----------------------------------------------------------------
+  async recordMovement(input) {
+    if (input.idempotencyKey) {
+      const existing = this.movements.find((m) => m.idempotencyKey === input.idempotencyKey);
+      if (existing) return existing;
+    }
+    const variant = this.variants.get(input.variantId);
+    if (!variant) {
+      throw new StockMovementError(`stock movement: variant ${input.variantId} not found`, input);
+    }
+    const lot = input.lotId ? this.lots.find((l) => l.id === input.lotId) ?? null : null;
+    try {
+      validateStockMovement(input, {
+        tracking: variant.tracking,
+        lot: lot ? { id: lot.id, variantId: lot.variantId, serial: lot.serial } : null,
+        // Summed over EVERY location: a serial is one physical unit in the
+        // whole store, so moving it between locations must not let a second
+        // copy appear. Same predicate as the SQL validator's SELECT.
+        lotOnHand: lot ? await this.lotOnHand(lot.id) : void 0
+      });
+    } catch (error) {
+      throw new StockMovementError(error.message, input);
+    }
+    const locationId = input.locationId ?? (await this.getDefaultLocation()).id;
+    if (!this.locations.some((l) => l.id === locationId)) {
+      throw new StockMovementError(
+        `stock movement: location ${locationId} does not belong to store ${this.tenantId}`,
+        input
+      );
+    }
+    const movement = {
+      id: nextId("mov"),
+      tenantId: variant.tenantId,
+      variantId: variant.id,
+      productId: variant.productId,
+      locationId,
+      lotId: input.lotId ?? null,
+      kind: input.kind,
+      reasonCode: input.reasonCode ?? null,
+      quantity: input.quantity,
+      unitCost: input.unitCost ?? null,
+      orderId: input.orderId ?? null,
+      reservationId: input.reservationId ?? null,
+      idempotencyKey: input.idempotencyKey ?? null,
+      occurredAt: input.occurredAt ?? ISO,
+      createdBy: null,
+      note: input.note ?? null,
+      createdAt: ISO
+    };
+    this.movements.push(movement);
+    await this.syncMirror(variant.id);
+    return movement;
+  }
+  // --- allocation and the reservation lifecycle (§9 step 4) ---------------------
+  /**
+   * Runs the SHARED allocateStock() over the mock's own balances and lots, so
+   * "fefo picked the right lot" is asserted against the same ordering the SQL
+   * executes rather than against a convenient imitation.
+   */
+  async allocate(request) {
+    const variant = this.variants.get(request.variantId);
+    if (!variant) {
+      throw new StockMovementError(`stock movement: variant ${request.variantId} not found`, {
+        variantId: request.variantId,
+        kind: "sale",
+        quantity: -request.quantity
+      });
+    }
+    await this.sweepExpiredReservations(request.variantId);
+    return allocateStock(
+      { ...request, tracking: variant.tracking },
+      await this.allocationCandidates(request.variantId, variant.tracking)
+    );
+  }
+  async allocationCandidates(variantId, tracking) {
+    const balances = await this.listBalances({ variantId });
+    const byId = new Map(this.locations.map((l) => [l.id, l]));
+    return balances.map((balance) => {
+      const lot = balance.lotId ? this.lots.find((l) => l.id === balance.lotId) : null;
+      const location = byId.get(balance.locationId);
+      return {
+        lotId: balance.lotId,
+        locationId: balance.locationId,
+        available: balance.onHand - balance.reserved,
+        expiresAt: lot?.expiresAt ?? null,
+        // A quantity-tracked variant's implicit lot has no receipt date of its
+        // own; the ledger's own order stands in, and with one position it never
+        // ties anything.
+        receivedAt: lot?.receivedAt ?? ISO,
+        isSellableLocation: (location?.isSellable ?? true) && (location?.status ?? "active") === "active",
+        isDefaultLocation: location?.isDefault ?? false
+      };
+    }).filter((candidate) => tracking === "quantity" ? candidate.lotId == null : true);
+  }
+  async reserve(input) {
+    if (input.idempotencyKey) {
+      const existing = this.reservations.find((r) => r.idempotencyKey === input.idempotencyKey);
+      if (existing) return existing;
+    }
+    return this.addReservation({
+      variantId: input.variantId,
+      locationId: input.locationId,
+      lotId: input.lotId ?? null,
+      quantity: input.quantity,
+      status: "held",
+      orderId: input.orderId ?? null,
+      cartToken: input.cartToken ?? null,
+      expiresAt: input.ttlMinutes == null ? null : new Date(Date.now() + input.ttlMinutes * 6e4).toISOString(),
+      idempotencyKey: input.idempotencyKey ?? null,
+      createdBy: null
+    });
+  }
+  async sweepExpiredReservations(variantId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let swept = 0;
+    for (const reservation of this.reservations) {
+      if (reservation.status !== "held") continue;
+      if (variantId && reservation.variantId !== variantId) continue;
+      if (!reservation.expiresAt || reservation.expiresAt > now) continue;
+      reservation.status = "released";
+      swept += 1;
+      await this.syncMirror(reservation.variantId);
+    }
+    return swept;
+  }
+  // --- the parts a database would do for us ------------------------------------
+  /** on_hand for one lot across every location — the serial-bound predicate. */
+  async lotOnHand(lotId) {
+    const rows = await this.listBalances({ lotId });
+    return rows.reduce((sum, row) => sum + row.onHand, 0);
+  }
+  sellableLocationIds() {
+    return new Set(this.locations.filter((l) => l.isSellable && l.status === "active").map((l) => l.id));
+  }
+  /** The 0036 mirror, in memory. */
+  async syncMirror(variantId) {
+    const variant = this.variants.get(variantId);
+    if (!variant) return;
+    if (variant.tracking === "none") return;
+    const balances = await this.listBalances({ variantId });
+    if (balances.length === 0) return;
+    variant.inventoryCount = mirroredInventoryCount(balances, this.sellableLocationIds());
+  }
+  /** The mirror column, for assertions. */
+  getInventoryCount(variantId) {
+    return this.variants.get(variantId)?.inventoryCount;
+  }
+  /**
+   * The 0036 I10 shim: a direct write to `inventory_count` is allowed, logged
+   * and TRANSLATED into an adjustment movement carrying the DELTA, so the
+   * ledger never diverges from the column every current writer still uses.
+   * Returns the warning the SQL trigger would have raised.
+   */
+  async writeInventoryCountDirectly(variantId, value) {
+    const variant = this.variants.get(variantId);
+    if (!variant) throw new Error(`variant ${variantId} not found`);
+    const delta = value - variant.inventoryCount;
+    if (delta === 0) return null;
+    if (variant.tracking === "none") {
+      variant.inventoryCount = value;
+      return null;
+    }
+    if (variant.tracking === "lot" || variant.tracking === "serial") {
+      throw new StockMovementError(
+        `plg_shop_product_variants.inventory_count is a derived mirror: variant ${variantId} is ${variant.tracking}-tracked, so a direct write cannot say which lot it means.`,
+        { variantId, kind: "adjustment", quantity: delta }
+      );
+    }
+    const warning = `DEPRECATED (I10): direct write to plg_shop_product_variants.inventory_count on variant ${variantId} (${variant.inventoryCount} -> ${value}). Translated to an adjustment movement; write plg_shop_stock_movements instead.`;
+    variant.inventoryCount = value;
+    await this.recordMovement({
+      variantId,
+      kind: "adjustment",
+      reasonCode: "legacy_write",
+      quantity: delta
+    });
+    return warning;
+  }
+  /** Rebuild balances by replaying the ledger — proof the balance is a cache. */
+  async rebuildBalances() {
+    return this.listBalances();
+  }
+  /**
+   * Seed a hold. The lifecycle itself is §9 step 4; this exists so
+   * `available = onHand − reserved` is provable today.
+   *
+   * async, and the mirror is AWAITED rather than fired and forgotten: a
+   * floating promise here meant `getInventoryCount()` read the pre-hold value
+   * on the very next line, which is the assertion a reservation test makes.
+   */
+  async addReservation(reservation) {
+    const row = {
+      // Spread FIRST: spreading last let an explicit `{ id: undefined }` win
+      // over the generated id and produced a reservation with no identity.
+      ...reservation,
+      id: reservation.id ?? nextId("res"),
+      tenantId: this.tenantId,
+      createdAt: ISO,
+      updatedAt: ISO
+    };
+    this.reservations.push(row);
+    await this.syncMirror(row.variantId);
+    return row;
+  }
+  /** Move a hold through its lifecycle, re-projecting the mirror. */
+  async setReservationStatus(id, status) {
+    const row = this.reservations.find((r) => r.id === id);
+    if (!row) throw new Error(`reservation ${id} not found`);
+    row.status = status;
+    await this.syncMirror(row.variantId);
+  }
+  /** Every ledger row, in insertion order. Nothing is ever removed from it. */
+  get ledger() {
+    return this.movements;
+  }
+  /** The stock the variant was created with, unchanged by the mock. */
+  getTracking(variantId) {
+    return this.variants.get(variantId)?.tracking;
+  }
+  /** Flip a variant's tracking policy (an admin action), for tests. */
+  setTracking(variantId, tracking) {
+    const variant = this.variants.get(variantId);
+    if (!variant) throw new Error(`variant ${variantId} not found`);
+    variant.tracking = tracking;
+  }
+};
+/** The balance key helper, re-exported for assertions that group by it. */
+MockStockStore.key = stockBalanceKey;
+function createMockStockStore(seed = {}) {
+  return new MockStockStore(seed);
+}
+
+export { BEYOND_SHOPIFY, CORE_RESERVATION_TTL_MINUTES, CORE_STOCK_ALLOCATION_STRATEGIES, CORE_STOCK_MOVEMENT_KINDS, CORE_STOCK_REASON_CODES, DEFAULT_STOCK_TRACKING, LEGACY_WRITE_REASON, MockStockStore, OPENING_BALANCE_REASON, SHOPIFY_ADJUSTMENT_REASONS, SHOPIFY_DEFAULT_OPTION_NAME, SHOPIFY_DEFAULT_VARIANT_TITLE, SHOPIFY_QUANTITY_STATES, STOCK_LOCATION_KINDS, STOCK_LOT_STATUSES, STOCK_MOVEMENT_DIRECTIONS, STOCK_RESERVATION_STATUSES, STOCK_TRACKING_MODES, StockAllocationError, StockMovementError, SupabaseStockStore, T, TRACKING_MODES_BEYOND_SHOPIFY, allocateStock, clearStockAllocationStrategies, clearStockStores, clearStockVocabulary, compareStockAllocationCandidates, createMockStockStore, createSupabaseStockStore, getRegisteredStockStore, listStockAllocationStrategies, listStockAllocationStrategyKeys, listStockMovementKindKeys, listStockMovementKinds, listStockReasonCodeKeys, listStockReasonCodes, mirroredInventoryCount, registerCoreStockAllocationStrategies, registerCoreStockVocabulary, registerStockAllocationStrategy, registerStockMovementKind, registerStockReasonCode, registerStockStore, replayStockLedger, resolveAllocationStrategyKey, resolveReservationTtlMinutes, resolveStockAllocationStrategy, resolveStockMovementKind, resolveStockReasonCode, resolveStockStore, shopifyDefaultOptions, shopifyReasonToStockReason, stockAllocationStrategyRegistry, stockBalanceKey, stockMovementKindRegistry, stockReasonCodeRegistry, toShopifyVariantTitle, validateStockMovement };
+//# sourceMappingURL=chunk-XERLK5LD.js.map
+//# sourceMappingURL=chunk-XERLK5LD.js.map