@open-mercato/core 0.6.7-develop.6661.1.0043ed1d03 → 0.6.7-develop.6670.1.4efa7961c6

package/dist/modules/wms/components/backend/inventoryMutationLoaders.js

@@ -0,0 +1,710 @@
+import { apiCall } from "@open-mercato/ui/backend/utils/apiCall";
+import {
+  buildQuery,
+  loadCatalogVariantOptions,
+  loadWarehouseOptions
+} from "./wmsLookupLoaders.js";
+async function loadCrudOptionsByIds(endpoint, ids, mapItem) {
+  const normalizedIds = [...new Set(ids.map((id) => id.trim()).filter(Boolean))];
+  if (normalizedIds.length === 0) return [];
+  const params = buildQuery({
+    page: 1,
+    pageSize: normalizedIds.length,
+    ids: normalizedIds.join(",")
+  });
+  const call = await apiCall(`${endpoint}?${params}`);
+  if (!call.ok) return [];
+  return (call.result?.items ?? []).map(mapItem).filter((option) => option !== null);
+}
+async function resolveCatalogVariantLabel(catalogVariantId) {
+  const id = catalogVariantId.trim();
+  if (!id) return null;
+  const params = buildQuery({ page: 1, pageSize: 1, id });
+  const call = await apiCall(
+    `/api/catalog/variants?${params}`
+  );
+  if (!call.ok) return null;
+  const item = call.result?.items?.[0];
+  if (!item) return null;
+  return item.sku?.trim() || item.name?.trim() || id;
+}
+async function resolveWarehouseLabel(warehouseId) {
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/warehouses",
+    [warehouseId],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      if (!value) return null;
+      return { value, label: item.name || item.code || value };
+    }
+  );
+  return option?.label ?? null;
+}
+async function resolveLocationLabel(locationId) {
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/locations",
+    [locationId],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      if (!value) return null;
+      return { value, label: item.code || value };
+    }
+  );
+  return option?.label ?? null;
+}
+async function resolveLotLabel(lotId) {
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/lots",
+    [lotId],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      if (!value) return null;
+      const lotNumber = item.lot_number?.trim() || value;
+      const expiresAt = item.expires_at?.trim();
+      const label = expiresAt ? `${lotNumber} \xB7 exp ${expiresAt.slice(0, 10)}` : lotNumber;
+      return { value, label };
+    }
+  );
+  return option?.label ?? null;
+}
+async function resolveLotNumberFromId(lotId) {
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/lots",
+    [lotId],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      const lotNumber = item.lot_number?.trim();
+      if (!value || !lotNumber) return null;
+      return { value, label: lotNumber };
+    }
+  );
+  return option?.label ?? null;
+}
+async function resolveCatalogVariantSku(catalogVariantId) {
+  const id = catalogVariantId.trim();
+  if (!id) return null;
+  const params = buildQuery({ page: 1, pageSize: 1, id });
+  const call = await apiCall(
+    `/api/catalog/variants?${params}`
+  );
+  if (!call.ok) return null;
+  const sku = call.result?.items?.[0]?.sku?.trim();
+  return sku || null;
+}
+async function loadInventoryProfileForVariant(catalogVariantId) {
+  const variantId = catalogVariantId.trim();
+  if (!variantId) return null;
+  const params = buildQuery({ page: 1, pageSize: 1, catalogVariantId: variantId });
+  const call = await apiCall(
+    `/api/wms/inventory-profiles?${params}`
+  );
+  if (!call.ok) return null;
+  return call.result?.items?.[0] ?? null;
+}
+async function findLotIdByNumber(catalogVariantId, lotNumber) {
+  const variantId = catalogVariantId.trim();
+  const normalizedLotNumber = lotNumber.trim();
+  if (!variantId || !normalizedLotNumber) return null;
+  const params = buildQuery({
+    page: 1,
+    pageSize: 20,
+    catalogVariantId: variantId,
+    search: normalizedLotNumber
+  });
+  const call = await apiCall(`/api/wms/lots?${params}`);
+  if (!call.ok) return null;
+  const match = (call.result?.items ?? []).find(
+    (item) => item.lot_number?.trim().toLowerCase() === normalizedLotNumber.toLowerCase()
+  );
+  return typeof match?.id === "string" ? match.id : null;
+}
+class InventoryLotMutationError extends Error {
+  constructor(message = "Failed to resolve inventory lot.") {
+    super(message);
+    this.name = "InventoryLotMutationError";
+  }
+}
+async function ensureLotIdForInventoryMutation(input) {
+  const lotNumber = input.lotNumber.trim();
+  if (!lotNumber) {
+    throw new InventoryLotMutationError("Lot number is required.");
+  }
+  const existingId = await findLotIdByNumber(input.catalogVariantId, lotNumber);
+  if (existingId) return existingId;
+  const sku = await resolveCatalogVariantSku(input.catalogVariantId);
+  if (!sku) {
+    throw new InventoryLotMutationError("Could not resolve SKU for the selected variant.");
+  }
+  const call = await apiCall("/api/wms/lots", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      organizationId: input.organizationId,
+      tenantId: input.tenantId,
+      catalogVariantId: input.catalogVariantId,
+      sku,
+      lotNumber,
+      status: "available"
+    })
+  });
+  if (!call.ok) {
+    const racedId = await findLotIdByNumber(input.catalogVariantId, lotNumber);
+    if (racedId) return racedId;
+    throw new InventoryLotMutationError("Failed to create inventory lot.");
+  }
+  const createdId = call.result?.id?.trim();
+  if (createdId) return createdId;
+  const resolvedId = await findLotIdByNumber(input.catalogVariantId, lotNumber);
+  if (resolvedId) return resolvedId;
+  throw new InventoryLotMutationError("Failed to resolve created inventory lot.");
+}
+function readZoneWarehouseId(item) {
+  if (typeof item.warehouse_id === "string" && item.warehouse_id.trim()) {
+    return item.warehouse_id.trim();
+  }
+  if (typeof item.warehouseId === "string" && item.warehouseId.trim()) {
+    return item.warehouseId.trim();
+  }
+  return null;
+}
+class BalanceLookupError extends Error {
+  constructor(message = "Failed to load inventory balance.", code = "LOOKUP_FAILED", candidateLotIds = []) {
+    super(message);
+    this.name = "BalanceLookupError";
+    this.code = code;
+    this.candidateLotIds = candidateLotIds;
+  }
+}
+class ScopeEstimateError extends Error {
+  constructor(message = "Failed to estimate cycle count scope.") {
+    super(message);
+    this.name = "ScopeEstimateError";
+  }
+}
+function compareLocationCodes(left, right) {
+  return left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" });
+}
+function isLocationCodeWithinRange(code, fromCode, toCode) {
+  const from = fromCode?.trim();
+  const to = toCode?.trim();
+  if (from && compareLocationCodes(code, from) < 0) return false;
+  if (to && compareLocationCodes(code, to) > 0) return false;
+  return true;
+}
+function formatCycleCountZoneLabel(baseLabel, stats) {
+  const trimmed = baseLabel.trim();
+  if (!trimmed || !stats) return trimmed;
+  return `${trimmed} \xB7 ${stats.expectedSkus} SKUs \xB7 ${stats.binCount} bins`;
+}
+function mapLocationOptions(items) {
+  return items.map((item) => {
+    const value = typeof item.id === "string" ? item.id : null;
+    if (!value) return null;
+    const label = item.code || value;
+    return { value, label };
+  }).filter((option) => option !== null);
+}
+async function loadAllLocations(warehouseId, filters) {
+  const items = [];
+  let page = 1;
+  let totalPages = 1;
+  while (page <= totalPages && page <= 10) {
+    const params = buildQuery({
+      page,
+      pageSize: 100,
+      warehouseId,
+      type: filters.type,
+      search: filters.search?.trim() || void 0
+    });
+    const call = await apiCall(`/api/wms/locations?${params}`);
+    if (!call.ok) break;
+    items.push(...call.result?.items ?? []);
+    totalPages = call.result?.totalPages ?? 1;
+    page += 1;
+  }
+  return items;
+}
+function filterLocationsByCodeRange(locations, fromCode, toCode) {
+  const from = fromCode?.trim();
+  const to = toCode?.trim();
+  if (!from && !to) return locations;
+  return locations.filter((location) => {
+    const code = location.code?.trim();
+    if (!code) return false;
+    return isLocationCodeWithinRange(code, from, to);
+  });
+}
+async function loadLocationPage(warehouseId, filters) {
+  const params = buildQuery({
+    page: filters.page ?? 1,
+    pageSize: filters.pageSize ?? 50,
+    warehouseId,
+    type: filters.type,
+    search: filters.search?.trim() || void 0
+  });
+  const call = await apiCall(`/api/wms/locations?${params}`);
+  if (!call.ok) {
+    throw new BalanceLookupError("Failed to load warehouse locations.");
+  }
+  return call.result ?? { items: [], total: 0, totalPages: 0 };
+}
+async function loadLocationOptions(warehouseId, query) {
+  if (!warehouseId) return [];
+  try {
+    const page = await loadLocationPage(warehouseId, { search: query });
+    return mapLocationOptions(page.items ?? []);
+  } catch {
+    return [];
+  }
+}
+async function loadBinLocationOptions(warehouseId, query) {
+  if (!warehouseId) return [];
+  try {
+    const page = await loadLocationPage(warehouseId, { type: "bin", search: query });
+    return mapLocationOptions(page.items ?? []);
+  } catch {
+    return [];
+  }
+}
+async function loadZoneOptions(warehouseId, query) {
+  const scopedWarehouseId = warehouseId.trim();
+  if (!scopedWarehouseId) return [];
+  const params = buildQuery({
+    page: 1,
+    pageSize: 50,
+    warehouseId: scopedWarehouseId,
+    search: query?.trim() || void 0
+  });
+  const call = await apiCall(`/api/wms/zones?${params}`);
+  if (!call.ok) return [];
+  return (call.result?.items ?? []).map((item) => {
+    const value = typeof item.id === "string" ? item.id : null;
+    if (!value) return null;
+    const label = item.name?.trim() || item.code?.trim() || value;
+    const zoneWarehouseId = readZoneWarehouseId(item);
+    return {
+      value,
+      label,
+      ...zoneWarehouseId ? { warehouseId: zoneWarehouseId } : {}
+    };
+  }).filter((option) => option !== null);
+}
+async function resolveZoneLabel(zoneId) {
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/zones",
+    [zoneId],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      if (!value) return null;
+      return { value, label: item.name?.trim() || item.code?.trim() || value };
+    }
+  );
+  return option?.label ?? null;
+}
+async function resolveZoneWarehouseId(zoneId) {
+  const id = zoneId.trim();
+  if (!id) return null;
+  const [option] = await loadCrudOptionsByIds(
+    "/api/wms/zones",
+    [id],
+    (item) => {
+      const value = typeof item.id === "string" ? item.id : null;
+      const warehouseId = readZoneWarehouseId(item);
+      if (!value || !warehouseId) return null;
+      return { value, label: warehouseId };
+    }
+  );
+  return option?.label ?? null;
+}
+async function loadAssigneeOptions(query, fallback) {
+  const fallbackUserId = fallback?.userId.trim();
+  const fallbackLabel = fallback?.label.trim();
+  const fallbackOption = fallbackUserId && fallbackLabel ? [{ value: fallbackUserId, label: fallbackLabel }] : [];
+  const params = buildQuery({
+    page: 1,
+    pageSize: 50,
+    search: query?.trim() || void 0
+  });
+  const call = await apiCall(`/api/auth/users?${params}`);
+  if (!call.ok) {
+    return {
+      options: fallbackOption,
+      canListUsers: false
+    };
+  }
+  const options = (call.result?.items ?? []).map((item) => {
+    const value = typeof item.id === "string" ? item.id : null;
+    if (!value) return null;
+    const email = item.email?.trim() || value;
+    const role = item.roles?.find((entry) => entry.trim().length > 0)?.trim();
+    const label = role ? `${email} (${role})` : email;
+    return { value, label };
+  }).filter((option) => option !== null);
+  return {
+    options,
+    canListUsers: true
+  };
+}
+async function resolveAssigneeLabel(userId) {
+  const params = buildQuery({ page: 1, pageSize: 1, id: userId.trim() });
+  const call = await apiCall(`/api/auth/users?${params}`);
+  if (!call.ok) return null;
+  const item = call.result?.items?.[0];
+  if (!item?.id) return null;
+  const email = item.email?.trim() || item.id;
+  const role = item.roles?.find((entry) => entry.trim().length > 0)?.trim();
+  return role ? `${email} (${role})` : email;
+}
+async function fetchCycleCountScopeEstimate(input) {
+  const warehouseId = input.warehouseId.trim();
+  if (!warehouseId) return { expectedSkus: 0, binCount: 0 };
+  const bins = await loadAllLocations(warehouseId, { type: "bin" });
+  const locationById = new Map(
+    bins.map((location) => {
+      const id = location.id?.trim();
+      return id ? [id, location] : null;
+    }).filter((entry) => entry !== null)
+  );
+  const fromCode = input.fromLocationId ? locationById.get(input.fromLocationId.trim())?.code : void 0;
+  const toCode = input.toLocationId ? locationById.get(input.toLocationId.trim())?.code : void 0;
+  const scopedBins = filterLocationsByCodeRange(bins, fromCode, toCode);
+  const scopedBinIds = new Set(
+    scopedBins.map((location) => location.id?.trim()).filter((id) => Boolean(id))
+  );
+  const binCount = scopedBinIds.size;
+  const variantIds = /* @__PURE__ */ new Set();
+  let page = 1;
+  let totalPages = 1;
+  while (page <= totalPages && page <= 10) {
+    const params = buildQuery({
+      page,
+      pageSize: 100,
+      warehouseId
+    });
+    const call = await apiCall(
+      `/api/wms/inventory/balances?${params}`
+    );
+    if (!call.ok) {
+      throw new ScopeEstimateError();
+    }
+    for (const row of call.result?.items ?? []) {
+      const locationId = row.location_id?.trim();
+      const variantId = row.catalog_variant_id?.trim();
+      const onHand = Number(row.quantity_on_hand ?? 0);
+      if (!locationId || !variantId || !Number.isFinite(onHand) || onHand <= 0) continue;
+      if (scopedBinIds.size > 0 && !scopedBinIds.has(locationId)) continue;
+      variantIds.add(variantId);
+    }
+    totalPages = call.result?.totalPages ?? 1;
+    page += 1;
+  }
+  return { expectedSkus: variantIds.size, binCount };
+}
+function normalizeBalanceLotId(value) {
+  const trimmed = value?.trim();
+  return trimmed || null;
+}
+function readBalanceAvailable(row) {
+  const available = Number(row.quantity_available ?? row.quantity_on_hand ?? 0);
+  return Number.isFinite(available) ? available : 0;
+}
+function selectBalanceLookupRow(items, lotId) {
+  if (items.length === 0) return null;
+  if (items.length === 1) return items[0];
+  const normalizedLotId = normalizeBalanceLotId(lotId);
+  if (normalizedLotId) {
+    const exactMatch = items.find(
+      (row) => normalizeBalanceLotId(row.lot_id) === normalizedLotId
+    );
+    if (exactMatch) return exactMatch;
+    throw new BalanceLookupError("No balance bucket matches the selected lot.", "LOT_NOT_FOUND");
+  }
+  const withoutLot = items.filter((row) => !normalizeBalanceLotId(row.lot_id));
+  if (withoutLot.length === 1) return withoutLot[0];
+  const candidateLotIds = [
+    ...new Set(
+      items.map((row) => normalizeBalanceLotId(row.lot_id)).filter((id) => Boolean(id))
+    )
+  ];
+  throw new BalanceLookupError(
+    "Multiple balance buckets match this location; specify a lot.",
+    "LOT_REQUIRED",
+    candidateLotIds
+  );
+}
+async function fetchBalanceAvailable(input) {
+  const params = buildQuery({
+    page: 1,
+    pageSize: 20,
+    warehouseId: input.warehouseId,
+    locationId: input.locationId,
+    catalogVariantId: input.catalogVariantId,
+    lotId: input.lotId?.trim() || void 0
+  });
+  const call = await apiCall(
+    `/api/wms/inventory/balances?${params}`
+  );
+  if (!call.ok) {
+    throw new BalanceLookupError();
+  }
+  const row = selectBalanceLookupRow(call.result?.items ?? [], input.lotId);
+  if (!row) return 0;
+  return readBalanceAvailable(row);
+}
+function mapInventoryLotListRowToOption(item) {
+  const value = typeof item.id === "string" ? item.id : null;
+  if (!value) return null;
+  const lotNumber = item.lot_number?.trim() || value;
+  const expiresAt = item.expires_at?.trim();
+  const label = expiresAt ? `${lotNumber} \xB7 exp ${expiresAt.slice(0, 10)}` : lotNumber;
+  return { value, label };
+}
+function mapInventoryLotListRowToLotNumberOption(item) {
+  const lotNumber = item.lot_number?.trim();
+  if (!lotNumber) return null;
+  const expiresAt = item.expires_at?.trim();
+  const label = expiresAt ? `${lotNumber} \xB7 exp ${expiresAt.slice(0, 10)}` : lotNumber;
+  return { value: lotNumber, label };
+}
+async function loadInventoryLotListOptions(catalogVariantId, query, mapItem) {
+  if (!catalogVariantId) return [];
+  const params = buildQuery({
+    page: 1,
+    pageSize: 50,
+    catalogVariantId,
+    status: "available",
+    search: query?.trim() || void 0
+  });
+  const call = await apiCall(`/api/wms/lots?${params}`);
+  if (!call.ok) return [];
+  return (call.result?.items ?? []).map(mapItem).filter((option) => option !== null);
+}
+async function loadLotOptions(catalogVariantId, query) {
+  return loadInventoryLotListOptions(catalogVariantId, query, mapInventoryLotListRowToOption);
+}
+async function loadLotOptionsByIds(lotIds) {
+  return loadCrudOptionsByIds(
+    "/api/wms/lots",
+    lotIds,
+    mapInventoryLotListRowToOption
+  );
+}
+async function loadLotOptionsForBalanceLocation(input) {
+  const warehouseId = input.warehouseId.trim();
+  const locationId = input.locationId.trim();
+  const catalogVariantId = input.catalogVariantId.trim();
+  if (!warehouseId || !locationId || !catalogVariantId) return [];
+  const params = buildQuery({
+    page: 1,
+    pageSize: 50,
+    warehouseId,
+    locationId,
+    catalogVariantId
+  });
+  const call = await apiCall(
+    `/api/wms/inventory/balances?${params}`
+  );
+  if (!call.ok) return [];
+  const lotIds = [
+    ...new Set(
+      (call.result?.items ?? []).map((row) => normalizeBalanceLotId(row.lot_id)).filter((id) => Boolean(id))
+    )
+  ];
+  if (lotIds.length === 0) return [];
+  const options = await loadCrudOptionsByIds(
+    "/api/wms/lots",
+    lotIds,
+    mapInventoryLotListRowToOption
+  );
+  const query = input.query?.trim().toLowerCase();
+  if (!query) return options;
+  return options.filter((option) => option.label.toLowerCase().includes(query));
+}
+async function loadLotNumberOptions(catalogVariantId, query) {
+  return loadInventoryLotListOptions(catalogVariantId, query, mapInventoryLotListRowToLotNumberOption);
+}
+class ScopeQueueError extends Error {
+  constructor(message = "Failed to build cycle count scope queue.") {
+    super(message);
+    this.name = "ScopeQueueError";
+  }
+}
+async function buildCycleCountScopeQueue(input) {
+  const warehouseId = input.warehouseId.trim();
+  if (!warehouseId) return [];
+  const bins = await loadAllLocations(warehouseId, { type: "bin" });
+  const binById = new Map(
+    bins.map((b) => {
+      const id = b.id?.trim();
+      return id ? [id, b] : null;
+    }).filter((entry) => entry !== null)
+  );
+  const fromCode = input.fromLocationId?.trim() ? binById.get(input.fromLocationId.trim())?.code : void 0;
+  const toCode = input.toLocationId?.trim() ? binById.get(input.toLocationId.trim())?.code : void 0;
+  const scopedBins = filterLocationsByCodeRange(bins, fromCode, toCode);
+  const scopedBinIds = new Set(
+    scopedBins.map((b) => b.id?.trim()).filter((id) => Boolean(id))
+  );
+  if (scopedBinIds.size === 0) return [];
+  const items = [];
+  let page = 1;
+  let totalPages = 1;
+  while (page <= totalPages && page <= 20) {
+    const params = buildQuery({ page, pageSize: 100, warehouseId });
+    const call = await apiCall(
+      `/api/wms/inventory/balances?${params}`
+    );
+    if (!call.ok) throw new ScopeQueueError();
+    for (const row of call.result?.items ?? []) {
+      const locationId = row.location_id?.trim();
+      const variantId = row.catalog_variant_id?.trim();
+      const lotId = row.lot_id?.trim() || null;
+      const onHand = Number(row.quantity_on_hand ?? 0);
+      if (!locationId || !variantId) continue;
+      if (!scopedBinIds.has(locationId)) continue;
+      if (!Number.isFinite(onHand) || onHand <= 0) continue;
+      const bin = binById.get(locationId);
+      items.push({
+        locationId,
+        locationCode: bin?.code?.trim() ?? locationId,
+        catalogVariantId: variantId,
+        lotId,
+        expectedOnHand: onHand
+      });
+    }
+    totalPages = call.result?.totalPages ?? 1;
+    page += 1;
+  }
+  items.sort((a, b) => {
+    const cmp = a.locationCode.localeCompare(b.locationCode, void 0, {
+      numeric: true,
+      sensitivity: "base"
+    });
+    return cmp !== 0 ? cmp : a.catalogVariantId.localeCompare(b.catalogVariantId);
+  });
+  return items;
+}
+async function fetchVariantReorderPoint(catalogVariantId) {
+  if (!catalogVariantId) return 0;
+  const params = buildQuery({
+    page: 1,
+    pageSize: 1,
+    catalogVariantId
+  });
+  const call = await apiCall(
+    `/api/wms/inventory-profiles?${params}`
+  );
+  if (!call.ok) return 0;
+  const row = call.result?.items?.[0];
+  if (!row) return 0;
+  const reorderPoint = Number(row.reorder_point ?? 0);
+  return Number.isFinite(reorderPoint) ? reorderPoint : 0;
+}
+async function fetchLocationCapacityUnits(locationId) {
+  const id = locationId.trim();
+  if (!id) return null;
+  const params = buildQuery({ page: 1, pageSize: 1, ids: id });
+  const call = await apiCall(
+    `/api/wms/locations?${params}`
+  );
+  if (!call.ok) return null;
+  const raw = call.result?.items?.[0]?.capacity_units;
+  if (raw == null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+const LOCATION_TOTAL_ON_HAND_PAGE_SIZE = 100;
+const LOCATION_TOTAL_ON_HAND_MAX_PAGES = 50;
+async function fetchLocationTotalOnHand(input) {
+  const locationId = input.locationId.trim();
+  if (!locationId) return 0;
+  let sum = 0;
+  let page = 1;
+  let totalPages = 1;
+  do {
+    const params = buildQuery({
+      page,
+      pageSize: LOCATION_TOTAL_ON_HAND_PAGE_SIZE,
+      warehouseId: input.warehouseId,
+      locationId
+    });
+    const call = await apiCall(
+      `/api/wms/inventory/balances?${params}`
+    );
+    if (!call.ok) break;
+    for (const row of call.result?.items ?? []) {
+      const value = Number(row.quantity_on_hand ?? 0);
+      if (Number.isFinite(value)) sum += value;
+    }
+    totalPages = call.result?.totalPages ?? 1;
+    page += 1;
+  } while (page <= totalPages && page <= LOCATION_TOTAL_ON_HAND_MAX_PAGES);
+  return sum;
+}
+async function fetchLocationCapacitySnapshot(input) {
+  const [capacityUnits, totalOnHand] = await Promise.all([
+    fetchLocationCapacityUnits(input.locationId),
+    fetchLocationTotalOnHand(input)
+  ]);
+  return { capacityUnits, totalOnHand };
+}
+async function fetchBalanceOnHand(input) {
+  const params = buildQuery({
+    page: 1,
+    pageSize: 20,
+    warehouseId: input.warehouseId,
+    locationId: input.locationId,
+    catalogVariantId: input.catalogVariantId,
+    lotId: input.lotId?.trim() || void 0
+  });
+  const call = await apiCall(
+    `/api/wms/inventory/balances?${params}`
+  );
+  if (!call.ok) {
+    throw new BalanceLookupError();
+  }
+  const row = selectBalanceLookupRow(call.result?.items ?? [], input.lotId);
+  if (!row) return 0;
+  const onHand = Number(row.quantity_on_hand ?? 0);
+  return Number.isFinite(onHand) ? onHand : 0;
+}
+export {
+  BalanceLookupError,
+  InventoryLotMutationError,
+  ScopeEstimateError,
+  ScopeQueueError,
+  buildCycleCountScopeQueue,
+  buildQuery,
+  ensureLotIdForInventoryMutation,
+  fetchBalanceAvailable,
+  fetchBalanceOnHand,
+  fetchCycleCountScopeEstimate,
+  fetchLocationCapacitySnapshot,
+  fetchVariantReorderPoint,
+  filterLocationsByCodeRange,
+  findLotIdByNumber,
+  formatCycleCountZoneLabel,
+  loadAllLocations,
+  loadAssigneeOptions,
+  loadBinLocationOptions,
+  loadCatalogVariantOptions,
+  loadInventoryProfileForVariant,
+  loadLocationOptions,
+  loadLotNumberOptions,
+  loadLotOptions,
+  loadLotOptionsByIds,
+  loadLotOptionsForBalanceLocation,
+  loadWarehouseOptions,
+  loadZoneOptions,
+  mapLocationOptions,
+  resolveAssigneeLabel,
+  resolveCatalogVariantLabel,
+  resolveCatalogVariantSku,
+  resolveLocationLabel,
+  resolveLotLabel,
+  resolveLotNumberFromId,
+  resolveWarehouseLabel,
+  resolveZoneLabel,
+  resolveZoneWarehouseId
+};
+//# sourceMappingURL=inventoryMutationLoaders.js.map