From 4239361d992ea5d79b08d4976eaa14082716b846 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:13 -0300
Subject: [PATCH 01/32] docs: add CHANGELOG.md with project history

---
 CHANGELOG.md | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..2fba3c3
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,36 @@
+# Changelog
+
+### Added
+
+- Added production-only Microsoft Clarity tracking.
+- Added AI product image prompt generation, including prompt management, price overlay controls, image sharing support, and a dedicated prompt generation page.
+- Added a stock movement detail page with model, view, types, and focused tests.
+- Added IndexedDB-backed stock movement draft persistence and runtime recovery tracking.
+- Added stock movement submit progress feedback.
+- Added product form image processing locks to prevent submitting while images are still being processed.
+
+### Changed
+
+- Redesigned the main operational views for batches, products, catalog setup, sales, stock movements, system administration, transfers, and warehouses.
+- Modernized the product detail page with a restructured layout and fixed bottom action bar.
+- Moved product prompt generation out of the product prompt list flow and into its own page.
+- Split product image dropzone UI states for clearer current, selected, removed, and processing behavior.
+- Centralized dynamic chart component loading for the sales chart.
+- Improved batch model state handling and authentication submit loading state clarity.
+
+### Fixed
+
+- Fixed Recharts client-only loading issues.
+- Stabilized warehouse client hydration.
+- Refined stock movement draft routing and cleaned up lingering debounce timers in tests.
+- Fixed uploaded company logo preview rendering.
+- Fixed iOS PWA product prompt sharing flows by restoring touch interaction, returning to the prompt list, and blocking unsupported file sharing when needed.
+- Preserved product image removal state when a replacement file picker is cancelled.
+- Autofilled prompt pricing from the latest batch after async batch data loads.
+- Fixed prompt share cleanup callback types so production builds pass type checking.
+
+### Maintenance
+
+- Added a React Doctor report.
+- Updated project agent instructions.
+- Expanded model and browser tests around product prompts, stock movement details, draft storage, and image handling.

From ecd53f6d0b7137bf73a18c204920c57a647e596b Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:21 -0300
Subject: [PATCH 02/32] feat(barcode-scanner): add error modal with copy
 content functionality

---
 components/product/barcode-scanner.tsx | 77 +++++++++++++++++++++++---
 1 file changed, 69 insertions(+), 8 deletions(-)

diff --git a/components/product/barcode-scanner.tsx b/components/product/barcode-scanner.tsx
index 0e6b59d..75ca466 100644
--- a/components/product/barcode-scanner.tsx
+++ b/components/product/barcode-scanner.tsx
@@ -5,6 +5,8 @@ import {
   Scanner,
   type IScannerProps,
 } from "@yudiel/react-qr-scanner";
+import { Button } from "@/components/ui/button";
+import { ResponsiveModal } from "@/components/ui/responsive-modal";
 import {
   barcodeScannerFormats,
   createBarcodeScannerCameraConstraints,
@@ -16,6 +18,26 @@ type BarcodeScannerProps = Omit<IScannerProps, "constraints" | "formats">;
 
 const BARCODE_SCANNER_DEVICE_REFRESH_DELAYS_MS = [750, 2500] as const;
 
+const formatBarcodeScannerError = (error: unknown): string => {
+  if (error instanceof Error) {
+    return JSON.stringify(
+      {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      },
+      null,
+      2,
+    );
+  }
+
+  try {
+    return JSON.stringify(error, null, 2);
+  } catch {
+    return String(error);
+  }
+};
+
 export const BarcodeScanner = ({
   onError,
   onScan,
@@ -24,6 +46,7 @@ export const BarcodeScanner = ({
   const [usesCompatibleCamera, setUsesCompatibleCamera] = useState(false);
   const [cameraDeviceIds, setCameraDeviceIds] = useState<string[]>([]);
   const [cameraDeviceIndex, setCameraDeviceIndex] = useState(0);
+  const [scannerErrorContent, setScannerErrorContent] = useState<string | null>(null);
 
   const selectedCameraDeviceId = cameraDeviceIds[cameraDeviceIndex] ?? null;
   const cameraConstraints = useMemo(
@@ -56,6 +79,8 @@ export const BarcodeScanner = ({
 
   const handleScannerError = useCallback(
     (error: unknown) => {
+      setScannerErrorContent(formatBarcodeScannerError(error));
+
       if (shouldRetryBarcodeScannerCamera(error)) {
         selectNextCameraConfiguration();
       }
@@ -66,6 +91,11 @@ export const BarcodeScanner = ({
     [onError, refreshCameraDevices, selectNextCameraConfiguration],
   );
 
+  const handleCopyScannerError = useCallback((): void => {
+    if (!scannerErrorContent) return;
+    void navigator.clipboard?.writeText(scannerErrorContent);
+  }, [scannerErrorContent]);
+
   useEffect(() => {
     void refreshCameraDevices();
 
@@ -84,13 +114,44 @@ export const BarcodeScanner = ({
   }, [cameraDeviceIds.length]);
 
   return (
-    <Scanner
-      key={scannerKey}
-      {...scannerProps}
-      constraints={cameraConstraints}
-      formats={barcodeScannerFormats}
-      onScan={onScan}
-      onError={handleScannerError}
-    />
+    <>
+      <Scanner
+        key={scannerKey}
+        {...scannerProps}
+        constraints={cameraConstraints}
+        formats={barcodeScannerFormats}
+        onScan={onScan}
+        onError={handleScannerError}
+      />
+      <ResponsiveModal
+        open={scannerErrorContent !== null}
+        onOpenChange={(open) => !open && setScannerErrorContent(null)}
+        title="Erro no leitor"
+        description="Conteúdo capturado pelo leitor de código de barras."
+        footer={
+          <>
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => setScannerErrorContent(null)}
+              className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
+            >
+              Fechar
+            </Button>
+            <Button
+              type="button"
+              onClick={handleCopyScannerError}
+              className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:w-auto"
+            >
+              Copiar Conteúdo
+            </Button>
+          </>
+        }
+      >
+        <pre className="max-h-[360px] overflow-auto rounded-[4px] border border-neutral-800 bg-neutral-950 p-3 text-xs text-neutral-300 whitespace-pre-wrap">
+          {scannerErrorContent}
+        </pre>
+      </ResponsiveModal>
+    </>
   );
 };

From f8d183c58493a0d1909f0517c96442bd36feb887 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:29 -0300
Subject: [PATCH 03/32] feat(product-form): add existing product modal and
 batch overlay types

---
 .../products/components/product-form.types.ts | 59 ++++++++++++++++-
 .../products/components/product-form.view.tsx | 64 +++++++++++++++++++
 2 files changed, 122 insertions(+), 1 deletion(-)

diff --git a/app/(pages)/products/components/product-form.types.ts b/app/(pages)/products/components/product-form.types.ts
index 6bbc16c..be9fe90 100644
--- a/app/(pages)/products/components/product-form.types.ts
+++ b/app/(pages)/products/components/product-form.types.ts
@@ -2,6 +2,11 @@
 import { UseFormReturn } from "react-hook-form";
 import { ProductCreateFormData, AiFillData } from "../create/products-create.types";
 import { CustomAttribute } from "@/components/product/custom-attributes-builder";
+import type {
+  ExistingProductBatchFormState,
+  ExistingProductPriceSuggestion,
+  ExistingProductProfitSummary,
+} from "../../stock-movements/create/create-stock-movement.types";
 
 interface Category {
   id: string;
@@ -45,6 +50,33 @@ export interface BatchesDrawerProps {
   form: UseFormReturn<{ batches: BatchDrawerFormItem[] }>;
 }
 
+export interface ExistingProductInfo {
+  id: string;
+  name: string;
+  barcode: string;
+}
+
+export interface NewProductBatchOverlay {
+  batchForm: ExistingProductBatchFormState;
+  onBatchOpenChange: (open: boolean) => void;
+  onBatchQuantityChange: (quantity: string) => void;
+  onBatchQuantityIncrement: () => void;
+  onBatchQuantityDecrement: () => void;
+  onBatchManufacturedDateChange: (date: string) => void;
+  onBatchExpirationDateChange: (date: string) => void;
+  onBatchCostPriceChange: (price?: number) => void;
+  onBatchSellingPriceChange: (price?: number) => void;
+  onApplyBatchCostPriceSuggestion: () => void;
+  onApplyBatchSalePriceSuggestion: () => void;
+  onConfirmBatch: () => void;
+  batchCostPriceSuggestion: ExistingProductPriceSuggestion | null;
+  batchSalePriceSuggestion: ExistingProductPriceSuggestion | null;
+  isBatchPriceSuggestionLoading: boolean;
+  shouldShowMissingBatchCostPriceSuggestion: boolean;
+  shouldShowMissingBatchSalePriceSuggestion: boolean;
+  batchProfitSummary: ExistingProductProfitSummary;
+}
+
 /**
  * Props for the shared ProductForm component used in both create and edit modes.
  *
@@ -92,7 +124,32 @@ export interface ProductFormProps {
   openScanner: () => void;
   closeScanner: () => void;
   isScannerOpen: boolean;
-  handleBarcodeScan: (barcode: string) => void;
+  handleBarcodeScan: (barcode: string) => void | Promise<void>;
+
+  // Existing product modal (new-product page)
+  scannedExistingProduct: ExistingProductInfo | null;
+  onExistingProductModalOpenChange?: (open: boolean) => void;
+  onCreateBatchForExistingProduct?: () => void;
+
+  // Batch overlay (new-product page)
+  batchForm?: ExistingProductBatchFormState;
+  onBatchOpenChange?: (open: boolean) => void;
+  onBatchQuantityChange?: (quantity: string) => void;
+  onBatchQuantityIncrement?: () => void;
+  onBatchQuantityDecrement?: () => void;
+  onBatchManufacturedDateChange?: (date: string) => void;
+  onBatchExpirationDateChange?: (date: string) => void;
+  onBatchCostPriceChange?: (price?: number) => void;
+  onBatchSellingPriceChange?: (price?: number) => void;
+  onApplyBatchCostPriceSuggestion?: () => void;
+  onApplyBatchSalePriceSuggestion?: () => void;
+  onConfirmBatch?: () => void;
+  batchCostPriceSuggestion?: ExistingProductPriceSuggestion | null;
+  batchSalePriceSuggestion?: ExistingProductPriceSuggestion | null;
+  isBatchPriceSuggestionLoading?: boolean;
+  shouldShowMissingBatchCostPriceSuggestion?: boolean;
+  shouldShowMissingBatchSalePriceSuggestion?: boolean;
+  batchProfitSummary?: ExistingProductProfitSummary;
 
   // AI Fill
   isAiModalOpen?: boolean;
diff --git a/app/(pages)/products/components/product-form.view.tsx b/app/(pages)/products/components/product-form.view.tsx
index c52827c..5d36e47 100644
--- a/app/(pages)/products/components/product-form.view.tsx
+++ b/app/(pages)/products/components/product-form.view.tsx
@@ -6,6 +6,7 @@ import { CustomAttributesBuilder } from "@/components/product/custom-attributes-
 import { BarcodeScannerModal } from "@/components/product/barcode-scanner-modal";
 import { ProductAiFillModal } from "@/components/product/product-ai-fill-modal";
 import { ImageDropzone } from "@/components/product/image-dropzone";
+import { ResponsiveModal } from "@/components/ui/responsive-modal";
 import { Button } from "@/components/ui/button";
 import {
   Card,
@@ -49,6 +50,7 @@ import {
 import { Switch } from "@/components/ui/switch";
 import { Textarea } from "@/components/ui/textarea";
 import {
+  AlertCircle,
   Calendar,
   CheckCircle2,
   DollarSign,
@@ -222,6 +224,7 @@ const ProductFormShell = ({
       onClose={productForm.closeScanner}
       onScan={productForm.handleBarcodeScan}
     />
+    <ExistingProductFoundModal productForm={productForm} />
     <main className="mx-auto w-full max-w-7xl px-4 py-8 md:px-6 lg:px-8">
       <ProductAiModal productForm={productForm} viewState={viewState} />
       <ProductFormBody productForm={productForm} viewState={viewState} />
@@ -230,6 +233,67 @@ const ProductFormShell = ({
   </div>
 );
 
+const ExistingProductFoundModal = ({
+  productForm,
+}: {
+  productForm: ProductFormProps;
+}) => {
+  const { scannedExistingProduct, onExistingProductModalOpenChange, onCreateBatchForExistingProduct } = productForm;
+  if (!onExistingProductModalOpenChange || !onCreateBatchForExistingProduct) return null;
+
+  return (
+    <ResponsiveModal
+      open={scannedExistingProduct !== null}
+      onOpenChange={onExistingProductModalOpenChange}
+      title="Produto já existe"
+      description={`O produto "${scannedExistingProduct?.name}" já está cadastrado no sistema.`}
+      footer={
+        <>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => onExistingProductModalOpenChange(false)}
+            className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
+          >
+            Cancelar
+          </Button>
+          <Button
+            type="button"
+            onClick={onCreateBatchForExistingProduct}
+            className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:w-auto"
+          >
+            Adicionar Lote
+          </Button>
+        </>
+      }
+    >
+      <div className="space-y-4 pb-2 pt-2">
+        <div className="flex items-start gap-3 rounded-[4px] border border-amber-900/30 bg-amber-950/10 px-4 py-3">
+          <AlertCircle className="size-5 shrink-0 text-amber-500" />
+          <div className="space-y-1">
+            <p className="text-sm font-semibold text-amber-400">
+              Produto existente encontrado
+            </p>
+            <p className="text-xs text-amber-400/80">
+              Não é possível criar um novo produto com este código. Deseja adicionar um novo lote ao produto existente?
+            </p>
+          </div>
+        </div>
+        {scannedExistingProduct && (
+          <div className="rounded-[4px] border border-neutral-800 bg-neutral-900 px-4 py-3">
+            <p className="text-[10px] font-bold uppercase tracking-wider text-neutral-400">
+              Código de barras
+            </p>
+            <p className="mt-1 font-mono text-sm font-bold text-white">
+              {scannedExistingProduct.barcode}
+            </p>
+          </div>
+        )}
+      </div>
+    </ResponsiveModal>
+  );
+};
+
 const ProductAiModal = ({
   productForm,
   viewState,

From 89ae90ebc387362c71279f22429e3f0936e5b523 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:38 -0300
Subject: [PATCH 04/32] feat(stock-movements): replace missing product toast
 with modal dialog

---
 .../create-stock-movement.model.test.ts       | 11 +--
 .../create/create-stock-movement.model.ts     | 25 ++++---
 .../create/create-stock-movement.types.ts     |  3 +
 .../create/create-stock-movement.view.tsx     | 70 +++++++++++++++++++
 4 files changed, 93 insertions(+), 16 deletions(-)

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index 92f670a..c188899 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -1122,7 +1122,7 @@ describe("useCreateStockMovementModel", () => {
     });
   });
 
-  it("mostra erro com ação para criação quando produto não existe", async () => {
+  it("abre modal de produto não encontrado quando produto não existe", async () => {
     fakeApi.get.mockRejectedValue(new Error("não encontrado"));
 
     const { result } = renderHook(() => useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }));
@@ -1131,13 +1131,8 @@ describe("useCreateStockMovementModel", () => {
       await result.current.onBarcodeScan("7891009999999");
     });
 
-    const lastCall = fakeToast.error.mock.calls.at(-1);
-    expect(lastCall?.[0]).toBe("Produto com código 7891009999999 não existe.");
-    expect(lastCall?.[1]).toMatchObject({
-      action: {
-        label: "Criar Produto",
-      },
-    });
+    expect(result.current.missingProductBarcode).toBe("7891009999999");
+    expect(fakeToast.error).not.toHaveBeenCalled();
   });
 
   it("mostra aviso sem ação para tipo de saída", async () => {
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index bcd0ef1..c85ff15 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -283,6 +283,7 @@ export function useCreateStockMovementModel({
   const [addItemError, setAddItemError] = useState<string | null>(null);
   const [isScannerOpen, setIsScannerOpen] = useState(false);
   const [isFooterVisible, setIsFooterVisible] = useState(false);
+  const [missingProductBarcode, setMissingProductBarcode] = useState<string | null>(null);
   const [existingProductBatchForm, setExistingProductBatchForm] =
     useState<ExistingProductBatchFormState>(EMPTY_EXISTING_BATCH_FORM);
   const lastScannedBarcodeRef = useRef<string | null>(null);
@@ -901,14 +902,19 @@ export function useCreateStockMovementModel({
       return;
     }
 
-    toast.error(`Produto com código ${barcode} não existe.`, {
-      action: {
-        label: "Criar Produto",
-        onClick: () => {
-          void navigateToInlineProductWithBarcode(barcode);
-        },
-      },
-    });
+    setMissingProductBarcode(barcode);
+  };
+
+  const handleMissingProductModalOpenChange = (open: boolean): void => {
+    if (!open) {
+      setMissingProductBarcode(null);
+    }
+  };
+
+  const handleCreateProductFromMissingModal = async (): Promise<void> => {
+    if (!missingProductBarcode) return;
+    await navigateToInlineProductWithBarcode(missingProductBarcode);
+    setMissingProductBarcode(null);
   };
 
   const onSubmit = async (data: CreateStockMovementSchema) => {
@@ -1000,5 +1006,8 @@ export function useCreateStockMovementModel({
     shouldShowMissingSalePriceSuggestion,
     existingProductProfitSummary,
     items: fields,
+    missingProductBarcode,
+    onMissingProductModalOpenChange: handleMissingProductModalOpenChange,
+    onCreateProductFromMissingModal: handleCreateProductFromMissingModal,
   };
 }
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.types.ts b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
index 3c14b62..cf070c4 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.types.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
@@ -153,6 +153,9 @@ export interface CreateStockMovementViewProps {
   shouldShowMissingCostPriceSuggestion: boolean;
   shouldShowMissingSalePriceSuggestion: boolean;
   existingProductProfitSummary: ExistingProductProfitSummary;
+  missingProductBarcode: string | null;
+  onMissingProductModalOpenChange: (open: boolean) => void;
+  onCreateProductFromMissingModal: () => void;
   items: Array<{
     id: string;
     productId?: string;
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
index bed48c4..b0a6a68 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
+++ b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
@@ -126,6 +126,7 @@ function StockMovementCreateOverlays({
     onApplyExistingProductSalePriceSuggestion,
     onBarcodeScan,
     onConfirmExistingProductBatchData,
+    onCreateProductFromMissingModal,
     onExistingProductBatchCostPriceChange,
     onExistingProductBatchExpirationDateChange,
     onExistingProductBatchManufacturedDateChange,
@@ -134,11 +135,13 @@ function StockMovementCreateOverlays({
     onExistingProductBatchQuantityDecrement,
     onExistingProductBatchQuantityIncrement,
     onExistingProductBatchSellingPriceChange,
+    onMissingProductModalOpenChange,
     existingProductCostPriceSuggestion,
     existingProductProfitSummary,
     existingProductSalePriceSuggestion,
     isExistingProductPriceSuggestionLoading,
     isScannerOpen,
+    missingProductBarcode,
     onScannerOpenChange,
     shouldShowMissingCostPriceSuggestion,
     shouldShowMissingSalePriceSuggestion,
@@ -171,6 +174,11 @@ function StockMovementCreateOverlays({
         shouldShowMissingSalePriceSuggestion={shouldShowMissingSalePriceSuggestion}
         profitSummary={existingProductProfitSummary}
       />
+      <StockMovementMissingProductModal
+        barcode={missingProductBarcode}
+        onOpenChange={onMissingProductModalOpenChange}
+        onCreateProduct={onCreateProductFromMissingModal}
+      />
     </>
   );
 }
@@ -656,3 +664,65 @@ function StockMovementSubmitOverlay({
     </div>
   );
 }
+
+function StockMovementMissingProductModal({
+  barcode,
+  onOpenChange,
+  onCreateProduct,
+}: {
+  barcode: string | null;
+  onOpenChange: (open: boolean) => void;
+  onCreateProduct: () => void;
+}) {
+  return (
+    <ResponsiveModal
+      open={barcode !== null}
+      onOpenChange={onOpenChange}
+      title="Produto não encontrado"
+      description={`O produto com código "${barcode}" não foi encontrado no sistema.`}
+      footer={
+        <>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => onOpenChange(false)}
+            className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
+          >
+            Cancelar
+          </Button>
+          <Button
+            type="button"
+            onClick={onCreateProduct}
+            className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:w-auto"
+          >
+            Criar Produto
+          </Button>
+        </>
+      }
+    >
+      <div className="space-y-4 pb-2 pt-2">
+        <div className="flex items-start gap-3 rounded-[4px] border border-amber-900/30 bg-amber-950/10 px-4 py-3">
+          <AlertCircle className="size-5 shrink-0 text-amber-500" />
+          <div className="space-y-1">
+            <p className="text-sm font-semibold text-amber-400">
+              Produto inexistente
+            </p>
+            <p className="text-xs text-amber-400/80">
+              Deseja criar um novo produto com este código de barras?
+            </p>
+          </div>
+        </div>
+        {barcode && (
+          <div className="rounded-[4px] border border-neutral-800 bg-neutral-900 px-4 py-3">
+            <p className="text-[10px] font-bold uppercase tracking-wider text-neutral-400">
+              Código de barras
+            </p>
+            <p className="mt-1 font-mono text-sm font-bold text-white">
+              {barcode}
+            </p>
+          </div>
+        )}
+      </div>
+    </ResponsiveModal>
+  );
+}

From 434fd2a4f95da63a20382c727e351f6eda030c69 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:46 -0300
Subject: [PATCH 05/32] feat(new-product-inline): check API for existing
 product on barcode scan and allow adding batch

---
 .../new-product-inline.model.test.ts          |  80 ++++++-
 .../new-product/new-product-inline.model.ts   | 196 +++++++++++++++++-
 .../create/new-product/page.client.tsx        |  35 ++++
 3 files changed, 305 insertions(+), 6 deletions(-)

diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
index 3913eeb..654d0a8 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
@@ -105,6 +105,10 @@ vi.mock("@/components/breadcrumb", () => ({
   useBreadcrumb: vi.fn(),
 }));
 
+vi.mock("@/hooks/use-selected-warehouse", () => ({
+  useSelectedWarehouse: () => ({ warehouseId: "wh-1" }),
+}));
+
 vi.mock("../create-stock-movement.storage", () => ({
   fileToInlineProductImage: async (file: File) => ({
     name: file.name,
@@ -501,7 +505,12 @@ describe("useNewProductInlineModel", () => {
     expect(mockRedirect).not.toHaveBeenCalled();
   });
 
-  it("alterna estado do scanner e registra barcode escaneado", () => {
+  it("alterna estado do scanner e preenche barcode quando produto não existe na API", async () => {
+    mockGet.mockReset();
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => { throw new Error("não encontrado"); }),
+    }));
+
     const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
 
     expect(result.current.isScannerOpen).toBe(false);
@@ -510,10 +519,12 @@ describe("useNewProductInlineModel", () => {
     });
     expect(result.current.isScannerOpen).toBe(true);
 
-    act(() => {
-      result.current.handleBarcodeScan("123456789");
+    await act(async () => {
+      await result.current.handleBarcodeScan("123456789");
     });
-    expect(result.current.form.getValues("barcode")).toBe("123456789");
+
+    expect(mockGet).toHaveBeenCalledWith("products/barcode/123456789");
+    expect(result.current.scannedExistingProduct).toBeNull();
 
     act(() => {
       result.current.closeScanner();
@@ -521,6 +532,67 @@ describe("useNewProductInlineModel", () => {
     expect(result.current.isScannerOpen).toBe(false);
   });
 
+  it("abre modal de produto existente quando barcode escaneado encontra produto", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-123", name: "Produto Existente", barcode: "987654321" },
+      })),
+    }));
+
+    const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("987654321");
+    });
+
+    expect(result.current.scannedExistingProduct).toEqual({
+      id: "p-123",
+      name: "Produto Existente",
+      barcode: "987654321",
+    });
+    expect(result.current.form.getValues("barcode")).toBe("7891000000001");
+  });
+
+  it("abre formulário de lote ao confirmar produto existente e adiciona ao draft", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-123", name: "Produto Existente", barcode: "987654321" },
+      })),
+    }));
+
+    const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("987654321");
+    });
+
+    act(() => {
+      result.current.onCreateBatchForExistingProduct?.();
+    });
+
+    expect(result.current.scannedExistingProduct).toBeNull();
+    expect(result.current.batchForm?.isOpen).toBe(true);
+    expect(result.current.batchForm?.productId).toBe("p-123");
+    expect(result.current.batchForm?.productName).toBe("Produto Existente");
+
+    act(() => {
+      result.current.onBatchQuantityChange?.("5");
+      result.current.onBatchCostPriceChange?.(1000);
+      result.current.onBatchSellingPriceChange?.(1500);
+    });
+
+    await act(async () => {
+      await result.current.onConfirmBatch?.();
+    });
+
+    expect(toastSuccess).toHaveBeenCalledWith("Produto Existente foi adicionado.");
+    expect(result.current.batchForm?.isOpen).toBe(false);
+    expect(result.current.form.getValues("name")).toBe("");
+    expect(mockWriteDraft).toHaveBeenCalled();
+  });
+
   it("controla quantidade com incremento e decremento sem ficar negativa", () => {
     const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
 
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
index e7ee88c..0bca05e 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
@@ -9,6 +9,7 @@ import { toast } from "sonner";
 
 import { useBreadcrumb } from "@/components/breadcrumb";
 import { api } from "@/lib/api";
+import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
 import { CustomAttribute } from "@/components/product/custom-attributes-builder";
 import {
   AiFillData,
@@ -18,10 +19,13 @@ import {
 } from "../../../products/create/products-create.types";
 import { applyProductAiFillData } from "../../../products/components/product-ai-fill.model";
 import { productInlineSchema } from "../../../products/create/products-create.schema";
-import { ProductFormProps } from "../../../products/components/product-form.types";
+import { ProductFormProps, ExistingProductInfo } from "../../../products/components/product-form.types";
 import type {
   InlineProductData,
   StockMovementDraftItem,
+  ExistingProductBatchFormState,
+  StockMovementProductBatchesResponse,
+  StockMovementProductOption,
 } from "../create-stock-movement.types";
 import { isManualMovementType } from "../../stock-movements.constants";
 import {
@@ -31,6 +35,13 @@ import {
   writeStockMovementDraft,
 } from "../create-stock-movement.storage";
 import type { StockMovementDraft } from "../create-stock-movement.storage";
+import {
+  buildExistingProductBatchesUrl,
+  buildExistingProductProfitSummary,
+  buildExistingProductSalePriceSuggestion,
+  buildExistingProductCostPriceSuggestion,
+  findMostRecentWarehouseProductBatch,
+} from "../stock-movement-batch-pricing.model";
 
 const buildReturnHref = (type: string | null): string => {
   if (!isManualMovementType(type)) return "/stock-movements/create";
@@ -108,6 +119,31 @@ const buildInlineMovementItem = (
   newProductData: product,
 });
 
+const buildExistingProductBatchItem = (
+  productId: string,
+  productName: string,
+  form: ExistingProductBatchFormState,
+): StockMovementDraftItem => ({
+  productId,
+  productName,
+  quantity: Number(form.quantity),
+  manufacturedDate: form.manufacturedDate || undefined,
+  expirationDate: form.expirationDate || undefined,
+  costPrice: form.costPrice,
+  sellingPrice: form.sellingPrice,
+});
+
+const EMPTY_BATCH_FORM: ExistingProductBatchFormState = {
+  isOpen: false,
+  productId: "",
+  productName: "",
+  quantity: "",
+  manufacturedDate: "",
+  expirationDate: "",
+  editingIndex: null,
+  error: null,
+};
+
 const isInlineProductRouteReady = (
   movementType: string | null,
   initialDraft: StockMovementDraft | null,
@@ -133,6 +169,18 @@ const appendProductToMovementDraft = (
   }));
 };
 
+const appendExistingProductBatchToDraft = (
+  item: StockMovementDraftItem,
+): Promise<void> => {
+  return updateMovementDraft((draft) => ({
+    ...draft,
+    items: [...draft.items, item],
+    selectedProductId: "",
+    itemQuantity: "",
+    inlineProductBarcode: undefined,
+  }));
+};
+
 const updateMovementDraft = async (
   buildNextDraft: (draft: StockMovementDraft) => StockMovementDraft,
 ): Promise<void> => {
@@ -184,7 +232,10 @@ export const useNewProductInlineModel = ({
   );
   const [isScannerOpen, setIsScannerOpen] = useState(false);
   const [isAiModalOpen, setIsAiModalOpen] = useState(false);
+  const [scannedExistingProduct, setScannedExistingProduct] = useState<ExistingProductInfo | null>(null);
+  const [existingProductBatchForm, setExistingProductBatchForm] = useState<ExistingProductBatchFormState>(EMPTY_BATCH_FORM);
   const nameInputRef = useRef<HTMLInputElement>(null);
+  const { warehouseId } = useSelectedWarehouse();
 
   useBreadcrumb({
     title: isEditingInlineProduct ? "Editar Produto" : "Novo Produto",
@@ -203,6 +254,28 @@ export const useNewProductInlineModel = ({
       api.get(url).json<BrandsResponse>(),
     );
 
+  const batchProductId = existingProductBatchForm.isOpen ? existingProductBatchForm.productId : null;
+  const productBatchesUrl = buildExistingProductBatchesUrl(warehouseId, batchProductId);
+  const { data: productBatchesData, isLoading: isLoadingProductBatches } =
+    useSWR<StockMovementProductBatchesResponse>(
+      productBatchesUrl,
+      (url: string) => api.get(url).json<StockMovementProductBatchesResponse>(),
+    );
+  const mostRecentBatch = findMostRecentWarehouseProductBatch(productBatchesData?.data ?? []);
+  const batchCostPriceSuggestion = buildExistingProductCostPriceSuggestion(mostRecentBatch);
+  const batchSalePriceSuggestion = buildExistingProductSalePriceSuggestion(mostRecentBatch);
+  const batchProfitSummary = buildExistingProductProfitSummary({
+    quantity: existingProductBatchForm.quantity,
+    costPrice: existingProductBatchForm.costPrice,
+    sellingPrice: existingProductBatchForm.sellingPrice,
+  });
+  const shouldShowMissingBatchCostPriceSuggestion = Boolean(
+    productBatchesUrl && !isLoadingProductBatches && !batchCostPriceSuggestion,
+  );
+  const shouldShowMissingBatchSalePriceSuggestion = Boolean(
+    productBatchesUrl && !isLoadingProductBatches && !batchSalePriceSuggestion,
+  );
+
   const form = useForm<ProductCreateFormData>({
     resolver: zodResolver(productInlineSchema),
     defaultValues: {
@@ -391,6 +464,104 @@ export const useNewProductInlineModel = ({
     window.setTimeout(() => nameInputRef.current?.focus(), 100);
   };
 
+  const handleBarcodeScan = async (barcode: string): Promise<void> => {
+    try {
+      const response = await api
+        .get(`products/barcode/${encodeURIComponent(barcode)}`)
+        .json<{ success: boolean; data: StockMovementProductOption }>();
+      setScannedExistingProduct({
+        id: response.data.id,
+        name: response.data.name,
+        barcode,
+      });
+    } catch {
+      form.setValue("barcode", barcode);
+    }
+  };
+
+  const handleExistingProductModalOpenChange = (open: boolean): void => {
+    if (!open) {
+      setScannedExistingProduct(null);
+    }
+  };
+
+  const handleCreateBatchForExistingProduct = (): void => {
+    if (!scannedExistingProduct) return;
+    setExistingProductBatchForm({
+      ...EMPTY_BATCH_FORM,
+      isOpen: true,
+      productId: scannedExistingProduct.id,
+      productName: scannedExistingProduct.name,
+    });
+    setScannedExistingProduct(null);
+  };
+
+  const updateBatchForm = (
+    patch: Partial<ExistingProductBatchFormState>,
+  ): void => {
+    setExistingProductBatchForm((current) => ({
+      ...current,
+      ...patch,
+      error: patch.error ?? null,
+    }));
+  };
+
+  const handleBatchOpenChange = (open: boolean): void => {
+    if (!open) {
+      setExistingProductBatchForm(EMPTY_BATCH_FORM);
+    }
+  };
+
+  const handleConfirmBatch = async (): Promise<void> => {
+    const quantity = Number(existingProductBatchForm.quantity);
+    if (!quantity || quantity <= 0) {
+      updateBatchForm({ error: "Informe uma quantidade válida para o lote." });
+      return;
+    }
+
+    if (existingProductBatchForm.costPrice === undefined || existingProductBatchForm.costPrice < 0) {
+      updateBatchForm({ error: "Informe um preço de custo válido." });
+      return;
+    }
+
+    if (existingProductBatchForm.sellingPrice === undefined || existingProductBatchForm.sellingPrice < 0) {
+      updateBatchForm({ error: "Informe um preço de venda válido." });
+      return;
+    }
+
+    const item = buildExistingProductBatchItem(
+      existingProductBatchForm.productId,
+      existingProductBatchForm.productName,
+      existingProductBatchForm,
+    );
+
+    await appendExistingProductBatchToDraft(item);
+    toast.success(`${existingProductBatchForm.productName} foi adicionado.`);
+    setExistingProductBatchForm(EMPTY_BATCH_FORM);
+    resetInlineFormForNextProduct();
+  };
+
+  const handleApplyBatchCostPriceSuggestion = (): void => {
+    if (!batchCostPriceSuggestion) return;
+    updateBatchForm({ costPrice: batchCostPriceSuggestion.priceCents });
+  };
+
+  const handleApplyBatchSalePriceSuggestion = (): void => {
+    if (!batchSalePriceSuggestion) return;
+    updateBatchForm({ sellingPrice: batchSalePriceSuggestion.priceCents });
+  };
+
+  const handleBatchQuantityIncrement = (): void => {
+    const current = Number(existingProductBatchForm.quantity) || 0;
+    updateBatchForm({ quantity: String(current + 1) });
+  };
+
+  const handleBatchQuantityDecrement = (): void => {
+    const current = Number(existingProductBatchForm.quantity) || 0;
+    const next = Math.max(current - 1, 0);
+    updateBatchForm({ quantity: next > 0 ? String(next) : "" });
+  };
+
   const updateInlineQuantity = (quantity: number): void => {
     form.setValue("quantity", Math.max(0, quantity), {
       shouldDirty: true,
@@ -475,7 +646,7 @@ export const useNewProductInlineModel = ({
     openScanner: () => setIsScannerOpen(true),
     closeScanner: () => setIsScannerOpen(false),
     isScannerOpen,
-    handleBarcodeScan: (barcode: string) => form.setValue("barcode", barcode),
+    handleBarcodeScan,
     isAiModalOpen,
     openAiModal: () => setIsAiModalOpen(true),
     closeAiModal: () => setIsAiModalOpen(false),
@@ -486,5 +657,26 @@ export const useNewProductInlineModel = ({
     isInlineEdit: isEditingInlineProduct,
     onQuantityIncrement,
     onQuantityDecrement,
+    scannedExistingProduct,
+    onExistingProductModalOpenChange: handleExistingProductModalOpenChange,
+    onCreateBatchForExistingProduct: handleCreateBatchForExistingProduct,
+    batchForm: existingProductBatchForm,
+    onBatchOpenChange: handleBatchOpenChange,
+    onBatchQuantityChange: (quantity: string) => updateBatchForm({ quantity }),
+    onBatchQuantityIncrement: handleBatchQuantityIncrement,
+    onBatchQuantityDecrement: handleBatchQuantityDecrement,
+    onBatchManufacturedDateChange: (date: string) => updateBatchForm({ manufacturedDate: date }),
+    onBatchExpirationDateChange: (date: string) => updateBatchForm({ expirationDate: date }),
+    onBatchCostPriceChange: (price?: number) => updateBatchForm({ costPrice: price }),
+    onBatchSellingPriceChange: (price?: number) => updateBatchForm({ sellingPrice: price }),
+    onApplyBatchCostPriceSuggestion: handleApplyBatchCostPriceSuggestion,
+    onApplyBatchSalePriceSuggestion: handleApplyBatchSalePriceSuggestion,
+    onConfirmBatch: handleConfirmBatch,
+    batchCostPriceSuggestion,
+    batchSalePriceSuggestion,
+    isBatchPriceSuggestionLoading: isLoadingProductBatches,
+    shouldShowMissingBatchCostPriceSuggestion,
+    shouldShowMissingBatchSalePriceSuggestion,
+    batchProfitSummary,
   };
 };
diff --git a/app/(pages)/stock-movements/create/new-product/page.client.tsx b/app/(pages)/stock-movements/create/new-product/page.client.tsx
index 7cc20b4..b251c1f 100644
--- a/app/(pages)/stock-movements/create/new-product/page.client.tsx
+++ b/app/(pages)/stock-movements/create/new-product/page.client.tsx
@@ -4,6 +4,7 @@ import { Suspense } from "react";
 import { ProductForm } from "../../../products/components/product-form.view";
 import { useNewProductInlineModel } from "./new-product-inline.model";
 import { StockMovementReloadGuard } from "../stock-movement-reload-guard";
+import { StockMovementBatchDataModal } from "../stock-movement-batch-data-modal.view";
 
 interface NewProductInlineContentProps {
   movementType: string | null;
@@ -15,10 +16,44 @@ function NewProductInlineContent({
   editItem,
 }: NewProductInlineContentProps) {
   const model = useNewProductInlineModel({ movementType, editItem });
+  const isBatchOverlayOpen = model.batchForm?.isOpen ?? false;
+
   return (
     <>
       <StockMovementReloadGuard />
       <ProductForm {...model} />
+      {isBatchOverlayOpen && (
+        <div className="fixed inset-0 z-40 bg-[#0A0A0A]" />
+      )}
+      <StockMovementBatchDataModal
+        form={model.batchForm ?? {
+          isOpen: false,
+          productId: "",
+          productName: "",
+          quantity: "",
+          manufacturedDate: "",
+          expirationDate: "",
+          editingIndex: null,
+          error: null,
+        }}
+        onOpenChange={model.onBatchOpenChange ?? (() => {})}
+        onQuantityChange={model.onBatchQuantityChange ?? (() => {})}
+        onQuantityIncrement={model.onBatchQuantityIncrement ?? (() => {})}
+        onQuantityDecrement={model.onBatchQuantityDecrement ?? (() => {})}
+        onManufacturedDateChange={model.onBatchManufacturedDateChange ?? (() => {})}
+        onExpirationDateChange={model.onBatchExpirationDateChange ?? (() => {})}
+        onCostPriceChange={model.onBatchCostPriceChange ?? (() => {})}
+        onSellingPriceChange={model.onBatchSellingPriceChange ?? (() => {})}
+        onApplyCostPriceSuggestion={model.onApplyBatchCostPriceSuggestion ?? (() => {})}
+        onApplySalePriceSuggestion={model.onApplyBatchSalePriceSuggestion ?? (() => {})}
+        onConfirm={model.onConfirmBatch ?? (() => {})}
+        costPriceSuggestion={model.batchCostPriceSuggestion ?? null}
+        salePriceSuggestion={model.batchSalePriceSuggestion ?? null}
+        isPriceSuggestionLoading={model.isBatchPriceSuggestionLoading ?? false}
+        shouldShowMissingCostPriceSuggestion={model.shouldShowMissingBatchCostPriceSuggestion ?? false}
+        shouldShowMissingSalePriceSuggestion={model.shouldShowMissingBatchSalePriceSuggestion ?? false}
+        profitSummary={model.batchProfitSummary ?? { kind: "incomplete", title: "" }}
+      />
     </>
   );
 }

From 16cd0ee50b6ca5a632d2647ef7adbbb2b3dadbb7 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 20:52:56 -0300
Subject: [PATCH 06/32] refactor(transfers): extract subcomponents, add batch
 drawer, product search, scanner, and helper functions

---
 .../new/new-transfer-batch-drawer.view.tsx    | 403 +++++++++++++
 .../new/new-transfer-items-list.view.tsx      | 207 +++++++
 .../new/new-transfer-product-search.view.tsx  | 196 +++++++
 .../new/new-transfer-scanner.view.tsx         |  91 +++
 .../transfers/new/new-transfer.model.test.ts  | 549 +++++++++++++-----
 .../transfers/new/new-transfer.model.ts       | 504 +++++++++++++---
 .../transfers/new/new-transfer.types.ts       |  67 ++-
 .../transfers/new/new-transfer.view.test.tsx  |  85 ++-
 .../transfers/new/new-transfer.view.tsx       | 373 ++----------
 9 files changed, 1907 insertions(+), 568 deletions(-)
 create mode 100644 app/(pages)/transfers/new/new-transfer-batch-drawer.view.tsx
 create mode 100644 app/(pages)/transfers/new/new-transfer-items-list.view.tsx
 create mode 100644 app/(pages)/transfers/new/new-transfer-product-search.view.tsx
 create mode 100644 app/(pages)/transfers/new/new-transfer-scanner.view.tsx

diff --git a/app/(pages)/transfers/new/new-transfer-batch-drawer.view.tsx b/app/(pages)/transfers/new/new-transfer-batch-drawer.view.tsx
new file mode 100644
index 0000000..54cf479
--- /dev/null
+++ b/app/(pages)/transfers/new/new-transfer-batch-drawer.view.tsx
@@ -0,0 +1,403 @@
+"use client";
+
+import type { ReactNode } from "react";
+import {
+  AlertCircle,
+  CalendarDays,
+  Check,
+  Loader2,
+  Minus,
+  PackageCheck,
+  Plus,
+  X,
+} from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import {
+  Drawer,
+  DrawerContent,
+  DrawerDescription,
+  DrawerFooter,
+  DrawerHeader,
+  DrawerTitle,
+} from "@/components/ui/drawer";
+import { NumberInput } from "@/components/ui/number-input";
+import { cn } from "@/lib/utils";
+import type {
+  TransferBatchDrawerState,
+  TransferBatchOption,
+} from "./new-transfer.types";
+
+interface NewTransferBatchDrawerProps {
+  form: TransferBatchDrawerState;
+  batches: TransferBatchOption[];
+  isLoading: boolean;
+  onOpenChange: (open: boolean) => void;
+  onBatchChange: (batchId: string) => void;
+  onQuantityChange: (quantity: string) => void;
+  onQuantityIncrement: () => void;
+  onQuantityDecrement: () => void;
+  onConfirm: () => void;
+}
+
+const transferBatchDateFormatter = new Intl.DateTimeFormat("pt-BR");
+
+export function NewTransferBatchDrawer({
+  form,
+  batches,
+  isLoading,
+  onOpenChange,
+  onBatchChange,
+  onQuantityChange,
+  onQuantityIncrement,
+  onQuantityDecrement,
+  onConfirm,
+}: NewTransferBatchDrawerProps) {
+  const selectedBatch = batches.find((batch) => batch.id === form.selectedBatchId);
+
+  return (
+    <Drawer open={form.isOpen} onOpenChange={onOpenChange} direction="bottom">
+      <DrawerContent className="max-h-[88vh] rounded-t-[4px] border-neutral-800 bg-[#171717]">
+        <TransferBatchDrawerHeader onOpenChange={onOpenChange} />
+        <div className="min-h-0 overflow-y-auto px-4 pb-4">
+          <TransferBatchProductSummary form={form} />
+          <TransferBatchOptions
+            batches={batches}
+            isLoading={isLoading}
+            quantity={form.quantity}
+            selectedBatchId={form.selectedBatchId}
+            onBatchChange={onBatchChange}
+          />
+          <TransferBatchQuantitySection
+            quantity={form.quantity}
+            selectedBatch={selectedBatch}
+            onQuantityChange={onQuantityChange}
+            onQuantityIncrement={onQuantityIncrement}
+            onQuantityDecrement={onQuantityDecrement}
+          />
+          <TransferBatchDrawerError error={form.error} />
+        </div>
+        <DrawerFooter className="flex-row gap-3 border-t border-neutral-800 px-4 pb-5 pt-4">
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => onOpenChange(false)}
+            className="h-10 flex-1 rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide"
+          >
+            Cancelar
+          </Button>
+          <Button
+            type="button"
+            disabled={isLoading || batches.length === 0}
+            onClick={onConfirm}
+            className="h-10 flex-1 rounded-[4px] bg-emerald-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-emerald-700 disabled:opacity-40"
+          >
+            Adicionar
+          </Button>
+        </DrawerFooter>
+      </DrawerContent>
+    </Drawer>
+  );
+}
+
+function TransferBatchDrawerHeader({
+  onOpenChange,
+}: {
+  onOpenChange: (open: boolean) => void;
+}) {
+  return (
+    <DrawerHeader className="border-b border-neutral-800 px-4 py-3 text-left">
+      <div className="flex items-center justify-between gap-3">
+        <div className="flex min-w-0 items-center gap-2">
+          <PackageCheck className="size-4 text-emerald-400" strokeWidth={2.5} />
+          <div className="min-w-0">
+            <DrawerTitle className="text-sm font-bold uppercase tracking-wide text-white">
+              Qual lote será utilizado?
+            </DrawerTitle>
+            <DrawerDescription className="text-[10px] text-neutral-500">
+              Escolha o lote e a quantidade que será transferida
+            </DrawerDescription>
+          </div>
+        </div>
+        <Button
+          type="button"
+          variant="ghost"
+          size="icon"
+          onClick={() => onOpenChange(false)}
+          className="size-8 rounded-[4px] text-neutral-400 hover:bg-neutral-800 hover:text-white"
+        >
+          <X className="size-4" strokeWidth={2} />
+        </Button>
+      </div>
+    </DrawerHeader>
+  );
+}
+
+function TransferBatchProductSummary({
+  form,
+}: {
+  form: TransferBatchDrawerState;
+}) {
+  return (
+    <div className="mt-4 rounded-[4px] border border-neutral-800 bg-neutral-900 px-4 py-3">
+      <p className="text-[10px] font-bold uppercase tracking-widest text-neutral-500">
+        Produto
+      </p>
+      <p className="mt-1 truncate text-sm font-bold text-white">
+        {form.productName || "Produto"}
+      </p>
+    </div>
+  );
+}
+
+function TransferBatchOptions({
+  batches,
+  isLoading,
+  quantity,
+  selectedBatchId,
+  onBatchChange,
+}: {
+  batches: TransferBatchOption[];
+  isLoading: boolean;
+  quantity: string;
+  selectedBatchId: string;
+  onBatchChange: (batchId: string) => void;
+}) {
+  if (isLoading) return <TransferBatchLoading />;
+  if (batches.length === 0) return <TransferBatchEmpty />;
+
+  return (
+    <div className="mt-4 space-y-2">
+      <p className="text-[10px] font-bold uppercase tracking-wider text-neutral-400">
+        Lotes disponíveis
+      </p>
+      {batches.map((batch) => (
+        <TransferBatchOptionCard
+          key={batch.id}
+          batch={batch}
+          isSelected={batch.id === selectedBatchId}
+          quantity={quantity}
+          onBatchChange={onBatchChange}
+        />
+      ))}
+    </div>
+  );
+}
+
+function TransferBatchOptionCard({
+  batch,
+  isSelected,
+  quantity,
+  onBatchChange,
+}: {
+  batch: TransferBatchOption;
+  isSelected: boolean;
+  quantity: string;
+  onBatchChange: (batchId: string) => void;
+}) {
+  return (
+    <Button
+      type="button"
+      variant="ghost"
+      onClick={() => onBatchChange(batch.id)}
+      className={cn(
+        "h-auto w-full rounded-[4px] border p-0 text-left hover:bg-neutral-800 hover:text-white",
+        isSelected
+          ? "border-emerald-600 bg-emerald-950/20"
+          : "border-neutral-800 bg-[#0A0A0A]",
+      )}
+    >
+      <div className="flex w-full items-start gap-3 p-3">
+        <TransferBatchSelectionIcon isSelected={isSelected} />
+        <TransferBatchOptionDetails batch={batch} />
+        <TransferBatchQuantityBadge
+          isSelected={isSelected}
+          quantity={quantity}
+        />
+      </div>
+    </Button>
+  );
+}
+
+function TransferBatchSelectionIcon({ isSelected }: { isSelected: boolean }) {
+  return (
+    <span
+      className={cn(
+        "mt-0.5 flex size-5 shrink-0 items-center justify-center rounded-[4px] border",
+        isSelected
+          ? "border-emerald-500 bg-emerald-600 text-white"
+          : "border-neutral-700 bg-neutral-900 text-transparent",
+      )}
+    >
+      <Check className="size-3.5" strokeWidth={2.5} />
+    </span>
+  );
+}
+
+function TransferBatchOptionDetails({
+  batch,
+}: {
+  batch: TransferBatchOption;
+}) {
+  return (
+    <span className="min-w-0 flex-1">
+      <span className="block font-mono text-xs font-bold tracking-tighter text-white">
+        {batch.batchCode}
+      </span>
+      <span className="mt-1 flex flex-wrap gap-x-3 gap-y-1 text-[10px] uppercase tracking-wide text-neutral-500">
+        <span>{batch.quantity} un. disponíveis</span>
+        <span className="flex items-center gap-1">
+          <CalendarDays className="size-3" />
+          Validade: {formatTransferBatchDate(batch.expirationDate, "Sem validade")}
+        </span>
+      </span>
+      {batch.manufacturedDate ? (
+        <span className="mt-1 block text-[10px] uppercase tracking-wide text-neutral-600">
+          Fabricação: {formatTransferBatchDate(batch.manufacturedDate, "-")}
+        </span>
+      ) : null}
+    </span>
+  );
+}
+
+function TransferBatchQuantityBadge({
+  isSelected,
+  quantity,
+}: {
+  isSelected: boolean;
+  quantity: string;
+}) {
+  if (!isSelected) return null;
+
+  return (
+    <span className="shrink-0 rounded-[4px] border border-emerald-900/50 bg-emerald-950/30 px-2 py-1 font-mono text-[10px] font-bold text-emerald-400">
+      {quantity || "0"} un.
+    </span>
+  );
+}
+
+function TransferBatchQuantitySection({
+  quantity,
+  selectedBatch,
+  onQuantityChange,
+  onQuantityIncrement,
+  onQuantityDecrement,
+}: {
+  quantity: string;
+  selectedBatch?: TransferBatchOption;
+  onQuantityChange: (quantity: string) => void;
+  onQuantityIncrement: () => void;
+  onQuantityDecrement: () => void;
+}) {
+  const numericQuantity = Number(quantity);
+  const canDecrement = Number.isFinite(numericQuantity) && numericQuantity > 1;
+  const canIncrement = selectedBatch
+    ? Number.isFinite(numericQuantity) && numericQuantity < selectedBatch.quantity
+    : true;
+
+  return (
+    <div className="mt-4 space-y-2">
+      <label
+        htmlFor="transfer-batch-quantity"
+        className="text-[10px] font-bold uppercase tracking-wider text-neutral-400"
+      >
+        Quantidade a transferir
+      </label>
+      <div className="flex">
+        <TransferBatchQuantityButton
+          disabled={!canDecrement}
+          onClick={onQuantityDecrement}
+          label="Diminuir"
+        >
+          <Minus className="size-4" />
+        </TransferBatchQuantityButton>
+        <NumberInput
+          id="transfer-batch-quantity"
+          value={quantity ? Number(quantity) : undefined}
+          onValueChange={(value) =>
+            onQuantityChange(value !== undefined ? String(value) : "")
+          }
+          className="h-10 min-w-0 flex-1 rounded-none border-x-0 border-neutral-800 bg-neutral-900 text-center font-mono text-sm text-white focus:border-blue-600"
+          placeholder="1"
+        />
+        <TransferBatchQuantityButton
+          disabled={!canIncrement}
+          onClick={onQuantityIncrement}
+          label="Aumentar"
+        >
+          <Plus className="size-4" />
+        </TransferBatchQuantityButton>
+      </div>
+      {selectedBatch ? (
+        <p className="text-[10px] text-neutral-500">
+          Lote selecionado com {selectedBatch.quantity} un. disponíveis.
+        </p>
+      ) : null}
+    </div>
+  );
+}
+
+function TransferBatchQuantityButton({
+  children,
+  disabled,
+  label,
+  onClick,
+}: {
+  children: ReactNode;
+  disabled: boolean;
+  label: string;
+  onClick: () => void;
+}) {
+  return (
+    <Button
+      type="button"
+      variant="outline"
+      disabled={disabled}
+      onClick={onClick}
+      className="size-10 rounded-[4px] border-neutral-800 bg-neutral-900 p-0 text-neutral-400 hover:bg-neutral-800 hover:text-white"
+      aria-label={label}
+    >
+      {children}
+    </Button>
+  );
+}
+
+function TransferBatchDrawerError({ error }: { error: string | null }) {
+  if (!error) return null;
+
+  return (
+    <div className="mt-4 flex items-center gap-2 rounded-[4px] border border-rose-900/30 bg-rose-950/10 px-4 py-3">
+      <AlertCircle className="size-4 shrink-0 text-rose-500" strokeWidth={2} />
+      <p className="text-xs font-medium text-rose-400">{error}</p>
+    </div>
+  );
+}
+
+function TransferBatchLoading() {
+  return (
+    <div className="mt-4 flex h-16 items-center gap-2 rounded-[4px] border border-neutral-800 bg-[#0A0A0A] px-4 text-xs text-neutral-500">
+      <Loader2 className="size-4 animate-spin" />
+      Carregando lotes disponíveis…
+    </div>
+  );
+}
+
+function TransferBatchEmpty() {
+  return (
+    <div className="mt-4 rounded-[4px] border border-amber-900/30 bg-amber-950/10 px-4 py-3">
+      <p className="text-xs font-bold uppercase tracking-wide text-amber-400">
+        Nenhum lote disponível
+      </p>
+      <p className="mt-1 text-xs text-amber-200/70">
+        Este produto não possui quantidade disponível no depósito atual.
+      </p>
+    </div>
+  );
+}
+
+function formatTransferBatchDate(value: string | null, fallback: string): string {
+  if (!value) return fallback;
+  const timestamp = new Date(value).getTime();
+  if (!Number.isFinite(timestamp)) return value;
+  return transferBatchDateFormatter.format(new Date(timestamp));
+}
diff --git a/app/(pages)/transfers/new/new-transfer-items-list.view.tsx b/app/(pages)/transfers/new/new-transfer-items-list.view.tsx
new file mode 100644
index 0000000..1a91243
--- /dev/null
+++ b/app/(pages)/transfers/new/new-transfer-items-list.view.tsx
@@ -0,0 +1,207 @@
+"use client";
+
+import { Hash, Package, Trash2 } from "lucide-react";
+
+import { EmptyState } from "@/components/ui/empty-state";
+import { SectionLabel } from "@/components/ui/section-label";
+import { Button } from "@/components/ui/button";
+import type { NewTransferViewProps } from "./new-transfer.types";
+
+interface TransferItemsListProps {
+  viewState: NewTransferViewProps;
+  totalQuantity: number;
+}
+
+export function TransferItemsList({
+  viewState,
+  totalQuantity,
+}: TransferItemsListProps) {
+  const { form, items } = viewState;
+
+  return (
+    <div>
+      <SectionLabel icon={Hash} className="mb-4">
+        Itens na Transferência ({items.length})
+      </SectionLabel>
+      {items.length === 0 ? (
+        <EmptyState
+          icon={Package}
+          title="Nenhum item adicionado"
+          description="Busque ou escaneie um produto para escolher o lote da transferência."
+        />
+      ) : (
+        <>
+          <TransferItemsMobileList viewState={viewState} />
+          <TransferItemsDesktopTable
+            viewState={viewState}
+            totalQuantity={totalQuantity}
+          />
+        </>
+      )}
+      {form.formState.errors.items ? (
+        <p className="mt-2 text-xs font-medium text-rose-500">
+          {form.formState.errors.items.message}
+        </p>
+      ) : null}
+    </div>
+  );
+}
+
+function TransferItemsMobileList({
+  viewState,
+}: {
+  viewState: NewTransferViewProps;
+}) {
+  return (
+    <div className="flex flex-col gap-3 md:hidden">
+      {viewState.items.map((item, index) => (
+        <div
+          key={item.id}
+          className="flex items-center gap-3 rounded-[4px] border border-neutral-800 bg-[#171717] p-4"
+        >
+          <div className="min-w-0 flex-1">
+            <p className="truncate text-sm font-bold text-white">
+              {item.productName || "Produto"}
+            </p>
+            <div className="mt-1 flex items-center gap-3 text-xs text-neutral-500">
+              <span>
+                Lote: <span className="font-mono text-neutral-400">{item.batchCode}</span>
+              </span>
+              <span>
+                Qtd: {" "}
+                <span className="font-mono font-bold tracking-tighter text-white">
+                  {item.quantity}
+                </span>
+              </span>
+            </div>
+          </div>
+          <TransferRemoveItemButton
+            index={index}
+            onRemoveItem={viewState.onRemoveItem}
+            sizeClassName="size-9"
+          />
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function TransferItemsDesktopTable({
+  viewState,
+  totalQuantity,
+}: {
+  viewState: NewTransferViewProps;
+  totalQuantity: number;
+}) {
+  return (
+    <div className="hidden md:block">
+      <div className="rounded-[4px] border border-neutral-800 bg-[#171717]">
+        <table className="w-full">
+          <TransferItemsDesktopHeader />
+          <tbody>
+            {viewState.items.map((item, index) => (
+              <TransferItemsDesktopRow
+                key={item.id}
+                index={index}
+                item={item}
+                onRemoveItem={viewState.onRemoveItem}
+              />
+            ))}
+          </tbody>
+          <TransferItemsDesktopFooter totalQuantity={totalQuantity} />
+        </table>
+      </div>
+    </div>
+  );
+}
+
+function TransferItemsDesktopHeader() {
+  return (
+    <thead>
+      <tr className="border-b border-neutral-800">
+        <th className="px-5 py-3 text-left text-[10px] font-bold uppercase tracking-widest text-neutral-500">
+          Produto
+        </th>
+        <th className="px-5 py-3 text-left text-[10px] font-bold uppercase tracking-widest text-neutral-500">
+          Lote
+        </th>
+        <th className="px-5 py-3 text-right text-[10px] font-bold uppercase tracking-widest text-neutral-500">
+          Quantidade
+        </th>
+        <th className="w-12 p-3" />
+      </tr>
+    </thead>
+  );
+}
+
+function TransferItemsDesktopFooter({ totalQuantity }: { totalQuantity: number }) {
+  return (
+    <tfoot>
+      <tr className="border-t border-neutral-700">
+        <td
+          colSpan={2}
+          className="px-5 py-3 text-[10px] font-bold uppercase tracking-widest text-neutral-500"
+        >
+          Total
+        </td>
+        <td className="px-5 py-3 text-right font-mono text-sm font-bold tracking-tighter text-white">
+          {totalQuantity}
+        </td>
+        <td />
+      </tr>
+    </tfoot>
+  );
+}
+
+function TransferItemsDesktopRow({
+  index,
+  item,
+  onRemoveItem,
+}: {
+  index: number;
+  item: NewTransferViewProps["items"][number];
+  onRemoveItem: (index: number) => void;
+}) {
+  return (
+    <tr className="border-b border-neutral-800 last:border-0">
+      <td className="px-5 py-3.5 text-sm font-medium text-white">
+        {item.productName || "Produto"}
+      </td>
+      <td className="px-5 py-3.5 font-mono text-xs text-neutral-400">
+        {item.batchCode || "—"}
+      </td>
+      <td className="px-5 py-3.5 text-right font-mono text-sm font-bold tracking-tighter text-white">
+        {item.quantity}
+      </td>
+      <td className="p-3.5">
+        <TransferRemoveItemButton
+          index={index}
+          onRemoveItem={onRemoveItem}
+          sizeClassName="size-8"
+        />
+      </td>
+    </tr>
+  );
+}
+
+function TransferRemoveItemButton({
+  index,
+  onRemoveItem,
+  sizeClassName,
+}: {
+  index: number;
+  onRemoveItem: (index: number) => void;
+  sizeClassName: string;
+}) {
+  return (
+    <Button
+      type="button"
+      variant="ghost"
+      size="icon"
+      onClick={() => onRemoveItem(index)}
+      className={`${sizeClassName} rounded-[4px] text-neutral-500 hover:bg-neutral-800 hover:text-rose-500`}
+    >
+      <Trash2 className="size-4" strokeWidth={2} />
+    </Button>
+  );
+}
diff --git a/app/(pages)/transfers/new/new-transfer-product-search.view.tsx b/app/(pages)/transfers/new/new-transfer-product-search.view.tsx
new file mode 100644
index 0000000..7356d1f
--- /dev/null
+++ b/app/(pages)/transfers/new/new-transfer-product-search.view.tsx
@@ -0,0 +1,196 @@
+"use client";
+
+import { Loader2, Package, ScanLine, Search, X } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import type { NewTransferViewProps } from "./new-transfer.types";
+
+interface NewTransferProductSearchProps {
+  viewState: NewTransferViewProps;
+}
+
+export function TransferProductSearch({
+  viewState,
+}: NewTransferProductSearchProps) {
+  const {
+    isLoading,
+    isProductOptionsOpen,
+    isProductSearchLoading,
+    onProductClear,
+    onProductSearchBlur,
+    onProductSearchChange,
+    onProductSearchFocus,
+    onProductSelect,
+    onScannerOpenChange,
+    productOptions,
+    productSearchQuery,
+  } = viewState;
+
+  return (
+    <div className="space-y-2">
+      <label
+        htmlFor="transfer-product-search"
+        className="text-xs font-bold text-neutral-400"
+      >
+        PRODUTO
+      </label>
+      <div className="relative">
+        <div className="flex gap-2">
+          <TransferProductSearchInput
+            isLoading={isLoading}
+            productSearchQuery={productSearchQuery}
+            onProductClear={onProductClear}
+            onProductSearchBlur={onProductSearchBlur}
+            onProductSearchChange={onProductSearchChange}
+            onProductSearchFocus={onProductSearchFocus}
+          />
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => onScannerOpenChange(true)}
+            className="size-10 shrink-0 rounded-[4px] border-neutral-800 bg-neutral-900 p-0 hover:bg-neutral-800 hover:text-white"
+            aria-label="Ler código de barras"
+          >
+            <ScanLine className="size-4" strokeWidth={2.5} />
+          </Button>
+        </div>
+        <TransferProductOptions
+          isOpen={isProductOptionsOpen}
+          isLoading={isProductSearchLoading}
+          products={productOptions}
+          onProductSelect={onProductSelect}
+        />
+      </div>
+    </div>
+  );
+}
+
+function TransferProductSearchInput({
+  isLoading,
+  productSearchQuery,
+  onProductClear,
+  onProductSearchBlur,
+  onProductSearchChange,
+  onProductSearchFocus,
+}: {
+  isLoading: boolean;
+  productSearchQuery: string;
+  onProductClear: () => void;
+  onProductSearchBlur: () => void;
+  onProductSearchChange: (query: string) => void;
+  onProductSearchFocus: () => void;
+}) {
+  return (
+    <div className="relative flex-1">
+      <Search className="pointer-events-none absolute left-3 top-1/2 size-4 -translate-y-1/2 text-neutral-500" />
+      <Input
+        id="transfer-product-search"
+        value={productSearchQuery}
+        onChange={(event) => onProductSearchChange(event.target.value)}
+        onFocus={onProductSearchFocus}
+        onBlur={onProductSearchBlur}
+        disabled={isLoading}
+        placeholder={
+          isLoading
+            ? "Carregando produtos…"
+            : "Pesquisar produto por nome, SKU ou código"
+        }
+        className="h-10 w-full rounded-[4px] border-2 border-neutral-800 bg-neutral-900 pl-9 pr-9 text-sm text-white focus:border-blue-600 disabled:opacity-40"
+      />
+      {productSearchQuery ? (
+        <Button
+          type="button"
+          variant="ghost"
+          onClick={onProductClear}
+          className="absolute right-1 top-1 size-8 rounded-[4px] p-0 text-neutral-500 hover:bg-neutral-800 hover:text-white"
+          aria-label="Limpar produto"
+        >
+          <X className="size-4" />
+        </Button>
+      ) : null}
+    </div>
+  );
+}
+
+function TransferProductOptions({
+  isOpen,
+  isLoading,
+  products,
+  onProductSelect,
+}: {
+  isOpen: boolean;
+  isLoading: boolean;
+  products: NewTransferViewProps["productOptions"];
+  onProductSelect: NewTransferViewProps["onProductSelect"];
+}) {
+  if (!isOpen || (!isLoading && products.length === 0)) return null;
+
+  const handleProductOptionSelect = (
+    product: NewTransferViewProps["productOptions"][number],
+  ): void => {
+    if (document.activeElement instanceof HTMLElement) {
+      document.activeElement.blur();
+    }
+    onProductSelect(product);
+  };
+
+  return (
+    <div className="absolute left-0 right-12 top-12 z-30 overflow-hidden rounded-[4px] border border-neutral-800 bg-[#171717]">
+      {isLoading ? (
+        <div className="flex h-10 items-center gap-2 px-3 text-xs text-neutral-500">
+          <Loader2 className="size-3.5 animate-spin" />
+          Buscando produtos…
+        </div>
+      ) : (
+        products.map((product) => (
+          <Button
+            key={product.id}
+            type="button"
+            variant="ghost"
+            onMouseDown={(event) => event.preventDefault()}
+            onClick={() => handleProductOptionSelect(product)}
+            className="flex h-auto w-full items-center justify-start gap-3 rounded-none border-b border-neutral-800 px-3 py-2 text-left hover:bg-neutral-800 hover:text-white last:border-b-0"
+          >
+            <TransferProductOptionImage product={product} />
+            <span className="min-w-0">
+              <span className="block truncate text-sm font-semibold text-white">
+                {product.name}
+              </span>
+              <span className="mt-0.5 block truncate font-mono text-[10px] uppercase tracking-wide text-neutral-500">
+                {product.stockQuantityLabel || "Quantidade: 0 un."}
+              </span>
+            </span>
+          </Button>
+        ))
+      )}
+    </div>
+  );
+}
+
+function TransferProductOptionImage({
+  product,
+}: {
+  product: NewTransferViewProps["productOptions"][number];
+}) {
+  if (product.imageUrl) {
+    return (
+      <span
+        role="img"
+        aria-label={`Foto de ${product.name}`}
+        className="size-10 shrink-0 rounded-[4px] border border-neutral-800 bg-neutral-900 bg-cover bg-center"
+        style={{ backgroundImage: `url("${product.imageUrl}")` }}
+      />
+    );
+  }
+
+  return (
+    <span
+      role="img"
+      aria-label="Produto sem foto"
+      className="flex size-10 shrink-0 items-center justify-center rounded-[4px] border border-neutral-800 bg-neutral-900 text-neutral-500"
+    >
+      <Package className="size-4" />
+    </span>
+  );
+}
diff --git a/app/(pages)/transfers/new/new-transfer-scanner.view.tsx b/app/(pages)/transfers/new/new-transfer-scanner.view.tsx
new file mode 100644
index 0000000..9c575b7
--- /dev/null
+++ b/app/(pages)/transfers/new/new-transfer-scanner.view.tsx
@@ -0,0 +1,91 @@
+"use client";
+
+import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { ScanLine, X } from "lucide-react";
+
+import { BarcodeScanner } from "@/components/product/barcode-scanner";
+import { Button } from "@/components/ui/button";
+import {
+  Drawer,
+  DrawerContent,
+  DrawerDescription,
+  DrawerHeader,
+  DrawerTitle,
+} from "@/components/ui/drawer";
+
+interface NewTransferScannerProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onScan: (barcode: string) => void;
+}
+
+export function NewTransferScanner({
+  open,
+  onOpenChange,
+  onScan,
+}: NewTransferScannerProps) {
+  const handleScan = (detectedCodes: IDetectedBarcode[]): void => {
+    const barcode = detectedCodes[0]?.rawValue;
+    if (!barcode) return;
+    onScan(barcode);
+  };
+
+  const handleError = (error: unknown): void => {
+    console.error("Erro ao acessar câmera:", error);
+  };
+
+  return (
+    <Drawer open={open} onOpenChange={onOpenChange} direction="bottom">
+      <DrawerContent className="max-h-[92vh] rounded-t-[4px] border-neutral-800 bg-[#171717]">
+        <DrawerHeader className="border-b border-neutral-800 px-4 py-3 text-left">
+          <div className="flex items-center justify-between gap-3">
+            <div className="flex min-w-0 items-center gap-2">
+              <ScanLine className="size-4 text-blue-400" strokeWidth={2.5} />
+              <div className="min-w-0">
+                <DrawerTitle className="text-sm font-bold uppercase tracking-wide text-white">
+                  Scanner de Produto
+                </DrawerTitle>
+                <DrawerDescription className="text-[10px] text-neutral-500">
+                  Aponte para o código de barras para escolher o lote
+                </DrawerDescription>
+              </div>
+            </div>
+            <Button
+              type="button"
+              variant="ghost"
+              size="icon"
+              onClick={() => onOpenChange(false)}
+              className="size-8 rounded-[4px] text-neutral-400 hover:bg-neutral-800 hover:text-white"
+            >
+              <X className="size-4" strokeWidth={2} />
+            </Button>
+          </div>
+        </DrawerHeader>
+
+        <div className="p-4">
+          <div className="relative overflow-hidden rounded-[4px] border border-neutral-800 bg-[#0A0A0A]">
+            <BarcodeScanner
+              onScan={handleScan}
+              onError={handleError}
+              components={{
+                finder: true,
+                onOff: false,
+                torch: false,
+                zoom: false,
+              }}
+              styles={{
+                container: { width: "100%", height: "min(64vh, 420px)" },
+                video: { objectFit: "cover" },
+              }}
+            />
+            <div className="absolute bottom-0 left-0 right-0 bg-[#0A0A0A]/80 px-4 py-3">
+              <p className="text-center text-[10px] font-bold uppercase tracking-wide text-blue-300">
+                Leitura contínua ativa
+              </p>
+            </div>
+          </div>
+        </div>
+      </DrawerContent>
+    </Drawer>
+  );
+}
diff --git a/app/(pages)/transfers/new/new-transfer.model.test.ts b/app/(pages)/transfers/new/new-transfer.model.test.ts
index bc44993..7476c96 100644
--- a/app/(pages)/transfers/new/new-transfer.model.test.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.test.ts
@@ -1,22 +1,50 @@
 import { act, renderHook } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { useNewTransferModel } from "./new-transfer.model";
+import {
+  buildTransferProductBatchesUrl,
+  clampTransferBatchQuantity,
+  filterTransferProductOptions,
+  formatTransferProductLabel,
+  formatTransferProductQuantityLabel,
+  getWarehouseBatchQuantityByProduct,
+  shouldShowTransferFooter,
+  useNewTransferModel,
+} from "./new-transfer.model";
 import type { NewTransferSchema } from "./new-transfer.schema";
+import type { TransferProductOption } from "./new-transfer.types";
 
 type JsonResponse<T> = { json: () => Promise<T> };
 
-type ProductResponse = Array<{ id: string; name: string }> | { content: Array<{ id: string; name: string }> };
-type BatchResponse = Array<{ id: string; code: string; quantity: number; productId: string }> | { content: Array<{ id: string; code: string; quantity: number; productId: string }> };
-
 type SwrState<T> = {
   data?: T;
   error: Error | null;
   isLoading: boolean;
 };
 
-type WarehouseListResponse = { success: boolean; data: Array<{ id: string; name: string }> };
-type ProductListResponse = { success: boolean; data: ProductResponse };
-type BatchListResponse = { success: boolean; data: BatchResponse };
+type WarehouseListResponse = {
+  success: boolean;
+  data: Array<{ id: string; name: string }>;
+};
+type ProductListResponse = {
+  success: boolean;
+  data: TransferProductOption[] | { content: TransferProductOption[] };
+};
+type BatchListResponse = {
+  success: boolean;
+  data:
+    | TransferBatchTestSource[]
+    | { content: TransferBatchTestSource[] };
+};
+type TransferBatchTestSource = {
+  id: string;
+  productId: string;
+  productName?: string;
+  batchCode?: string | null;
+  code?: string | null;
+  quantity: number;
+  manufacturedDate?: string | null;
+  expirationDate?: string | null;
+};
 
 const fakeSWR = vi.hoisted(() => {
   class FakeSWR {
@@ -47,9 +75,9 @@ const fakeSWR = vi.hoisted(() => {
 const fakeApi = vi.hoisted(() => {
   class FakeApi {
     public readonly post = vi.fn<
-      (url: string, body: { json: NewTransferSchema }) => JsonResponse<unknown>
+      (url: string, body: { json: unknown }) => JsonResponse<unknown>
     >();
-    public readonly get = vi.fn<(url: string) => Promise<JsonResponse<unknown>>>();
+    public readonly get = vi.fn<(url: string) => JsonResponse<unknown>>();
   }
 
   return new FakeApi();
@@ -128,6 +156,36 @@ const createResponse = <T>(payload: T): JsonResponse<T> => ({
   json: vi.fn(async () => payload),
 });
 
+const products: TransferProductOption[] = [
+  {
+    id: "prod-leite",
+    name: "Leite Integral",
+    sku: "LEI-01",
+    barcode: "7891000000001",
+    imageUrl: "https://img.test/leite.png",
+    totalQuantity: 12,
+    stockQuantityLabel: "Quantidade: 12 un.",
+  },
+  {
+    id: "prod-cafe",
+    name: "Café Torrado",
+    sku: "CAF-02",
+    barcode: "7891000000002",
+    imageUrl: null,
+    totalQuantity: 7,
+    stockQuantityLabel: "Quantidade: 7 un.",
+  },
+  {
+    id: "prod-cha",
+    name: "Chá Mate",
+    sku: null,
+    barcode: "7891000000003",
+    imageUrl: null,
+    totalQuantity: 0,
+    stockQuantityLabel: "Quantidade: 0 un.",
+  },
+];
+
 const warehousesResponse: WarehouseListResponse = {
   success: true,
   data: [
@@ -139,59 +197,106 @@ const warehousesResponse: WarehouseListResponse = {
 
 const productsArrayResponse: ProductListResponse = {
   success: true,
-  data: [
-    { id: "prod-leite", name: "Leite" },
-    { id: "prod-cafe", name: "Café" },
-  ],
+  data: products,
 };
 
 const productsContentResponse: ProductListResponse = {
   success: true,
-  data: {
-    content: [
-      { id: "prod-suco", name: "Suco" },
-      { id: "prod-cha", name: "Chá" },
-    ],
-  },
+  data: { content: [products[2]] },
 };
 
-const batchContentResponse: BatchListResponse = {
+const leiteBatchResponse: BatchListResponse = {
+  success: true,
+  data: [
+    {
+      id: "batch-leite-1",
+      productId: "prod-leite",
+      productName: "Leite Integral",
+      batchCode: "L-01",
+      quantity: 5,
+      manufacturedDate: "2026-01-01",
+      expirationDate: "2026-12-31",
+    },
+    {
+      id: "batch-leite-2",
+      productId: "prod-leite",
+      productName: "Leite Integral",
+      code: "L-02",
+      quantity: 0,
+      expirationDate: "2027-01-31",
+    },
+  ],
+};
+
+const cafeBatchResponse: BatchListResponse = {
   success: true,
   data: {
     content: [
-      {
-        id: "batch-leite-1",
-        code: "L-01",
-        quantity: 5,
-        productId: "prod-leite",
-      },
-      {
-        id: "batch-leite-2",
-        code: "L-02",
-        quantity: 2,
-        productId: "prod-leite",
-      },
       {
         id: "batch-cafe",
-        code: "C-01",
-        quantity: 10,
         productId: "prod-cafe",
+        productName: "Café Torrado",
+        batchCode: "C-01",
+        quantity: 10,
+        manufacturedDate: null,
+        expirationDate: null,
       },
     ],
   },
 };
 
+const warehouseBatchesResponse: BatchListResponse = {
+  success: true,
+  data: [
+    {
+      id: "batch-leite-warehouse-1",
+      productId: "prod-leite",
+      productName: "Leite Integral",
+      batchCode: "L-WH-01",
+      quantity: 4,
+    },
+    {
+      id: "batch-leite-warehouse-2",
+      productId: "prod-leite",
+      productName: "Leite Integral",
+      batchCode: "L-WH-02",
+      quantity: 6,
+    },
+    {
+      id: "batch-cafe-warehouse",
+      productId: "prod-cafe",
+      productName: "Café Torrado",
+      batchCode: "C-WH-01",
+      quantity: 7,
+    },
+  ],
+};
+
+const getWarehouseBatchSources = (
+  response: BatchListResponse,
+): TransferBatchTestSource[] => {
+  return Array.isArray(response.data) ? response.data : response.data.content;
+};
+
 beforeEach(() => {
   vi.clearAllMocks();
+  vi.useRealTimers();
   fakeSWR.reset();
   fakeApi.post.mockReset();
   fakeApi.get.mockReset();
-  fakeToast.success.mockClear();
-  fakeToast.error.mockClear();
   fakeRouter.push.mockClear();
   fakeBreadcrumb.useBreadcrumb.mockClear();
   fakeSelectedWarehouse.warehouseId = "warehouse-origin";
   fakeApi.post.mockReturnValue(createResponse({ success: true }));
+  fakeApi.get.mockImplementation((url: string) => {
+    if (url === "products/barcode/7891000000001") {
+      return createResponse({ success: true, data: products[0] });
+    }
+    if (url === "products/barcode/7891000000002") {
+      return createResponse({ success: true, data: products[1] });
+    }
+    throw new Error(`Sem fake para GET ${url}`);
+  });
 
   fakeSWR.setState("warehouses", {
     data: warehousesResponse,
@@ -204,23 +309,126 @@ beforeEach(() => {
     isLoading: false,
   });
   fakeSWR.setState("batches/warehouse/warehouse-origin", {
-    data: batchContentResponse,
+    data: warehouseBatchesResponse,
+    error: null,
+    isLoading: false,
+  });
+  fakeSWR.setState("batches/warehouses/warehouse-origin/products/prod-leite/batches", {
+    data: leiteBatchResponse,
+    error: null,
+    isLoading: false,
+  });
+  fakeSWR.setState("batches/warehouses/warehouse-origin/products/prod-cafe/batches", {
+    data: cafeBatchResponse,
     error: null,
     isLoading: false,
   });
 });
 
+describe("helpers de nova transferência", () => {
+  it("formata produto com SKU quando disponível", () => {
+    expect(formatTransferProductLabel(products[0])).toBe(
+      "Leite Integral (LEI-01)",
+    );
+    expect(formatTransferProductLabel(products[2])).toBe("Chá Mate");
+  });
+
+  it("formata quantidade disponível do produto", () => {
+    expect(formatTransferProductQuantityLabel(products[0])).toBe(
+      "Quantidade: 12 un.",
+    );
+    expect(formatTransferProductQuantityLabel({ id: "p", name: "Produto" })).toBe(
+      "Quantidade: 0 un.",
+    );
+  });
+
+  it("soma quantidades de todos os lotes do produto", () => {
+    const quantityByProduct = getWarehouseBatchQuantityByProduct(
+      getWarehouseBatchSources(warehouseBatchesResponse),
+    );
+
+    expect(quantityByProduct.get("prod-leite")).toBe(10);
+    expect(quantityByProduct.get("prod-cafe")).toBe(7);
+    expect(quantityByProduct.get("prod-cha")).toBeUndefined();
+  });
+
+  it("filtra produtos por nome, SKU e barcode com mínimo de dois caracteres", () => {
+    expect(filterTransferProductOptions(products, " l ")).toEqual([]);
+    expect(filterTransferProductOptions(products, "caf")[0].id).toBe("prod-cafe");
+    expect(filterTransferProductOptions(products, "LEI-01")[0].id).toBe("prod-leite");
+    expect(filterTransferProductOptions(products, "0003")[0].id).toBe("prod-cha");
+  });
+
+  it("limita resultados de autocomplete a cinco produtos", () => {
+    const manyProducts = Array.from({ length: 6 }, (_, index) => ({
+      id: `prod-${index}`,
+      name: `Produto ${index}`,
+    }));
+
+    expect(filterTransferProductOptions(manyProducts, "produto")).toHaveLength(5);
+  });
+
+  it("monta URL de lotes apenas com drawer aberto e IDs válidos", () => {
+    expect(buildTransferProductBatchesUrl(null, "prod-1", true)).toBeNull();
+    expect(buildTransferProductBatchesUrl("wh-1", "", true)).toBeNull();
+    expect(buildTransferProductBatchesUrl("wh-1", "prod-1", false)).toBeNull();
+    expect(buildTransferProductBatchesUrl("wh-1", "prod-1", true)).toBe(
+      "batches/warehouses/wh-1/products/prod-1/batches",
+    );
+  });
+
+  it("limita quantidade do lote entre um e o estoque disponível", () => {
+    expect(clampTransferBatchQuantity("0", 5)).toBe("1");
+    expect(clampTransferBatchQuantity("texto", 5)).toBe("1");
+    expect(clampTransferBatchQuantity("3", 5)).toBe("3");
+    expect(clampTransferBatchQuantity("8", 5)).toBe("5");
+    expect(clampTransferBatchQuantity("8")).toBe("8");
+  });
+
+  it("mostra footer no fim da página ou quando usuário rola para cima", () => {
+    expect(
+      shouldShowTransferFooter({
+        currentScrollY: 200,
+        lastScrollY: 100,
+        maxScrollY: 1000,
+      }),
+    ).toBe(false);
+    expect(
+      shouldShowTransferFooter({
+        currentScrollY: 995,
+        lastScrollY: 900,
+        maxScrollY: 1000,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowTransferFooter({
+        currentScrollY: 600,
+        lastScrollY: 700,
+        maxScrollY: 1000,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowTransferFooter({
+        currentScrollY: 0,
+        lastScrollY: 0,
+        maxScrollY: 0,
+      }),
+    ).toBe(true);
+  });
+});
+
 describe("useNewTransferModel", () => {
-  it("mapeia opções de destino ignorando o warehouse atual", () => {
+  it("mapeia destinos e produtos ignorando warehouse atual", () => {
     const { result } = renderHook(() => useNewTransferModel());
 
     expect(result.current.warehouses).toEqual([
       { id: "warehouse-destination", name: "Loja Matriz" },
       { id: "warehouse-destination-b", name: "Loja B" },
     ]);
-    expect(result.current.products).toEqual([
-      { id: "prod-leite", name: "Leite" },
-      { id: "prod-cafe", name: "Café" },
+    expect(result.current.products).toMatchObject([
+      { id: "prod-leite", totalQuantity: 10, stockQuantityLabel: "Quantidade: 10 un." },
+      { id: "prod-cafe", totalQuantity: 7, stockQuantityLabel: "Quantidade: 7 un." },
+      { id: "prod-cha", totalQuantity: 0, stockQuantityLabel: "Quantidade: 0 un." },
     ]);
     expect(result.current.isLoading).toBe(false);
   });
@@ -234,148 +442,227 @@ describe("useNewTransferModel", () => {
 
     const { result } = renderHook(() => useNewTransferModel());
 
-    expect(result.current.products).toEqual([
-      { id: "prod-suco", name: "Suco" },
-      { id: "prod-cha", name: "Chá" },
+    expect(result.current.products).toMatchObject([
+      { id: "prod-cha", totalQuantity: 0, stockQuantityLabel: "Quantidade: 0 un." },
     ]);
   });
 
-  it("limpa seleção e erro ao trocar produto", () => {
+  it("abre autocomplete e seleciona produto para abrir drawer de lote", () => {
     const { result } = renderHook(() => useNewTransferModel());
 
     act(() => {
-      result.current.onProductChange("prod-leite");
-      result.current.onBatchChange("batch-leite-1");
-      result.current.onQuantityChange("1");
-      result.current.onAddItem();
+      result.current.onProductSearchFocus();
+      result.current.onProductSearchChange("lei");
     });
+    expect(result.current.isProductOptionsOpen).toBe(true);
+    expect(result.current.addItemError).toBeNull();
 
     act(() => {
-      result.current.onProductChange("prod-cafe");
+      result.current.onProductSelect(products[0]);
     });
 
-    expect(result.current.selectedProductId).toBe("prod-cafe");
-    expect(result.current.selectedBatchId).toBe("");
-    expect(result.current.itemQuantity).toBe("");
-    expect(result.current.addItemError).toBeNull();
+    expect(result.current.selectedProductId).toBe("prod-leite");
+    expect(result.current.productSearchQuery).toBe("Leite Integral (LEI-01)");
+    expect(result.current.batchDrawer).toMatchObject({
+      isOpen: true,
+      productId: "prod-leite",
+      productName: "Leite Integral",
+      quantity: "1",
+    });
+    expect(fakeSWR.hook).toHaveBeenCalledWith(
+      "batches/warehouses/warehouse-origin/products/prod-leite/batches",
+      expect.any(Function),
+    );
   });
 
-  it("rejeita inclusão de item sem produto e sem lote", () => {
+  it("limpa seleção quando busca muda após produto selecionado", () => {
     const { result } = renderHook(() => useNewTransferModel());
 
     act(() => {
-      result.current.onAddItem();
+      result.current.onProductSelect(products[0]);
     });
-    expect(result.current.addItemError).toBe("Selecione um produto.");
-
     act(() => {
-      result.current.onProductChange("prod-leite");
+      result.current.onProductSearchChange("outro");
     });
+
+    expect(result.current.selectedProductId).toBe("");
+    expect(result.current.productSearchQuery).toBe("outro");
+    expect(result.current.addItemError).toBeNull();
+  });
+
+  it("limpa produto, busca e drawer", () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
     act(() => {
-      result.current.onAddItem();
+      result.current.onProductSelect(products[0]);
+      result.current.onProductClear();
     });
-    expect(result.current.addItemError).toBe("Selecione um lote.");
 
-    act(() => {
-      result.current.onBatchChange("batch-leite-1");
-      result.current.onQuantityChange("0");
+    expect(result.current.selectedProductId).toBe("");
+    expect(result.current.productSearchQuery).toBe("");
+    expect(result.current.batchDrawer.isOpen).toBe(false);
+  });
+
+  it("abre drawer de lote ao ler código de barras", async () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891000000001");
+    });
+
+    expect(fakeApi.get).toHaveBeenCalledWith("products/barcode/7891000000001");
+    expect(result.current.isScannerOpen).toBe(false);
+    expect(result.current.batchDrawer).toMatchObject({
+      isOpen: true,
+      productId: "prod-leite",
+      productName: "Leite Integral",
+    });
+  });
+
+  it("ignora leitura duplicada imediata", async () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891000000001");
+      await result.current.onBarcodeScan("7891000000001");
+    });
+
+    expect(fakeApi.get).toHaveBeenCalledTimes(1);
+  });
+
+  it("mostra erro quando barcode não encontra produto", async () => {
+    fakeApi.get.mockImplementation(() => {
+      throw new Error("não encontrado");
     });
+    const { result } = renderHook(() => useNewTransferModel());
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891009999999");
+    });
+
+    expect(fakeToast.error).toHaveBeenCalledWith(
+      "Produto com código 7891009999999 não existe.",
+    );
+  });
+
+  it("normaliza lotes e remove lote sem estoque", () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
     act(() => {
-      result.current.onAddItem();
+      result.current.onProductSelect(products[0]);
     });
-    expect(result.current.addItemError).toBe("Quantidade inválida.");
+
+    expect(result.current.batches).toEqual([
+      {
+        id: "batch-leite-1",
+        productId: "prod-leite",
+        productName: "Leite Integral",
+        batchCode: "L-01",
+        quantity: 5,
+        manufacturedDate: "2026-01-01",
+        expirationDate: "2026-12-31",
+      },
+    ]);
   });
 
-  it("rejeita lote inválido ou quantidade acima do disponível", () => {
+  it("exige seleção de lote antes de confirmar", () => {
     const { result } = renderHook(() => useNewTransferModel());
 
     act(() => {
-      result.current.onProductChange("prod-cafe");
+      result.current.onProductSelect(products[0]);
     });
     act(() => {
-      result.current.onBatchChange("batch-invalido");
+      result.current.onConfirmBatch();
     });
+    expect(result.current.batchDrawer.error).toBe("Selecione um lote.");
+  });
+
+  it("mantém quantidade do drawer entre um e o estoque do lote", () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
     act(() => {
-      result.current.onQuantityChange("1");
+      result.current.onProductSelect(products[0]);
+      result.current.onQuantityChange("8");
     });
+    expect(result.current.batchDrawer.quantity).toBe("8");
+
     act(() => {
-      result.current.onAddItem();
+      result.current.onBatchChange("batch-leite-1");
     });
+    expect(result.current.batchDrawer.quantity).toBe("5");
 
-    expect(result.current.addItemError).toBe("Lote inválido.");
+    act(() => {
+      result.current.onQuantityChange("0");
+    });
+    expect(result.current.batchDrawer.quantity).toBe("1");
 
     act(() => {
-      result.current.onProductChange("prod-cafe");
+      result.current.onQuantityDecrement();
     });
+    expect(result.current.batchDrawer.quantity).toBe("1");
+
     act(() => {
-      result.current.onBatchChange("batch-cafe");
+      result.current.onQuantityChange("5");
     });
     act(() => {
-      result.current.onQuantityChange("11");
+      result.current.onQuantityIncrement();
     });
+    expect(result.current.batchDrawer.quantity).toBe("5");
+  });
+
+  it("incrementa, decrementa e confirma lote adicionando item", () => {
+    const { result } = renderHook(() => useNewTransferModel());
+
     act(() => {
-      result.current.onAddItem();
+      result.current.onProductSelect(products[0]);
+      result.current.onBatchChange("batch-leite-1");
+      result.current.onQuantityIncrement();
     });
+    expect(result.current.batchDrawer.quantity).toBe("2");
 
-    expect(result.current.addItemError).toBe(
-      "Quantidade indisponível no lote (Máx: 10).",
-    );
-  });
+    act(() => {
+      result.current.onQuantityDecrement();
+    });
+    expect(result.current.batchDrawer.quantity).toBe("1");
 
-  it("adiciona item com sucesso e limpa campos do formulário", () => {
-    fakeSWR.setState("batches/warehouse/warehouse-origin", {
-      data: {
-        success: true,
-        data: [
-          {
-            id: "batch-cha-array",
-            code: "CH-99",
-            quantity: 8,
-            productId: "prod-cha",
-          },
-        ],
-      },
-      error: null,
-      isLoading: false,
+    act(() => {
+      result.current.onConfirmBatch();
     });
-    fakeSWR.setState("products", {
-      data: {
-        success: true,
-        data: {
-          content: [{ id: "prod-cha", name: "Chá" }],
-        },
-      },
-      error: null,
-      isLoading: false,
+
+    expect(result.current.items).toHaveLength(1);
+    expect(result.current.items[0]).toMatchObject({
+      sourceBatchId: "batch-leite-1",
+      quantity: 1,
+      productName: "Leite Integral",
+      batchCode: "L-01",
+      availableQuantity: 5,
     });
+    expect(result.current.selectedProductId).toBe("");
+    expect(result.current.productSearchQuery).toBe("");
+    expect(result.current.batchDrawer.isOpen).toBe(false);
+  });
 
+  it("confirma lote com resposta no formato content", () => {
     const { result } = renderHook(() => useNewTransferModel());
 
     act(() => {
-      result.current.onProductChange("prod-cha");
-    });
-    act(() => {
-      result.current.onBatchChange("batch-cha-array");
+      result.current.onProductSelect(products[1]);
     });
     act(() => {
+      result.current.onBatchChange("batch-cafe");
       result.current.onQuantityChange("4");
     });
     act(() => {
-      result.current.onAddItem();
+      result.current.onConfirmBatch();
     });
 
-    expect(result.current.items).toHaveLength(1);
     expect(result.current.items[0]).toMatchObject({
-      sourceBatchId: "batch-cha-array",
+      sourceBatchId: "batch-cafe",
       quantity: 4,
-      productName: "Chá",
-      batchCode: "CH-99",
-      availableQuantity: 8,
+      productName: "Café Torrado",
+      batchCode: "C-01",
+      availableQuantity: 10,
     });
-    expect(result.current.selectedProductId).toBe("");
-    expect(result.current.selectedBatchId).toBe("");
-    expect(result.current.itemQuantity).toBe("");
-    expect(result.current.addItemError).toBeNull();
   });
 
   it("sinaliza erro quando não existe warehouse de origem", async () => {
@@ -387,9 +674,9 @@ describe("useNewTransferModel", () => {
       notes: "",
       items: [
         {
-          sourceBatchId: "batch-leite-1",
+          sourceBatchId: "11111111-1111-4111-8111-111111111111",
           quantity: 1,
-          productName: "Leite",
+          productName: "Leite Integral",
           batchCode: "L-01",
           availableQuantity: 5,
         },
@@ -412,9 +699,9 @@ describe("useNewTransferModel", () => {
       notes: "",
       items: [
         {
-          sourceBatchId: "batch-leite-1",
+          sourceBatchId: "11111111-1111-4111-8111-111111111111",
           quantity: 1,
-          productName: "Leite",
+          productName: "Leite Integral",
           batchCode: "L-01",
           availableQuantity: 5,
         },
@@ -433,21 +720,14 @@ describe("useNewTransferModel", () => {
 
   it("envia nova transferência com sucesso e redireciona", async () => {
     const { result } = renderHook(() => useNewTransferModel());
-    fakeApi.post.mockReturnValue(
-      createResponse({
-        success: true,
-        message: "Transferência criada",
-      }),
-    );
-
     const payload: NewTransferSchema = {
       destinationWarehouseId: "warehouse-destination-b",
       notes: "Observação do lote",
       items: [
         {
-          sourceBatchId: "batch-cafe",
+          sourceBatchId: "11111111-1111-4111-8111-111111111111",
           quantity: 2,
-          productName: "Café",
+          productName: "Café Torrado",
           batchCode: "C-01",
           availableQuantity: 10,
         },
@@ -464,7 +744,7 @@ describe("useNewTransferModel", () => {
         notes: "Observação do lote",
         items: [
           {
-            sourceBatchId: "batch-cafe",
+            sourceBatchId: "11111111-1111-4111-8111-111111111111",
             quantity: 2,
           },
         ],
@@ -480,15 +760,14 @@ describe("useNewTransferModel", () => {
     fakeApi.post.mockImplementation(() => {
       throw new Error("Falha no servidor");
     });
-
     const payload: NewTransferSchema = {
       destinationWarehouseId: "warehouse-destination-b",
       notes: "",
       items: [
         {
-          sourceBatchId: "batch-cafe",
+          sourceBatchId: "11111111-1111-4111-8111-111111111111",
           quantity: 2,
-          productName: "Café",
+          productName: "Café Torrado",
           batchCode: "C-01",
           availableQuantity: 10,
         },
diff --git a/app/(pages)/transfers/new/new-transfer.model.ts b/app/(pages)/transfers/new/new-transfer.model.ts
index 84af8fa..934f962 100644
--- a/app/(pages)/transfers/new/new-transfer.model.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.ts
@@ -1,15 +1,31 @@
-import { useState } from "react";
-import { useForm, useFieldArray } from "react-hook-form";
+import { useEffect, useRef, useState } from "react";
+import { useFieldArray, useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import useSWR from "swr";
 import { useRouter } from "next/navigation";
 import { toast } from "sonner";
 
-import { api } from "@/lib/api";
-import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
-import { newTransferSchema, NewTransferSchema } from "./new-transfer.schema";
-import { NewTransferViewProps } from "./new-transfer.types";
 import { useBreadcrumb } from "@/components/breadcrumb";
+import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
+import { api } from "@/lib/api";
+import { newTransferSchema, type NewTransferSchema } from "./new-transfer.schema";
+import type {
+  NewTransferViewProps,
+  TransferBatchDrawerState,
+  TransferBatchOption,
+  TransferProductOption,
+} from "./new-transfer.types";
+
+const PRODUCT_SEARCH_LIMIT = 5;
+
+const EMPTY_BATCH_DRAWER: TransferBatchDrawerState = {
+  isOpen: false,
+  productId: "",
+  productName: "",
+  selectedBatchId: "",
+  quantity: "1",
+  error: null,
+};
 
 interface WarehouseListResponse {
   success: boolean;
@@ -18,26 +34,151 @@ interface WarehouseListResponse {
 
 interface ProductListResponse {
   success: boolean;
-  data:
-    | { content: Array<{ id: string; name: string }> }
-    | Array<{ id: string; name: string }>;
+  data: { content: TransferProductOption[] } | TransferProductOption[];
+}
+
+interface ProductByBarcodeResponse {
+  success: boolean;
+  data: TransferProductOption;
+}
+
+interface TransferBatchSource {
+  id: string;
+  productId: string;
+  productName?: string;
+  batchCode?: string | null;
+  code?: string | null;
+  quantity: number;
+  manufacturedDate?: string | null;
+  expirationDate?: string | null;
 }
 
 interface BatchListResponse {
   success: boolean;
-  data:
-    | { content: Array<{ id: string; code: string; quantity: number; productId: string }> }
-    | Array<{ id: string; code: string; quantity: number; productId: string }>;
+  data: { content: TransferBatchSource[] } | TransferBatchSource[];
+}
+
+export const formatTransferProductLabel = (
+  product: TransferProductOption,
+): string => (product.sku ? `${product.name} (${product.sku})` : product.name);
+
+export const formatTransferProductQuantityLabel = (
+  product: TransferProductOption,
+): string => `Quantidade: ${product.totalQuantity ?? 0} un.`;
+
+export const filterTransferProductOptions = (
+  products: TransferProductOption[],
+  query: string,
+): TransferProductOption[] => {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (normalizedQuery.length < 2) return [];
+
+  return products
+    .filter((product) => doesTransferProductMatch(product, normalizedQuery))
+    .slice(0, PRODUCT_SEARCH_LIMIT);
+};
+
+export const buildTransferProductBatchesUrl = (
+  warehouseId: string | null,
+  productId: string,
+  isDrawerOpen: boolean,
+): string | null => {
+  if (!warehouseId || !productId || !isDrawerOpen) return null;
+  return `batches/warehouses/${warehouseId}/products/${productId}/batches`;
+};
+
+export const clampTransferBatchQuantity = (
+  value: string,
+  maxQuantity?: number,
+): string => {
+  const quantity = Number(value);
+  if (!Number.isFinite(quantity) || quantity < 1) return "1";
+  if (maxQuantity === undefined) return String(quantity);
+  return String(Math.min(quantity, Math.max(1, maxQuantity)));
+};
+
+const doesTransferProductMatch = (
+  product: TransferProductOption,
+  normalizedQuery: string,
+): boolean => {
+  const searchText = [product.name, product.sku || "", product.barcode || ""]
+    .join(" ")
+    .toLowerCase();
+  return searchText.includes(normalizedQuery);
+};
+
+const getRawResponseContent = <T>(response: { content: T[] } | T[] | undefined): T[] => {
+  if (!response) return [];
+  return Array.isArray(response) ? response : response.content;
+};
+
+const normalizeTransferBatch = (
+  batch: TransferBatchSource,
+): TransferBatchOption => ({
+  id: batch.id,
+  productId: batch.productId,
+  productName: batch.productName,
+  batchCode: batch.batchCode?.trim() || batch.code?.trim() || batch.id,
+  quantity: batch.quantity,
+  manufacturedDate: batch.manufacturedDate ?? null,
+  expirationDate: batch.expirationDate ?? null,
+});
+
+export const getWarehouseBatchQuantityByProduct = (
+  batches: TransferBatchSource[],
+): Map<string, number> => {
+  return batches.reduce((quantityByProduct, batch) => {
+    const currentQuantity = quantityByProduct.get(batch.productId) ?? 0;
+    quantityByProduct.set(batch.productId, currentQuantity + batch.quantity);
+    return quantityByProduct;
+  }, new Map<string, number>());
+};
+
+interface TransferFooterVisibilityParams {
+  currentScrollY: number;
+  lastScrollY: number;
+  maxScrollY: number;
 }
 
+export const shouldShowTransferFooter = ({
+  currentScrollY,
+  lastScrollY,
+  maxScrollY,
+}: TransferFooterVisibilityParams): boolean => {
+  const isShortPage = maxScrollY <= 8;
+  const isAtPageEnd = currentScrollY >= maxScrollY - 8;
+  const isScrollingUp = currentScrollY < lastScrollY;
+  return isShortPage || isAtPageEnd || isScrollingUp;
+};
+
+const resolvePositiveQuantity = (value: string): number => {
+  const quantity = Number(value);
+  return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
+};
+
 export function useNewTransferModel(): NewTransferViewProps {
   const router = useRouter();
   const { warehouseId: currentWarehouseId } = useSelectedWarehouse();
   const [isSubmitting, setIsSubmitting] = useState(false);
+  const [selectedProduct, setSelectedProduct] =
+    useState<TransferProductOption | null>(null);
   const [selectedProductId, setSelectedProductId] = useState("");
-  const [selectedBatchId, setSelectedBatchId] = useState("");
-  const [itemQuantity, setItemQuantity] = useState("");
+  const [productSearchQuery, setProductSearchQuery] = useState("");
+  const [debouncedProductSearchQuery, setDebouncedProductSearchQuery] =
+    useState("");
+  const [isProductOptionsOpen, setIsProductOptionsOpen] = useState(false);
+  const [isScannerOpen, setIsScannerOpen] = useState(false);
+  const [batchDrawer, setBatchDrawer] =
+    useState<TransferBatchDrawerState>(EMPTY_BATCH_DRAWER);
   const [addItemError, setAddItemError] = useState<string | null>(null);
+  const [isFooterVisible, setIsFooterVisible] = useState(true);
+  const productSearchBlurTimeoutRef =
+    useRef<ReturnType<typeof setTimeout> | null>(null);
+  const lastScannedBarcodeRef = useRef<string | null>(null);
+  const barcodeResetTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(
+    null,
+  );
+  const lastScrollYRef = useRef(0);
 
   useBreadcrumb({
     title: "Nova Transferência",
@@ -60,103 +201,275 @@ export function useNewTransferModel(): NewTransferViewProps {
   });
 
   const { data: warehousesData, isLoading: isLoadingWarehouses } =
-    useSWR<WarehouseListResponse>("warehouses", async (url: string) =>
-      api.get(url).json<WarehouseListResponse>()
+    useSWR<WarehouseListResponse>("warehouses", (url: string) =>
+      api.get(url).json<WarehouseListResponse>(),
     );
 
   const { data: productsData, isLoading: isLoadingProducts } =
-    useSWR<ProductListResponse>("products", async (url: string) =>
-      api.get(url).json<ProductListResponse>()
+    useSWR<ProductListResponse>("products", (url: string) =>
+      api.get(url).json<ProductListResponse>(),
     );
 
-  const { data: batchesData } = useSWR<BatchListResponse>(
-    selectedProductId && currentWarehouseId
-      ? `batches/warehouse/${currentWarehouseId}`
-      : null,
-    async (url: string) => api.get(url).json<BatchListResponse>()
+  const { data: warehouseBatchesData } = useSWR<BatchListResponse>(
+    currentWarehouseId ? `batches/warehouse/${currentWarehouseId}` : null,
+    (url: string) => api.get(url).json<BatchListResponse>(),
   );
 
+  const batchesUrl = buildTransferProductBatchesUrl(
+    currentWarehouseId,
+    batchDrawer.productId,
+    batchDrawer.isOpen,
+  );
+  const { data: batchesData, isLoading: isBatchLoading } =
+    useSWR<BatchListResponse>(batchesUrl, (url: string) =>
+      api.get(url).json<BatchListResponse>(),
+    );
+
+  useEffect(() => {
+    const timeoutId = setTimeout(() => {
+      setDebouncedProductSearchQuery(productSearchQuery);
+    }, 350);
+    return () => clearTimeout(timeoutId);
+  }, [productSearchQuery]);
+
+  useEffect(() => {
+    return () => {
+      clearProductSearchBlurTimeout();
+      if (!barcodeResetTimeoutRef.current) return;
+      clearTimeout(barcodeResetTimeoutRef.current);
+    };
+  }, []);
+
+  useEffect(() => {
+    const handleScroll = (): void => {
+      const currentScrollY = window.scrollY;
+      const maxScrollY =
+        document.documentElement.scrollHeight - window.innerHeight;
+      setIsFooterVisible(
+        shouldShowTransferFooter({
+          currentScrollY,
+          lastScrollY: lastScrollYRef.current,
+          maxScrollY,
+        }),
+      );
+      lastScrollYRef.current = Math.max(currentScrollY, 0);
+    };
+
+    handleScroll();
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => window.removeEventListener("scroll", handleScroll);
+  }, []);
+
   const warehouses = (warehousesData?.data || []).flatMap((warehouse) =>
     warehouse.id === currentWarehouseId
       ? []
       : [{ id: warehouse.id, name: warehouse.name }],
   );
-
-  const rawProducts = productsData?.data;
-  const products = (
-    Array.isArray(rawProducts) ? rawProducts : rawProducts?.content || []
-  ).map((p) => ({
-    id: p.id,
-    name: p.name,
-  }));
-
-  const rawBatches = batchesData?.data;
-  const batches = (
-    Array.isArray(rawBatches) ? rawBatches : rawBatches?.content || []
-  ).flatMap((batch) =>
-    batch.productId === selectedProductId
-      ? [
-          {
-            id: batch.id,
-            code: batch.code,
-            quantity: batch.quantity,
-          },
-        ]
-      : [],
+  const warehouseBatchQuantityByProduct = getWarehouseBatchQuantityByProduct(
+    getRawResponseContent(warehouseBatchesData?.data),
   );
+  const products = getRawResponseContent(productsData?.data).map((product) => {
+    const totalQuantity = warehouseBatchQuantityByProduct.get(product.id) ?? 0;
+    return {
+      id: product.id,
+      name: product.name,
+      sku: product.sku,
+      barcode: product.barcode,
+      imageUrl: product.imageUrl,
+      totalQuantity,
+      stockQuantityLabel: formatTransferProductQuantityLabel({
+        ...product,
+        totalQuantity,
+      }),
+    };
+  });
+  const batches = getRawResponseContent(batchesData?.data).flatMap((batch) => {
+    const normalizedBatch = normalizeTransferBatch(batch);
+    if (normalizedBatch.productId !== batchDrawer.productId) return [];
+    return normalizedBatch.quantity > 0 ? [normalizedBatch] : [];
+  });
+  const productOptions = filterTransferProductOptions(
+    products,
+    debouncedProductSearchQuery,
+  );
+
+  const clearProductSearchBlurTimeout = (): void => {
+    if (!productSearchBlurTimeoutRef.current) return;
+    clearTimeout(productSearchBlurTimeoutRef.current);
+    productSearchBlurTimeoutRef.current = null;
+  };
+
+  const openBatchDrawerForProduct = (product: TransferProductOption): void => {
+    if (!currentWarehouseId) {
+      setAddItemError("Selecione um warehouse de origem.");
+      return;
+    }
+
+    setBatchDrawer({
+      isOpen: true,
+      productId: product.id,
+      productName: product.name,
+      selectedBatchId: "",
+      quantity: "1",
+      error: null,
+    });
+  };
 
-  const handleProductChange = (productId: string) => {
-    setSelectedProductId(productId);
-    setSelectedBatchId("");
-    setItemQuantity("");
+  const handleProductSelect = (product: TransferProductOption): void => {
+    setSelectedProduct(product);
+    setSelectedProductId(product.id);
+    setProductSearchQuery(formatTransferProductLabel(product));
+    setIsProductOptionsOpen(false);
     setAddItemError(null);
+    openBatchDrawerForProduct(product);
+  };
+
+  const handleProductSearchFocus = (): void => {
+    clearProductSearchBlurTimeout();
+    setIsProductOptionsOpen(true);
   };
 
-  const handleAddItem = () => {
+  const handleProductSearchBlur = (): void => {
+    productSearchBlurTimeoutRef.current = setTimeout(() => {
+      setIsProductOptionsOpen(false);
+    }, 120);
+  };
+
+  const handleProductSearchChange = (query: string): void => {
+    setProductSearchQuery(query);
+    setIsProductOptionsOpen(true);
     setAddItemError(null);
+    if (!selectedProduct) return;
+    if (query === formatTransferProductLabel(selectedProduct)) return;
+    setSelectedProduct(null);
+    setSelectedProductId("");
+  };
 
-    if (!selectedProductId) {
-      setAddItemError("Selecione um produto.");
-      return;
-    }
-    if (!selectedBatchId) {
-      setAddItemError("Selecione um lote.");
-      return;
-    }
+  const resetProductBuilder = (): void => {
+    setSelectedProduct(null);
+    setSelectedProductId("");
+    setProductSearchQuery("");
+    setIsProductOptionsOpen(false);
+    setBatchDrawer(EMPTY_BATCH_DRAWER);
+  };
+
+  const handleProductClear = (): void => {
+    resetProductBuilder();
+    setAddItemError(null);
+  };
+
+  const handleBatchDrawerOpenChange = (open: boolean): void => {
+    setBatchDrawer((current) => ({
+      ...current,
+      isOpen: open,
+      error: open ? current.error : null,
+    }));
+  };
+
+  const updateBatchDrawer = (
+    patch: Partial<TransferBatchDrawerState>,
+  ): void => {
+    setBatchDrawer((current) => ({
+      ...current,
+      ...patch,
+      error: patch.error ?? null,
+    }));
+  };
+
+  const updateBatchQuantity = (
+    calculateNextQuantity: (quantity: number) => number,
+  ): void => {
+    setBatchDrawer((current) => {
+      const batch = batches.find((item) => item.id === current.selectedBatchId);
+      const currentQuantity = Number(
+        clampTransferBatchQuantity(current.quantity, batch?.quantity),
+      );
+      const nextQuantity = calculateNextQuantity(currentQuantity);
+      return {
+        ...current,
+        quantity: clampTransferBatchQuantity(String(nextQuantity), batch?.quantity),
+        error: null,
+      };
+    });
+  };
 
-    const qty = Number(itemQuantity);
-    if (!qty || qty <= 0) {
-      setAddItemError("Quantidade inválida.");
+  const handleBatchChange = (batchId: string): void => {
+    const batch = batches.find((item) => item.id === batchId);
+    setBatchDrawer((current) => ({
+      ...current,
+      selectedBatchId: batchId,
+      quantity: clampTransferBatchQuantity(current.quantity, batch?.quantity),
+      error: null,
+    }));
+  };
+
+  const handleQuantityChange = (quantity: string): void => {
+    const batch = batches.find((item) => item.id === batchDrawer.selectedBatchId);
+    updateBatchDrawer({
+      quantity: clampTransferBatchQuantity(quantity, batch?.quantity),
+    });
+  };
+
+  const appendSelectedBatch = (
+    batch: TransferBatchOption,
+    quantity: number,
+  ): void => {
+    append({
+      sourceBatchId: batch.id,
+      quantity,
+      productName: batch.productName || batchDrawer.productName,
+      batchCode: batch.batchCode,
+      availableQuantity: batch.quantity,
+    });
+    resetProductBuilder();
+  };
+
+  const handleConfirmBatch = (): void => {
+    const batch = batches.find((item) => item.id === batchDrawer.selectedBatchId);
+    const quantity = resolvePositiveQuantity(batchDrawer.quantity);
+    if (!batchDrawer.selectedBatchId) {
+      updateBatchDrawer({ error: "Selecione um lote." });
       return;
     }
-
-    const batch = batches.find((b) => b.id === selectedBatchId);
     if (!batch) {
-      setAddItemError("Lote inválido.");
+      updateBatchDrawer({ error: "Lote indisponível para o produto selecionado." });
       return;
     }
-
-    if (qty > batch.quantity) {
-      setAddItemError(`Quantidade indisponível no lote (Máx: ${batch.quantity}).`);
+    if (!quantity) {
+      updateBatchDrawer({ error: "Informe uma quantidade válida." });
       return;
     }
+    if (quantity > batch.quantity) {
+      updateBatchDrawer({ error: `Quantidade indisponível no lote (Máx: ${batch.quantity}).` });
+      return;
+    }
+    appendSelectedBatch(batch, quantity);
+  };
 
-    const product = products.find((p) => p.id === selectedProductId);
-
-    append({
-      sourceBatchId: selectedBatchId,
-      quantity: qty,
-      productName: product?.name || "Desconhecido",
-      batchCode: batch.code,
-      availableQuantity: batch.quantity,
-    });
+  const markBarcodeAsProcessing = (barcode: string): boolean => {
+    if (lastScannedBarcodeRef.current === barcode) return false;
+    lastScannedBarcodeRef.current = barcode;
+    if (barcodeResetTimeoutRef.current) clearTimeout(barcodeResetTimeoutRef.current);
+    barcodeResetTimeoutRef.current = setTimeout(() => {
+      lastScannedBarcodeRef.current = null;
+    }, 1500);
+    return true;
+  };
 
-    setSelectedProductId("");
-    setSelectedBatchId("");
-    setItemQuantity("");
+  const handleBarcodeScan = async (barcode: string): Promise<void> => {
+    if (!markBarcodeAsProcessing(barcode)) return;
+    try {
+      const response = await api
+        .get(`products/barcode/${encodeURIComponent(barcode)}`)
+        .json<ProductByBarcodeResponse>();
+      setIsScannerOpen(false);
+      handleProductSelect(response.data);
+    } catch {
+      toast.error(`Produto com código ${barcode} não existe.`);
+    }
   };
 
-  const onSubmit = async (data: NewTransferSchema) => {
+  const onSubmit = async (data: NewTransferSchema): Promise<void> => {
     if (!currentWarehouseId) {
       toast.error("Selecione um warehouse de origem.");
       return;
@@ -186,8 +499,7 @@ export function useNewTransferModel(): NewTransferViewProps {
       router.push("/transfers");
     } catch (err: unknown) {
       const error = err as Error;
-      const errorMessage = error.message || "Erro ao criar transferência.";
-      toast.error(errorMessage);
+      toast.error(error.message || "Erro ao criar transferência.");
     } finally {
       setIsSubmitting(false);
     }
@@ -198,17 +510,33 @@ export function useNewTransferModel(): NewTransferViewProps {
     onSubmit,
     warehouses,
     products,
+    productOptions,
     batches,
+    batchDrawer,
     isLoading: isLoadingWarehouses || isLoadingProducts,
+    isProductSearchLoading:
+      isLoadingProducts && debouncedProductSearchQuery.trim().length >= 2,
+    isProductOptionsOpen,
+    isBatchLoading,
+    isScannerOpen,
+    isFooterVisible,
     isSubmitting,
     selectedProductId,
-    selectedBatchId,
-    itemQuantity,
+    productSearchQuery,
     addItemError,
-    onProductChange: handleProductChange,
-    onBatchChange: setSelectedBatchId,
-    onQuantityChange: setItemQuantity,
-    onAddItem: handleAddItem,
+    onProductSearchChange: handleProductSearchChange,
+    onProductSearchFocus: handleProductSearchFocus,
+    onProductSearchBlur: handleProductSearchBlur,
+    onProductSelect: handleProductSelect,
+    onProductClear: handleProductClear,
+    onScannerOpenChange: setIsScannerOpen,
+    onBarcodeScan: handleBarcodeScan,
+    onBatchDrawerOpenChange: handleBatchDrawerOpenChange,
+    onBatchChange: handleBatchChange,
+    onQuantityChange: handleQuantityChange,
+    onQuantityIncrement: () => updateBatchQuantity((quantity) => quantity + 1),
+    onQuantityDecrement: () => updateBatchQuantity((quantity) => quantity - 1),
+    onConfirmBatch: handleConfirmBatch,
     onRemoveItem: remove,
     items: fields,
   };
diff --git a/app/(pages)/transfers/new/new-transfer.types.ts b/app/(pages)/transfers/new/new-transfer.types.ts
index 4100e95..4bd1fa8 100644
--- a/app/(pages)/transfers/new/new-transfer.types.ts
+++ b/app/(pages)/transfers/new/new-transfer.types.ts
@@ -1,24 +1,75 @@
 import { UseFormReturn } from "react-hook-form";
 import { NewTransferSchema } from "./new-transfer.schema";
 
+export interface TransferProductOption {
+  id: string;
+  name: string;
+  sku?: string | null;
+  barcode?: string | null;
+  imageUrl?: string | null;
+  totalQuantity?: number | null;
+  stockQuantityLabel?: string;
+}
+
+export interface TransferBatchOption {
+  id: string;
+  productId: string;
+  productName?: string;
+  batchCode: string;
+  quantity: number;
+  manufacturedDate: string | null;
+  expirationDate: string | null;
+}
+
+export interface TransferBatchDrawerState {
+  isOpen: boolean;
+  productId: string;
+  productName: string;
+  selectedBatchId: string;
+  quantity: string;
+  error: string | null;
+}
+
+export interface NewTransferItemView {
+  id: string;
+  productName?: string;
+  batchCode?: string;
+  quantity: number;
+  availableQuantity?: number;
+}
+
 export interface NewTransferViewProps {
   form: UseFormReturn<NewTransferSchema>;
   onSubmit: (data: NewTransferSchema) => void;
   warehouses: { id: string; name: string }[];
-  products: { id: string; name: string }[];
-  batches: { id: string; code: string; quantity: number }[];
+  products: TransferProductOption[];
+  productOptions: TransferProductOption[];
+  batches: TransferBatchOption[];
+  batchDrawer: TransferBatchDrawerState;
   isLoading: boolean;
+  isProductSearchLoading: boolean;
+  isProductOptionsOpen: boolean;
+  isBatchLoading: boolean;
+  isScannerOpen: boolean;
+  isFooterVisible: boolean;
   isSubmitting: boolean;
 
-  // Item builder state (managed by model)
   selectedProductId: string;
-  selectedBatchId: string;
-  itemQuantity: string;
+  productSearchQuery: string;
   addItemError: string | null;
-  onProductChange: (productId: string) => void;
+  onProductSearchChange: (query: string) => void;
+  onProductSearchFocus: () => void;
+  onProductSearchBlur: () => void;
+  onProductSelect: (product: TransferProductOption) => void;
+  onProductClear: () => void;
+  onScannerOpenChange: (open: boolean) => void;
+  onBarcodeScan: (barcode: string) => void;
+  onBatchDrawerOpenChange: (open: boolean) => void;
   onBatchChange: (batchId: string) => void;
   onQuantityChange: (value: string) => void;
-  onAddItem: () => void;
+  onQuantityIncrement: () => void;
+  onQuantityDecrement: () => void;
+  onConfirmBatch: () => void;
   onRemoveItem: (index: number) => void;
-  items: Array<{ id: string; productName?: string; batchCode?: string; quantity: number }>;
+  items: NewTransferItemView[];
 }
diff --git a/app/(pages)/transfers/new/new-transfer.view.test.tsx b/app/(pages)/transfers/new/new-transfer.view.test.tsx
index ae273e4..f363c1c 100644
--- a/app/(pages)/transfers/new/new-transfer.view.test.tsx
+++ b/app/(pages)/transfers/new/new-transfer.view.test.tsx
@@ -26,6 +26,14 @@ vi.mock("@/lib/contexts/auth-context", () => ({
   }),
 }));
 
+vi.mock("./new-transfer-scanner.view", () => ({
+  NewTransferScanner: () => <div data-testid="transfer-scanner" />,
+}));
+
+vi.mock("./new-transfer-batch-drawer.view", () => ({
+  NewTransferBatchDrawer: () => <div data-testid="transfer-batch-drawer" />,
+}));
+
 const TestWrapper = (props: Partial<NewTransferViewProps>) => {
   const form = useForm<NewTransferSchema>({
     resolver: zodResolver(newTransferSchema),
@@ -42,18 +50,67 @@ const TestWrapper = (props: Partial<NewTransferViewProps>) => {
       { id: "w1", name: "Warehouse A" },
       { id: "w2", name: "Warehouse B" },
     ],
-    products: [{ id: "p1", name: "Product 1" }],
-    batches: [{ id: "b1", code: "BATCH-001", quantity: 100 }],
+    products: [
+      {
+        id: "p1",
+        name: "Product 1",
+        sku: "P1",
+        barcode: "789",
+        totalQuantity: 12,
+        stockQuantityLabel: "Quantidade: 12 un.",
+      },
+    ],
+    productOptions: [
+      {
+        id: "p1",
+        name: "Product 1",
+        sku: "P1",
+        barcode: "789",
+        totalQuantity: 12,
+        stockQuantityLabel: "Quantidade: 12 un.",
+      },
+    ],
+    batches: [
+      {
+        id: "b1",
+        productId: "p1",
+        batchCode: "BATCH-001",
+        quantity: 100,
+        manufacturedDate: null,
+        expirationDate: "2026-12-31",
+      },
+    ],
+    batchDrawer: {
+      isOpen: false,
+      productId: "",
+      productName: "",
+      selectedBatchId: "",
+      quantity: "1",
+      error: null,
+    },
     isLoading: false,
+    isProductSearchLoading: false,
+    isProductOptionsOpen: false,
+    isBatchLoading: false,
+    isScannerOpen: false,
+    isFooterVisible: true,
     isSubmitting: false,
     selectedProductId: "",
-    selectedBatchId: "",
-    itemQuantity: "",
+    productSearchQuery: "",
     addItemError: null,
-    onProductChange: vi.fn(),
+    onProductSearchChange: vi.fn(),
+    onProductSearchFocus: vi.fn(),
+    onProductSearchBlur: vi.fn(),
+    onProductSelect: vi.fn(),
+    onProductClear: vi.fn(),
+    onScannerOpenChange: vi.fn(),
+    onBarcodeScan: vi.fn(),
+    onBatchDrawerOpenChange: vi.fn(),
     onBatchChange: vi.fn(),
     onQuantityChange: vi.fn(),
-    onAddItem: vi.fn(),
+    onQuantityIncrement: vi.fn(),
+    onQuantityDecrement: vi.fn(),
+    onConfirmBatch: vi.fn(),
     onRemoveItem: vi.fn(),
     items: [],
     ...props,
@@ -66,7 +123,7 @@ describe("NewTransferView", () => {
   it("renders the form correctly", () => {
     render(<TestWrapper />);
     expect(screen.getByText("Rota")).toBeTruthy();
-    expect(screen.getByText("Adicionar Item")).toBeTruthy();
+    expect(screen.getByText("Selecionar produto")).toBeTruthy();
 
     const buttons = screen.getAllByText("CRIAR TRANSFERÊNCIA");
     expect(buttons.length).toBeGreaterThan(0);
@@ -81,4 +138,18 @@ describe("NewTransferView", () => {
     expect(await screen.findByText("Selecione um warehouse de destino")).toBeTruthy();
     expect(await screen.findByText("Adicione pelo menos um item")).toBeTruthy();
   });
+
+  it("shows product quantity instead of product code in autocomplete", () => {
+    render(
+      <TestWrapper
+        isProductOptionsOpen={true}
+        productSearchQuery="Product"
+      />,
+    );
+
+    expect(screen.getByText("Product 1")).toBeTruthy();
+    expect(screen.getByText("Quantidade: 12 un.")).toBeTruthy();
+    expect(screen.queryByText(/P1/)).toBeNull();
+    expect(screen.queryByText(/789/)).toBeNull();
+  });
 });
diff --git a/app/(pages)/transfers/new/new-transfer.view.tsx b/app/(pages)/transfers/new/new-transfer.view.tsx
index 9760711..2f8e1c7 100644
--- a/app/(pages)/transfers/new/new-transfer.view.tsx
+++ b/app/(pages)/transfers/new/new-transfer.view.tsx
@@ -2,17 +2,13 @@ import {
   AlertCircle,
   ArrowRight,
   FileText,
-  Hash,
   MapPin,
   Package,
-  Plus,
   Save,
-  Trash2,
   Warehouse,
 } from "lucide-react";
 import { useState, type Dispatch, type SetStateAction } from "react";
 import { PermissionGate } from "@/components/permission-gate";
-import { EmptyState } from "@/components/ui/empty-state";
 import { FixedBottomBar } from "@/components/ui/fixed-bottom-bar";
 import {
   Form,
@@ -22,11 +18,9 @@ import {
   FormMessage,
 } from "@/components/ui/form";
 import { FormSection } from "@/components/ui/form-section";
-import { NumberInput } from "@/components/ui/number-input";
 import { PageContainer } from "@/components/ui/page-container";
 import { PageHeader } from "@/components/ui/page-header";
 import { ResponsiveModal } from "@/components/ui/responsive-modal";
-import { SectionLabel } from "@/components/ui/section-label";
 import {
   Select,
   SelectContent,
@@ -36,7 +30,12 @@ import {
 } from "@/components/ui/select";
 import { Button } from "@/components/ui/button";
 import { Textarea } from "@/components/ui/textarea";
+import { cn } from "@/lib/utils";
 import type { NewTransferViewProps } from "./new-transfer.types";
+import { NewTransferBatchDrawer } from "./new-transfer-batch-drawer.view";
+import { TransferItemsList } from "./new-transfer-items-list.view";
+import { TransferProductSearch } from "./new-transfer-product-search.view";
+import { NewTransferScanner } from "./new-transfer-scanner.view";
 
 interface NewTransferViewState extends NewTransferViewProps {
   isNotesOpen: boolean;
@@ -61,8 +60,24 @@ export function NewTransferView(props: NewTransferViewProps) {
   };
 
   return (
-    <PageContainer bottomPadding="fixed-bar">
+    <PageContainer bottomPadding="fixed-bar" className="pb-44 md:pb-28">
       <PageHeader title="Nova Transferência" subtitle="Criar Transferência" />
+      <NewTransferScanner
+        open={props.isScannerOpen}
+        onOpenChange={props.onScannerOpenChange}
+        onScan={props.onBarcodeScan}
+      />
+      <NewTransferBatchDrawer
+        form={props.batchDrawer}
+        batches={props.batches}
+        isLoading={props.isBatchLoading}
+        onOpenChange={props.onBatchDrawerOpenChange}
+        onBatchChange={props.onBatchChange}
+        onQuantityChange={props.onQuantityChange}
+        onQuantityIncrement={props.onQuantityIncrement}
+        onQuantityDecrement={props.onQuantityDecrement}
+        onConfirm={props.onConfirmBatch}
+      />
       <Form {...props.form}>
         <form
           onSubmit={props.form.handleSubmit(props.onSubmit)}
@@ -71,7 +86,10 @@ export function NewTransferView(props: NewTransferViewProps) {
           <TransferRouteCard viewState={viewState} />
           <TransferNotesModal viewState={viewState} />
           <TransferItemBuilder viewState={viewState} />
-          <TransferItemsList viewState={viewState} />
+          <TransferItemsList
+            viewState={viewState}
+            totalQuantity={viewState.totalQuantity}
+          />
           <TransferSubmitBar viewState={viewState} />
         </form>
       </Form>
@@ -261,147 +279,17 @@ function TransferItemBuilder({
     <FormSection
       icon={Package}
       iconColor="text-emerald-400"
-      title="Adicionar Item"
-      description="Selecione produto, lote e quantidade"
+      title="Selecionar produto"
+      description="Busque ou escaneie o produto para escolher o lote"
     >
       <div className="space-y-4">
-        <TransferProductBatchSelectors viewState={viewState} />
-        <TransferQuantityInput viewState={viewState} />
+        <TransferProductSearch viewState={viewState} />
         <TransferAddItemError addItemError={viewState.addItemError} />
       </div>
     </FormSection>
   );
 }
 
-function TransferProductBatchSelectors({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  return (
-    <div className="flex flex-col gap-4 md:flex-row">
-      <TransferProductSelect viewState={viewState} />
-      <TransferBatchSelect viewState={viewState} />
-    </div>
-  );
-}
-
-function TransferProductSelect({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  const { onProductChange, products, selectedProductId } = viewState;
-
-  return (
-    <div className="min-w-0 flex-1 space-y-2">
-      <label
-        htmlFor="transfer-product-select"
-        className="text-xs font-bold text-neutral-400"
-      >
-        PRODUTO
-      </label>
-      <Select value={selectedProductId} onValueChange={onProductChange}>
-        <SelectTrigger
-          id="transfer-product-select"
-          className="h-10 w-full rounded-[4px] border-2 border-neutral-800 bg-neutral-900 text-sm text-white focus:border-blue-600"
-        >
-          <SelectValue placeholder="Selecione um produto..." />
-        </SelectTrigger>
-        <SelectContent className="rounded-[4px] border-neutral-800 bg-neutral-900">
-          {products.map((product) => (
-            <SelectItem key={product.id} value={product.id}>
-              {product.name}
-            </SelectItem>
-          ))}
-        </SelectContent>
-      </Select>
-    </div>
-  );
-}
-
-function TransferBatchSelect({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  const { batches, onBatchChange, selectedBatchId, selectedProductId } =
-    viewState;
-
-  return (
-    <div className="min-w-0 flex-1 space-y-2">
-      <label
-        htmlFor="transfer-batch-select"
-        className="text-xs font-bold text-neutral-400"
-      >
-        LOTE (DISPONÍVEL)
-      </label>
-      <Select
-        value={selectedBatchId}
-        onValueChange={onBatchChange}
-        disabled={!selectedProductId}
-      >
-        <SelectTrigger
-          id="transfer-batch-select"
-          className="h-10 w-full rounded-[4px] border-2 border-neutral-800 bg-neutral-900 text-sm text-white focus:border-blue-600 disabled:opacity-40"
-        >
-          <SelectValue placeholder="Selecione o lote" />
-        </SelectTrigger>
-        <SelectContent className="rounded-[4px] border-neutral-800 bg-neutral-900">
-          {batches.map((batch) => (
-            <SelectItem key={batch.id} value={batch.id}>
-              <span className="font-mono text-xs tracking-tighter">
-                {batch.code}
-              </span>
-              <span className="ml-2 text-neutral-500">
-                ({batch.quantity} un.)
-              </span>
-            </SelectItem>
-          ))}
-        </SelectContent>
-      </Select>
-    </div>
-  );
-}
-
-function TransferQuantityInput({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  const { itemQuantity, onAddItem, onQuantityChange } = viewState;
-
-  return (
-    <div className="space-y-2">
-      <label
-        htmlFor="transfer-item-quantity"
-        className="text-xs font-bold text-neutral-400"
-      >
-        QUANTIDADE
-      </label>
-      <div className="flex items-center gap-3">
-        <NumberInput
-          id="transfer-item-quantity"
-          value={itemQuantity ? Number(itemQuantity) : undefined}
-          onValueChange={(value) =>
-            onQuantityChange(value !== undefined ? String(value) : "")
-          }
-          className="h-10 w-full rounded-[4px] border-2 border-neutral-800 bg-neutral-900 font-mono text-sm tracking-tighter text-white focus:border-blue-600"
-          placeholder="0"
-        />
-        <Button
-          type="button"
-          onClick={onAddItem}
-          className="h-10 flex-shrink-0 rounded-[4px] bg-emerald-600 px-5 text-xs font-bold uppercase tracking-wide text-white hover:bg-emerald-700"
-        >
-          <Plus className="mr-2 size-4" strokeWidth={2.5} />
-          Adicionar
-        </Button>
-      </div>
-    </div>
-  );
-}
-
 function TransferAddItemError({
   addItemError,
 }: {
@@ -417,206 +305,31 @@ function TransferAddItemError({
   );
 }
 
-function TransferItemsList({
+function TransferSubmitBar({
   viewState,
 }: {
   viewState: NewTransferViewState;
 }) {
-  const { form, items } = viewState;
+  const { isFooterVisible, isLoading, isSubmitting, items, totalQuantity } =
+    viewState;
 
   return (
-    <div>
-      <SectionLabel icon={Hash} className="mb-4">
-        Itens na Transferência ({items.length})
-      </SectionLabel>
-      {items.length === 0 ? (
-        <EmptyState
-          icon={Package}
-          title="Nenhum item adicionado"
-          description="Selecione um produto e lote acima para adicionar itens à transferência."
-        />
-      ) : (
-        <>
-          <TransferItemsMobileList viewState={viewState} />
-          <TransferItemsDesktopTable viewState={viewState} />
-        </>
+    <FixedBottomBar
+      className={cn(
+        "bg-[#0A0A0A]/95 backdrop-blur-sm transition-transform duration-200 ease-in-out",
+        isFooterVisible
+          ? "translate-y-0"
+          : "pointer-events-none translate-y-[calc(100%+1rem)]",
       )}
-      {form.formState.errors.items && (
-        <p className="mt-2 text-xs font-medium text-rose-500">
-          {form.formState.errors.items.message}
-        </p>
-      )}
-    </div>
-  );
-}
-
-function TransferItemsMobileList({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  return (
-    <div className="flex flex-col gap-3 md:hidden">
-      {viewState.items.map((item, index) => (
-        <div
-          key={item.id}
-          className="flex items-center gap-3 rounded-[4px] border border-neutral-800 bg-[#171717] p-4"
-        >
-          <div className="min-w-0 flex-1">
-            <p className="truncate text-sm font-bold text-white">
-              {item.productName || "Produto"}
-            </p>
-            <div className="mt-1 flex items-center gap-3 text-xs text-neutral-500">
-              <span>
-                Lote:{" "}
-                <span className="font-mono text-neutral-400">
-                  {item.batchCode}
-                </span>
-              </span>
-              <span>
-                Qtd:{" "}
-                <span className="font-mono font-bold tracking-tighter text-white">
-                  {item.quantity}
-                </span>
-              </span>
-            </div>
-          </div>
-          <TransferRemoveItemButton
-            index={index}
-            onRemoveItem={viewState.onRemoveItem}
-            sizeClassName="size-9"
-          />
-        </div>
-      ))}
-    </div>
-  );
-}
-
-function TransferItemsDesktopTable({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  const { items, totalQuantity } = viewState;
-
-  return (
-    <div className="hidden md:block">
-      <div className="rounded-[4px] border border-neutral-800 bg-[#171717]">
-        <table className="w-full">
-          <thead>
-            <tr className="border-b border-neutral-800">
-              <th className="px-5 py-3 text-left text-[10px] font-bold uppercase tracking-widest text-neutral-500">
-                Produto
-              </th>
-              <th className="px-5 py-3 text-left text-[10px] font-bold uppercase tracking-widest text-neutral-500">
-                Lote
-              </th>
-              <th className="px-5 py-3 text-right text-[10px] font-bold uppercase tracking-widest text-neutral-500">
-                Quantidade
-              </th>
-              <th className="w-12 p-3" />
-            </tr>
-          </thead>
-          <tbody>
-            {items.map((item, index) => (
-              <TransferItemsDesktopRow
-                key={item.id}
-                index={index}
-                item={item}
-                onRemoveItem={viewState.onRemoveItem}
-              />
-            ))}
-          </tbody>
-          <tfoot>
-            <tr className="border-t border-neutral-700">
-              <td
-                colSpan={2}
-                className="px-5 py-3 text-[10px] font-bold uppercase tracking-widest text-neutral-500"
-              >
-                Total
-              </td>
-              <td className="px-5 py-3 text-right font-mono text-sm font-bold tracking-tighter text-white">
-                {totalQuantity}
-              </td>
-              <td />
-            </tr>
-          </tfoot>
-        </table>
-      </div>
-    </div>
-  );
-}
-
-function TransferItemsDesktopRow({
-  index,
-  item,
-  onRemoveItem,
-}: {
-  index: number;
-  item: NewTransferViewProps["items"][number];
-  onRemoveItem: (index: number) => void;
-}) {
-  return (
-    <tr className="border-b border-neutral-800 last:border-0">
-      <td className="px-5 py-3.5 text-sm font-medium text-white">
-        {item.productName || "Produto"}
-      </td>
-      <td className="px-5 py-3.5 font-mono text-xs text-neutral-400">
-        {item.batchCode || "—"}
-      </td>
-      <td className="px-5 py-3.5 text-right font-mono text-sm font-bold tracking-tighter text-white">
-        {item.quantity}
-      </td>
-      <td className="p-3.5">
-        <TransferRemoveItemButton
-          index={index}
-          onRemoveItem={onRemoveItem}
-          sizeClassName="size-8"
-        />
-      </td>
-    </tr>
-  );
-}
-
-function TransferRemoveItemButton({
-  index,
-  onRemoveItem,
-  sizeClassName,
-}: {
-  index: number;
-  onRemoveItem: (index: number) => void;
-  sizeClassName: string;
-}) {
-  return (
-    <Button
-      type="button"
-      variant="ghost"
-      size="icon"
-      onClick={() => onRemoveItem(index)}
-      className={`${sizeClassName} rounded-[4px] text-neutral-500 hover:bg-neutral-800 hover:text-rose-500`}
     >
-      <Trash2 className="size-4" strokeWidth={2} />
-    </Button>
-  );
-}
-
-function TransferSubmitBar({
-  viewState,
-}: {
-  viewState: NewTransferViewState;
-}) {
-  const { isLoading, isSubmitting, items, totalQuantity } = viewState;
-
-  return (
-    <FixedBottomBar>
-      <div className="mx-auto flex max-w-7xl items-center justify-between gap-3">
+      <div className="mx-auto flex w-full max-w-7xl flex-col gap-3 md:flex-row md:items-center md:justify-between">
         <TransferSummary items={items} totalQuantity={totalQuantity} />
-        <div className="flex items-center gap-3">
+        <div className="flex w-full flex-col items-stretch gap-3 md:w-auto md:flex-row md:items-center">
           <Button
             type="button"
             variant="outline"
             onClick={() => window.history.back()}
-            className="h-10 rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide"
+            className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
           >
             CANCELAR
           </Button>
@@ -624,7 +337,7 @@ function TransferSubmitBar({
             <Button
               type="submit"
               disabled={isSubmitting || isLoading}
-              className="h-10 rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700"
+              className="h-12 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:h-10 md:w-auto"
             >
               <Save className="mr-2 size-4" strokeWidth={2} />
               {isSubmitting ? "CRIANDO..." : "CRIAR TRANSFERÊNCIA"}
@@ -644,7 +357,7 @@ function TransferSummary({
   totalQuantity: number;
 }) {
   return (
-    <div className="hidden items-center gap-4 text-xs text-neutral-500 sm:flex">
+    <div className="flex items-center justify-between md:justify-start md:gap-4 text-xs text-neutral-500">
       <span>
         <span className="font-mono font-bold tracking-tighter text-neutral-300">
           {items.length}

From 15dc3b2b7d3b80aecc53cf4b2553f3dc6f78c788 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 23:57:46 -0300
Subject: [PATCH 07/32] feat(barcode-scanner): use barcode-detector stream

---
 app/(pages)/sales/pdv/pdv.view.tsx            |   8 +-
 .../create/stock-movement-scanner.view.tsx    |  11 +-
 .../[id]/validate/validate-transfer.view.tsx  |  13 +-
 .../new/new-transfer-scanner.view.tsx         |  11 +-
 components/product/barcode-scanner-camera.ts  |   4 +-
 .../product/barcode-scanner-error-modal.tsx   |  71 ++++++++
 components/product/barcode-scanner-modal.tsx  |  11 +-
 components/product/barcode-scanner.tsx        | 169 ++++++++++--------
 components/product/barcode-scanner.types.ts   |  22 +++
 .../product/use-barcode-detection-loop.ts     |  87 +++++++++
 .../product/use-barcode-scanner-stream.ts     |  68 +++++++
 package.json                                  |   2 +-
 pnpm-lock.yaml                                |  56 ++----
 13 files changed, 375 insertions(+), 158 deletions(-)
 create mode 100644 components/product/barcode-scanner-error-modal.tsx
 create mode 100644 components/product/barcode-scanner.types.ts
 create mode 100644 components/product/use-barcode-detection-loop.ts
 create mode 100644 components/product/use-barcode-scanner-stream.ts

diff --git a/app/(pages)/sales/pdv/pdv.view.tsx b/app/(pages)/sales/pdv/pdv.view.tsx
index 164cadb..14d0064 100644
--- a/app/(pages)/sales/pdv/pdv.view.tsx
+++ b/app/(pages)/sales/pdv/pdv.view.tsx
@@ -9,7 +9,7 @@ import {
 } from "react";
 import type { PointerEvent } from "react";
 import type { UseFormReturn } from "react-hook-form";
-import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { type BarcodeScannerDetectedCode } from "@/components/product/barcode-scanner.types";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { NumberInput } from "@/components/ui/number-input";
@@ -128,7 +128,7 @@ export const PdvView = ({
     selectedPayment && METHODS_WITH_INSTALLMENTS.includes(selectedPayment) && selectedMode !== "LINK";
 
   const handleBarcodeScan = useCallback(
-    (detectedCodes: IDetectedBarcode[]) => {
+    (detectedCodes: BarcodeScannerDetectedCode[]) => {
       if (detectedCodes && detectedCodes.length > 0) {
         const code = detectedCodes[0].rawValue;
         if (code) onBarcodeScanned(code);
@@ -673,7 +673,7 @@ function DiscountRow({ form, discountAmount }: DiscountRowProps) {
 interface BarcodeDrawerProps {
   open: boolean;
   onClose: () => void;
-  onScan: (codes: IDetectedBarcode[]) => void;
+  onScan: (codes: BarcodeScannerDetectedCode[]) => void;
 }
 
 function BarcodeDrawer({ open, onClose, onScan }: BarcodeDrawerProps) {
@@ -692,7 +692,7 @@ function BarcodeDrawer({ open, onClose, onScan }: BarcodeDrawerProps) {
               onScan={onScan}
               onError={(err: unknown) => console.error("Camera error:", err)}
               styles={{ container: { width: "100%", height: "280px" }, video: { objectFit: "cover" } }}
-              components={{ onOff: false, torch: false, zoom: false, finder: true }}
+              components={{ finder: true }}
             />
           </div>
           <Button
diff --git a/app/(pages)/stock-movements/create/stock-movement-scanner.view.tsx b/app/(pages)/stock-movements/create/stock-movement-scanner.view.tsx
index aa37ac9..377ca7b 100644
--- a/app/(pages)/stock-movements/create/stock-movement-scanner.view.tsx
+++ b/app/(pages)/stock-movements/create/stock-movement-scanner.view.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { type BarcodeScannerDetectedCode } from "@/components/product/barcode-scanner.types";
 import { ScanLine, X } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
@@ -24,7 +24,7 @@ export function StockMovementScanner({
   onOpenChange,
   onScan,
 }: StockMovementScannerProps) {
-  const handleScan = (detectedCodes: IDetectedBarcode[]) => {
+  const handleScan = (detectedCodes: BarcodeScannerDetectedCode[]) => {
     const barcode = detectedCodes[0]?.rawValue;
     if (!barcode) return;
     onScan(barcode);
@@ -67,12 +67,7 @@ export function StockMovementScanner({
             <BarcodeScanner
               onScan={handleScan}
               onError={handleError}
-              components={{
-                finder: true,
-                onOff: false,
-                torch: false,
-                zoom: false,
-              }}
+              components={{ finder: true }}
               styles={{
                 container: { width: "100%", height: "min(64vh, 420px)" },
                 video: { objectFit: "cover" },
diff --git a/app/(pages)/transfers/[id]/validate/validate-transfer.view.tsx b/app/(pages)/transfers/[id]/validate/validate-transfer.view.tsx
index 04cf8ea..bbe5eb9 100644
--- a/app/(pages)/transfers/[id]/validate/validate-transfer.view.tsx
+++ b/app/(pages)/transfers/[id]/validate/validate-transfer.view.tsx
@@ -7,7 +7,7 @@ import {
   type ReactNode,
   type SetStateAction,
 } from "react";
-import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { type BarcodeScannerDetectedCode } from "@/components/product/barcode-scanner.types";
 import {
   AlertCircle,
   AlertTriangle,
@@ -40,7 +40,7 @@ import type {
 interface ValidateTransferViewState extends ValidateTransferViewProps {
   circumference: number;
   completedItems: number;
-  handleCameraScan: (detectedCodes: IDetectedBarcode[]) => void;
+  handleCameraScan: (detectedCodes: BarcodeScannerDetectedCode[]) => void;
   handleSubmit: (event: FormEvent) => void;
   radius: number;
   setShowScanner: Dispatch<SetStateAction<boolean>>;
@@ -63,7 +63,7 @@ export function ValidateTransferView(props: ValidateTransferViewProps) {
     event.preventDefault();
     props.onScan();
   };
-  const handleCameraScan = (detectedCodes: IDetectedBarcode[]) => {
+  const handleCameraScan = (detectedCodes: BarcodeScannerDetectedCode[]) => {
     if (!detectedCodes || detectedCodes.length === 0) return;
     props.onBarcodeChange(detectedCodes[0].rawValue);
     setShowScanner(false);
@@ -542,12 +542,7 @@ function CameraScannerModal({
             container: { width: "100%", height: "280px" },
             video: { objectFit: "cover" },
           }}
-          components={{
-            onOff: false,
-            torch: false,
-            zoom: false,
-            finder: true,
-          }}
+          components={{ finder: true }}
         />
         <CameraScannerOverlay />
       </div>
diff --git a/app/(pages)/transfers/new/new-transfer-scanner.view.tsx b/app/(pages)/transfers/new/new-transfer-scanner.view.tsx
index 9c575b7..591bec2 100644
--- a/app/(pages)/transfers/new/new-transfer-scanner.view.tsx
+++ b/app/(pages)/transfers/new/new-transfer-scanner.view.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { type BarcodeScannerDetectedCode } from "@/components/product/barcode-scanner.types";
 import { ScanLine, X } from "lucide-react";
 
 import { BarcodeScanner } from "@/components/product/barcode-scanner";
@@ -24,7 +24,7 @@ export function NewTransferScanner({
   onOpenChange,
   onScan,
 }: NewTransferScannerProps) {
-  const handleScan = (detectedCodes: IDetectedBarcode[]): void => {
+  const handleScan = (detectedCodes: BarcodeScannerDetectedCode[]): void => {
     const barcode = detectedCodes[0]?.rawValue;
     if (!barcode) return;
     onScan(barcode);
@@ -67,12 +67,7 @@ export function NewTransferScanner({
             <BarcodeScanner
               onScan={handleScan}
               onError={handleError}
-              components={{
-                finder: true,
-                onOff: false,
-                torch: false,
-                zoom: false,
-              }}
+              components={{ finder: true }}
               styles={{
                 container: { width: "100%", height: "min(64vh, 420px)" },
                 video: { objectFit: "cover" },
diff --git a/components/product/barcode-scanner-camera.ts b/components/product/barcode-scanner-camera.ts
index 198da1e..797bcc5 100644
--- a/components/product/barcode-scanner-camera.ts
+++ b/components/product/barcode-scanner-camera.ts
@@ -1,6 +1,6 @@
-import type { IScannerProps } from "@yudiel/react-qr-scanner";
+import type { BarcodeFormat } from "barcode-detector/ponyfill";
 
-type BarcodeScannerFormatList = NonNullable<IScannerProps["formats"]>;
+type BarcodeScannerFormatList = BarcodeFormat[];
 
 type BarcodeScannerCameraOptions = {
   deviceId: string | null;
diff --git a/components/product/barcode-scanner-error-modal.tsx b/components/product/barcode-scanner-error-modal.tsx
new file mode 100644
index 0000000..f0c7780
--- /dev/null
+++ b/components/product/barcode-scanner-error-modal.tsx
@@ -0,0 +1,71 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { ResponsiveModal } from "@/components/ui/responsive-modal";
+
+interface BarcodeScannerErrorModalProps {
+  content: string | null;
+  onClose: () => void;
+}
+
+export const formatBarcodeScannerError = (error: unknown): string => {
+  if (error instanceof Error) {
+    return JSON.stringify(
+      {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      },
+      null,
+      2,
+    );
+  }
+
+  try {
+    return JSON.stringify(error, null, 2);
+  } catch {
+    return String(error);
+  }
+};
+
+export const BarcodeScannerErrorModal = ({
+  content,
+  onClose,
+}: BarcodeScannerErrorModalProps) => {
+  const handleCopyContent = (): void => {
+    if (!content) return;
+    void navigator.clipboard?.writeText(content);
+  };
+
+  return (
+    <ResponsiveModal
+      open={content !== null}
+      onOpenChange={(open) => !open && onClose()}
+      title="Erro no leitor"
+      description="Conteúdo capturado pelo leitor de código de barras."
+      footer={
+        <>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={onClose}
+            className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
+          >
+            Fechar
+          </Button>
+          <Button
+            type="button"
+            onClick={handleCopyContent}
+            className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:w-auto"
+          >
+            Copiar Conteúdo
+          </Button>
+        </>
+      }
+    >
+      <pre className="max-h-[360px] overflow-auto rounded-[4px] border border-neutral-800 bg-neutral-950 p-3 text-xs text-neutral-300 whitespace-pre-wrap">
+        {content}
+      </pre>
+    </ResponsiveModal>
+  );
+};
diff --git a/components/product/barcode-scanner-modal.tsx b/components/product/barcode-scanner-modal.tsx
index de59ed2..54b4491 100644
--- a/components/product/barcode-scanner-modal.tsx
+++ b/components/product/barcode-scanner-modal.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { type IDetectedBarcode } from "@yudiel/react-qr-scanner";
+import { type BarcodeScannerDetectedCode } from "@/components/product/barcode-scanner.types";
 import { AlertCircle } from "lucide-react";
 import { ResponsiveModal } from "@/components/ui/responsive-modal";
 import { Button } from "@/components/ui/button";
@@ -17,7 +17,7 @@ export const BarcodeScannerModal = ({
   onClose,
   onScan,
 }: BarcodeScannerModalProps) => {
-  const handleScan = (detectedCodes: IDetectedBarcode[]) => {
+  const handleScan = (detectedCodes: BarcodeScannerDetectedCode[]) => {
     if (detectedCodes && detectedCodes.length > 0) {
       const code = detectedCodes[0].rawValue;
       onScan(code);
@@ -61,12 +61,7 @@ export const BarcodeScannerModal = ({
                 objectFit: "cover",
               },
             }}
-            components={{
-              onOff: false,
-              torch: false,
-              zoom: false,
-              finder: true,
-            }}
+            components={{ finder: true }}
           />
 
           {/* Overlay Instructions - Corporate Solid */}
diff --git a/components/product/barcode-scanner.tsx b/components/product/barcode-scanner.tsx
index 75ca466..5465354 100644
--- a/components/product/barcode-scanner.tsx
+++ b/components/product/barcode-scanner.tsx
@@ -1,48 +1,49 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { DetectedBarcode } from "barcode-detector/ponyfill";
 import {
-  Scanner,
-  type IScannerProps,
-} from "@yudiel/react-qr-scanner";
-import { Button } from "@/components/ui/button";
-import { ResponsiveModal } from "@/components/ui/responsive-modal";
-import {
-  barcodeScannerFormats,
   createBarcodeScannerCameraConstraints,
   getBarcodeScannerDeviceIds,
   shouldRetryBarcodeScannerCamera,
 } from "@/components/product/barcode-scanner-camera";
-
-type BarcodeScannerProps = Omit<IScannerProps, "constraints" | "formats">;
+import {
+  BarcodeScannerErrorModal,
+  formatBarcodeScannerError,
+} from "@/components/product/barcode-scanner-error-modal";
+import { useBarcodeDetectionLoop } from "@/components/product/use-barcode-detection-loop";
+import { useBarcodeScannerStream } from "@/components/product/use-barcode-scanner-stream";
+import type {
+  BarcodeScannerDetectedCode,
+  BarcodeScannerProps,
+} from "@/components/product/barcode-scanner.types";
 
 const BARCODE_SCANNER_DEVICE_REFRESH_DELAYS_MS = [750, 2500] as const;
-
-const formatBarcodeScannerError = (error: unknown): string => {
-  if (error instanceof Error) {
-    return JSON.stringify(
-      {
-        name: error.name,
-        message: error.message,
-        stack: error.stack,
-      },
-      null,
-      2,
-    );
-  }
-
-  try {
-    return JSON.stringify(error, null, 2);
-  } catch {
-    return String(error);
-  }
-};
+const BARCODE_SCANNER_RESCAN_DELAY_MS = 1500;
+const BARCODE_SCANNER_MAX_CAMERA_RETRIES = 4;
+
+const toBarcodeScannerDetectedCode = (
+  detectedBarcode: DetectedBarcode,
+): BarcodeScannerDetectedCode => ({
+  rawValue: detectedBarcode.rawValue,
+  format: detectedBarcode.format,
+});
+
+const BarcodeScannerFinder = () => (
+  <div className="pointer-events-none absolute inset-0 flex items-center justify-center">
+    <div className="h-[45%] w-[80%] rounded-[4px] border-2 border-white/70" />
+  </div>
+);
 
 export const BarcodeScanner = ({
-  onError,
   onScan,
-  ...scannerProps
+  onError,
+  styles,
+  components,
 }: BarcodeScannerProps) => {
+  const videoRef = useRef<HTMLVideoElement>(null);
+  const lastScanRef = useRef({ value: "", scannedAt: 0 });
+  const cameraRetryCountRef = useRef(0);
   const [usesCompatibleCamera, setUsesCompatibleCamera] = useState(false);
   const [cameraDeviceIds, setCameraDeviceIds] = useState<string[]>([]);
   const [cameraDeviceIndex, setCameraDeviceIndex] = useState(0);
@@ -58,10 +59,6 @@ export const BarcodeScanner = ({
     [selectedCameraDeviceId, usesCompatibleCamera],
   );
 
-  const scannerKey = `${selectedCameraDeviceId ?? "environment"}:${
-    usesCompatibleCamera ? "compatible" : "preferred"
-  }`;
-
   const refreshCameraDevices = useCallback(async (): Promise<void> => {
     if (!navigator.mediaDevices?.enumerateDevices) return;
 
@@ -70,6 +67,9 @@ export const BarcodeScanner = ({
   }, []);
 
   const selectNextCameraConfiguration = useCallback(() => {
+    if (cameraRetryCountRef.current >= BARCODE_SCANNER_MAX_CAMERA_RETRIES) return;
+
+    cameraRetryCountRef.current += 1;
     setUsesCompatibleCamera(true);
     setCameraDeviceIndex((currentIndex) => {
       if (cameraDeviceIds.length < 2) return currentIndex;
@@ -77,6 +77,11 @@ export const BarcodeScanner = ({
     });
   }, [cameraDeviceIds.length]);
 
+  const handleStreamStart = useCallback(() => {
+    cameraRetryCountRef.current = 0;
+    void refreshCameraDevices();
+  }, [refreshCameraDevices]);
+
   const handleScannerError = useCallback(
     (error: unknown) => {
       setScannerErrorContent(formatBarcodeScannerError(error));
@@ -91,10 +96,33 @@ export const BarcodeScanner = ({
     [onError, refreshCameraDevices, selectNextCameraConfiguration],
   );
 
-  const handleCopyScannerError = useCallback((): void => {
-    if (!scannerErrorContent) return;
-    void navigator.clipboard?.writeText(scannerErrorContent);
-  }, [scannerErrorContent]);
+  const emitDetectedBarcodes = useCallback(
+    (detectedBarcodes: DetectedBarcode[]) => {
+      const scannedValue = detectedBarcodes[0]?.rawValue;
+      if (!scannedValue) return;
+
+      const scannedAt = Date.now();
+      const lastScan = lastScanRef.current;
+      const isRepeatedScan =
+        scannedValue === lastScan.value &&
+        scannedAt - lastScan.scannedAt < BARCODE_SCANNER_RESCAN_DELAY_MS;
+
+      lastScanRef.current = { value: scannedValue, scannedAt };
+      if (isRepeatedScan) return;
+
+      onScan(detectedBarcodes.map(toBarcodeScannerDetectedCode));
+    },
+    [onScan],
+  );
+
+  useBarcodeScannerStream({
+    videoRef,
+    constraints: cameraConstraints,
+    onStreamStart: handleStreamStart,
+    onStreamError: handleScannerError,
+  });
+
+  useBarcodeDetectionLoop({ videoRef, onDetect: emitDetectedBarcodes });
 
   useEffect(() => {
     void refreshCameraDevices();
@@ -115,43 +143,32 @@ export const BarcodeScanner = ({
 
   return (
     <>
-      <Scanner
-        key={scannerKey}
-        {...scannerProps}
-        constraints={cameraConstraints}
-        formats={barcodeScannerFormats}
-        onScan={onScan}
-        onError={handleScannerError}
-      />
-      <ResponsiveModal
-        open={scannerErrorContent !== null}
-        onOpenChange={(open) => !open && setScannerErrorContent(null)}
-        title="Erro no leitor"
-        description="Conteúdo capturado pelo leitor de código de barras."
-        footer={
-          <>
-            <Button
-              type="button"
-              variant="outline"
-              onClick={() => setScannerErrorContent(null)}
-              className="h-10 w-full rounded-[4px] border-neutral-800 text-xs font-bold uppercase tracking-wide md:w-auto"
-            >
-              Fechar
-            </Button>
-            <Button
-              type="button"
-              onClick={handleCopyScannerError}
-              className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700 md:w-auto"
-            >
-              Copiar Conteúdo
-            </Button>
-          </>
-        }
+      <div
+        style={{
+          position: "relative",
+          width: "100%",
+          overflow: "hidden",
+          ...styles?.container,
+        }}
       >
-        <pre className="max-h-[360px] overflow-auto rounded-[4px] border border-neutral-800 bg-neutral-950 p-3 text-xs text-neutral-300 whitespace-pre-wrap">
-          {scannerErrorContent}
-        </pre>
-      </ResponsiveModal>
+        <video
+          ref={videoRef}
+          autoPlay
+          muted
+          playsInline
+          style={{
+            width: "100%",
+            height: "100%",
+            objectFit: "cover",
+            ...styles?.video,
+          }}
+        />
+        {components?.finder !== false && <BarcodeScannerFinder />}
+      </div>
+      <BarcodeScannerErrorModal
+        content={scannerErrorContent}
+        onClose={() => setScannerErrorContent(null)}
+      />
     </>
   );
 };
diff --git a/components/product/barcode-scanner.types.ts b/components/product/barcode-scanner.types.ts
new file mode 100644
index 0000000..5443392
--- /dev/null
+++ b/components/product/barcode-scanner.types.ts
@@ -0,0 +1,22 @@
+import type { CSSProperties } from "react";
+
+export interface BarcodeScannerDetectedCode {
+  rawValue: string;
+  format: string;
+}
+
+export interface BarcodeScannerStyles {
+  container?: CSSProperties;
+  video?: CSSProperties;
+}
+
+export interface BarcodeScannerComponents {
+  finder?: boolean;
+}
+
+export interface BarcodeScannerProps {
+  onScan: (detectedCodes: BarcodeScannerDetectedCode[]) => void;
+  onError?: (error: unknown) => void;
+  styles?: BarcodeScannerStyles;
+  components?: BarcodeScannerComponents;
+}
diff --git a/components/product/use-barcode-detection-loop.ts b/components/product/use-barcode-detection-loop.ts
new file mode 100644
index 0000000..da9845f
--- /dev/null
+++ b/components/product/use-barcode-detection-loop.ts
@@ -0,0 +1,87 @@
+"use client";
+
+import { useEffect, type RefObject } from "react";
+import {
+  BarcodeDetector,
+  type DetectedBarcode,
+} from "barcode-detector/ponyfill";
+import { barcodeScannerFormats } from "@/components/product/barcode-scanner-camera";
+
+type BarcodeDetectionLoopOptions = {
+  videoRef: RefObject<HTMLVideoElement | null>;
+  onDetect: (detectedBarcodes: DetectedBarcode[]) => void;
+};
+
+const BARCODE_DETECTION_MAX_FRAME_WIDTH_PX = 640;
+const BARCODE_DETECTION_VERTICAL_CROP_RATIO = 0.6;
+
+const canDetectFromVideo = (video: HTMLVideoElement | null): video is HTMLVideoElement =>
+  video !== null &&
+  video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA &&
+  video.videoWidth > 0;
+
+const cropBarcodeDetectionFrame = (
+  video: HTMLVideoElement,
+  canvas: HTMLCanvasElement,
+): ImageData | null => {
+  const sourceHeight = video.videoHeight * BARCODE_DETECTION_VERTICAL_CROP_RATIO;
+  const sourceTop = (video.videoHeight - sourceHeight) / 2;
+  const scale = Math.min(1, BARCODE_DETECTION_MAX_FRAME_WIDTH_PX / video.videoWidth);
+
+  canvas.width = Math.round(video.videoWidth * scale);
+  canvas.height = Math.round(sourceHeight * scale);
+
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) return null;
+
+  context.drawImage(
+    video,
+    0,
+    sourceTop,
+    video.videoWidth,
+    sourceHeight,
+    0,
+    0,
+    canvas.width,
+    canvas.height,
+  );
+  return context.getImageData(0, 0, canvas.width, canvas.height);
+};
+
+export const useBarcodeDetectionLoop = ({
+  videoRef,
+  onDetect,
+}: BarcodeDetectionLoopOptions): void => {
+  useEffect(() => {
+    const detector = new BarcodeDetector({ formats: barcodeScannerFormats });
+    const frameCanvas = document.createElement("canvas");
+    let isCancelled = false;
+
+    const detectCurrentFrame = async (): Promise<void> => {
+      const video = videoRef.current;
+      if (!canDetectFromVideo(video)) return;
+
+      try {
+        const frame = cropBarcodeDetectionFrame(video, frameCanvas);
+        if (!frame) return;
+
+        const detectedBarcodes = await detector.detect(frame);
+        if (detectedBarcodes.length > 0 && !isCancelled) onDetect(detectedBarcodes);
+      } catch {
+        // Frames podem falhar durante troca de câmera; o loop continua.
+      }
+    };
+
+    const runDetectionLoop = (): void => {
+      if (isCancelled) return;
+      void detectCurrentFrame().finally(() =>
+        window.requestAnimationFrame(runDetectionLoop),
+      );
+    };
+
+    runDetectionLoop();
+    return () => {
+      isCancelled = true;
+    };
+  }, [onDetect, videoRef]);
+};
diff --git a/components/product/use-barcode-scanner-stream.ts b/components/product/use-barcode-scanner-stream.ts
new file mode 100644
index 0000000..62e24fb
--- /dev/null
+++ b/components/product/use-barcode-scanner-stream.ts
@@ -0,0 +1,68 @@
+"use client";
+
+import { useEffect, type RefObject } from "react";
+
+type BarcodeScannerStreamOptions = {
+  videoRef: RefObject<HTMLVideoElement | null>;
+  constraints: MediaTrackConstraints;
+  onStreamStart: () => void;
+  onStreamError: (error: unknown) => void;
+};
+
+const stopMediaStream = (stream: MediaStream | null): void => {
+  if (!stream) return;
+  stream.getTracks().forEach((track) => track.stop());
+};
+
+const isInterruptedPlaybackError = (error: unknown): boolean =>
+  error instanceof DOMException && error.name === "AbortError";
+
+const attachStreamToVideo = async (
+  video: HTMLVideoElement,
+  stream: MediaStream,
+): Promise<void> => {
+  video.srcObject = stream;
+  await video.play();
+};
+
+export const useBarcodeScannerStream = ({
+  videoRef,
+  constraints,
+  onStreamStart,
+  onStreamError,
+}: BarcodeScannerStreamOptions): void => {
+  useEffect(() => {
+    const video = videoRef.current;
+    if (!video || !navigator.mediaDevices?.getUserMedia) return;
+
+    let activeStream: MediaStream | null = null;
+    let isCancelled = false;
+
+    const startStream = async (): Promise<void> => {
+      try {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          audio: false,
+          video: constraints,
+        });
+        if (isCancelled) {
+          stopMediaStream(stream);
+          return;
+        }
+        activeStream = stream;
+        await attachStreamToVideo(video, stream);
+        onStreamStart();
+      } catch (error) {
+        if (isCancelled || isInterruptedPlaybackError(error)) return;
+        onStreamError(error);
+      }
+    };
+
+    void startStream();
+
+    return () => {
+      isCancelled = true;
+      stopMediaStream(activeStream);
+      video.srcObject = null;
+    };
+  }, [constraints, onStreamError, onStreamStart, videoRef]);
+};
diff --git a/package.json b/package.json
index 6b50536..3651d6b 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@testing-library/react": "^16.3.1",
-    "@yudiel/react-qr-scanner": "^2.5.0",
+    "barcode-detector": "^3.2.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b6a8295..162cec4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -95,9 +95,9 @@ importers:
       '@testing-library/react':
         specifier: ^16.3.1
         version: 16.3.1(@testing-library/dom@10.4.1)(@types/react-dom@19.2.1(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
-      '@yudiel/react-qr-scanner':
-        specifier: ^2.5.0
-        version: 2.5.0(@types/emscripten@1.41.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+      barcode-detector:
+        specifier: ^3.2.0
+        version: 3.2.0(@types/emscripten@1.41.5)
       class-variance-authority:
         specifier: ^0.7.1
         version: 0.7.1
@@ -1947,12 +1947,6 @@ packages:
   '@vitest/utils@3.2.4':
     resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==}
 
-  '@yudiel/react-qr-scanner@2.5.0':
-    resolution: {integrity: sha512-wVWvm0z5kGGc3tiMcxyr2aji3C6aU5K3Q7R08MOdyFDFkvMbFMF1Hz5P5WFYW+zuuqxDPBcRZPCvmVs6jBheTQ==}
-    peerDependencies:
-      react: ^17 || ^18 || ^19
-      react-dom: ^17 || ^18 || ^19
-
   acorn-jsx@5.3.2:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -2069,8 +2063,8 @@ packages:
     resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
     engines: {node: 18 || 20 || >=22}
 
-  barcode-detector@3.0.8:
-    resolution: {integrity: sha512-Z9jzzE8ngEDyN9EU7lWdGgV07mcnEQnrX8W9WecXDqD2v+5CcVjt9+a134a5zb+kICvpsrDx6NYA6ay4LGFs8A==}
+  barcode-detector@3.2.0:
+    resolution: {integrity: sha512-MrT5TT058ptG5YB157pHLfXKVpp0BKEfQBOb8QvzTbatzmLDu85JJ0Gd/sCYwbwdwStJvxsYflrSN6D6E4Ndyw==}
 
   bidi-js@1.0.3:
     resolution: {integrity: sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==}
@@ -3378,9 +3372,6 @@ packages:
   scheduler@0.26.0:
     resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==}
 
-  sdp@3.2.1:
-    resolution: {integrity: sha512-lwsAIzOPlH8/7IIjjz3K0zYBk7aBVVcvjMwt3M4fLxpjMYyy7i3I97SLHebgn4YBjirkzfp3RvRDWSKsh/+WFw==}
-
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
@@ -3624,8 +3615,8 @@ packages:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
 
-  type-fest@5.3.1:
-    resolution: {integrity: sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg==}
+  type-fest@5.7.0:
+    resolution: {integrity: sha512-1URUxUqfHFM1c+zfSPsa3gnkO7Aq21qyH75SIduNYz4SzY964rn1X2vCMQaHSHhktiw+0kPa2iyb6PUpXqB6Vg==}
     engines: {node: '>=20'}
 
   typed-array-buffer@1.0.3:
@@ -3781,10 +3772,6 @@ packages:
     resolution: {integrity: sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==}
     engines: {node: '>=20'}
 
-  webrtc-adapter@9.0.3:
-    resolution: {integrity: sha512-5fALBcroIl31OeXAdd1YUntxiZl1eHlZZWzNg3U4Fn+J9/cGL3eT80YlrsWGvj2ojuz1rZr2OXkgCzIxAZ7vRQ==}
-    engines: {node: '>=6.0.0', npm: '>=3.10.0'}
-
   whatwg-mimetype@4.0.0:
     resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
     engines: {node: '>=18'}
@@ -3861,8 +3848,8 @@ packages:
   zod@4.1.12:
     resolution: {integrity: sha512-JInaHOamG8pt5+Ey8kGmdcAcg3OL9reK8ltczgHTAwNhMys/6ThXHityHxVV2p3fkw/c+MAvBHFVYHFZDmjMCQ==}
 
-  zxing-wasm@2.2.4:
-    resolution: {integrity: sha512-1gq5zs4wuNTs5umWLypzNNeuJoluFvwmvjiiT3L9z/TMlVveeJRWy7h90xyUqCe+Qq0zL0w7o5zkdDMWDr9aZA==}
+  zxing-wasm@3.1.0:
+    resolution: {integrity: sha512-5+3V1wPRx4gvbeLH2jB7n2cKrYJ1q4i3QgjnBUtrDPeqxJSi6BdzKJg4y6aF6bgW8zfntnYJyrkqFMevDhL2NA==}
     peerDependencies:
       '@types/emscripten': '>=1.39.6'
 
@@ -5404,15 +5391,6 @@ snapshots:
       loupe: 3.2.1
       tinyrainbow: 2.0.0
 
-  '@yudiel/react-qr-scanner@2.5.0(@types/emscripten@1.41.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)':
-    dependencies:
-      barcode-detector: 3.0.8(@types/emscripten@1.41.5)
-      react: 19.1.0
-      react-dom: 19.1.0(react@19.1.0)
-      webrtc-adapter: 9.0.3
-    transitivePeerDependencies:
-      - '@types/emscripten'
-
   acorn-jsx@5.3.2(acorn@8.15.0):
     dependencies:
       acorn: 8.15.0
@@ -5543,9 +5521,9 @@ snapshots:
 
   balanced-match@4.0.4: {}
 
-  barcode-detector@3.0.8(@types/emscripten@1.41.5):
+  barcode-detector@3.2.0(@types/emscripten@1.41.5):
     dependencies:
-      zxing-wasm: 2.2.4(@types/emscripten@1.41.5)
+      zxing-wasm: 3.1.0(@types/emscripten@1.41.5)
     transitivePeerDependencies:
       - '@types/emscripten'
 
@@ -7051,8 +7029,6 @@ snapshots:
 
   scheduler@0.26.0: {}
 
-  sdp@3.2.1: {}
-
   semver@6.3.1: {}
 
   semver@7.7.3: {}
@@ -7340,7 +7316,7 @@ snapshots:
     dependencies:
       prelude-ls: 1.2.1
 
-  type-fest@5.3.1:
+  type-fest@5.7.0:
     dependencies:
       tagged-tag: 1.0.0
 
@@ -7546,10 +7522,6 @@ snapshots:
 
   webidl-conversions@8.0.1: {}
 
-  webrtc-adapter@9.0.3:
-    dependencies:
-      sdp: 3.2.1
-
   whatwg-mimetype@4.0.0: {}
 
   whatwg-url@15.1.0:
@@ -7633,7 +7605,7 @@ snapshots:
 
   zod@4.1.12: {}
 
-  zxing-wasm@2.2.4(@types/emscripten@1.41.5):
+  zxing-wasm@3.1.0(@types/emscripten@1.41.5):
     dependencies:
       '@types/emscripten': 1.41.5
-      type-fest: 5.3.1
+      type-fest: 5.7.0

From 4aaa23c1404874fb5472bed60ec796043a633d59 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 23:58:04 -0300
Subject: [PATCH 08/32] fix(warehouse): hydrate selected warehouse
 synchronously

---
 lib/contexts/warehouse-context.tsx | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/contexts/warehouse-context.tsx b/lib/contexts/warehouse-context.tsx
index 60bf4fa..053b824 100644
--- a/lib/contexts/warehouse-context.tsx
+++ b/lib/contexts/warehouse-context.tsx
@@ -3,7 +3,6 @@
 import {
   createContext,
   use,
-  useEffect,
   useState,
   useSyncExternalStore,
   ReactNode,
@@ -28,8 +27,14 @@ const getClientSnapshot = (): boolean => true;
 
 const getServerSnapshot = (): boolean => false;
 
+const readStoredWarehouseId = (): string | null => {
+  if (typeof window === "undefined") return null;
+  return localStorage.getItem(WAREHOUSE_STORAGE_KEY);
+};
+
 export const WarehouseProvider = ({ children }: { children: ReactNode }) => {
-  const [selectedWarehouseId, setSelectedWarehouseIdState] = useState<string | null>(null);
+  const [selectedWarehouseId, setSelectedWarehouseIdState] =
+    useState<string | null>(readStoredWarehouseId);
   const isClient = useSyncExternalStore(
     subscribeToClientHydration,
     getClientSnapshot,
@@ -37,13 +42,6 @@ export const WarehouseProvider = ({ children }: { children: ReactNode }) => {
   );
   const { push } = useRouter();
 
-  useEffect(() => {
-    const stored = localStorage.getItem(WAREHOUSE_STORAGE_KEY);
-    if (stored) {
-      setSelectedWarehouseIdState(stored);
-    }
-  }, []);
-
   const setSelectedWarehouseId = (id: string) => {
     setSelectedWarehouseIdState(id);
     if (typeof window !== "undefined") {

From 935b364416204462352a2265b280c1ae4bebceec Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Tue, 9 Jun 2026 23:58:29 -0300
Subject: [PATCH 09/32] feat(stock-movements): harden draft and barcode flows

---
 .../products/components/product-form.types.ts |   2 +-
 .../create-stock-movement.model.test.ts       | 209 +++++++++++--
 .../create/create-stock-movement.model.ts     | 212 +++++++------
 .../create-stock-movement.storage.test.ts     | 101 ++++++-
 .../create/create-stock-movement.storage.ts   | 102 ++++++-
 .../create/create-stock-movement.types.ts     |   1 +
 .../new-product-inline.model.test.ts          | 278 +++++++++++++++++-
 .../new-product/new-product-inline.model.ts   | 195 ++++++------
 .../stock-movement-batch-data-modal.view.tsx  |   6 +
 ...ock-movement-batch-form-validation.test.ts |  88 ++++++
 .../stock-movement-batch-form-validation.ts   |  35 +++
 .../stock-movement-draft-guards.test.ts       |  98 ++++++
 .../create/stock-movement-draft-guards.ts     |  60 ++++
 .../stock-movement-product-lookup.test.ts     |  75 +++++
 .../create/stock-movement-product-lookup.ts   |  37 +++
 lib/api.ts                                    |   6 +-
 16 files changed, 1272 insertions(+), 233 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-batch-form-validation.test.ts
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-batch-form-validation.ts
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-product-lookup.test.ts
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-product-lookup.ts

diff --git a/app/(pages)/products/components/product-form.types.ts b/app/(pages)/products/components/product-form.types.ts
index be9fe90..a4a875c 100644
--- a/app/(pages)/products/components/product-form.types.ts
+++ b/app/(pages)/products/components/product-form.types.ts
@@ -129,7 +129,7 @@ export interface ProductFormProps {
   // Existing product modal (new-product page)
   scannedExistingProduct: ExistingProductInfo | null;
   onExistingProductModalOpenChange?: (open: boolean) => void;
-  onCreateBatchForExistingProduct?: () => void;
+  onCreateBatchForExistingProduct?: () => void | Promise<void>;
 
   // Batch overlay (new-product page)
   batchForm?: ExistingProductBatchFormState;
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index c188899..3f54b10 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -3,8 +3,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { useCreateStockMovementModel } from "./create-stock-movement.model";
 import {
   buildMovementPayload,
-  filterStockMovementProductOptions,
+  buildStockMovementProductSearchUrl,
   formatStockMovementProductLabel,
+  mapStockMovementProductOptions,
   shouldShowStockMovementFooter,
 } from "./create-stock-movement.model";
 import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
@@ -134,14 +135,20 @@ const fakeStorage = vi.hoisted(() => {
     public readonly readStockMovementDraft = vi.fn<() => Promise<StockMovementDraft | null>>(async () => {
       return this.draftState;
     });
-    public readonly writeStockMovementDraft = vi.fn<(draft: WritableStockMovementDraft) => Promise<void>>(
-      async (draft) => {
+    public readonly writeStockMovementDraft = vi.fn(
+      async (draft: WritableStockMovementDraft, expectedRevision?: number) => {
+        const storedRevision = this.draftState?.revision ?? 0;
+        if (expectedRevision !== undefined && storedRevision !== expectedRevision) {
+          return { status: "conflict" as const, revision: storedRevision };
+        }
         this.draftState = {
           ...draft,
-          schemaVersion: 1,
+          schemaVersion: 2,
           updatedAt: "2026-01-20T10:00:00.000Z",
+          revision: storedRevision + 1,
           runtimeId: this.currentRuntimeId,
         };
+        return { status: "written" as const, revision: storedRevision + 1 };
       },
     );
     public readonly clearStockMovementDraft = vi.fn(async () => {
@@ -210,14 +217,18 @@ vi.mock("@/hooks/use-selected-warehouse", () => ({
 
 vi.mock("@/lib/api", () => ({
   api: fakeApi,
+  isApiNotFoundError: (error: unknown) =>
+    Boolean((error as { notFound?: boolean })?.notFound),
 }));
 
 vi.mock("./create-stock-movement.storage", () => ({
   readStockMovementDraft: () => fakeStorage.readStockMovementDraft(),
   isStockMovementDraftRecoveredFromPreviousRuntime: (draft: StockMovementDraft) =>
     fakeStorage.isStockMovementDraftRecoveredFromPreviousRuntime(draft),
-  writeStockMovementDraft: (draft: WritableStockMovementDraft) =>
-    fakeStorage.writeStockMovementDraft(draft),
+  writeStockMovementDraft: (
+    draft: WritableStockMovementDraft,
+    expectedRevision?: number,
+  ) => fakeStorage.writeStockMovementDraft(draft, expectedRevision),
   clearStockMovementDraft: () => fakeStorage.clearStockMovementDraft(),
   inlineProductImageToFile: (image: {
     name: string;
@@ -308,9 +319,11 @@ const barcodeIndex: Record<string, StockMovementProductOption> = {
 const createDraftState = (
   overrides?: Partial<StockMovementDraft>,
 ): StockMovementDraft => ({
-  schemaVersion: 1,
+  schemaVersion: 2,
   updatedAt: "2026-01-20T09:00:00.000Z",
+  revision: 1,
   type: "PURCHASE_IN",
+  warehouseId: "wh-1",
   notes: "Notas iniciais",
   items: [
     {
@@ -406,7 +419,12 @@ beforeEach(() => {
     if (url.startsWith("products/barcode/")) {
       const barcode = decodeURIComponent(url.replace("products/barcode/", ""));
       const product = barcodeIndex[barcode];
-      if (!product) throw new Error(`Produto com código ${barcode} não existe.`);
+      if (!product) {
+        throw Object.assign(
+          new Error(`Produto com código ${barcode} não existe.`),
+          { notFound: true },
+        );
+      }
       return createJsonResponse({
         success: true,
         data: product,
@@ -440,23 +458,28 @@ afterEach(() => {
 describe("helpers de produto", () => {
   const products: StockMovementProductOption[] = movementProducts;
 
-  it("exige pelo menos dois caracteres para filtrar", () => {
-    expect(filterStockMovementProductOptions(products, " c ")).toEqual([]);
+  it("não monta URL de busca com menos de dois caracteres", () => {
+    expect(buildStockMovementProductSearchUrl(" c ")).toBeNull();
+    expect(buildStockMovementProductSearchUrl("")).toBeNull();
   });
 
-  it("busca por nome, sku e código de barras", () => {
-    expect(filterStockMovementProductOptions(products, "fil")[0].id).toBe("p-2");
-    expect(filterStockMovementProductOptions(products, "ACU")[0].id).toBe("p-3");
-    expect(filterStockMovementProductOptions(products, "0001")[0].id).toBe("p-1");
+  it("monta URL de busca com query escapada", () => {
+    expect(buildStockMovementProductSearchUrl(" café cristal ")).toBe(
+      "products/search?q=caf%C3%A9%20cristal",
+    );
   });
 
-  it("limita os resultados da busca para cinco itens", () => {
-    const manyProducts = Array.from({ length: 6 }, (_, index) => ({
-      id: `extra-${index}`,
-      name: `Produto ${index}`,
-    }));
-
-    expect(filterStockMovementProductOptions(manyProducts, "produto")).toHaveLength(5);
+  it("mapeia resposta de produtos em lista ou paginada", () => {
+    expect(
+      mapStockMovementProductOptions({ success: true, data: products }),
+    ).toHaveLength(4);
+    expect(
+      mapStockMovementProductOptions({
+        success: true,
+        data: { content: products.slice(0, 2) },
+      }),
+    ).toHaveLength(2);
+    expect(mapStockMovementProductOptions(null)).toEqual([]);
   });
 
   it("mostra SKU quando disponível", () => {
@@ -669,6 +692,7 @@ describe("useCreateStockMovementModel", () => {
         expect.objectContaining({
           notes: "Nova observação",
         }),
+        expect.any(Number),
       );
     });
 
@@ -686,6 +710,7 @@ describe("useCreateStockMovementModel", () => {
     await waitFor(() => {
       expect(fakeStorage.writeStockMovementDraft).toHaveBeenCalledWith(
         expect.objectContaining({
+          warehouseId: "wh-1",
           items: [
             {
               productId: validExistingProductUuid,
@@ -694,12 +719,19 @@ describe("useCreateStockMovementModel", () => {
             },
           ],
         }),
+        expect.any(Number),
       );
     });
   });
 
-  it("aplica debounce de busca de produto", () => {
+  it("aplica debounce e busca produtos na API de pesquisa", () => {
     vi.useFakeTimers();
+    fakeSWR.setState("products/search?q=filtro", {
+      data: { success: true, data: [movementProducts[1]] },
+      error: null,
+      isLoading: false,
+      mutate: vi.fn(),
+    });
     const { result } = renderHook(() =>
       useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
     );
@@ -714,7 +746,12 @@ describe("useCreateStockMovementModel", () => {
     act(() => {
       vi.advanceTimersByTime(350);
     });
+    expect(fakeSWR.hook).toHaveBeenCalledWith(
+      "products/search?q=filtro",
+      expect.any(Function),
+    );
     expect(result.current.productOptions).toHaveLength(1);
+    expect(result.current.productOptions[0].id).toBe("p-2");
   });
 
   it("cancela debounce de busca ao desmontar", () => {
@@ -1123,8 +1160,6 @@ describe("useCreateStockMovementModel", () => {
   });
 
   it("abre modal de produto não encontrado quando produto não existe", async () => {
-    fakeApi.get.mockRejectedValue(new Error("não encontrado"));
-
     const { result } = renderHook(() => useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }));
 
     await act(async () => {
@@ -1138,7 +1173,6 @@ describe("useCreateStockMovementModel", () => {
   it("mostra aviso sem ação para tipo de saída", async () => {
     fakeSearchParams.setType("USAGE");
     const { result } = renderHook(() => useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }));
-    fakeApi.get.mockRejectedValue(new Error("não encontrado"));
 
     await act(async () => {
       await result.current.onBarcodeScan("7891009999999");
@@ -1151,6 +1185,131 @@ describe("useCreateStockMovementModel", () => {
     expect(lastCall?.[1]).toBeUndefined();
   });
 
+  it("não trata falha de rede do scanner como produto inexistente", async () => {
+    fakeApi.get.mockImplementation(() => {
+      throw new Error("timeout");
+    });
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891009999999");
+    });
+
+    expect(result.current.missingProductBarcode).toBeNull();
+    expect(fakeToast.error).toHaveBeenCalledWith(
+      "Não foi possível consultar o código 7891009999999 (timeout). Verifique a conexão e tente novamente.",
+    );
+  });
+
+  it("bloqueia produto existente quando há produto novo pendente com o mesmo barcode", async () => {
+    fakeSearchParams.setType("USAGE");
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    act(() => {
+      result.current.form.setValue("items", [
+        {
+          quantity: 1,
+          productName: "Produto Pendente",
+          newProductData: {
+            name: "Produto Pendente",
+            barcode: "7891000000004",
+            active: true,
+            isKit: false,
+            hasExpiration: false,
+          },
+        },
+      ]);
+    });
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891000000004");
+    });
+
+    expect(fakeToast.error).toHaveBeenCalledWith(
+      'O código 7891000000004 já pertence ao produto novo "Produto Pendente" nesta movimentação. Remova-o antes de adicionar o produto existente.',
+    );
+    expect(result.current.form.getValues("items")).toHaveLength(1);
+
+    act(() => {
+      result.current.onProductSelect(movementProducts[3]);
+    });
+
+    expect(result.current.selectedProductId).toBe("");
+    expect(result.current.addItemError).toBe(
+      'O código 7891000000004 já pertence ao produto novo "Produto Pendente" nesta movimentação. Remova-o antes de adicionar o produto existente.',
+    );
+  });
+
+  it("avisa ao abrir dados de lote de produto que já está na movimentação", () => {
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    act(() => {
+      result.current.form.setValue("items", [
+        {
+          productId: "p-1",
+          productName: "Café Torrado",
+          quantity: 2,
+        },
+      ]);
+    });
+    act(() => {
+      result.current.onProductSelect(movementProducts[0]);
+    });
+
+    expect(result.current.existingProductBatchForm.isOpen).toBe(true);
+    expect(result.current.existingProductBatchForm.repeatedProductWarning).toBe(
+      "Café Torrado já está na movimentação. Este lote será adicionado como um novo item.",
+    );
+  });
+
+  it("não restaura rascunho de outro warehouse", async () => {
+    fakeStorage.setDraftState(
+      createDraftState({ warehouseId: "wh-2", selectedProductId: "p-2" }),
+    );
+
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    await waitFor(() => {
+      expect(fakeStorage.readStockMovementDraft).toHaveBeenCalled();
+    });
+
+    expect(result.current.form.getValues("notes")).toBe("");
+    expect(result.current.selectedProductId).toBe("");
+  });
+
+  it("recusa lote com validade anterior à fabricação", () => {
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    act(() => {
+      result.current.onProductSelect(movementProducts[0]);
+    });
+    act(() => {
+      result.current.onExistingProductBatchQuantityChange("2");
+      result.current.onExistingProductBatchCostPriceChange(1290);
+      result.current.onExistingProductBatchSellingPriceChange(2490);
+      result.current.onExistingProductBatchManufacturedDateChange("2026-06-01");
+      result.current.onExistingProductBatchExpirationDateChange("2026-01-01");
+    });
+    act(() => {
+      result.current.onConfirmExistingProductBatchData();
+    });
+
+    expect(result.current.existingProductBatchForm.error).toBe(
+      "A data de validade não pode ser anterior à data de fabricação.",
+    );
+    expect(result.current.items).toHaveLength(0);
+  });
+
   it("abre editor de produto novo quando o item do índice é válido", async () => {
     const { result } = renderHook(() => useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }));
 
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index c85ff15..c9de2af 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -37,27 +37,22 @@ import {
   buildExistingProductCostPriceSuggestion,
   findMostRecentWarehouseProductBatch,
 } from "./stock-movement-batch-pricing.model";
-
-const getOptionalText = (value: string | undefined): string | undefined => {
-  const trimmedValue = value?.trim();
-  return trimmedValue || undefined;
-};
+import {
+  getOptionalText,
+  validateExistingProductBatchForm,
+} from "./stock-movement-batch-form-validation";
+import {
+  buildRepeatedProductBatchWarning,
+  getPendingInlineProductBarcodeConflictError,
+  hasExistingProductInItems,
+} from "./stock-movement-draft-guards";
+import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
 
 const resolveExistingProductBatchQuantity = (value: string): number => {
   const quantity = Number(value);
   return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
 };
 
-const isExistingProductBatchDateRangeInvalid = (
-  manufacturedDate: string,
-  expirationDate: string,
-): boolean => {
-  const optionalManufacturedDate = getOptionalText(manufacturedDate);
-  const optionalExpirationDate = getOptionalText(expirationDate);
-  if (!optionalManufacturedDate || !optionalExpirationDate) return false;
-  return new Date(optionalExpirationDate) < new Date(optionalManufacturedDate);
-};
-
 const buildExistingProductItemPayload = (
   item: CreateStockMovementSchema["items"][number],
 ): ExistingProductMovementPayload => {
@@ -201,11 +196,6 @@ interface ProductListResponse {
     | StockMovementProductOption[];
 }
 
-interface ProductByBarcodeResponse {
-  success: boolean;
-  data: StockMovementProductOption;
-}
-
 interface CreateStockMovementModelParams {
   typeParam?: string | null;
 }
@@ -244,25 +234,28 @@ export const formatStockMovementProductLabel = (
   product: StockMovementProductOption,
 ): string => (product.sku ? `${product.name} (${product.sku})` : product.name);
 
-export const filterStockMovementProductOptions = (
-  products: StockMovementProductOption[],
-  query: string,
+export const mapStockMovementProductOptions = (
+  response: ProductListResponse | null | undefined,
 ): StockMovementProductOption[] => {
-  const normalizedQuery = query.trim().toLowerCase();
-  if (normalizedQuery.length < 2) return [];
-
-  return products
-    .filter((product) => {
-      const searchText = [
-        product.name,
-        product.sku || "",
-        product.barcode || "",
-      ]
-        .join(" ")
-        .toLowerCase();
-      return searchText.includes(normalizedQuery);
-    })
-    .slice(0, PRODUCT_SEARCH_LIMIT);
+  const rawProducts = response?.data;
+  const productList = Array.isArray(rawProducts)
+    ? rawProducts
+    : rawProducts?.content || [];
+  return productList.map((product) => ({
+    id: product.id,
+    name: product.name,
+    sku: product.sku,
+    barcode: product.barcode,
+    imageUrl: product.imageUrl,
+  }));
+};
+
+export const buildStockMovementProductSearchUrl = (
+  query: string,
+): string | null => {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery.length < 2) return null;
+  return `products/search?q=${encodeURIComponent(normalizedQuery)}`;
 };
 
 export function useCreateStockMovementModel({
@@ -291,6 +284,8 @@ export function useCreateStockMovementModel({
   const productSearchBlurTimeoutRef =
     useRef<ReturnType<typeof setTimeout> | null>(null);
   const inlineProductBarcodeRef = useRef<string | undefined>(undefined);
+  const draftRevisionRef = useRef(0);
+  const persistQueueRef = useRef<Promise<void>>(Promise.resolve());
   const selectedMovementType = isManualMovementType(typeParam)
     ? typeParam
     : undefined;
@@ -335,7 +330,8 @@ export function useCreateStockMovementModel({
       const draft = await readStockMovementDraft();
       if (!isMounted) return;
 
-      if (draft?.type === selectedMovementType) {
+      draftRevisionRef.current = draft?.revision ?? 0;
+      if (draft?.type === selectedMovementType && draft.warehouseId === warehouseId) {
         form.reset({
           type: draft.type,
           notes: draft.notes,
@@ -356,7 +352,7 @@ export function useCreateStockMovementModel({
     return () => {
       isMounted = false;
     };
-  }, [form, selectedMovementType]);
+  }, [form, selectedMovementType, warehouseId]);
 
   const { data: productsData, isLoading: isLoadingProducts } =
     useSWR<ProductListResponse>("products", (url: string) =>
@@ -393,16 +389,15 @@ export function useCreateStockMovementModel({
       !existingProductCostPriceSuggestion,
   );
 
-  const rawProducts = productsData?.data;
-  const products = (
-    Array.isArray(rawProducts) ? rawProducts : rawProducts?.content || []
-  ).map((p) => ({
-    id: p.id,
-    name: p.name,
-    sku: p.sku,
-    barcode: p.barcode,
-    imageUrl: p.imageUrl,
-  }));
+  const products = mapStockMovementProductOptions(productsData);
+
+  const productSearchUrl = selectedProduct
+    ? null
+    : buildStockMovementProductSearchUrl(debouncedProductSearchQuery);
+  const { data: productSearchData, isLoading: isSearchingProducts } =
+    useSWR<ProductListResponse>(productSearchUrl, (url: string) =>
+      api.get(url).json<ProductListResponse>(),
+    );
 
   useEffect(() => {
     if (!selectedProductId || productSearchQuery || products.length === 0) return;
@@ -419,6 +414,7 @@ export function useCreateStockMovementModel({
       if (!selectedMovementType) return null;
       return {
         type: selectedMovementType,
+        warehouseId,
         notes: form.getValues("notes") || "",
         items: form.getValues("items"),
         selectedProductId,
@@ -426,14 +422,23 @@ export function useCreateStockMovementModel({
         inlineProductBarcode,
       };
     },
-    [form, itemQuantity, selectedMovementType, selectedProductId],
+    [form, itemQuantity, selectedMovementType, selectedProductId, warehouseId],
   );
 
   const persistCurrentDraft = useCallback(
-    async (inlineProductBarcode = inlineProductBarcodeRef.current): Promise<void> => {
+    (inlineProductBarcode = inlineProductBarcodeRef.current): Promise<void> => {
       const draft = buildCurrentDraft(inlineProductBarcode);
-      if (!draft) return;
-      await writeStockMovementDraft(draft);
+      if (!draft) return Promise.resolve();
+
+      const queuedWrite = persistQueueRef.current.then(async () => {
+        const writeResult = await writeStockMovementDraft(
+          draft,
+          draftRevisionRef.current,
+        );
+        draftRevisionRef.current = writeResult.revision;
+      });
+      persistQueueRef.current = queuedWrite.catch(() => undefined);
+      return queuedWrite;
     },
     [buildCurrentDraft],
   );
@@ -516,10 +521,12 @@ export function useCreateStockMovementModel({
     return () => window.removeEventListener("scroll", handleScroll);
   }, []);
 
-  const productOptions = filterStockMovementProductOptions(
-    products,
-    debouncedProductSearchQuery,
-  );
+  const productOptions = productSearchUrl
+    ? mapStockMovementProductOptions(productSearchData).slice(
+        0,
+        PRODUCT_SEARCH_LIMIT,
+      )
+    : [];
 
   const clearProductSearchBlurTimeout = () => {
     if (!productSearchBlurTimeoutRef.current) return;
@@ -527,7 +534,23 @@ export function useCreateStockMovementModel({
     productSearchBlurTimeoutRef.current = null;
   };
 
+  const findScannedProductBarcodeConflict = (
+    barcode: string | null | undefined,
+  ): string | null => {
+    return getPendingInlineProductBarcodeConflictError(
+      form.getValues("items"),
+      barcode,
+    );
+  };
+
   const handleProductSelect = (product: StockMovementProductOption) => {
+    const barcodeConflictError = findScannedProductBarcodeConflict(product.barcode);
+    if (barcodeConflictError) {
+      setIsProductOptionsOpen(false);
+      setAddItemError(barcodeConflictError);
+      return;
+    }
+
     setSelectedProduct(product);
     setSelectedProductId(product.id);
     setProductSearchQuery(formatStockMovementProductLabel(product));
@@ -597,6 +620,16 @@ export function useCreateStockMovementModel({
     setExistingProductBatchForm(EMPTY_EXISTING_BATCH_FORM);
   };
 
+  const buildBatchRepeatedProductWarning = (
+    params: Pick<ExistingProductBatchFormState, "productId" | "productName" | "editingIndex">,
+  ): string | null => {
+    if (params.editingIndex !== null) return null;
+    if (!hasExistingProductInItems(form.getValues("items"), params.productId)) {
+      return null;
+    }
+    return buildRepeatedProductBatchWarning(params.productName);
+  };
+
   const openExistingProductBatchForm = (
     params: Omit<ExistingProductBatchFormState, "isOpen" | "error">,
   ): void => {
@@ -604,6 +637,7 @@ export function useCreateStockMovementModel({
       ...params,
       isOpen: true,
       error: null,
+      repeatedProductWarning: buildBatchRepeatedProductWarning(params),
     });
   };
 
@@ -617,7 +651,7 @@ export function useCreateStockMovementModel({
   };
 
   const hasExistingProductAlreadyAdded = (productId: string): boolean => {
-    return form.getValues("items").some((item) => item.productId === productId);
+    return hasExistingProductInItems(form.getValues("items"), productId);
   };
 
   const getSelectedProductQuantity = (): number | null => {
@@ -636,6 +670,12 @@ export function useCreateStockMovementModel({
       selectedProduct || products.find((p) => p.id === selectedProductId);
     const productName = product?.name || "Produto";
 
+    const barcodeConflictError = findScannedProductBarcodeConflict(product?.barcode);
+    if (barcodeConflictError) {
+      setAddItemError(barcodeConflictError);
+      return;
+    }
+
     if (isSelectedInMovement()) {
       openExistingProductBatchForm({
         productId: selectedProductId,
@@ -733,31 +773,11 @@ export function useCreateStockMovementModel({
   });
 
   const handleConfirmExistingProductBatchData = (): void => {
-    const quantity = Number(existingProductBatchForm.quantity);
-    if (!quantity || quantity <= 0) {
-      updateExistingProductBatchForm({
-        error: "Informe uma quantidade válida para o lote.",
-      });
-      return;
-    }
-
-    if (existingProductBatchForm.costPrice === undefined || existingProductBatchForm.costPrice < 0) {
-      updateExistingProductBatchForm({ error: "Informe um preço de custo válido." });
-      return;
-    }
-
-    if (existingProductBatchForm.sellingPrice === undefined || existingProductBatchForm.sellingPrice < 0) {
-      updateExistingProductBatchForm({ error: "Informe um preço de venda válido." });
-      return;
-    }
-
-    if (
-      isExistingProductBatchDateRangeInvalid(
-        existingProductBatchForm.manufacturedDate,
-        existingProductBatchForm.expirationDate,
-      )
-    ) {
-      updateExistingProductBatchForm({ error: "A data de validade não pode ser anterior à data de fabricação." });
+    const validationError = validateExistingProductBatchForm(
+      existingProductBatchForm,
+    );
+    if (validationError) {
+      updateExistingProductBatchForm({ error: validationError });
       return;
     }
 
@@ -843,6 +863,12 @@ export function useCreateStockMovementModel({
   };
 
   const appendScannedProduct = (product: StockMovementProductOption) => {
+    const barcodeConflictError = findScannedProductBarcodeConflict(product.barcode);
+    if (barcodeConflictError) {
+      toast.error(barcodeConflictError);
+      return;
+    }
+
     if (isSelectedInMovement()) {
       setIsScannerOpen(false);
       openExistingProductBatchForm({
@@ -878,14 +904,16 @@ export function useCreateStockMovementModel({
       lastScannedBarcodeRef.current = null;
     }, 1500);
 
-    try {
-      const response = await api
-        .get(`products/barcode/${encodeURIComponent(barcode)}`)
-        .json<ProductByBarcodeResponse>();
-      appendScannedProduct(response.data);
-    } catch {
+    const lookup = await lookupStockMovementProductByBarcode(barcode);
+    if (lookup.status === "found") {
+      appendScannedProduct(lookup.product);
+      return;
+    }
+    if (lookup.status === "not-found") {
       showMissingProductToast(barcode);
+      return;
     }
+    toast.error(lookup.message);
   };
 
   const showMissingProductToast = (barcode: string) => {
@@ -937,6 +965,7 @@ export function useCreateStockMovementModel({
 
       setSubmittingStep("Finalizando…");
       await clearStockMovementDraft();
+      draftRevisionRef.current = 0;
       toast.success("Movimentação criada com sucesso!");
       router.push("/stock-movements");
     } catch (err: unknown) {
@@ -960,8 +989,7 @@ export function useCreateStockMovementModel({
     productSearchQuery,
     productOptions,
     isProductOptionsOpen,
-    isProductSearchLoading:
-      isLoadingProducts && debouncedProductSearchQuery.trim().length >= 2,
+    isProductSearchLoading: Boolean(productSearchUrl) && isSearchingProducts,
     itemQuantity,
     addItemError,
     isScannerOpen,
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
index de44b7f..ee04521 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   clearStockMovementDraft,
   isStockMovementDraftRecoveredFromPreviousRuntime,
+  mutateStockMovementDraft,
   readStockMovementDraft,
   STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
   writeStockMovementDraft,
@@ -39,35 +40,39 @@ const createMutableOpenRequest = (): MutableOpenRequest => ({
 class FakeObjectStore {
   public constructor(
     private readonly values: Map<string, unknown>,
-    private readonly completeTransaction: () => void,
+    private readonly registerRequest: () => void,
+    private readonly settleRequest: () => void,
   ) {}
 
   public get(key: IDBValidKey): IDBRequest<unknown> {
     const request = createMutableRequest<unknown>(undefined);
+    this.registerRequest();
     queueMicrotask(() => {
       request.result = this.values.get(String(key));
       request.onsuccess?.call(request as IDBRequest<unknown>, new Event("success"));
-      this.completeTransaction();
+      this.settleRequest();
     });
     return request as IDBRequest<unknown>;
   }
 
   public put(value: unknown, key?: IDBValidKey): IDBRequest<IDBValidKey> {
     const request = createMutableRequest<IDBValidKey>(key ?? DRAFT_KEY);
+    this.registerRequest();
     queueMicrotask(() => {
       this.values.set(String(key ?? DRAFT_KEY), value);
       request.onsuccess?.call(request as IDBRequest<IDBValidKey>, new Event("success"));
-      this.completeTransaction();
+      this.settleRequest();
     });
     return request as IDBRequest<IDBValidKey>;
   }
 
   public delete(key: IDBValidKey): IDBRequest<undefined> {
     const request = createMutableRequest<undefined>(undefined);
+    this.registerRequest();
     queueMicrotask(() => {
       this.values.delete(String(key));
       request.onsuccess?.call(request as IDBRequest<undefined>, new Event("success"));
-      this.completeTransaction();
+      this.settleRequest();
     });
     return request as IDBRequest<undefined>;
   }
@@ -79,13 +84,24 @@ class FakeTransaction {
     null;
   public onabort: ((this: IDBTransaction, event: Event) => unknown) | null =
     null;
+  private pendingRequests = 0;
+  private hasCompleted = false;
 
   public constructor(private readonly values: Map<string, unknown>) {}
 
   public objectStore(): IDBObjectStore {
-    return new FakeObjectStore(this.values, () => {
-      this.oncomplete?.call(this as unknown as IDBTransaction, new Event("complete"));
-    }) as unknown as IDBObjectStore;
+    return new FakeObjectStore(
+      this.values,
+      () => {
+        this.pendingRequests += 1;
+      },
+      () => {
+        this.pendingRequests -= 1;
+        if (this.pendingRequests > 0 || this.hasCompleted) return;
+        this.hasCompleted = true;
+        this.oncomplete?.call(this as unknown as IDBTransaction, new Event("complete"));
+      },
+    ) as unknown as IDBObjectStore;
   }
 }
 
@@ -99,7 +115,7 @@ class FakeDatabase {
   public createObjectStore(storeName: string): IDBObjectStore {
     const values = new Map<string, unknown>();
     this.stores.set(storeName, values);
-    return new FakeObjectStore(values, () => {}) as unknown as IDBObjectStore;
+    return new FakeObjectStore(values, () => {}, () => {}) as unknown as IDBObjectStore;
   }
 
   public transaction(storeName: string): IDBTransaction {
@@ -156,6 +172,7 @@ class FakeIndexedDb {
 
 const createDraft = (): WritableStockMovementDraft => ({
   type: "PURCHASE_IN",
+  warehouseId: "wh-1",
   notes: "Observação",
   selectedProductId: "product-1",
   itemQuantity: "3",
@@ -200,9 +217,11 @@ describe("create-stock-movement.storage", () => {
     expect(draft).toMatchObject({
       schemaVersion: STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
       type: "PURCHASE_IN",
+      warehouseId: "wh-1",
       notes: "Observação",
       selectedProductId: "product-1",
       itemQuantity: "3",
+      revision: 1,
     });
     expect(typeof draft?.updatedAt).toBe("string");
     expect(typeof draft?.runtimeId).toBe("string");
@@ -211,6 +230,48 @@ describe("create-stock-movement.storage", () => {
     expect(await readStockMovementDraft()).toBeNull();
   });
 
+  it("incrementa a revisão a cada gravação", async () => {
+    const firstWrite = await writeStockMovementDraft(createDraft());
+    const secondWrite = await writeStockMovementDraft(createDraft());
+
+    expect(firstWrite).toEqual({ status: "written", revision: 1 });
+    expect(secondWrite).toEqual({ status: "written", revision: 2 });
+    expect((await readStockMovementDraft())?.revision).toBe(2);
+  });
+
+  it("rejeita gravação com revisão esperada desatualizada", async () => {
+    await writeStockMovementDraft(createDraft());
+    await writeStockMovementDraft({ ...createDraft(), notes: "Mais nova" }, 1);
+
+    const staleWrite = await writeStockMovementDraft(
+      { ...createDraft(), notes: "Antiga" },
+      1,
+    );
+
+    expect(staleWrite).toEqual({ status: "conflict", revision: 2 });
+    expect((await readStockMovementDraft())?.notes).toBe("Mais nova");
+  });
+
+  it("aplica mutação atômica sobre o draft atual", async () => {
+    await writeStockMovementDraft(createDraft());
+
+    const mutatedDraft = await mutateStockMovementDraft((draft) => ({
+      ...draft,
+      items: [...draft.items, { quantity: 1, productName: "Novo item" }],
+    }));
+
+    expect(mutatedDraft?.items).toHaveLength(2);
+    expect(mutatedDraft?.revision).toBe(2);
+    expect((await readStockMovementDraft())?.items).toHaveLength(2);
+  });
+
+  it("não aplica mutação quando não há draft salvo", async () => {
+    const mutatedDraft = await mutateStockMovementDraft((draft) => draft);
+
+    expect(mutatedDraft).toBeNull();
+    expect(await readStockMovementDraft()).toBeNull();
+  });
+
   it("ignora JSON inválido e remove o valor salvo", async () => {
     fakeIndexedDb.putStoredDraft("{invalid-json");
 
@@ -220,7 +281,7 @@ describe("create-stock-movement.storage", () => {
 
   it("ignora draft com schema incompatível", async () => {
     fakeIndexedDb.putStoredDraft({
-      schemaVersion: 999,
+      schemaVersion: 1,
       type: "PURCHASE_IN",
       notes: "inválido",
       items: [],
@@ -233,6 +294,21 @@ describe("create-stock-movement.storage", () => {
     expect(fakeIndexedDb.getStoredDraft()).toBeUndefined();
   });
 
+  it("ignora draft sem warehouseId ou sem revisão", async () => {
+    fakeIndexedDb.putStoredDraft({
+      schemaVersion: STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
+      type: "PURCHASE_IN",
+      notes: "sem campos novos",
+      items: [],
+      selectedProductId: "",
+      itemQuantity: "",
+      updatedAt: "2026-01-20T10:00:00.000Z",
+    });
+
+    expect(await readStockMovementDraft()).toBeNull();
+    expect(fakeIndexedDb.getStoredDraft()).toBeUndefined();
+  });
+
   it("preserva imagem inline em dataUrl", async () => {
     await writeStockMovementDraft(createDraft());
 
@@ -249,10 +325,11 @@ describe("create-stock-movement.storage", () => {
   it("mantém fallback em memória quando IndexedDB falha", async () => {
     fakeIndexedDb.shouldFailOpen = true;
 
-    await writeStockMovementDraft(createDraft());
+    const writeResult = await writeStockMovementDraft(createDraft());
 
     const draft = await readStockMovementDraft();
 
+    expect(writeResult).toEqual({ status: "written", revision: 1 });
     expect(draft?.notes).toBe("Observação");
     expect(console.error).toHaveBeenCalled();
   });
@@ -278,10 +355,12 @@ describe("create-stock-movement.storage", () => {
     ).toBe(true);
   });
 
-  it("mantém compatibilidade com rascunho legado sem runtimeId", async () => {
+  it("mantém compatibilidade com rascunho sem runtimeId", async () => {
     fakeIndexedDb.putStoredDraft({
       schemaVersion: STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
       type: "PURCHASE_IN",
+      warehouseId: "wh-1",
+      revision: 1,
       notes: "legado",
       items: [],
       selectedProductId: "",
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.storage.ts b/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
index 1df1e78..2e6d4cd 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
@@ -9,7 +9,7 @@ const DRAFT_DATABASE_NAME = "stockshift";
 const DRAFT_DATABASE_VERSION = 1;
 const DRAFT_STORE_NAME = "stockMovementDrafts";
 const DRAFT_STORAGE_KEY = "current";
-export const STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION = 1;
+export const STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION = 2;
 
 const createStockMovementDraftRuntimeId = (): string => {
   if (typeof globalThis.crypto?.randomUUID === "function") {
@@ -25,7 +25,9 @@ const STOCK_MOVEMENT_DRAFT_RUNTIME_ID = createStockMovementDraftRuntimeId();
 export interface StockMovementDraft {
   schemaVersion: typeof STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION;
   updatedAt: string;
+  revision: number;
   type: ManualMovementType;
+  warehouseId: string | null;
   notes: string;
   items: StockMovementDraftItem[];
   selectedProductId: string;
@@ -36,9 +38,14 @@ export interface StockMovementDraft {
 
 export type WritableStockMovementDraft = Omit<
   StockMovementDraft,
-  "schemaVersion" | "updatedAt"
+  "schemaVersion" | "updatedAt" | "revision"
 > &
-  Partial<Pick<StockMovementDraft, "schemaVersion" | "updatedAt">>;
+  Partial<Pick<StockMovementDraft, "schemaVersion" | "updatedAt" | "revision">>;
+
+export interface StockMovementDraftWriteResult {
+  status: "written" | "conflict";
+  revision: number;
+}
 
 let fallbackDraft: StockMovementDraft | null = null;
 
@@ -95,18 +102,27 @@ const readDraftFromIndexedDb = async (): Promise<unknown> => {
   });
 };
 
-const writeDraftToIndexedDb = async (
-  draft: StockMovementDraft,
-): Promise<void> => {
+const applyDraftTransaction = async (
+  buildNextDraft: (storedDraft: StockMovementDraft | null) => StockMovementDraft | null,
+): Promise<StockMovementDraft | null> => {
   const database = await openDraftDatabase();
   return new Promise((resolve, reject) => {
     const transaction = database.transaction(DRAFT_STORE_NAME, "readwrite");
     const store = transaction.objectStore(DRAFT_STORE_NAME);
-    const request = store.put(draft, DRAFT_STORAGE_KEY);
-    request.onerror = () => reject(createRequestError("gravar", request.error));
+    const readRequest = store.get(DRAFT_STORAGE_KEY);
+    let nextDraft: StockMovementDraft | null = null;
+    readRequest.onerror = () =>
+      reject(createRequestError("ler", readRequest.error));
+    readRequest.onsuccess = () => {
+      nextDraft = buildNextDraft(normalizeStoredDraft(readRequest.result));
+      if (!nextDraft) return;
+      const writeRequest = store.put(nextDraft, DRAFT_STORAGE_KEY);
+      writeRequest.onerror = () =>
+        reject(createRequestError("gravar", writeRequest.error));
+    };
     transaction.oncomplete = () => {
       database.close();
-      resolve();
+      resolve(nextDraft);
     };
     transaction.onabort = () => {
       database.close();
@@ -221,15 +237,23 @@ const normalizeStoredDraft = (
   if (typeof parsedDraft.itemQuantity !== "string") return null;
   if (!isOptionalString(parsedDraft.inlineProductBarcode)) return null;
   if (!isOptionalString(parsedDraft.runtimeId)) return null;
+  if (typeof parsedDraft.revision !== "number" || !Number.isFinite(parsedDraft.revision)) {
+    return null;
+  }
+  if (parsedDraft.warehouseId !== null && typeof parsedDraft.warehouseId !== "string") {
+    return null;
+  }
   return parsedDraft as unknown as StockMovementDraft;
 };
 
 const buildPersistedDraft = (
   draft: WritableStockMovementDraft,
+  revision: number,
 ): StockMovementDraft => ({
   ...draft,
   schemaVersion: STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
   updatedAt: new Date().toISOString(),
+  revision,
   runtimeId: STOCK_MOVEMENT_DRAFT_RUNTIME_ID,
 });
 
@@ -256,15 +280,67 @@ export const readStockMovementDraft =
     }
   };
 
+const writeDraftToMemoryFallback = (
+  draft: WritableStockMovementDraft,
+  expectedRevision?: number,
+): StockMovementDraftWriteResult => {
+  const storedRevision = fallbackDraft?.revision ?? 0;
+  if (expectedRevision !== undefined && storedRevision !== expectedRevision) {
+    return { status: "conflict", revision: storedRevision };
+  }
+  fallbackDraft = buildPersistedDraft(draft, storedRevision + 1);
+  return { status: "written", revision: fallbackDraft.revision };
+};
+
 export const writeStockMovementDraft = async (
   draft: WritableStockMovementDraft,
-): Promise<void> => {
-  const persistedDraft = buildPersistedDraft(draft);
-  fallbackDraft = persistedDraft;
+  expectedRevision?: number,
+): Promise<StockMovementDraftWriteResult> => {
   try {
-    await writeDraftToIndexedDb(persistedDraft);
+    let writeResult: StockMovementDraftWriteResult = {
+      status: "conflict",
+      revision: expectedRevision ?? 0,
+    };
+    await applyDraftTransaction((storedDraft) => {
+      const storedRevision = storedDraft?.revision ?? 0;
+      if (expectedRevision !== undefined && storedRevision !== expectedRevision) {
+        writeResult = { status: "conflict", revision: storedRevision };
+        return null;
+      }
+      const persistedDraft = buildPersistedDraft(draft, storedRevision + 1);
+      fallbackDraft = persistedDraft;
+      writeResult = { status: "written", revision: persistedDraft.revision };
+      return persistedDraft;
+    });
+    return writeResult;
   } catch (error) {
     logDraftStorageError("gravar", error);
+    return writeDraftToMemoryFallback(draft, expectedRevision);
+  }
+};
+
+export const mutateStockMovementDraft = async (
+  buildNextDraft: (draft: StockMovementDraft) => WritableStockMovementDraft,
+): Promise<StockMovementDraft | null> => {
+  try {
+    return await applyDraftTransaction((storedDraft) => {
+      const baseDraft = storedDraft ?? fallbackDraft;
+      if (!baseDraft) return null;
+      const persistedDraft = buildPersistedDraft(
+        buildNextDraft(baseDraft),
+        baseDraft.revision + 1,
+      );
+      fallbackDraft = persistedDraft;
+      return persistedDraft;
+    });
+  } catch (error) {
+    logDraftStorageError("gravar", error);
+    if (!fallbackDraft) return null;
+    fallbackDraft = buildPersistedDraft(
+      buildNextDraft(fallbackDraft),
+      fallbackDraft.revision + 1,
+    );
+    return fallbackDraft;
   }
 };
 
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.types.ts b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
index cf070c4..f32ed17 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.types.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
@@ -46,6 +46,7 @@ export interface ExistingProductBatchFormState {
   sellingPrice?: number;
   editingIndex: number | null;
   error: string | null;
+  repeatedProductWarning?: string | null;
 }
 
 export interface StockMovementProductBatchPriceSource {
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
index 654d0a8..e045acd 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
@@ -34,9 +34,11 @@ const brandsResponse = {
 };
 
 const createDraft = (overrides?: Partial<StockMovementDraft>): StockMovementDraft => ({
-  schemaVersion: 1,
+  schemaVersion: 2,
   updatedAt: "2026-01-20T09:00:00.000Z",
+  revision: 1,
   type: "PURCHASE_IN",
+  warehouseId: "wh-1",
   notes: "",
   items: [],
   selectedProductId: "",
@@ -45,6 +47,9 @@ const createDraft = (overrides?: Partial<StockMovementDraft>): StockMovementDraf
   ...overrides,
 });
 
+const notFoundApiError = (): Error =>
+  Object.assign(new Error("não encontrado"), { notFound: true });
+
 const buildFormData = (
   overrides: Partial<ProductCreateFormData> = {},
 ): ProductCreateFormData => ({
@@ -80,6 +85,8 @@ vi.mock("@/lib/api", () => ({
   api: {
     get: (...args: unknown[]) => mockGet(...args),
   },
+  isApiNotFoundError: (error: unknown) =>
+    Boolean((error as { notFound?: boolean })?.notFound),
 }));
 
 vi.mock("next/navigation", () => ({
@@ -121,9 +128,18 @@ vi.mock("../create-stock-movement.storage", () => ({
     dataUrl: string;
   }) => new File(["x"], image.name, { type: image.type }),
   readStockMovementDraft: async () => currentDraft,
-  writeStockMovementDraft: async (draft: StockMovementDraft) => {
-    currentDraft = draft;
-    mockWriteDraft(draft);
+  mutateStockMovementDraft: async (
+    buildNextDraft: (draft: StockMovementDraft) => StockMovementDraft,
+  ) => {
+    if (!currentDraft) return null;
+    const nextRevision = currentDraft.revision + 1;
+    currentDraft = {
+      ...currentDraft,
+      ...buildNextDraft(currentDraft),
+      revision: nextRevision,
+    };
+    mockWriteDraft(currentDraft);
+    return currentDraft;
   },
 }));
 
@@ -508,11 +524,15 @@ describe("useNewProductInlineModel", () => {
   it("alterna estado do scanner e preenche barcode quando produto não existe na API", async () => {
     mockGet.mockReset();
     mockGet.mockImplementation(() => ({
-      json: vi.fn(async () => { throw new Error("não encontrado"); }),
+      json: vi.fn(async () => { throw notFoundApiError(); }),
     }));
 
     const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
 
+    await waitFor(() => {
+      expect(result.current.form.getValues("barcode")).toBe("7891000000001");
+    });
+
     expect(result.current.isScannerOpen).toBe(false);
     act(() => {
       result.current.openScanner();
@@ -525,6 +545,8 @@ describe("useNewProductInlineModel", () => {
 
     expect(mockGet).toHaveBeenCalledWith("products/barcode/123456789");
     expect(result.current.scannedExistingProduct).toBeNull();
+    expect(result.current.form.getValues("barcode")).toBe("123456789");
+    expect(toastError).not.toHaveBeenCalled();
 
     act(() => {
       result.current.closeScanner();
@@ -532,6 +554,27 @@ describe("useNewProductInlineModel", () => {
     expect(result.current.isScannerOpen).toBe(false);
   });
 
+  it("mostra erro e não preenche barcode quando a consulta do scanner falha", async () => {
+    mockGet.mockReset();
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => { throw new Error("timeout"); }),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("123456789");
+    });
+
+    expect(toastError).toHaveBeenCalledWith(
+      "Não foi possível consultar o código 123456789 (timeout). Verifique a conexão e tente novamente.",
+    );
+    expect(result.current.form.getValues("barcode")).not.toBe("123456789");
+    expect(result.current.scannedExistingProduct).toBeNull();
+  });
+
   it("abre modal de produto existente quando barcode escaneado encontra produto", async () => {
     mockGet.mockImplementation(() => ({
       json: vi.fn(async () => ({
@@ -568,14 +611,15 @@ describe("useNewProductInlineModel", () => {
       await result.current.handleBarcodeScan("987654321");
     });
 
-    act(() => {
-      result.current.onCreateBatchForExistingProduct?.();
+    await act(async () => {
+      await result.current.onCreateBatchForExistingProduct?.();
     });
 
     expect(result.current.scannedExistingProduct).toBeNull();
     expect(result.current.batchForm?.isOpen).toBe(true);
     expect(result.current.batchForm?.productId).toBe("p-123");
     expect(result.current.batchForm?.productName).toBe("Produto Existente");
+    expect(result.current.batchForm?.repeatedProductWarning).toBeNull();
 
     act(() => {
       result.current.onBatchQuantityChange?.("5");
@@ -593,6 +637,226 @@ describe("useNewProductInlineModel", () => {
     expect(mockWriteDraft).toHaveBeenCalled();
   });
 
+  it("redireciona quando o draft é de outro tipo de movimentação", async () => {
+    currentDraft = createDraft({ type: "ADJUSTMENT_IN" });
+    movementType = "PURCHASE_IN";
+
+    renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await waitFor(() => {
+      expect(mockReplace).toHaveBeenCalledWith("/stock-movements");
+    });
+  });
+
+  it("redireciona quando o draft pertence a outro warehouse", async () => {
+    currentDraft = createDraft({ warehouseId: "wh-2" });
+
+    renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await waitFor(() => {
+      expect(mockReplace).toHaveBeenCalledWith("/stock-movements");
+    });
+  });
+
+  it("abre modal de produto existente quando barcode digitado já está cadastrado", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-9", name: "Produto Cadastrado", barcode: "789000111" },
+      })),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit(
+        buildFormData({ name: "Produto Manual", barcode: "789000111" }),
+      );
+    });
+
+    expect(result.current.scannedExistingProduct).toEqual({
+      id: "p-9",
+      name: "Produto Cadastrado",
+      barcode: "789000111",
+    });
+    expect(mockWriteDraft).not.toHaveBeenCalled();
+    expect(result.current.isSubmitting).toBe(false);
+  });
+
+  it("salva produto quando barcode digitado não existe na API", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => { throw notFoundApiError(); }),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit(
+        buildFormData({ name: "Produto Manual", barcode: "789000111" }),
+      );
+    });
+
+    expect(mockWriteDraft).toHaveBeenCalledTimes(1);
+    expect(result.current.scannedExistingProduct).toBeNull();
+  });
+
+  it("bloqueia envio quando a consulta do barcode digitado falha", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => { throw new Error("erro 500"); }),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit(
+        buildFormData({ name: "Produto Manual", barcode: "789000111" }),
+      );
+    });
+
+    expect(toastError).toHaveBeenCalledWith(
+      "Não foi possível consultar o código 789000111 (erro 500). Verifique a conexão e tente novamente.",
+    );
+    expect(mockWriteDraft).not.toHaveBeenCalled();
+    expect(result.current.isSubmitting).toBe(false);
+  });
+
+  it("recusa produto novo com barcode já usado por outro produto novo do draft", async () => {
+    currentDraft = createDraft({
+      items: [
+        {
+          quantity: 1,
+          productName: "Produto A",
+          newProductData: { name: "Produto A", barcode: "789000111" },
+        },
+      ],
+    });
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit(
+        buildFormData({ name: "Produto B", barcode: "789000111" }),
+      );
+    });
+
+    expect(toastError).toHaveBeenCalledWith(
+      'O código 789000111 já está em uso pelo produto "Produto A" nesta movimentação.',
+    );
+    expect(mockWriteDraft).not.toHaveBeenCalled();
+  });
+
+  it("bloqueia lote de produto existente quando há produto novo pendente com o mesmo barcode", async () => {
+    currentDraft = createDraft({
+      items: [
+        {
+          quantity: 1,
+          productName: "Produto Pendente",
+          newProductData: { name: "Produto Pendente", barcode: "987654321" },
+        },
+      ],
+    });
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-123", name: "Produto Existente", barcode: "987654321" },
+      })),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("987654321");
+    });
+    await act(async () => {
+      await result.current.onCreateBatchForExistingProduct?.();
+    });
+
+    expect(toastError).toHaveBeenCalledWith(
+      'O código 987654321 já pertence ao produto novo "Produto Pendente" nesta movimentação. Remova-o antes de adicionar o produto existente.',
+    );
+    expect(result.current.batchForm?.isOpen).toBe(false);
+    expect(result.current.scannedExistingProduct).toBeNull();
+  });
+
+  it("avisa quando o produto existente já está na movimentação ao abrir o lote", async () => {
+    currentDraft = createDraft({
+      items: [{ productId: "p-123", quantity: 2, productName: "Produto Existente" }],
+    });
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-123", name: "Produto Existente", barcode: "987654321" },
+      })),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("987654321");
+    });
+    await act(async () => {
+      await result.current.onCreateBatchForExistingProduct?.();
+    });
+
+    expect(result.current.batchForm?.isOpen).toBe(true);
+    expect(result.current.batchForm?.repeatedProductWarning).toBe(
+      "Produto Existente já está na movimentação. Este lote será adicionado como um novo item.",
+    );
+  });
+
+  it("recusa lote de produto existente com validade anterior à fabricação", async () => {
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-123", name: "Produto Existente", barcode: "987654321" },
+      })),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("987654321");
+    });
+    await act(async () => {
+      await result.current.onCreateBatchForExistingProduct?.();
+    });
+
+    act(() => {
+      result.current.onBatchQuantityChange?.("5");
+      result.current.onBatchCostPriceChange?.(1000);
+      result.current.onBatchSellingPriceChange?.(1500);
+      result.current.onBatchManufacturedDateChange?.("2026-06-01");
+      result.current.onBatchExpirationDateChange?.("2026-01-01");
+    });
+
+    await act(async () => {
+      await result.current.onConfirmBatch?.();
+    });
+
+    expect(result.current.batchForm?.error).toBe(
+      "A data de validade não pode ser anterior à data de fabricação.",
+    );
+    expect(mockWriteDraft).not.toHaveBeenCalled();
+  });
+
   it("controla quantidade com incremento e decremento sem ficar negativa", () => {
     const { result } = renderHook(() => useNewProductInlineModel({ movementType, editItem: editItemQuery }));
 
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
index 0bca05e..e5e3387 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
@@ -25,14 +25,13 @@ import type {
   StockMovementDraftItem,
   ExistingProductBatchFormState,
   StockMovementProductBatchesResponse,
-  StockMovementProductOption,
 } from "../create-stock-movement.types";
 import { isManualMovementType } from "../../stock-movements.constants";
 import {
   fileToInlineProductImage,
   inlineProductImageToFile,
+  mutateStockMovementDraft,
   readStockMovementDraft,
-  writeStockMovementDraft,
 } from "../create-stock-movement.storage";
 import type { StockMovementDraft } from "../create-stock-movement.storage";
 import {
@@ -42,6 +41,14 @@ import {
   buildExistingProductCostPriceSuggestion,
   findMostRecentWarehouseProductBatch,
 } from "../stock-movement-batch-pricing.model";
+import { validateExistingProductBatchForm } from "../stock-movement-batch-form-validation";
+import {
+  buildRepeatedProductBatchWarning,
+  findDuplicateInlineProductError,
+  getPendingInlineProductBarcodeConflictError,
+  hasExistingProductInItems,
+} from "../stock-movement-draft-guards";
+import { lookupStockMovementProductByBarcode } from "../stock-movement-product-lookup";
 
 const buildReturnHref = (type: string | null): string => {
   if (!isManualMovementType(type)) return "/stock-movements/create";
@@ -97,19 +104,6 @@ const buildInlineProductData = async (
   image: image ? await fileToInlineProductImage(image) : undefined,
 });
 
-const hasDuplicateInlineProductName = (
-  productName: string,
-  draft: StockMovementDraft | null,
-  ignoredIndex: number | null,
-): boolean => {
-  const normalizedName = productName.toLowerCase();
-  const duplicateInDraft = draft?.items.some((item, index) => {
-    if (index === ignoredIndex) return false;
-    return item.newProductData?.name.toLowerCase() === normalizedName;
-  });
-  return Boolean(duplicateInDraft);
-};
-
 const buildInlineMovementItem = (
   product: InlineProductData,
   quantity: number,
@@ -147,20 +141,21 @@ const EMPTY_BATCH_FORM: ExistingProductBatchFormState = {
 const isInlineProductRouteReady = (
   movementType: string | null,
   initialDraft: StockMovementDraft | null,
+  warehouseId: string | null,
   editItemIndex: number | null,
   isEditingInlineProduct: boolean,
 ): boolean => {
-  const hasValidEditItem = editItemIndex === null || isEditingInlineProduct;
-  return Boolean(
-    isManualMovementType(movementType) && initialDraft && hasValidEditItem,
-  );
+  if (!isManualMovementType(movementType)) return false;
+  if (!initialDraft || initialDraft.type !== movementType) return false;
+  if (initialDraft.warehouseId !== warehouseId) return false;
+  return editItemIndex === null || isEditingInlineProduct;
 };
 
-const appendProductToMovementDraft = (
+const appendProductToMovementDraft = async (
   product: InlineProductData,
   quantity: number,
 ): Promise<void> => {
-  return updateMovementDraft((draft) => ({
+  await mutateStockMovementDraft((draft) => ({
     ...draft,
     items: [...draft.items, buildInlineMovementItem(product, quantity)],
     selectedProductId: "",
@@ -169,10 +164,10 @@ const appendProductToMovementDraft = (
   }));
 };
 
-const appendExistingProductBatchToDraft = (
+const appendExistingProductBatchToDraft = async (
   item: StockMovementDraftItem,
 ): Promise<void> => {
-  return updateMovementDraft((draft) => ({
+  await mutateStockMovementDraft((draft) => ({
     ...draft,
     items: [...draft.items, item],
     selectedProductId: "",
@@ -181,20 +176,12 @@ const appendExistingProductBatchToDraft = (
   }));
 };
 
-const updateMovementDraft = async (
-  buildNextDraft: (draft: StockMovementDraft) => StockMovementDraft,
-): Promise<void> => {
-  const draft = await readStockMovementDraft();
-  if (!draft) return;
-  await writeStockMovementDraft(buildNextDraft(draft));
-};
-
-const updateProductInMovementDraft = (
+const updateProductInMovementDraft = async (
   index: number,
   product: InlineProductData,
   quantity: number,
 ): Promise<void> => {
-  return updateMovementDraft((draft) => ({
+  await mutateStockMovementDraft((draft) => ({
     ...draft,
     items: draft.items.map((item, itemIndex) => {
       return itemIndex === index
@@ -322,6 +309,7 @@ export const useNewProductInlineModel = ({
       isInlineProductRouteReady(
         movementType,
         initialDraft,
+        warehouseId,
         editItemIndex,
         isEditingInlineProduct,
       )
@@ -336,6 +324,7 @@ export const useNewProductInlineModel = ({
     isEditingInlineProduct,
     movementType,
     router,
+    warehouseId,
   ]);
 
   useEffect(() => {
@@ -344,6 +333,7 @@ export const useNewProductInlineModel = ({
       !isInlineProductRouteReady(
         movementType,
         initialDraft,
+        warehouseId,
         editItemIndex,
         isEditingInlineProduct,
       )
@@ -382,6 +372,7 @@ export const useNewProductInlineModel = ({
     isDraftLoaded,
     isEditingInlineProduct,
     movementType,
+    warehouseId,
   ]);
 
   const addCustomAttribute = (): void => {
@@ -465,18 +456,20 @@ export const useNewProductInlineModel = ({
   };
 
   const handleBarcodeScan = async (barcode: string): Promise<void> => {
-    try {
-      const response = await api
-        .get(`products/barcode/${encodeURIComponent(barcode)}`)
-        .json<{ success: boolean; data: StockMovementProductOption }>();
+    const lookup = await lookupStockMovementProductByBarcode(barcode);
+    if (lookup.status === "found") {
       setScannedExistingProduct({
-        id: response.data.id,
-        name: response.data.name,
+        id: lookup.product.id,
+        name: lookup.product.name,
         barcode,
       });
-    } catch {
+      return;
+    }
+    if (lookup.status === "not-found") {
       form.setValue("barcode", barcode);
+      return;
     }
+    toast.error(lookup.message);
   };
 
   const handleExistingProductModalOpenChange = (open: boolean): void => {
@@ -485,13 +478,32 @@ export const useNewProductInlineModel = ({
     }
   };
 
-  const handleCreateBatchForExistingProduct = (): void => {
+  const handleCreateBatchForExistingProduct = async (): Promise<void> => {
     if (!scannedExistingProduct) return;
+    const draft = await readStockMovementDraft();
+    const draftItems = draft?.items ?? [];
+
+    const barcodeConflictError = getPendingInlineProductBarcodeConflictError(
+      draftItems,
+      scannedExistingProduct.barcode,
+    );
+    if (barcodeConflictError) {
+      toast.error(barcodeConflictError);
+      setScannedExistingProduct(null);
+      return;
+    }
+
     setExistingProductBatchForm({
       ...EMPTY_BATCH_FORM,
       isOpen: true,
       productId: scannedExistingProduct.id,
       productName: scannedExistingProduct.name,
+      repeatedProductWarning: hasExistingProductInItems(
+        draftItems,
+        scannedExistingProduct.id,
+      )
+        ? buildRepeatedProductBatchWarning(scannedExistingProduct.name)
+        : null,
     });
     setScannedExistingProduct(null);
   };
@@ -513,19 +525,11 @@ export const useNewProductInlineModel = ({
   };
 
   const handleConfirmBatch = async (): Promise<void> => {
-    const quantity = Number(existingProductBatchForm.quantity);
-    if (!quantity || quantity <= 0) {
-      updateBatchForm({ error: "Informe uma quantidade válida para o lote." });
-      return;
-    }
-
-    if (existingProductBatchForm.costPrice === undefined || existingProductBatchForm.costPrice < 0) {
-      updateBatchForm({ error: "Informe um preço de custo válido." });
-      return;
-    }
-
-    if (existingProductBatchForm.sellingPrice === undefined || existingProductBatchForm.sellingPrice < 0) {
-      updateBatchForm({ error: "Informe um preço de venda válido." });
+    const validationError = validateExistingProductBatchForm(
+      existingProductBatchForm,
+    );
+    if (validationError) {
+      updateBatchForm({ error: validationError });
       return;
     }
 
@@ -577,50 +581,75 @@ export const useNewProductInlineModel = ({
     updateInlineQuantity((form.getValues("quantity") || 0) - 1);
   };
 
-  const onSubmit = async (data: ProductCreateFormData): Promise<void> => {
-    if (!validateCustomAttributes()) return;
+  const ensureInlineBarcodeIsAvailable = async (
+    barcode: string,
+  ): Promise<boolean> => {
+    const lookup = await lookupStockMovementProductByBarcode(barcode);
+    if (lookup.status === "not-found") return true;
+    if (lookup.status === "error") {
+      toast.error(lookup.message);
+      return false;
+    }
+    setScannedExistingProduct({
+      id: lookup.product.id,
+      name: lookup.product.name,
+      barcode,
+    });
+    return false;
+  };
 
-    const currentDraft = await readStockMovementDraft();
-    if (!currentDraft) {
-      router.replace("/stock-movements");
+  const saveInlineProductToDraft = async (
+    data: ProductCreateFormData,
+  ): Promise<void> => {
+    const product = await buildInlineProductData(
+      data,
+      mergeAttributes(data),
+      productImage,
+    );
+    if (isEditingInlineProduct && editItemIndex !== null) {
+      await updateProductInMovementDraft(editItemIndex, product, data.quantity);
+      toast.success(`${data.name} foi atualizado na movimentação.`);
+      router.push(cancelHref);
       return;
     }
 
-    if (
-      hasDuplicateInlineProductName(
-        data.name,
-        currentDraft,
-        editItemIndex,
-      )
-    ) {
-      toast.error(`O produto "${data.name}" já foi adicionado nesta movimentação.`);
+    await appendProductToMovementDraft(product, data.quantity);
+    if (data.continuousMode) {
+      toast.success(
+        `${data.name} já está na movimentação. Continue adicionando novos produtos.`,
+      );
+      resetInlineFormForNextProduct();
       return;
     }
 
+    router.push(cancelHref);
+  };
+
+  const onSubmit = async (data: ProductCreateFormData): Promise<void> => {
+    if (!validateCustomAttributes()) return;
+
     setIsSubmitting(true);
     try {
-      const product = await buildInlineProductData(
-        data,
-        mergeAttributes(data),
-        productImage,
-      );
-      if (isEditingInlineProduct && editItemIndex !== null) {
-        await updateProductInMovementDraft(editItemIndex, product, data.quantity);
-        toast.success(`${data.name} foi atualizado na movimentação.`);
-        router.push(cancelHref);
+      const currentDraft = await readStockMovementDraft();
+      if (!currentDraft) {
+        router.replace("/stock-movements");
         return;
       }
 
-      await appendProductToMovementDraft(product, data.quantity);
-      if (data.continuousMode) {
-        toast.success(
-          `${data.name} já está na movimentação. Continue adicionando novos produtos.`,
-        );
-        resetInlineFormForNextProduct();
+      const duplicateError = findDuplicateInlineProductError(
+        { name: data.name, barcode: data.barcode },
+        currentDraft.items,
+        editItemIndex,
+      );
+      if (duplicateError) {
+        toast.error(duplicateError);
         return;
       }
 
-      router.push(cancelHref);
+      const barcode = data.barcode?.trim();
+      if (barcode && !(await ensureInlineBarcodeIsAvailable(barcode))) return;
+
+      await saveInlineProductToDraft(data);
     } catch {
       toast.error("Não foi possível preparar a imagem do produto.");
     } finally {
diff --git a/app/(pages)/stock-movements/create/stock-movement-batch-data-modal.view.tsx b/app/(pages)/stock-movements/create/stock-movement-batch-data-modal.view.tsx
index 42439a5..fb25422 100644
--- a/app/(pages)/stock-movements/create/stock-movement-batch-data-modal.view.tsx
+++ b/app/(pages)/stock-movements/create/stock-movement-batch-data-modal.view.tsx
@@ -227,6 +227,12 @@ export function StockMovementBatchDataModal({
           </div>
         </div>
 
+        {form.repeatedProductWarning && (
+          <div className="rounded-[4px] border border-amber-900/30 bg-amber-950/10 px-4 py-3 text-xs font-medium text-amber-400">
+            {form.repeatedProductWarning}
+          </div>
+        )}
+
         {form.error && (
           <div className="rounded-[4px] border border-rose-900/30 bg-rose-950/10 px-4 py-3 text-xs font-medium text-rose-400">
             {form.error}
diff --git a/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.test.ts b/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.test.ts
new file mode 100644
index 0000000..5a25cbb
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  getOptionalText,
+  validateExistingProductBatchForm,
+} from "./stock-movement-batch-form-validation";
+import type { ExistingProductBatchFormState } from "./create-stock-movement.types";
+
+const createBatchForm = (
+  overrides: Partial<ExistingProductBatchFormState> = {},
+): ExistingProductBatchFormState => ({
+  isOpen: true,
+  productId: "p-1",
+  productName: "Café Torrado",
+  quantity: "2",
+  manufacturedDate: "",
+  expirationDate: "",
+  costPrice: 1290,
+  sellingPrice: 2490,
+  editingIndex: null,
+  error: null,
+  ...overrides,
+});
+
+describe("getOptionalText", () => {
+  it("retorna undefined para texto vazio ou só com espaços", () => {
+    expect(getOptionalText(undefined)).toBeUndefined();
+    expect(getOptionalText("")).toBeUndefined();
+    expect(getOptionalText("   ")).toBeUndefined();
+  });
+
+  it("retorna o texto aparado quando preenchido", () => {
+    expect(getOptionalText(" 2026-01-01 ")).toBe("2026-01-01");
+  });
+});
+
+describe("validateExistingProductBatchForm", () => {
+  it("aceita formulário completo sem datas", () => {
+    expect(validateExistingProductBatchForm(createBatchForm())).toBeNull();
+  });
+
+  it("exige quantidade positiva", () => {
+    expect(
+      validateExistingProductBatchForm(createBatchForm({ quantity: "0" })),
+    ).toBe("Informe uma quantidade válida para o lote.");
+    expect(
+      validateExistingProductBatchForm(createBatchForm({ quantity: "" })),
+    ).toBe("Informe uma quantidade válida para o lote.");
+  });
+
+  it("exige preço de custo válido", () => {
+    expect(
+      validateExistingProductBatchForm(createBatchForm({ costPrice: undefined })),
+    ).toBe("Informe um preço de custo válido.");
+    expect(
+      validateExistingProductBatchForm(createBatchForm({ costPrice: -1 })),
+    ).toBe("Informe um preço de custo válido.");
+  });
+
+  it("exige preço de venda válido", () => {
+    expect(
+      validateExistingProductBatchForm(
+        createBatchForm({ sellingPrice: undefined }),
+      ),
+    ).toBe("Informe um preço de venda válido.");
+  });
+
+  it("rejeita validade anterior à fabricação", () => {
+    expect(
+      validateExistingProductBatchForm(
+        createBatchForm({
+          manufacturedDate: "2026-06-01",
+          expirationDate: "2026-01-01",
+        }),
+      ),
+    ).toBe("A data de validade não pode ser anterior à data de fabricação.");
+  });
+
+  it("aceita intervalo de datas válido", () => {
+    expect(
+      validateExistingProductBatchForm(
+        createBatchForm({
+          manufacturedDate: "2026-01-01",
+          expirationDate: "2026-06-01",
+        }),
+      ),
+    ).toBeNull();
+  });
+});
diff --git a/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.ts b/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.ts
new file mode 100644
index 0000000..ccd874e
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-batch-form-validation.ts
@@ -0,0 +1,35 @@
+import type { ExistingProductBatchFormState } from "./create-stock-movement.types";
+
+export const getOptionalText = (value: string | undefined): string | undefined => {
+  const trimmedValue = value?.trim();
+  return trimmedValue || undefined;
+};
+
+const isBatchDateRangeInvalid = (
+  manufacturedDate: string,
+  expirationDate: string,
+): boolean => {
+  const optionalManufacturedDate = getOptionalText(manufacturedDate);
+  const optionalExpirationDate = getOptionalText(expirationDate);
+  if (!optionalManufacturedDate || !optionalExpirationDate) return false;
+  return new Date(optionalExpirationDate) < new Date(optionalManufacturedDate);
+};
+
+export const validateExistingProductBatchForm = (
+  form: ExistingProductBatchFormState,
+): string | null => {
+  const quantity = Number(form.quantity);
+  if (!quantity || quantity <= 0) {
+    return "Informe uma quantidade válida para o lote.";
+  }
+  if (form.costPrice === undefined || form.costPrice < 0) {
+    return "Informe um preço de custo válido.";
+  }
+  if (form.sellingPrice === undefined || form.sellingPrice < 0) {
+    return "Informe um preço de venda válido.";
+  }
+  if (isBatchDateRangeInvalid(form.manufacturedDate, form.expirationDate)) {
+    return "A data de validade não pode ser anterior à data de fabricação.";
+  }
+  return null;
+};
diff --git a/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts b/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
new file mode 100644
index 0000000..6dd4f29
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildRepeatedProductBatchWarning,
+  findDuplicateInlineProductError,
+  getPendingInlineProductBarcodeConflictError,
+  hasExistingProductInItems,
+} from "./stock-movement-draft-guards";
+import type { StockMovementDraftItem } from "./create-stock-movement.types";
+
+const draftItems: StockMovementDraftItem[] = [
+  {
+    quantity: 2,
+    productName: "Produto Novo A",
+    newProductData: { name: "Produto Novo A", barcode: "789100000001" },
+  },
+  {
+    productId: "p-1",
+    quantity: 1,
+    productName: "Produto Existente",
+  },
+];
+
+describe("findDuplicateInlineProductError", () => {
+  it("acusa nome duplicado ignorando caixa", () => {
+    expect(
+      findDuplicateInlineProductError(
+        { name: "produto novo a" },
+        draftItems,
+        null,
+      ),
+    ).toBe('O produto "produto novo a" já foi adicionado nesta movimentação.');
+  });
+
+  it("acusa barcode duplicado entre produtos novos", () => {
+    expect(
+      findDuplicateInlineProductError(
+        { name: "Outro Produto", barcode: "789100000001" },
+        draftItems,
+        null,
+      ),
+    ).toBe(
+      'O código 789100000001 já está em uso pelo produto "Produto Novo A" nesta movimentação.',
+    );
+  });
+
+  it("ignora o item que está sendo editado", () => {
+    expect(
+      findDuplicateInlineProductError(
+        { name: "Produto Novo A", barcode: "789100000001" },
+        draftItems,
+        0,
+      ),
+    ).toBeNull();
+  });
+
+  it("aceita produto sem conflito", () => {
+    expect(
+      findDuplicateInlineProductError(
+        { name: "Produto Inédito", barcode: "789100000999" },
+        draftItems,
+        null,
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("getPendingInlineProductBarcodeConflictError", () => {
+  it("acusa conflito com produto novo pendente de mesmo barcode", () => {
+    expect(
+      getPendingInlineProductBarcodeConflictError(draftItems, "789100000001"),
+    ).toBe(
+      'O código 789100000001 já pertence ao produto novo "Produto Novo A" nesta movimentação. Remova-o antes de adicionar o produto existente.',
+    );
+  });
+
+  it("retorna null sem barcode ou sem conflito", () => {
+    expect(getPendingInlineProductBarcodeConflictError(draftItems, null)).toBeNull();
+    expect(getPendingInlineProductBarcodeConflictError(draftItems, "")).toBeNull();
+    expect(
+      getPendingInlineProductBarcodeConflictError(draftItems, "789100000999"),
+    ).toBeNull();
+  });
+});
+
+describe("hasExistingProductInItems", () => {
+  it("encontra item pelo productId", () => {
+    expect(hasExistingProductInItems(draftItems, "p-1")).toBe(true);
+    expect(hasExistingProductInItems(draftItems, "p-2")).toBe(false);
+  });
+});
+
+describe("buildRepeatedProductBatchWarning", () => {
+  it("monta aviso com o nome do produto", () => {
+    expect(buildRepeatedProductBatchWarning("Café Torrado")).toBe(
+      "Café Torrado já está na movimentação. Este lote será adicionado como um novo item.",
+    );
+  });
+});
diff --git a/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts b/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
new file mode 100644
index 0000000..36b66d6
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
@@ -0,0 +1,60 @@
+import type { StockMovementDraftItem } from "./create-stock-movement.types";
+
+export interface InlineProductIdentity {
+  name: string;
+  barcode?: string;
+}
+
+const withoutIgnoredIndex = (
+  items: StockMovementDraftItem[],
+  ignoredIndex: number | null,
+): StockMovementDraftItem[] => {
+  return items.filter((_, index) => index !== ignoredIndex);
+};
+
+export const findDuplicateInlineProductError = (
+  product: InlineProductIdentity,
+  items: StockMovementDraftItem[],
+  ignoredIndex: number | null,
+): string | null => {
+  const normalizedName = product.name.trim().toLowerCase();
+  const normalizedBarcode = product.barcode?.trim();
+  const consideredItems = withoutIgnoredIndex(items, ignoredIndex);
+
+  const hasDuplicateName = consideredItems.some((item) => {
+    return item.newProductData?.name.toLowerCase() === normalizedName;
+  });
+  if (hasDuplicateName) {
+    return `O produto "${product.name}" já foi adicionado nesta movimentação.`;
+  }
+
+  if (!normalizedBarcode) return null;
+  const barcodeConflictItem = consideredItems.find((item) => {
+    return item.newProductData?.barcode === normalizedBarcode;
+  });
+  if (!barcodeConflictItem) return null;
+  return `O código ${normalizedBarcode} já está em uso pelo produto "${barcodeConflictItem.productName}" nesta movimentação.`;
+};
+
+export const getPendingInlineProductBarcodeConflictError = (
+  items: StockMovementDraftItem[],
+  barcode: string | null | undefined,
+): string | null => {
+  if (!barcode) return null;
+  const conflictingItem = items.find((item) => {
+    return item.newProductData?.barcode === barcode;
+  });
+  if (!conflictingItem) return null;
+  return `O código ${barcode} já pertence ao produto novo "${conflictingItem.productName}" nesta movimentação. Remova-o antes de adicionar o produto existente.`;
+};
+
+export const hasExistingProductInItems = (
+  items: StockMovementDraftItem[],
+  productId: string,
+): boolean => {
+  return items.some((item) => item.productId === productId);
+};
+
+export const buildRepeatedProductBatchWarning = (productName: string): string => {
+  return `${productName} já está na movimentação. Este lote será adicionado como um novo item.`;
+};
diff --git a/app/(pages)/stock-movements/create/stock-movement-product-lookup.test.ts b/app/(pages)/stock-movements/create/stock-movement-product-lookup.test.ts
new file mode 100644
index 0000000..69c0b41
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-product-lookup.test.ts
@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
+
+const mockGet = vi.fn();
+const mockIsApiNotFoundError = vi.fn();
+
+vi.mock("@/lib/api", () => ({
+  api: {
+    get: (...args: unknown[]) => mockGet(...args),
+  },
+  isApiNotFoundError: (error: unknown) => mockIsApiNotFoundError(error),
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("lookupStockMovementProductByBarcode", () => {
+  it("retorna produto encontrado", async () => {
+    mockGet.mockReturnValue({
+      json: vi.fn(async () => ({
+        success: true,
+        data: { id: "p-1", name: "Café Torrado", barcode: "789" },
+      })),
+    });
+
+    const lookup = await lookupStockMovementProductByBarcode("789");
+
+    expect(mockGet).toHaveBeenCalledWith("products/barcode/789");
+    expect(lookup).toEqual({
+      status: "found",
+      product: { id: "p-1", name: "Café Torrado", barcode: "789" },
+    });
+  });
+
+  it("retorna not-found quando a API responde 404", async () => {
+    mockGet.mockReturnValue({
+      json: vi.fn(async () => {
+        throw new Error("não encontrado");
+      }),
+    });
+    mockIsApiNotFoundError.mockReturnValue(true);
+
+    const lookup = await lookupStockMovementProductByBarcode("789");
+
+    expect(lookup).toEqual({ status: "not-found" });
+  });
+
+  it("retorna erro com mensagem para falhas que não são 404", async () => {
+    mockGet.mockReturnValue({
+      json: vi.fn(async () => {
+        throw new Error("timeout");
+      }),
+    });
+    mockIsApiNotFoundError.mockReturnValue(false);
+
+    const lookup = await lookupStockMovementProductByBarcode("789");
+
+    expect(lookup).toEqual({
+      status: "error",
+      message:
+        "Não foi possível consultar o código 789 (timeout). Verifique a conexão e tente novamente.",
+    });
+  });
+
+  it("escapa o barcode na URL", async () => {
+    mockGet.mockReturnValue({
+      json: vi.fn(async () => ({ success: true, data: { id: "p", name: "x" } })),
+    });
+
+    await lookupStockMovementProductByBarcode("a/b c");
+
+    expect(mockGet).toHaveBeenCalledWith("products/barcode/a%2Fb%20c");
+  });
+});
diff --git a/app/(pages)/stock-movements/create/stock-movement-product-lookup.ts b/app/(pages)/stock-movements/create/stock-movement-product-lookup.ts
new file mode 100644
index 0000000..f69e11f
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-product-lookup.ts
@@ -0,0 +1,37 @@
+import { api, isApiNotFoundError } from "@/lib/api";
+import type { StockMovementProductOption } from "./create-stock-movement.types";
+
+interface StockMovementProductByBarcodeResponse {
+  success: boolean;
+  data: StockMovementProductOption;
+}
+
+export type StockMovementBarcodeLookup =
+  | { status: "found"; product: StockMovementProductOption }
+  | { status: "not-found" }
+  | { status: "error"; message: string };
+
+const buildBarcodeLookupErrorMessage = (
+  barcode: string,
+  error: unknown,
+): string => {
+  const detail = error instanceof Error && error.message ? ` (${error.message})` : "";
+  return `Não foi possível consultar o código ${barcode}${detail}. Verifique a conexão e tente novamente.`;
+};
+
+export const lookupStockMovementProductByBarcode = async (
+  barcode: string,
+): Promise<StockMovementBarcodeLookup> => {
+  try {
+    const response = await api
+      .get(`products/barcode/${encodeURIComponent(barcode)}`)
+      .json<StockMovementProductByBarcodeResponse>();
+    return { status: "found", product: response.data };
+  } catch (error) {
+    if (isApiNotFoundError(error)) return { status: "not-found" };
+    return {
+      status: "error",
+      message: buildBarcodeLookupErrorMessage(barcode, error),
+    };
+  }
+};
diff --git a/lib/api.ts b/lib/api.ts
index dde22c0..b208f51 100644
--- a/lib/api.ts
+++ b/lib/api.ts
@@ -1,4 +1,8 @@
-import ky from "ky";
+import ky, { HTTPError } from "ky";
+
+export const isApiNotFoundError = (error: unknown): boolean => {
+  return error instanceof HTTPError && error.response.status === 404;
+};
 
 const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL?.replace(/\/+$/, "");
 

From a402988a7a5798c8adf55a019e8bf880602e022a Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 14:51:45 -0300
Subject: [PATCH 10/32] fix(product-form): make scannedExistingProduct optional
 and fix all tsc errors

- Make scannedExistingProduct prop optional in ProductFormProps
- Fix !== null to != null in ExistingProductFoundModal guard
- Recipe A: cast NormalizedOptions in HTTPError constructors
- Recipe B: add error/isValidating to SWR mock returns
- Recipe C: use vi.mocked() for mockClear on plain function types
- Recipe D: narrow Zod safeParse results before helper calls
- Recipe E: add missing view-prop mocks (onNewTransfer, as const, ProductSearchOption)
- Recipe F: align test signatures with current function signatures
- Add 'typecheck' script to package.json
- Add Typecheck step to CI quality workflow
---
 .github/workflows/quality.yml                     |  3 +++
 app/(pages)/batches/batches.view.test.tsx         |  2 +-
 .../batches/create/batches-create.schema.test.ts  |  4 +++-
 .../batches/create/batches-create.view.test.tsx   |  6 +++++-
 app/(pages)/categories/categories.model.test.ts   |  2 +-
 app/(pages)/layout.test.tsx                       | 10 +++-------
 .../products/components/product-form.types.ts     |  2 +-
 .../products/components/product-form.view.tsx     |  2 +-
 .../stock-movements/stock-movements.model.test.ts |  4 ++--
 .../transfers/[id]/transfer-detail.model.test.ts  |  4 ++--
 .../transfers/new/new-transfer.schema.test.ts     |  5 ++++-
 app/(pages)/transfers/transfers.model.test.ts     |  2 +-
 app/(pages)/transfers/transfers.view.test.tsx     |  1 +
 app/change-password/change-password.model.test.ts |  5 +++--
 app/login/login.model.test.ts                     | 15 ++++++++-------
 app/register/register.model.test.ts               |  3 ++-
 lib/contexts/auth-context.test.tsx                |  8 ++++++++
 package.json                                      |  1 +
 18 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/.github/workflows/quality.yml b/.github/workflows/quality.yml
index 7c6e3bd..d2c5dc1 100644
--- a/.github/workflows/quality.yml
+++ b/.github/workflows/quality.yml
@@ -35,6 +35,9 @@ jobs:
       - name: Lint
         run: pnpm lint
 
+      - name: Typecheck
+        run: pnpm typecheck
+
       - name: Unit tests
         run: pnpm exec vitest run
 
diff --git a/app/(pages)/batches/batches.view.test.tsx b/app/(pages)/batches/batches.view.test.tsx
index 1c15e5b..1b4cb30 100644
--- a/app/(pages)/batches/batches.view.test.tsx
+++ b/app/(pages)/batches/batches.view.test.tsx
@@ -32,7 +32,7 @@ const baseProps = {
     status: "all" as const,
     lowStockThreshold: 10,
   },
-  sortConfig: { key: "createdAt", direction: "desc" as const },
+  sortConfig: { key: "createdAt" as const, direction: "desc" as const },
   isGroupedByProduct: false,
   isMobileFiltersOpen: false,
   mobileFiltersDraft: {
diff --git a/app/(pages)/batches/create/batches-create.schema.test.ts b/app/(pages)/batches/create/batches-create.schema.test.ts
index 1aa28e6..5a33fbd 100644
--- a/app/(pages)/batches/create/batches-create.schema.test.ts
+++ b/app/(pages)/batches/create/batches-create.schema.test.ts
@@ -10,7 +10,7 @@ const baseData = {
 };
 
 const expectErrorPath = (
-  result: { success: false; error: { issues: { path: (string | number)[]; message: string }[] } },
+  result: { success: false; error: { issues: { path: PropertyKey[]; message: string }[] } },
   path: string,
 ): void => {
   if (result.success) {
@@ -52,6 +52,7 @@ describe("batchCreateSchema", () => {
       productId: "",
     });
     expect(result.success).toBe(false);
+    if (result.success) throw new Error("expected parse failure");
     expectErrorPath(result, "productId");
   });
 
@@ -61,6 +62,7 @@ describe("batchCreateSchema", () => {
       quantity: 0,
     });
     expect(result.success).toBe(false);
+    if (result.success) throw new Error("expected parse failure");
     expectErrorPath(result, "quantity");
   });
 
diff --git a/app/(pages)/batches/create/batches-create.view.test.tsx b/app/(pages)/batches/create/batches-create.view.test.tsx
index eaedfe8..264ba11 100644
--- a/app/(pages)/batches/create/batches-create.view.test.tsx
+++ b/app/(pages)/batches/create/batches-create.view.test.tsx
@@ -67,7 +67,11 @@ const baseProps = {
   selectedWarehouseId: "wh-1",
   onQuantityIncrement: vi.fn(),
   onQuantityDecrement: vi.fn(),
-  selectedProduct: { hasExpiration: false },
+  selectedProduct: { id: "prod-1", name: "Produto A", hasExpiration: false },
+  latestBatchPriceSuggestion: null,
+  isLatestBatchPriceLoading: false,
+  onApplyLatestCostPrice: vi.fn(),
+  onApplyLatestSellingPrice: vi.fn(),
 };
 
 const Wrapper = ({
diff --git a/app/(pages)/categories/categories.model.test.ts b/app/(pages)/categories/categories.model.test.ts
index 3b47561..b659d2c 100644
--- a/app/(pages)/categories/categories.model.test.ts
+++ b/app/(pages)/categories/categories.model.test.ts
@@ -80,7 +80,7 @@ const fakeSWR = vi.hoisted(() => {
 
     public reset(): void {
       this.responses.clear();
-      this.defaultState.mutate.mockClear();
+      vi.mocked(this.defaultState.mutate).mockClear();
       this.hook.mockClear();
     }
   }
diff --git a/app/(pages)/layout.test.tsx b/app/(pages)/layout.test.tsx
index daddf5e..fc4c82f 100644
--- a/app/(pages)/layout.test.tsx
+++ b/app/(pages)/layout.test.tsx
@@ -38,13 +38,9 @@ vi.mock("@/lib/contexts/warehouse-context", () => ({
   }),
 }));
 
-vi.mock(
-  "@/components/layout/mobile-menu-context",
-  () => ({
-    useMobileMenu: () => mobileMenuMock,
-  }),
-  { virtual: true }
-);
+vi.mock("@/components/layout/mobile-menu-context", () => ({
+  useMobileMenu: () => mobileMenuMock,
+}));
 
 const getClassTokens = (element: Element | null): string[] =>
   element?.getAttribute("class")?.split(/\s+/) ?? [];
diff --git a/app/(pages)/products/components/product-form.types.ts b/app/(pages)/products/components/product-form.types.ts
index a4a875c..a910da8 100644
--- a/app/(pages)/products/components/product-form.types.ts
+++ b/app/(pages)/products/components/product-form.types.ts
@@ -127,7 +127,7 @@ export interface ProductFormProps {
   handleBarcodeScan: (barcode: string) => void | Promise<void>;
 
   // Existing product modal (new-product page)
-  scannedExistingProduct: ExistingProductInfo | null;
+  scannedExistingProduct?: ExistingProductInfo | null;
   onExistingProductModalOpenChange?: (open: boolean) => void;
   onCreateBatchForExistingProduct?: () => void | Promise<void>;
 
diff --git a/app/(pages)/products/components/product-form.view.tsx b/app/(pages)/products/components/product-form.view.tsx
index 5d36e47..dac9d51 100644
--- a/app/(pages)/products/components/product-form.view.tsx
+++ b/app/(pages)/products/components/product-form.view.tsx
@@ -243,7 +243,7 @@ const ExistingProductFoundModal = ({
 
   return (
     <ResponsiveModal
-      open={scannedExistingProduct !== null}
+      open={scannedExistingProduct != null}
       onOpenChange={onExistingProductModalOpenChange}
       title="Produto já existe"
       description={`O produto "${scannedExistingProduct?.name}" já está cadastrado no sistema.`}
diff --git a/app/(pages)/stock-movements/stock-movements.model.test.ts b/app/(pages)/stock-movements/stock-movements.model.test.ts
index 20fa474..6b1a800 100644
--- a/app/(pages)/stock-movements/stock-movements.model.test.ts
+++ b/app/(pages)/stock-movements/stock-movements.model.test.ts
@@ -33,7 +33,7 @@ const fakeSWR = vi.hoisted(() => {
 
     public reset(): void {
       this.states.clear();
-      this.defaultState.mutate.mockClear();
+      vi.mocked(this.defaultState.mutate).mockClear();
       this.hook.mockClear();
     }
   }
@@ -66,7 +66,7 @@ const fakeWarehouse = vi.hoisted(() => {
 });
 
 vi.mock("swr", () => ({
-  default: (...args: unknown[]) => fakeSWR.hook(...args),
+  default: (...args: [string | null, unknown?]) => fakeSWR.hook(...args),
 }));
 
 vi.mock("@/lib/api", () => ({
diff --git a/app/(pages)/transfers/[id]/transfer-detail.model.test.ts b/app/(pages)/transfers/[id]/transfer-detail.model.test.ts
index b776e74..188d457 100644
--- a/app/(pages)/transfers/[id]/transfer-detail.model.test.ts
+++ b/app/(pages)/transfers/[id]/transfer-detail.model.test.ts
@@ -30,7 +30,7 @@ const fakeSWR = vi.hoisted(() => {
 
     public reset(): void {
       this.responses.clear();
-      this.defaultState.mutate.mockClear();
+      vi.mocked(this.defaultState.mutate).mockClear();
       this.hook.mockClear();
     }
   }
@@ -131,7 +131,7 @@ const baseTransfer: Transfer = {
   destinationWarehouseId: "warehouse-destination",
   destinationWarehouseName: "Loja Centro",
   status: TransferStatus.DRAFT,
-  notes: null,
+  notes: undefined,
   items: [],
   createdAt: "2026-01-01T09:00:00.000Z",
 };
diff --git a/app/(pages)/transfers/new/new-transfer.schema.test.ts b/app/(pages)/transfers/new/new-transfer.schema.test.ts
index c772221..386f5eb 100644
--- a/app/(pages)/transfers/new/new-transfer.schema.test.ts
+++ b/app/(pages)/transfers/new/new-transfer.schema.test.ts
@@ -17,7 +17,7 @@ const baseTransferPayload: NewTransferSchema = {
   ],
 };
 
-const expectErrorPath = (result: { success: false; error: { issues: { path: (string | number)[] }[] } }, path: string): void => {
+const expectErrorPath = (result: { success: false; error: { issues: { path: PropertyKey[] }[] } }, path: string): void => {
   if (result.success) {
     throw new Error("Parsing deveria falhar");
   }
@@ -40,6 +40,7 @@ describe("newTransferSchema", () => {
     });
 
     expect(result.success).toBe(false);
+    if (result.success) throw new Error("expected parse failure");
     expectErrorPath(result, "destinationWarehouseId");
   });
 
@@ -50,6 +51,7 @@ describe("newTransferSchema", () => {
     });
 
     expect(result.success).toBe(false);
+    if (result.success) throw new Error("expected parse failure");
     expectErrorPath(result, "items");
   });
 
@@ -65,6 +67,7 @@ describe("newTransferSchema", () => {
     });
 
     expect(result.success).toBe(false);
+    if (result.success) throw new Error("expected parse failure");
     expectErrorPath(result, "items");
   });
 
diff --git a/app/(pages)/transfers/transfers.model.test.ts b/app/(pages)/transfers/transfers.model.test.ts
index 410759d..7a92376 100644
--- a/app/(pages)/transfers/transfers.model.test.ts
+++ b/app/(pages)/transfers/transfers.model.test.ts
@@ -30,7 +30,7 @@ const fakeSWR = vi.hoisted(() => {
 
     public reset(): void {
       this.responses.clear();
-      this.defaultState.mutate.mockClear();
+      vi.mocked(this.defaultState.mutate).mockClear();
       this.hook.mockClear();
     }
   }
diff --git a/app/(pages)/transfers/transfers.view.test.tsx b/app/(pages)/transfers/transfers.view.test.tsx
index c38f1e7..ce0fb99 100644
--- a/app/(pages)/transfers/transfers.view.test.tsx
+++ b/app/(pages)/transfers/transfers.view.test.tsx
@@ -82,6 +82,7 @@ describe("TransfersView", () => {
     onTabChange: vi.fn(),
     stats: { total: 1, inTransit: 0, pending: 1, completed: 0 },
     onRetry: vi.fn(),
+    onNewTransfer: vi.fn(),
   };
 
   it("renders the header and tab buttons", () => {
diff --git a/app/change-password/change-password.model.test.ts b/app/change-password/change-password.model.test.ts
index d016c22..1833a44 100644
--- a/app/change-password/change-password.model.test.ts
+++ b/app/change-password/change-password.model.test.ts
@@ -1,5 +1,6 @@
 import { act, renderHook } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { NormalizedOptions } from "ky";
 import { useChangePasswordModel } from "./change-password.model";
 import { changePasswordSchema, type ChangePasswordFormData } from "./change-password.schema";
 
@@ -195,7 +196,7 @@ describe("useChangePasswordModel", () => {
     const response = new Response(JSON.stringify({ message: "Senha incorreta" }), {
       status: 400,
     });
-    const httpError = new HTTPError(response, new Request("http://localhost"));
+    const httpError = new HTTPError(response, new Request("http://localhost"), {} as unknown as NormalizedOptions);
 
     fakeApi.post.mockReturnValue(
       new FakeApiJsonResponse({
@@ -219,7 +220,7 @@ describe("useChangePasswordModel", () => {
   it("falls back to generic message when HTTP error has no message", async () => {
     const { HTTPError } = await import("ky");
     const response = new Response("not-json", { status: 400 });
-    const httpError = new HTTPError(response, new Request("http://localhost"));
+    const httpError = new HTTPError(response, new Request("http://localhost"), {} as unknown as NormalizedOptions);
 
     fakeApi.post.mockReturnValue(
       new FakeApiJsonResponse({
diff --git a/app/login/login.model.test.ts b/app/login/login.model.test.ts
index 65ae29a..a899c9b 100644
--- a/app/login/login.model.test.ts
+++ b/app/login/login.model.test.ts
@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { NormalizedOptions } from "ky";
 import { renderHook, act, waitFor } from "@testing-library/react";
 import { useLoginModel } from "./login.model";
 import { loginSchema } from "./login.schema";
@@ -197,7 +198,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 401 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -228,7 +229,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -258,7 +259,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -298,7 +299,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -354,7 +355,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -402,7 +403,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response("not json", { status: 500 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
@@ -474,7 +475,7 @@ describe("useLoginModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorData), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
diff --git a/app/register/register.model.test.ts b/app/register/register.model.test.ts
index b45821d..aadaf21 100644
--- a/app/register/register.model.test.ts
+++ b/app/register/register.model.test.ts
@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { NormalizedOptions } from "ky";
 import { renderHook, act, waitFor } from "@testing-library/react";
 import { useRegisterModel } from "./register.model";
 import { registerSchema } from "./register.schema";
@@ -163,7 +164,7 @@ describe("useRegisterModel", () => {
     const httpError = new HTTPError(
       new Response(JSON.stringify(errorResponse), { status: 400 }),
       new Request("http://test.com"),
-      {}
+      {} as unknown as NormalizedOptions
     );
 
     mockApiPost.mockReturnValue({
diff --git a/lib/contexts/auth-context.test.tsx b/lib/contexts/auth-context.test.tsx
index e1a62ee..ac3aea6 100644
--- a/lib/contexts/auth-context.test.tsx
+++ b/lib/contexts/auth-context.test.tsx
@@ -129,6 +129,8 @@ describe("useAuth", () => {
         },
         isLoading: false,
         mutate: vi.fn(),
+        error: undefined,
+        isValidating: false,
       } as ReturnType<typeof useSWR.default>);
 
       const { result } = renderHook(() => useAuth(), { wrapper });
@@ -149,6 +151,8 @@ describe("useAuth", () => {
         data: mockMeData,
         isLoading: false,
         mutate: vi.fn(),
+        error: undefined,
+        isValidating: false,
       } as ReturnType<typeof useSWR.default>);
 
       const { result } = renderHook(() => useAuth(), { wrapper });
@@ -179,6 +183,8 @@ describe("useAuth", () => {
         data: mockMeData,
         isLoading: false,
         mutate: vi.fn(),
+        error: undefined,
+        isValidating: false,
       } as ReturnType<typeof useSWR.default>);
 
       const { result } = renderHook(() => useAuth(), { wrapper });
@@ -203,6 +209,8 @@ describe("useAuth", () => {
         },
         isLoading: false,
         mutate: vi.fn(),
+        error: undefined,
+        isValidating: false,
       } as ReturnType<typeof useSWR.default>);
 
       const { result } = renderHook(() => useAuth(), { wrapper });
diff --git a/package.json b/package.json
index 3651d6b..a065669 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,7 @@
     "build": "next build --turbopack",
     "start": "next start",
     "lint": "eslint",
+    "typecheck": "tsc --noEmit",
     "test": "vitest",
     "test:e2e": "playwright test",
     "test:e2e:ui": "playwright test --ui",

From 53dff8e1d314b291abe8bc19324d093359eeee4e Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:09:47 -0300
Subject: [PATCH 11/32] fix(api): preserve client config on post-refresh
 retries

---
 lib/api.test.ts | 46 ++++++++++++++++++++++++++++++++++++++-
 lib/api.ts      | 57 +++++++++++++++++++++++++++----------------------
 2 files changed, 76 insertions(+), 27 deletions(-)

diff --git a/lib/api.test.ts b/lib/api.test.ts
index acdeb77..5da693a 100644
--- a/lib/api.test.ts
+++ b/lib/api.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { shouldRefreshAccessToken } from "./api";
+import { HTTPError } from "ky";
+import type { NormalizedOptions } from "ky";
+import { shouldRefreshAccessToken, attachApiErrorMessage } from "./api";
+
+const stubOptions = {} as unknown as NormalizedOptions;
 
 describe("shouldRefreshAccessToken", () => {
   it("refreshes on unauthorized responses", async () => {
@@ -22,3 +26,43 @@ describe("shouldRefreshAccessToken", () => {
     await expect(shouldRefreshAccessToken(response)).resolves.toBe(true);
   });
 });
+
+describe("attachApiErrorMessage", () => {
+  it("extracts message from API error body", async () => {
+    const response = new Response(
+      JSON.stringify({ message: "Estoque insuficiente" }),
+      { status: 422 },
+    );
+    const request = new Request("https://example.test/api/x");
+    const error = new HTTPError(response, request, stubOptions);
+
+    const result = await attachApiErrorMessage(error);
+
+    expect(result.message).toBe("Estoque insuficiente");
+  });
+
+  it("leaves 403 responses untouched", async () => {
+    const response = new Response(
+      JSON.stringify({ message: "Forbidden" }),
+      { status: 403 },
+    );
+    const request = new Request("https://example.test/api/x");
+    const error = new HTTPError(response, request, stubOptions);
+    const originalMessage = error.message;
+
+    const result = await attachApiErrorMessage(error);
+
+    expect(result.message).toBe(originalMessage);
+  });
+
+  it("keeps original message for non-JSON body", async () => {
+    const response = new Response("not-json", { status: 500 });
+    const request = new Request("https://example.test/api/x");
+    const error = new HTTPError(response, request, stubOptions);
+    const originalMessage = error.message;
+
+    const result = await attachApiErrorMessage(error);
+
+    expect(result.message).toBe(originalMessage);
+  });
+});
diff --git a/lib/api.ts b/lib/api.ts
index b208f51..ab2803d 100644
--- a/lib/api.ts
+++ b/lib/api.ts
@@ -51,6 +51,25 @@ export const shouldRefreshAccessToken = async (response: Response) => {
   }
 };
 
+export const attachApiErrorMessage = async (
+  error: HTTPError,
+): Promise<HTTPError> => {
+  const { response } = error;
+
+  if (isRedirectingToLogin) return error;
+
+  if (response && response.status !== 403) {
+    try {
+      const body = (await response.json()) as { message?: string };
+      error.message = body.message || error.message;
+    } catch {
+      // Se não conseguir parsear, mantém mensagem original
+    }
+  }
+
+  return error;
+};
+
 const redirectToLogin = () => {
   if (typeof window === "undefined" || isRedirectingToLogin) return;
   isRedirectingToLogin = true;
@@ -59,32 +78,22 @@ const redirectToLogin = () => {
   window.location.href = "/login";
 };
 
+const retryAfterRefreshClient = ky.create({
+  credentials: "include",
+  timeout: 30000,
+  retry: 0,
+  hooks: {
+    beforeError: [attachApiErrorMessage],
+  },
+});
+
 export const api = ky.create({
   prefixUrl: `${API_BASE_URL}/api`,
   credentials: "include",
   timeout: 30000,
   retry: 0,
   hooks: {
-    beforeError: [
-      async (error) => {
-        const { response } = error;
-
-        // Não tenta processar se já estamos redirecionando
-        if (isRedirectingToLogin) return error;
-
-        // Para erros que não são 403, tenta extrair mensagem da API
-        if (response && response.status !== 403) {
-          try {
-            const body = (await response.json()) as { message?: string };
-            error.message = body.message || error.message;
-          } catch {
-            // Se não conseguir parsear, mantém mensagem original
-          }
-        }
-
-        return error;
-      },
-    ],
+    beforeError: [attachApiErrorMessage],
     afterResponse: [
       async (request, _options, response) => {
         // Se já estamos redirecionando, não processa mais nada
@@ -103,9 +112,7 @@ export const api = ky.create({
               isRefreshing = false;
 
               // Retry da requisição original
-              return ky(request.clone(), {
-                credentials: "include",
-              });
+              return retryAfterRefreshClient(request.clone());
             } catch (refreshError) {
               processQueue(refreshError as Error);
               isRefreshing = false;
@@ -125,9 +132,7 @@ export const api = ky.create({
               if (isRedirectingToLogin) return response;
 
               // Retry da requisição original após refresh
-              return ky(request.clone(), {
-                credentials: "include",
-              });
+              return retryAfterRefreshClient(request.clone());
             } catch {
               // Refresh falhou enquanto esperava na fila
               return response;

From 30db4b55c819c040559efc51acee34a491fc665c Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:24:44 -0300
Subject: [PATCH 12/32] refactor(stock-movements): store draft images as blobs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace base64 dataUrl strings with native Blob objects in the
InlineProductImageData interface. IndexedDB stores Blobs natively via
structured clone, so the base64 round-trip was unnecessary and cost ~33%
size inflation plus main-thread encode/decode on every draft write.

- Change InlineProductImageData.dataUrl (string) to .blob (Blob)
- Make fileToInlineProductImage synchronous (File IS a Blob)
- Simplify inlineProductImageToFile to wrap blob in File constructor
- Bump STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION 2→3 (old drafts discarded)
- Update Zod schema to validate blob with z.instanceof(Blob)
- Remove window.atob and FileReader usage
- Update all test fixtures and mocks
- Add regression test for malformed blob draft rejection
---
 .../create-stock-movement.model.test.ts       | 22 +++++-----
 .../create-stock-movement.schema.test.ts      |  4 +-
 .../create/create-stock-movement.schema.ts    |  2 +-
 .../create-stock-movement.storage.test.ts     | 43 ++++++++++++++++---
 .../create/create-stock-movement.storage.ts   | 34 ++++-----------
 .../create/create-stock-movement.types.ts     |  2 +-
 .../new-product-inline.model.test.ts          | 16 ++++---
 .../new-product/new-product-inline.model.ts   | 12 +++---
 8 files changed, 74 insertions(+), 61 deletions(-)

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index 3f54b10..3b09a78 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -113,6 +113,7 @@ const fakeToast = vi.hoisted(() => {
   class FakeToast {
     public readonly success = vi.fn<(message: string) => void>();
     public readonly error = vi.fn<(message: string, options?: unknown) => void>();
+    public readonly warning = vi.fn<(message: string) => void>();
   }
 
   return new FakeToast();
@@ -143,7 +144,7 @@ const fakeStorage = vi.hoisted(() => {
         }
         this.draftState = {
           ...draft,
-          schemaVersion: 2,
+          schemaVersion: 3,
           updatedAt: "2026-01-20T10:00:00.000Z",
           revision: storedRevision + 1,
           runtimeId: this.currentRuntimeId,
@@ -233,17 +234,16 @@ vi.mock("./create-stock-movement.storage", () => ({
   inlineProductImageToFile: (image: {
     name: string;
     type: string;
-    dataUrl: string;
+    blob: Blob;
   }): File =>
-    new File(["img"], image.name, {
+    new File([image.blob], image.name, {
       type: image.type,
     }),
-  fileToInlineProductImage: (file: File) =>
-    Promise.resolve({
-      name: file.name,
-      type: file.type,
-      dataUrl: "data:image/png;base64,YQ==",
-    }),
+  fileToInlineProductImage: (file: File) => ({
+    name: file.name,
+    type: file.type,
+    blob: file,
+  }),
 }));
 
 const movementProducts: StockMovementProductOption[] = [
@@ -319,7 +319,7 @@ const barcodeIndex: Record<string, StockMovementProductOption> = {
 const createDraftState = (
   overrides?: Partial<StockMovementDraft>,
 ): StockMovementDraft => ({
-  schemaVersion: 2,
+  schemaVersion: 3,
   updatedAt: "2026-01-20T09:00:00.000Z",
   revision: 1,
   type: "PURCHASE_IN",
@@ -384,7 +384,7 @@ const createInlineSubmitPayload = (): CreateStockMovementSchema => ({
         image: {
           name: "inline.png",
           type: "image/png",
-          dataUrl: "data:image/png;base64,ZmFrZQ==",
+          blob: new Blob(["fake"], { type: "image/png" }),
         },
       },
     },
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.schema.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.schema.test.ts
index a7faef7..d39f9cf 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.schema.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.schema.test.ts
@@ -51,7 +51,7 @@ describe("createStockMovementSchema", () => {
             image: {
               name: "foto.png",
               type: "image/png",
-              dataUrl: "data:image/png;base64,YQ==",
+              blob: new Blob(["a"], { type: "image/png" }),
             },
           },
         },
@@ -140,7 +140,7 @@ describe("createStockMovementSchema", () => {
             image: {
               name: "",
               type: "",
-              dataUrl: "",
+              blob: "not-a-blob",
             },
           },
         },
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.schema.ts b/app/(pages)/stock-movements/create/create-stock-movement.schema.ts
index 91545c1..56d9e6c 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.schema.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.schema.ts
@@ -4,7 +4,7 @@ import { MANUAL_MOVEMENT_TYPES } from "../stock-movements.constants";
 const inlineProductImageSchema = z.object({
   name: z.string().min(1),
   type: z.string().min(1),
-  dataUrl: z.string().min(1),
+  blob: z.instanceof(Blob),
 });
 
 const inlineProductSchema = z.object({
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
index ee04521..b9e9bd3 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.storage.test.ts
@@ -185,7 +185,7 @@ const createDraft = (): WritableStockMovementDraft => ({
         image: {
           name: "produto.png",
           type: "image/png",
-          dataUrl: "data:image/png;base64,YQ==",
+          blob: new Blob(["a"], { type: "image/png" }),
         },
       },
     },
@@ -309,17 +309,46 @@ describe("create-stock-movement.storage", () => {
     expect(fakeIndexedDb.getStoredDraft()).toBeUndefined();
   });
 
-  it("preserva imagem inline em dataUrl", async () => {
+  it("preserva imagem inline em blob", async () => {
     await writeStockMovementDraft(createDraft());
 
     const draft = await readStockMovementDraft();
-    const image = draft?.items[0].newProductData?.image;
+    const savedImage = draft?.items[0].newProductData?.image;
 
-    expect(image).toEqual({
-      name: "produto.png",
-      type: "image/png",
-      dataUrl: "data:image/png;base64,YQ==",
+    expect(savedImage).toBeDefined();
+    expect(savedImage!.name).toBe("produto.png");
+    expect(savedImage!.type).toBe("image/png");
+    expect(savedImage!.blob).toBeInstanceOf(Blob);
+  });
+
+  it("rejeita draft com imagem cujo blob não é Blob", async () => {
+    fakeIndexedDb.putStoredDraft({
+      schemaVersion: STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION,
+      type: "PURCHASE_IN",
+      warehouseId: "wh-1",
+      revision: 1,
+      notes: "draft inválido",
+      items: [
+        {
+          quantity: 1,
+          productName: "Produto quebrado",
+          newProductData: {
+            name: "Produto quebrado",
+            image: {
+              name: "foto.png",
+              type: "image/png",
+              blob: "not-a-blob",
+            },
+          },
+        },
+      ],
+      selectedProductId: "",
+      itemQuantity: "",
+      updatedAt: "2026-01-20T10:00:00.000Z",
     });
+
+    expect(await readStockMovementDraft()).toBeNull();
+    expect(fakeIndexedDb.getStoredDraft()).toBeUndefined();
   });
 
   it("mantém fallback em memória quando IndexedDB falha", async () => {
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.storage.ts b/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
index 2e6d4cd..113bb41 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.storage.ts
@@ -9,7 +9,7 @@ const DRAFT_DATABASE_NAME = "stockshift";
 const DRAFT_DATABASE_VERSION = 1;
 const DRAFT_STORE_NAME = "stockMovementDrafts";
 const DRAFT_STORAGE_KEY = "current";
-export const STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION = 2;
+export const STOCK_MOVEMENT_DRAFT_SCHEMA_VERSION = 3;
 
 const createStockMovementDraftRuntimeId = (): string => {
   if (typeof globalThis.crypto?.randomUUID === "function") {
@@ -172,7 +172,7 @@ const isInlineProductImageData = (
     isRecord(value) &&
     typeof value.name === "string" &&
     typeof value.type === "string" &&
-    typeof value.dataUrl === "string"
+    value.blob instanceof Blob
   );
 };
 
@@ -355,30 +355,12 @@ export const clearStockMovementDraft = async (): Promise<void> => {
 
 export const fileToInlineProductImage = (
   file: File,
-): Promise<InlineProductImageData> => {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onerror = () => reject(new Error(`Falha ao ler a imagem ${file.name}`));
-    reader.onload = () => {
-      resolve({
-        name: file.name,
-        type: file.type,
-        dataUrl: String(reader.result),
-      });
-    };
-    reader.readAsDataURL(file);
-  });
-};
+): InlineProductImageData => ({
+  name: file.name,
+  type: file.type,
+  blob: file,
+});
 
 export const inlineProductImageToFile = (
   image: InlineProductImageData,
-): File => {
-  const [metadata, base64] = image.dataUrl.split(",");
-  const mime = metadata.match(/data:(.*);base64/)?.[1] || image.type;
-  const bytes = window.atob(base64);
-  const buffer = new Uint8Array(bytes.length);
-  for (let index = 0; index < bytes.length; index += 1) {
-    buffer[index] = bytes.charCodeAt(index);
-  }
-  return new File([buffer], image.name, { type: mime });
-};
+): File => new File([image.blob], image.name, { type: image.type });
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.types.ts b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
index f32ed17..e7e8ba1 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.types.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
@@ -21,7 +21,7 @@ export interface InlineProductData {
 export interface InlineProductImageData {
   name: string;
   type: string;
-  dataUrl: string;
+  blob: Blob;
 }
 
 export interface StockMovementDraftItem {
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
index e045acd..d6e8730 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
@@ -14,6 +14,7 @@ const mockRedirect = vi.fn((url: string): never => {
 const mockWriteDraft = vi.fn();
 const toastSuccess = vi.fn();
 const toastError = vi.fn();
+const toastWarning = vi.fn();
 
 let movementType: string | null = "PURCHASE_IN";
 let editItemQuery: string | null = null;
@@ -34,7 +35,7 @@ const brandsResponse = {
 };
 
 const createDraft = (overrides?: Partial<StockMovementDraft>): StockMovementDraft => ({
-  schemaVersion: 2,
+  schemaVersion: 3,
   updatedAt: "2026-01-20T09:00:00.000Z",
   revision: 1,
   type: "PURCHASE_IN",
@@ -105,6 +106,7 @@ vi.mock("sonner", () => ({
   toast: {
     success: (...args: unknown[]) => toastSuccess(...args),
     error: (...args: unknown[]) => toastError(...args),
+    warning: (...args: unknown[]) => toastWarning(...args),
   },
 }));
 
@@ -117,16 +119,16 @@ vi.mock("@/hooks/use-selected-warehouse", () => ({
 }));
 
 vi.mock("../create-stock-movement.storage", () => ({
-  fileToInlineProductImage: async (file: File) => ({
+  fileToInlineProductImage: (file: File) => ({
     name: file.name,
     type: file.type,
-    dataUrl: "data:application/octet-stream;base64,Yg==",
+    blob: file,
   }),
   inlineProductImageToFile: (image: {
     name: string;
     type: string;
-    dataUrl: string;
-  }) => new File(["x"], image.name, { type: image.type }),
+    blob: Blob;
+  }) => new File([image.blob], image.name, { type: image.type }),
   readStockMovementDraft: async () => currentDraft,
   mutateStockMovementDraft: async (
     buildNextDraft: (draft: StockMovementDraft) => StockMovementDraft,
@@ -260,7 +262,7 @@ describe("useNewProductInlineModel", () => {
             image: {
               name: "inline.png",
               type: "image/png",
-              dataUrl: "data:image/png;base64,YQ==",
+              blob: new Blob(["a"], { type: "image/png" }),
             },
           },
         },
@@ -316,7 +318,7 @@ describe("useNewProductInlineModel", () => {
       await result.current.onSubmit(buildFormData());
     });
 
-    expect(toastError).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
+    expect(toastWarning).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
     expect(mockWriteDraft).not.toHaveBeenCalled();
     expect(result.current.isSubmitting).toBe(false);
   });
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
index e5e3387..5e32d3c 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
@@ -83,11 +83,11 @@ const resolveInitialProductImage = (
   return product?.image ? inlineProductImageToFile(product.image) : null;
 };
 
-const buildInlineProductData = async (
+const buildInlineProductData = (
   data: ProductCreateFormData,
   attributes: Record<string, string> | undefined,
   image: File | null,
-): Promise<InlineProductData> => ({
+): InlineProductData => ({
   name: data.name,
   description: data.description || undefined,
   barcode: data.barcode || undefined,
@@ -101,7 +101,7 @@ const buildInlineProductData = async (
   expirationDate: data.expirationDate || undefined,
   costPrice: data.costPrice,
   sellingPrice: data.sellingPrice,
-  image: image ? await fileToInlineProductImage(image) : undefined,
+  image: image ? fileToInlineProductImage(image) : undefined,
 });
 
 const buildInlineMovementItem = (
@@ -407,14 +407,14 @@ export const useNewProductInlineModel = ({
       return !attr.key.trim() || !attr.value.trim();
     });
     if (invalidIndex >= 0) {
-      toast.error(`Atributo ${invalidIndex + 1}: Nome e valor são obrigatórios`);
+      toast.warning(`Atributo ${invalidIndex + 1}: Nome e valor são obrigatórios`);
       return false;
     }
 
     const keys = customAttributes.map((attr) => attr.key.trim().toLowerCase());
     const duplicate = keys.find((key, index) => keys.indexOf(key) !== index);
     if (duplicate) {
-      toast.error(`Já existe um atributo com o nome "${duplicate}"`);
+      toast.warning(`Já existe um atributo com o nome "${duplicate}"`);
       return false;
     }
 
@@ -601,7 +601,7 @@ export const useNewProductInlineModel = ({
   const saveInlineProductToDraft = async (
     data: ProductCreateFormData,
   ): Promise<void> => {
-    const product = await buildInlineProductData(
+    const product = buildInlineProductData(
       data,
       mergeAttributes(data),
       productImage,

From d6dadb74a3eafad7dde5707b25f6882f014769e6 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:31:33 -0300
Subject: [PATCH 13/32] refactor(stock-movements): extract payload builders
 from model

---
 .../create-stock-movement.model.test.ts       |   2 +-
 .../create/create-stock-movement.model.ts     | 153 +-----------------
 .../create/create-stock-movement.payload.ts   | 144 +++++++++++++++++
 3 files changed, 153 insertions(+), 146 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/create-stock-movement.payload.ts

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index 3b09a78..a138eb9 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -2,12 +2,12 @@ import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { useCreateStockMovementModel } from "./create-stock-movement.model";
 import {
-  buildMovementPayload,
   buildStockMovementProductSearchUrl,
   formatStockMovementProductLabel,
   mapStockMovementProductOptions,
   shouldShowStockMovementFooter,
 } from "./create-stock-movement.model";
+import { buildMovementPayload } from "./create-stock-movement.payload";
 import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
 import type {
   StockMovementDraft,
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index c9de2af..95beb29 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -24,12 +24,16 @@ import {
 } from "../stock-movements.constants";
 import {
   clearStockMovementDraft,
-  inlineProductImageToFile,
   isStockMovementDraftRecoveredFromPreviousRuntime,
   readStockMovementDraft,
   writeStockMovementDraft,
 } from "./create-stock-movement.storage";
 import type { WritableStockMovementDraft } from "./create-stock-movement.storage";
+import {
+  buildMovementPayload,
+  resolveExistingProductBatchQuantity,
+  uploadInlineProductImages,
+} from "./create-stock-movement.payload";
 import {
   buildExistingProductBatchesUrl,
   buildExistingProductProfitSummary,
@@ -48,147 +52,6 @@ import {
 } from "./stock-movement-draft-guards";
 import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
 
-const resolveExistingProductBatchQuantity = (value: string): number => {
-  const quantity = Number(value);
-  return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
-};
-
-const buildExistingProductItemPayload = (
-  item: CreateStockMovementSchema["items"][number],
-): ExistingProductMovementPayload => {
-  const payload: {
-    productId: string | undefined;
-    quantity: number;
-    manufacturedDate?: string;
-    expirationDate?: string;
-    costPrice?: number;
-    sellingPrice?: number;
-  } = { productId: item.productId, quantity: item.quantity };
-
-  const manufacturedDate = getOptionalText(item.manufacturedDate);
-  const expirationDate = getOptionalText(item.expirationDate);
-  if (manufacturedDate) payload.manufacturedDate = manufacturedDate;
-  if (expirationDate) payload.expirationDate = expirationDate;
-  if (item.costPrice !== undefined) payload.costPrice = item.costPrice;
-  if (item.sellingPrice !== undefined) payload.sellingPrice = item.sellingPrice;
-  return payload;
-};
-
-interface ExistingProductMovementPayload {
-  productId: string | undefined;
-  quantity: number;
-  manufacturedDate?: string;
-  expirationDate?: string;
-  costPrice?: number;
-  sellingPrice?: number;
-}
-
-interface NewProductMovementPayload {
-  quantity: number;
-  newProduct: {
-    name: string;
-    description?: string;
-    barcode?: string;
-    categoryId?: string;
-    brandId?: string;
-    isKit?: boolean;
-    hasExpiration: boolean;
-    active?: boolean;
-    attributes?: Record<string, string>;
-  };
-  manufacturedDate?: string;
-  expirationDate?: string;
-  costPrice?: number;
-  sellingPrice?: number;
-  imageUploadId?: string;
-}
-
-type MovementItemPayload =
-  | ExistingProductMovementPayload
-  | NewProductMovementPayload;
-
-interface StockMovementPayload {
-  type: NonNullable<CreateStockMovementSchema["type"]>;
-  notes?: string;
-  items: MovementItemPayload[];
-}
-
-const buildMovementItemPayload = (
-  item: CreateStockMovementSchema["items"][number],
-): MovementItemPayload => {
-  if (!item.newProductData) return buildExistingProductItemPayload(item);
-  const newProduct = {
-    name: item.newProductData.name,
-    description: item.newProductData.description,
-    barcode: item.newProductData.barcode,
-    categoryId: item.newProductData.categoryId,
-    brandId: item.newProductData.brandId,
-    isKit: item.newProductData.isKit,
-    hasExpiration: Boolean(item.newProductData.expirationDate),
-    active: item.newProductData.active,
-    attributes: item.newProductData.attributes,
-  };
-  return {
-    quantity: item.quantity,
-    newProduct,
-    manufacturedDate: getOptionalText(item.newProductData.manufacturedDate),
-    expirationDate: getOptionalText(item.newProductData.expirationDate),
-    costPrice: item.newProductData.costPrice,
-    sellingPrice: item.newProductData.sellingPrice,
-  };
-};
-
-export const buildMovementPayload = (
-  selectedMovementType: NonNullable<CreateStockMovementSchema["type"]>,
-  data: CreateStockMovementSchema,
-): StockMovementPayload => ({
-  type: selectedMovementType,
-  notes: data.notes || undefined,
-  items: data.items.map(buildMovementItemPayload),
-});
-
-interface TemporaryProductImageUploadResponse {
-  success: boolean;
-  data: {
-    uploadId: string;
-    fileName: string;
-    contentType: string;
-    sizeBytes: number;
-  };
-}
-
-const uploadTemporaryInlineProductImage = async (
-  image: NonNullable<
-    NonNullable<CreateStockMovementSchema["items"][number]["newProductData"]>["image"]
-  >,
-): Promise<string> => {
-  const formData = new FormData();
-  formData.append("image", inlineProductImageToFile(image));
-  const response = await api
-    .post("uploads/product-images/temp", { body: formData })
-    .json<TemporaryProductImageUploadResponse>();
-  return response.data.uploadId;
-};
-
-const uploadInlineProductImages = async (
-  payload: StockMovementPayload,
-  items: CreateStockMovementSchema["items"],
-): Promise<StockMovementPayload> => {
-  const movementItems = [...payload.items];
-  for (const [index, formItem] of items.entries()) {
-    if (!formItem.newProductData?.image) continue;
-    const itemPayload = movementItems[index];
-    if (!("newProduct" in itemPayload)) continue;
-    movementItems[index] = {
-      ...itemPayload,
-      imageUploadId: await uploadTemporaryInlineProductImage(
-        formItem.newProductData.image,
-      ),
-    };
-  }
-  return { ...payload, items: movementItems };
-};
-
 interface ProductListResponse {
   success: boolean;
   data:
@@ -795,7 +658,7 @@ export function useCreateStockMovementModel({
     setAddItemError(null);
 
     if (!selectedMovementType) {
-      toast.error("Selecione o tipo de movimentação antes de continuar.");
+      toast.warning("Selecione o tipo de movimentação antes de continuar.");
       router.replace("/stock-movements");
       return;
     }
@@ -885,7 +748,7 @@ export function useCreateStockMovementModel({
     }
 
     if (hasExistingProductAlreadyAdded(product.id)) {
-      toast.error(`${product.name} já está na movimentação.`);
+      toast.warning(`${product.name} já está na movimentação.`);
       return;
     }
 
@@ -947,7 +810,7 @@ export function useCreateStockMovementModel({
 
   const onSubmit = async (data: CreateStockMovementSchema) => {
     if (!selectedMovementType) {
-      toast.error("Selecione o tipo de movimentação antes de continuar.");
+      toast.warning("Selecione o tipo de movimentação antes de continuar.");
       router.replace("/stock-movements");
       return;
     }
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.payload.ts b/app/(pages)/stock-movements/create/create-stock-movement.payload.ts
new file mode 100644
index 0000000..e54d2aa
--- /dev/null
+++ b/app/(pages)/stock-movements/create/create-stock-movement.payload.ts
@@ -0,0 +1,144 @@
+import { api } from "@/lib/api";
+import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
+import { getOptionalText } from "./stock-movement-batch-form-validation";
+import { inlineProductImageToFile } from "./create-stock-movement.storage";
+import type { InlineProductImageData } from "./create-stock-movement.types";
+
+interface ExistingProductMovementPayload {
+  productId: string | undefined;
+  quantity: number;
+  manufacturedDate?: string;
+  expirationDate?: string;
+  costPrice?: number;
+  sellingPrice?: number;
+}
+
+interface NewProductMovementPayload {
+  quantity: number;
+  newProduct: {
+    name: string;
+    description?: string;
+    barcode?: string;
+    categoryId?: string;
+    brandId?: string;
+    isKit?: boolean;
+    hasExpiration: boolean;
+    active?: boolean;
+    attributes?: Record<string, string>;
+  };
+  manufacturedDate?: string;
+  expirationDate?: string;
+  costPrice?: number;
+  sellingPrice?: number;
+  imageUploadId?: string;
+}
+
+type MovementItemPayload =
+  | ExistingProductMovementPayload
+  | NewProductMovementPayload;
+
+interface StockMovementPayload {
+  type: NonNullable<CreateStockMovementSchema["type"]>;
+  notes?: string;
+  items: MovementItemPayload[];
+}
+
+export const resolveExistingProductBatchQuantity = (value: string): number => {
+  const quantity = Number(value);
+  return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
+};
+
+const buildExistingProductItemPayload = (
+  item: CreateStockMovementSchema["items"][number],
+): ExistingProductMovementPayload => {
+  const payload: {
+    productId: string | undefined;
+    quantity: number;
+    manufacturedDate?: string;
+    expirationDate?: string;
+    costPrice?: number;
+    sellingPrice?: number;
+  } = { productId: item.productId, quantity: item.quantity };
+
+  const manufacturedDate = getOptionalText(item.manufacturedDate);
+  const expirationDate = getOptionalText(item.expirationDate);
+  if (manufacturedDate) payload.manufacturedDate = manufacturedDate;
+  if (expirationDate) payload.expirationDate = expirationDate;
+  if (item.costPrice !== undefined) payload.costPrice = item.costPrice;
+  if (item.sellingPrice !== undefined) payload.sellingPrice = item.sellingPrice;
+  return payload;
+};
+
+const buildMovementItemPayload = (
+  item: CreateStockMovementSchema["items"][number],
+): MovementItemPayload => {
+  if (!item.newProductData) return buildExistingProductItemPayload(item);
+  const newProduct = {
+    name: item.newProductData.name,
+    description: item.newProductData.description,
+    barcode: item.newProductData.barcode,
+    categoryId: item.newProductData.categoryId,
+    brandId: item.newProductData.brandId,
+    isKit: item.newProductData.isKit,
+    hasExpiration: Boolean(item.newProductData.expirationDate),
+    active: item.newProductData.active,
+    attributes: item.newProductData.attributes,
+  };
+  return {
+    quantity: item.quantity,
+    newProduct,
+    manufacturedDate: getOptionalText(item.newProductData.manufacturedDate),
+    expirationDate: getOptionalText(item.newProductData.expirationDate),
+    costPrice: item.newProductData.costPrice,
+    sellingPrice: item.newProductData.sellingPrice,
+  };
+};
+
+export const buildMovementPayload = (
+  selectedMovementType: NonNullable<CreateStockMovementSchema["type"]>,
+  data: CreateStockMovementSchema,
+): StockMovementPayload => ({
+  type: selectedMovementType,
+  notes: data.notes || undefined,
+  items: data.items.map(buildMovementItemPayload),
+});
+
+interface TemporaryProductImageUploadResponse {
+  success: boolean;
+  data: {
+    uploadId: string;
+    fileName: string;
+    contentType: string;
+    sizeBytes: number;
+  };
+}
+
+const uploadTemporaryInlineProductImage = async (
+  image: InlineProductImageData,
+): Promise<string> => {
+  const formData = new FormData();
+  formData.append("image", inlineProductImageToFile(image));
+  const response = await api
+    .post("uploads/product-images/temp", { body: formData })
+    .json<TemporaryProductImageUploadResponse>();
+  return response.data.uploadId;
+};
+
+export const uploadInlineProductImages = async (
+  payload: StockMovementPayload,
+  items: CreateStockMovementSchema["items"],
+): Promise<StockMovementPayload> => {
+  const movementItems = [...payload.items];
+  for (const [index, formItem] of items.entries()) {
+    if (!formItem.newProductData?.image) continue;
+    const itemPayload = movementItems[index];
+    if (!("newProduct" in itemPayload)) continue;
+    movementItems[index] = {
+      ...itemPayload,
+      imageUploadId: await uploadTemporaryInlineProductImage(
+        formItem.newProductData.image,
+      ),
+    };
+  }
+  return { ...payload, items: movementItems };
+};

From 2fd4e6925a2c1180646db78d1f69af319f532e3c Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:33:04 -0300
Subject: [PATCH 14/32] refactor(stock-movements): extract product options and
 footer helpers from model

---
 .../create-stock-movement.model.test.ts       |  4 +-
 .../create/create-stock-movement.model.ts     | 62 +++----------------
 .../create/stock-movement-product-options.ts  | 55 ++++++++++++++++
 3 files changed, 65 insertions(+), 56 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/stock-movement-product-options.ts

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index a138eb9..a1480c9 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -1,13 +1,13 @@
 import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { useCreateStockMovementModel } from "./create-stock-movement.model";
+import { buildMovementPayload } from "./create-stock-movement.payload";
 import {
   buildStockMovementProductSearchUrl,
   formatStockMovementProductLabel,
   mapStockMovementProductOptions,
   shouldShowStockMovementFooter,
-} from "./create-stock-movement.model";
-import { buildMovementPayload } from "./create-stock-movement.payload";
+} from "./stock-movement-product-options";
 import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
 import type {
   StockMovementDraft,
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index 95beb29..a259114 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -51,20 +51,19 @@ import {
   hasExistingProductInItems,
 } from "./stock-movement-draft-guards";
 import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
-
-interface ProductListResponse {
-  success: boolean;
-  data:
-    | { content: StockMovementProductOption[] }
-    | StockMovementProductOption[];
-}
+import {
+  buildStockMovementProductSearchUrl,
+  formatStockMovementProductLabel,
+  mapStockMovementProductOptions,
+  PRODUCT_SEARCH_LIMIT,
+  shouldShowStockMovementFooter,
+  type ProductListResponse,
+} from "./stock-movement-product-options";
 
 interface CreateStockMovementModelParams {
   typeParam?: string | null;
 }
 
-const PRODUCT_SEARCH_LIMIT = 5;
-
 const EMPTY_EXISTING_BATCH_FORM: ExistingProductBatchFormState = {
   isOpen: false,
   productId: "",
@@ -76,51 +75,6 @@ const EMPTY_EXISTING_BATCH_FORM: ExistingProductBatchFormState = {
   error: null,
 };
 
-interface FooterVisibilityParams {
-  currentScrollY: number;
-  lastScrollY: number;
-  maxScrollY: number;
-}
-
-export const shouldShowStockMovementFooter = ({
-  currentScrollY,
-  lastScrollY,
-  maxScrollY,
-}: FooterVisibilityParams): boolean => {
-  const isShortPage = maxScrollY <= 8;
-  const isAtPageEnd = currentScrollY >= maxScrollY - 8;
-  const isScrollingUp = currentScrollY < lastScrollY;
-  return isShortPage || isAtPageEnd || isScrollingUp;
-};
-
-export const formatStockMovementProductLabel = (
-  product: StockMovementProductOption,
-): string => (product.sku ? `${product.name} (${product.sku})` : product.name);
-
-export const mapStockMovementProductOptions = (
-  response: ProductListResponse | null | undefined,
-): StockMovementProductOption[] => {
-  const rawProducts = response?.data;
-  const productList = Array.isArray(rawProducts)
-    ? rawProducts
-    : rawProducts?.content || [];
-  return productList.map((product) => ({
-    id: product.id,
-    name: product.name,
-    sku: product.sku,
-    barcode: product.barcode,
-    imageUrl: product.imageUrl,
-  }));
-};
-
-export const buildStockMovementProductSearchUrl = (
-  query: string,
-): string | null => {
-  const normalizedQuery = query.trim();
-  if (normalizedQuery.length < 2) return null;
-  return `products/search?q=${encodeURIComponent(normalizedQuery)}`;
-};
-
 export function useCreateStockMovementModel({
   typeParam = null,
 }: CreateStockMovementModelParams = {}): CreateStockMovementViewProps {
diff --git a/app/(pages)/stock-movements/create/stock-movement-product-options.ts b/app/(pages)/stock-movements/create/stock-movement-product-options.ts
new file mode 100644
index 0000000..4cb4764
--- /dev/null
+++ b/app/(pages)/stock-movements/create/stock-movement-product-options.ts
@@ -0,0 +1,55 @@
+import type { StockMovementProductOption } from "./create-stock-movement.types";
+
+export interface ProductListResponse {
+  success: boolean;
+  data:
+    | { content: StockMovementProductOption[] }
+    | StockMovementProductOption[];
+}
+
+export const PRODUCT_SEARCH_LIMIT = 5;
+
+interface FooterVisibilityParams {
+  currentScrollY: number;
+  lastScrollY: number;
+  maxScrollY: number;
+}
+
+export const shouldShowStockMovementFooter = ({
+  currentScrollY,
+  lastScrollY,
+  maxScrollY,
+}: FooterVisibilityParams): boolean => {
+  const isShortPage = maxScrollY <= 8;
+  const isAtPageEnd = currentScrollY >= maxScrollY - 8;
+  const isScrollingUp = currentScrollY < lastScrollY;
+  return isShortPage || isAtPageEnd || isScrollingUp;
+};
+
+export const formatStockMovementProductLabel = (
+  product: StockMovementProductOption,
+): string => (product.sku ? `${product.name} (${product.sku})` : product.name);
+
+export const mapStockMovementProductOptions = (
+  response: ProductListResponse | null | undefined,
+): StockMovementProductOption[] => {
+  const rawProducts = response?.data;
+  const productList = Array.isArray(rawProducts)
+    ? rawProducts
+    : rawProducts?.content || [];
+  return productList.map((product) => ({
+    id: product.id,
+    name: product.name,
+    sku: product.sku,
+    barcode: product.barcode,
+    imageUrl: product.imageUrl,
+  }));
+};
+
+export const buildStockMovementProductSearchUrl = (
+  query: string,
+): string | null => {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery.length < 2) return null;
+  return `products/search?q=${encodeURIComponent(normalizedQuery)}`;
+};

From ad11fd754732ee5d6f62ab9b08f9783baf046823 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:38:34 -0300
Subject: [PATCH 15/32] refactor(stock-movements): extract draft persistence
 hook from model

---
 .../create/create-stock-movement.model.ts     | 144 +++------------
 ...-stock-movement-draft-persistence.model.ts | 174 ++++++++++++++++++
 2 files changed, 196 insertions(+), 122 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/use-stock-movement-draft-persistence.model.ts

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index a259114..f2aa736 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -24,11 +24,7 @@ import {
 } from "../stock-movements.constants";
 import {
   clearStockMovementDraft,
-  isStockMovementDraftRecoveredFromPreviousRuntime,
-  readStockMovementDraft,
-  writeStockMovementDraft,
 } from "./create-stock-movement.storage";
-import type { WritableStockMovementDraft } from "./create-stock-movement.storage";
 import {
   buildMovementPayload,
   resolveExistingProductBatchQuantity,
@@ -59,6 +55,7 @@ import {
   shouldShowStockMovementFooter,
   type ProductListResponse,
 } from "./stock-movement-product-options";
+import { useStockMovementDraftPersistence } from "./use-stock-movement-draft-persistence.model";
 
 interface CreateStockMovementModelParams {
   typeParam?: string | null;
@@ -100,9 +97,6 @@ export function useCreateStockMovementModel({
   const lastScrollYRef = useRef(0);
   const productSearchBlurTimeoutRef =
     useRef<ReturnType<typeof setTimeout> | null>(null);
-  const inlineProductBarcodeRef = useRef<string | undefined>(undefined);
-  const draftRevisionRef = useRef(0);
-  const persistQueueRef = useRef<Promise<void>>(Promise.resolve());
   const selectedMovementType = isManualMovementType(typeParam)
     ? typeParam
     : undefined;
@@ -133,43 +127,27 @@ export function useCreateStockMovementModel({
     name: "items",
   });
 
-  const [isDraftHydrated, setIsDraftHydrated] = useState(false);
-
-  useEffect(() => {
-    let isMounted = true;
-
-    const hydrateDraft = async (): Promise<void> => {
-      if (!selectedMovementType) {
-        setIsDraftHydrated(true);
-        return;
-      }
-
-      const draft = await readStockMovementDraft();
-      if (!isMounted) return;
-
-      draftRevisionRef.current = draft?.revision ?? 0;
-      if (draft?.type === selectedMovementType && draft.warehouseId === warehouseId) {
-        form.reset({
-          type: draft.type,
-          notes: draft.notes,
-          items: draft.items,
-        });
-        setSelectedProductId(draft.selectedProductId);
-        setItemQuantity(draft.itemQuantity);
-        inlineProductBarcodeRef.current = draft.inlineProductBarcode;
-        if (isStockMovementDraftRecoveredFromPreviousRuntime(draft)) {
-          toast.success("Rascunho da movimentação restaurado.");
-        }
-      }
-
-      setIsDraftHydrated(true);
-    };
+  const handleDraftRestored = useCallback(
+    ({ selectedProductId: restoredId, itemQuantity: restoredQty }: { selectedProductId: string; itemQuantity: string }) => {
+      setSelectedProductId(restoredId);
+      setItemQuantity(restoredQty);
+    },
+    [],
+  );
 
-    void hydrateDraft();
-    return () => {
-      isMounted = false;
-    };
-  }, [form, selectedMovementType, warehouseId]);
+  const {
+    isDraftHydrated,
+    persistCurrentDraft,
+    inlineProductBarcodeRef,
+    resetDraftRevision,
+  } = useStockMovementDraftPersistence({
+    form,
+    selectedMovementType,
+    warehouseId,
+    selectedProductId,
+    itemQuantity,
+    onDraftRestored: handleDraftRestored,
+  });
 
   const { data: productsData, isLoading: isLoadingProducts } =
     useSWR<ProductListResponse>("products", (url: string) =>
@@ -226,84 +204,6 @@ export function useCreateStockMovementModel({
     setProductSearchQuery(formatStockMovementProductLabel(restoredProduct));
   }, [productSearchQuery, products, selectedProductId]);
 
-  const buildCurrentDraft = useCallback(
-    (inlineProductBarcode = inlineProductBarcodeRef.current): WritableStockMovementDraft | null => {
-      if (!selectedMovementType) return null;
-      return {
-        type: selectedMovementType,
-        warehouseId,
-        notes: form.getValues("notes") || "",
-        items: form.getValues("items"),
-        selectedProductId,
-        itemQuantity,
-        inlineProductBarcode,
-      };
-    },
-    [form, itemQuantity, selectedMovementType, selectedProductId, warehouseId],
-  );
-
-  const persistCurrentDraft = useCallback(
-    (inlineProductBarcode = inlineProductBarcodeRef.current): Promise<void> => {
-      const draft = buildCurrentDraft(inlineProductBarcode);
-      if (!draft) return Promise.resolve();
-
-      const queuedWrite = persistQueueRef.current.then(async () => {
-        const writeResult = await writeStockMovementDraft(
-          draft,
-          draftRevisionRef.current,
-        );
-        draftRevisionRef.current = writeResult.revision;
-      });
-      persistQueueRef.current = queuedWrite.catch(() => undefined);
-      return queuedWrite;
-    },
-    [buildCurrentDraft],
-  );
-
-  useEffect(() => {
-    if (!isDraftHydrated || !selectedMovementType) return;
-    void persistCurrentDraft();
-  }, [
-    isDraftHydrated,
-    itemQuantity,
-    persistCurrentDraft,
-    selectedMovementType,
-    selectedProductId,
-  ]);
-
-  useEffect(() => {
-    if (!isDraftHydrated || !selectedMovementType) return;
-
-    const subscription = form.watch((_value, { name }) => {
-      if (!name || (name !== "notes" && !name.startsWith("items"))) return;
-      void persistCurrentDraft();
-    });
-
-    return () => subscription.unsubscribe();
-  }, [form, isDraftHydrated, persistCurrentDraft, selectedMovementType]);
-
-  useEffect(() => {
-    if (!isDraftHydrated || !selectedMovementType) return;
-
-    const persistBeforePageHide = (): void => {
-      void persistCurrentDraft();
-    };
-    const persistBeforeVisibilityLoss = (): void => {
-      if (document.visibilityState !== "hidden") return;
-      void persistCurrentDraft();
-    };
-
-    window.addEventListener("pagehide", persistBeforePageHide);
-    document.addEventListener("visibilitychange", persistBeforeVisibilityLoss);
-    return () => {
-      window.removeEventListener("pagehide", persistBeforePageHide);
-      document.removeEventListener(
-        "visibilitychange",
-        persistBeforeVisibilityLoss,
-      );
-    };
-  }, [isDraftHydrated, persistCurrentDraft, selectedMovementType]);
-
   useEffect(() => {
     const timeoutId = setTimeout(() => {
       setDebouncedProductSearchQuery(productSearchQuery);
@@ -782,7 +682,7 @@ export function useCreateStockMovementModel({
 
       setSubmittingStep("Finalizando…");
       await clearStockMovementDraft();
-      draftRevisionRef.current = 0;
+      resetDraftRevision();
       toast.success("Movimentação criada com sucesso!");
       router.push("/stock-movements");
     } catch (err: unknown) {
diff --git a/app/(pages)/stock-movements/create/use-stock-movement-draft-persistence.model.ts b/app/(pages)/stock-movements/create/use-stock-movement-draft-persistence.model.ts
new file mode 100644
index 0000000..c1970e4
--- /dev/null
+++ b/app/(pages)/stock-movements/create/use-stock-movement-draft-persistence.model.ts
@@ -0,0 +1,174 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { UseFormReturn } from "react-hook-form";
+import { toast } from "sonner";
+
+import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
+import type { ManualMovementType } from "../stock-movements.constants";
+import {
+  isStockMovementDraftRecoveredFromPreviousRuntime,
+  readStockMovementDraft,
+  writeStockMovementDraft,
+} from "./create-stock-movement.storage";
+import type { WritableStockMovementDraft } from "./create-stock-movement.storage";
+
+interface StockMovementDraftRestoredData {
+  selectedProductId: string;
+  itemQuantity: string;
+}
+
+interface StockMovementDraftPersistenceParams {
+  form: UseFormReturn<CreateStockMovementSchema>;
+  selectedMovementType: ManualMovementType | undefined;
+  warehouseId: string | null;
+  selectedProductId: string;
+  itemQuantity: string;
+  onDraftRestored: (data: StockMovementDraftRestoredData) => void;
+}
+
+interface StockMovementDraftPersistence {
+  isDraftHydrated: boolean;
+  persistCurrentDraft: (inlineProductBarcode?: string) => Promise<void>;
+  inlineProductBarcodeRef: React.MutableRefObject<string | undefined>;
+  resetDraftRevision: () => void;
+}
+
+export function useStockMovementDraftPersistence({
+  form,
+  selectedMovementType,
+  warehouseId,
+  selectedProductId,
+  itemQuantity,
+  onDraftRestored,
+}: StockMovementDraftPersistenceParams): StockMovementDraftPersistence {
+  const [isDraftHydrated, setIsDraftHydrated] = useState(false);
+  const inlineProductBarcodeRef = useRef<string | undefined>(undefined);
+  const draftRevisionRef = useRef(0);
+  const persistQueueRef = useRef<Promise<void>>(Promise.resolve());
+
+  useEffect(() => {
+    let isMounted = true;
+
+    const hydrateDraft = async (): Promise<void> => {
+      if (!selectedMovementType) {
+        setIsDraftHydrated(true);
+        return;
+      }
+
+      const draft = await readStockMovementDraft();
+      if (!isMounted) return;
+
+      draftRevisionRef.current = draft?.revision ?? 0;
+      if (draft?.type === selectedMovementType && draft.warehouseId === warehouseId) {
+        form.reset({
+          type: draft.type,
+          notes: draft.notes,
+          items: draft.items,
+        });
+        onDraftRestored({
+          selectedProductId: draft.selectedProductId,
+          itemQuantity: draft.itemQuantity,
+        });
+        inlineProductBarcodeRef.current = draft.inlineProductBarcode;
+        if (isStockMovementDraftRecoveredFromPreviousRuntime(draft)) {
+          toast.success("Rascunho da movimentação restaurado.");
+        }
+      }
+
+      setIsDraftHydrated(true);
+    };
+
+    void hydrateDraft();
+    return () => {
+      isMounted = false;
+    };
+  }, [form, selectedMovementType, warehouseId, onDraftRestored]);
+
+  const buildCurrentDraft = useCallback(
+    (inlineProductBarcode = inlineProductBarcodeRef.current): WritableStockMovementDraft | null => {
+      if (!selectedMovementType) return null;
+      return {
+        type: selectedMovementType,
+        warehouseId,
+        notes: form.getValues("notes") || "",
+        items: form.getValues("items"),
+        selectedProductId,
+        itemQuantity,
+        inlineProductBarcode,
+      };
+    },
+    [form, itemQuantity, selectedMovementType, selectedProductId, warehouseId],
+  );
+
+  const persistCurrentDraft = useCallback(
+    (inlineProductBarcode = inlineProductBarcodeRef.current): Promise<void> => {
+      const draft = buildCurrentDraft(inlineProductBarcode);
+      if (!draft) return Promise.resolve();
+
+      const queuedWrite = persistQueueRef.current.then(async () => {
+        const writeResult = await writeStockMovementDraft(
+          draft,
+          draftRevisionRef.current,
+        );
+        draftRevisionRef.current = writeResult.revision;
+      });
+      persistQueueRef.current = queuedWrite.catch(() => undefined);
+      return queuedWrite;
+    },
+    [buildCurrentDraft],
+  );
+
+  useEffect(() => {
+    if (!isDraftHydrated || !selectedMovementType) return;
+    void persistCurrentDraft();
+  }, [
+    isDraftHydrated,
+    itemQuantity,
+    persistCurrentDraft,
+    selectedMovementType,
+    selectedProductId,
+  ]);
+
+  useEffect(() => {
+    if (!isDraftHydrated || !selectedMovementType) return;
+
+    const subscription = form.watch((_value, { name }) => {
+      if (!name || (name !== "notes" && !name.startsWith("items"))) return;
+      void persistCurrentDraft();
+    });
+
+    return () => subscription.unsubscribe();
+  }, [form, isDraftHydrated, persistCurrentDraft, selectedMovementType]);
+
+  useEffect(() => {
+    if (!isDraftHydrated || !selectedMovementType) return;
+
+    const persistBeforePageHide = (): void => {
+      void persistCurrentDraft();
+    };
+    const persistBeforeVisibilityLoss = (): void => {
+      if (document.visibilityState !== "hidden") return;
+      void persistCurrentDraft();
+    };
+
+    window.addEventListener("pagehide", persistBeforePageHide);
+    document.addEventListener("visibilitychange", persistBeforeVisibilityLoss);
+    return () => {
+      window.removeEventListener("pagehide", persistBeforePageHide);
+      document.removeEventListener(
+        "visibilitychange",
+        persistBeforeVisibilityLoss,
+      );
+    };
+  }, [isDraftHydrated, persistCurrentDraft, selectedMovementType]);
+
+  const resetDraftRevision = useCallback((): void => {
+    draftRevisionRef.current = 0;
+  }, []);
+
+  return {
+    isDraftHydrated,
+    persistCurrentDraft,
+    inlineProductBarcodeRef,
+    resetDraftRevision,
+  };
+}

From 949c74a7e05cf592bd90f1c2da170d8214a00ba0 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 10 Jun 2026 15:55:03 -0300
Subject: [PATCH 16/32] refactor(stock-movements): extract batch form and
 scanner hooks from model

---
 .../create/create-stock-movement.model.ts     | 427 ++++--------------
 .../use-existing-product-batch-form.model.ts  | 219 +++++++++
 .../use-stock-movement-scanner.model.ts       | 246 ++++++++++
 3 files changed, 549 insertions(+), 343 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/use-existing-product-batch-form.model.ts
 create mode 100644 app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index f2aa736..71faf73 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -12,7 +12,6 @@ import {
 } from "./create-stock-movement.schema";
 import {
   CreateStockMovementViewProps,
-  ExistingProductBatchFormState,
   StockMovementProductBatchesResponse,
   StockMovementProductOption,
 } from "./create-stock-movement.types";
@@ -20,14 +19,12 @@ import { useBreadcrumb } from "@/components/breadcrumb";
 import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
 import {
   isManualMovementType,
-  MANUAL_IN_MOVEMENT_TYPES,
 } from "../stock-movements.constants";
 import {
   clearStockMovementDraft,
 } from "./create-stock-movement.storage";
 import {
   buildMovementPayload,
-  resolveExistingProductBatchQuantity,
   uploadInlineProductImages,
 } from "./create-stock-movement.payload";
 import {
@@ -38,15 +35,9 @@ import {
   findMostRecentWarehouseProductBatch,
 } from "./stock-movement-batch-pricing.model";
 import {
-  getOptionalText,
-  validateExistingProductBatchForm,
-} from "./stock-movement-batch-form-validation";
-import {
-  buildRepeatedProductBatchWarning,
   getPendingInlineProductBarcodeConflictError,
   hasExistingProductInItems,
 } from "./stock-movement-draft-guards";
-import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
 import {
   buildStockMovementProductSearchUrl,
   formatStockMovementProductLabel,
@@ -56,22 +47,13 @@ import {
   type ProductListResponse,
 } from "./stock-movement-product-options";
 import { useStockMovementDraftPersistence } from "./use-stock-movement-draft-persistence.model";
+import { useExistingProductBatchForm } from "./use-existing-product-batch-form.model";
+import { isSelectedInMovement, useStockMovementScanner } from "./use-stock-movement-scanner.model";
 
 interface CreateStockMovementModelParams {
   typeParam?: string | null;
 }
 
-const EMPTY_EXISTING_BATCH_FORM: ExistingProductBatchFormState = {
-  isOpen: false,
-  productId: "",
-  productName: "",
-  quantity: "",
-  manufacturedDate: "",
-  expirationDate: "",
-  editingIndex: null,
-  error: null,
-};
-
 export function useCreateStockMovementModel({
   typeParam = null,
 }: CreateStockMovementModelParams = {}): CreateStockMovementViewProps {
@@ -88,12 +70,7 @@ export function useCreateStockMovementModel({
   const [isProductOptionsOpen, setIsProductOptionsOpen] = useState(false);
   const [itemQuantity, setItemQuantity] = useState("");
   const [addItemError, setAddItemError] = useState<string | null>(null);
-  const [isScannerOpen, setIsScannerOpen] = useState(false);
   const [isFooterVisible, setIsFooterVisible] = useState(false);
-  const [missingProductBarcode, setMissingProductBarcode] = useState<string | null>(null);
-  const [existingProductBatchForm, setExistingProductBatchForm] =
-    useState<ExistingProductBatchFormState>(EMPTY_EXISTING_BATCH_FORM);
-  const lastScannedBarcodeRef = useRef<string | null>(null);
   const lastScrollYRef = useRef(0);
   const productSearchBlurTimeoutRef =
     useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -136,7 +113,6 @@ export function useCreateStockMovementModel({
   );
 
   const {
-    isDraftHydrated,
     persistCurrentDraft,
     inlineProductBarcodeRef,
     resetDraftRevision,
@@ -154,6 +130,61 @@ export function useCreateStockMovementModel({
       api.get(url).json<ProductListResponse>(),
     );
 
+  const resetProductBuilder = (): void => {
+    setSelectedProductId("");
+    setSelectedProduct(null);
+    setProductSearchQuery("");
+    setItemQuantity("");
+  };
+
+  const salePriceSuggestionRef = useRef<{ priceCents: number } | undefined>(undefined);
+  const costPriceSuggestionRef = useRef<{ priceCents: number } | undefined>(undefined);
+
+  const {
+    existingProductBatchForm,
+    onExistingProductBatchOpenChange,
+    onExistingProductBatchQuantityChange,
+    onExistingProductBatchQuantityIncrement,
+    onExistingProductBatchQuantityDecrement,
+    onExistingProductBatchManufacturedDateChange,
+    onExistingProductBatchExpirationDateChange,
+    onExistingProductBatchCostPriceChange,
+    onExistingProductBatchSellingPriceChange,
+    onApplyExistingProductCostPriceSuggestion,
+    onApplyExistingProductSalePriceSuggestion,
+    onConfirmExistingProductBatchData,
+    openExistingProductBatchForm,
+  } = useExistingProductBatchForm({
+    formItems: fields,
+    append,
+    update,
+    onItemConfirmed: resetProductBuilder,
+    salePriceSuggestionRef,
+    costPriceSuggestionRef,
+  });
+
+  const {
+    isScannerOpen,
+    setScannerOpen,
+    onBarcodeScan,
+    missingProductBarcode,
+    onMissingProductModalOpenChange,
+    onCreateProductFromMissingModal,
+    onCreateNewProduct,
+    onEditNewProductItem,
+    onEditExistingProductBatchData,
+  } = useStockMovementScanner({
+    selectedMovementType,
+    router,
+    form,
+    append,
+    persistCurrentDraft,
+    inlineProductBarcodeRef,
+    itemQuantity,
+    openExistingProductBatchForm,
+    setAddItemError,
+  });
+
   const productBatchesUrl = buildExistingProductBatchesUrl(
     warehouseId,
     existingProductBatchForm.isOpen ? existingProductBatchForm.productId : null,
@@ -184,6 +215,9 @@ export function useCreateStockMovementModel({
       !existingProductCostPriceSuggestion,
   );
 
+  salePriceSuggestionRef.current = existingProductSalePriceSuggestion ?? undefined;
+  costPriceSuggestionRef.current = existingProductCostPriceSuggestion ?? undefined;
+
   const products = mapStockMovementProductOptions(productsData);
 
   const productSearchUrl = selectedProduct
@@ -251,17 +285,11 @@ export function useCreateStockMovementModel({
     productSearchBlurTimeoutRef.current = null;
   };
 
-  const findScannedProductBarcodeConflict = (
-    barcode: string | null | undefined,
-  ): string | null => {
-    return getPendingInlineProductBarcodeConflictError(
-      form.getValues("items"),
-      barcode,
-    );
-  };
+  const findBarcodeConflict = (barcode: string | null | undefined): string | null =>
+    getPendingInlineProductBarcodeConflictError(form.getValues("items"), barcode);
 
   const handleProductSelect = (product: StockMovementProductOption) => {
-    const barcodeConflictError = findScannedProductBarcodeConflict(product.barcode);
+    const barcodeConflictError = findBarcodeConflict(product.barcode);
     if (barcodeConflictError) {
       setIsProductOptionsOpen(false);
       setAddItemError(barcodeConflictError);
@@ -274,7 +302,7 @@ export function useCreateStockMovementModel({
     setIsProductOptionsOpen(false);
     setAddItemError(null);
 
-    if (isSelectedInMovement()) {
+    if (isSelectedInMovement(selectedMovementType)) {
       openExistingProductBatchForm({
         productId: product.id,
         productName: product.name,
@@ -319,45 +347,6 @@ export function useCreateStockMovementModel({
     setAddItemError(null);
   };
 
-  const isSelectedInMovement = (): boolean => {
-    if (!selectedMovementType) return false;
-    return MANUAL_IN_MOVEMENT_TYPES.includes(
-      selectedMovementType as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
-    );
-  };
-
-  const resetProductBuilder = (): void => {
-    setSelectedProductId("");
-    setSelectedProduct(null);
-    setProductSearchQuery("");
-    setItemQuantity("");
-  };
-
-  const closeExistingProductBatchForm = (): void => {
-    setExistingProductBatchForm(EMPTY_EXISTING_BATCH_FORM);
-  };
-
-  const buildBatchRepeatedProductWarning = (
-    params: Pick<ExistingProductBatchFormState, "productId" | "productName" | "editingIndex">,
-  ): string | null => {
-    if (params.editingIndex !== null) return null;
-    if (!hasExistingProductInItems(form.getValues("items"), params.productId)) {
-      return null;
-    }
-    return buildRepeatedProductBatchWarning(params.productName);
-  };
-
-  const openExistingProductBatchForm = (
-    params: Omit<ExistingProductBatchFormState, "isOpen" | "error">,
-  ): void => {
-    setExistingProductBatchForm({
-      ...params,
-      isOpen: true,
-      error: null,
-      repeatedProductWarning: buildBatchRepeatedProductWarning(params),
-    });
-  };
-
   const appendExistingProductItem = (
     productId: string,
     productName: string,
@@ -387,13 +376,13 @@ export function useCreateStockMovementModel({
       selectedProduct || products.find((p) => p.id === selectedProductId);
     const productName = product?.name || "Produto";
 
-    const barcodeConflictError = findScannedProductBarcodeConflict(product?.barcode);
+    const barcodeConflictError = findBarcodeConflict(product?.barcode);
     if (barcodeConflictError) {
       setAddItemError(barcodeConflictError);
       return;
     }
 
-    if (isSelectedInMovement()) {
+    if (isSelectedInMovement(selectedMovementType)) {
       openExistingProductBatchForm({
         productId: selectedProductId,
         productName,
@@ -423,245 +412,6 @@ export function useCreateStockMovementModel({
     appendExistingProductItem(selectedProductId, productName, quantity);
   };
 
-  const handleExistingProductBatchOpenChange = (open: boolean): void => {
-    if (open) {
-      setExistingProductBatchForm((current) => ({ ...current, isOpen: true }));
-      return;
-    }
-    closeExistingProductBatchForm();
-  };
-
-  const updateExistingProductBatchForm = (
-    patch: Partial<ExistingProductBatchFormState>,
-  ): void => {
-    setExistingProductBatchForm((current) => ({
-      ...current,
-      ...patch,
-      error: patch.error ?? null,
-    }));
-  };
-
-  const updateExistingProductBatchQuantity = (
-    calculateNextQuantity: (quantity: number) => number,
-  ): void => {
-    setExistingProductBatchForm((current) => {
-      const currentQuantity = resolveExistingProductBatchQuantity(
-        current.quantity,
-      );
-      const nextQuantity = Math.max(calculateNextQuantity(currentQuantity), 0);
-      return {
-        ...current,
-        quantity: nextQuantity > 0 ? String(nextQuantity) : "",
-        error: null,
-      };
-    });
-  };
-
-  const handleExistingProductBatchQuantityIncrement = (): void => {
-    updateExistingProductBatchQuantity((quantity) => quantity + 1);
-  };
-
-  const handleExistingProductBatchQuantityDecrement = (): void => {
-    updateExistingProductBatchQuantity((quantity) => quantity - 1);
-  };
-
-  const handleApplyExistingProductSalePriceSuggestion = (): void => {
-    if (!existingProductSalePriceSuggestion) return;
-    updateExistingProductBatchForm({
-      sellingPrice: existingProductSalePriceSuggestion.priceCents,
-    });
-  };
-
-  const handleApplyExistingProductCostPriceSuggestion = (): void => {
-    if (!existingProductCostPriceSuggestion) return;
-    updateExistingProductBatchForm({
-      costPrice: existingProductCostPriceSuggestion.priceCents,
-    });
-  };
-
-  const buildExistingProductBatchItem = (): CreateStockMovementSchema["items"][number] => ({
-    productId: existingProductBatchForm.productId,
-    productName: existingProductBatchForm.productName,
-    quantity: Number(existingProductBatchForm.quantity),
-    manufacturedDate: getOptionalText(existingProductBatchForm.manufacturedDate),
-    expirationDate: getOptionalText(existingProductBatchForm.expirationDate),
-    costPrice: existingProductBatchForm.costPrice,
-    sellingPrice: existingProductBatchForm.sellingPrice,
-  });
-
-  const handleConfirmExistingProductBatchData = (): void => {
-    const validationError = validateExistingProductBatchForm(
-      existingProductBatchForm,
-    );
-    if (validationError) {
-      updateExistingProductBatchForm({ error: validationError });
-      return;
-    }
-
-    const item = buildExistingProductBatchItem();
-    if (existingProductBatchForm.editingIndex !== null) {
-      update(existingProductBatchForm.editingIndex, item);
-    } else {
-      append(item);
-      resetProductBuilder();
-    }
-    closeExistingProductBatchForm();
-  };
-
-  const handleCreateNewProduct = async (): Promise<void> => {
-    setAddItemError(null);
-
-    if (!selectedMovementType) {
-      toast.warning("Selecione o tipo de movimentação antes de continuar.");
-      router.replace("/stock-movements");
-      return;
-    }
-
-    if (
-      !MANUAL_IN_MOVEMENT_TYPES.includes(
-        selectedMovementType as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
-      )
-    ) {
-      setAddItemError(
-        "Novos produtos só podem ser criados em movimentações de entrada.",
-      );
-      return;
-    }
-
-    inlineProductBarcodeRef.current = undefined;
-    await persistCurrentDraft(undefined);
-    router.push(`/stock-movements/create/new-product?type=${selectedMovementType}`);
-  };
-
-  const navigateToInlineProductWithBarcode = async (
-    barcode: string,
-  ): Promise<void> => {
-    if (!selectedMovementType) return;
-
-    inlineProductBarcodeRef.current = barcode;
-    await persistCurrentDraft(barcode);
-    setIsScannerOpen(false);
-    router.push(`/stock-movements/create/new-product?type=${selectedMovementType}`);
-  };
-
-  const handleEditNewProductItem = async (index: number): Promise<void> => {
-    if (!selectedMovementType) return;
-
-    const item = form.getValues("items")[index];
-    if (!item?.newProductData) return;
-
-    inlineProductBarcodeRef.current = undefined;
-    await persistCurrentDraft(undefined);
-    router.push(
-      `/stock-movements/create/new-product?type=${selectedMovementType}&editItem=${index}`,
-    );
-  };
-
-  const handleEditExistingProductBatchData = (index: number): void => {
-    if (!isSelectedInMovement()) return;
-    const item = form.getValues("items")[index];
-    if (!item?.productId || item.newProductData) return;
-
-    openExistingProductBatchForm({
-      productId: item.productId,
-      productName: item.productName || "Produto",
-      quantity: String(item.quantity),
-      manufacturedDate: item.manufacturedDate || "",
-      expirationDate: item.expirationDate || "",
-      costPrice: item.costPrice,
-      sellingPrice: item.sellingPrice,
-      editingIndex: index,
-    });
-  };
-
-  const resolveScannerQuantity = (): number => {
-    const qty = Number(itemQuantity);
-    return qty > 0 ? qty : 1;
-  };
-
-  const appendScannedProduct = (product: StockMovementProductOption) => {
-    const barcodeConflictError = findScannedProductBarcodeConflict(product.barcode);
-    if (barcodeConflictError) {
-      toast.error(barcodeConflictError);
-      return;
-    }
-
-    if (isSelectedInMovement()) {
-      setIsScannerOpen(false);
-      openExistingProductBatchForm({
-        productId: product.id,
-        productName: product.name,
-        quantity: "",
-        manufacturedDate: "",
-        expirationDate: "",
-        costPrice: undefined,
-        sellingPrice: undefined,
-        editingIndex: null,
-      });
-      return;
-    }
-
-    if (hasExistingProductAlreadyAdded(product.id)) {
-      toast.warning(`${product.name} já está na movimentação.`);
-      return;
-    }
-
-    append({
-      productId: product.id,
-      productName: product.name,
-      quantity: resolveScannerQuantity(),
-    });
-    toast.success(`${product.name} foi adicionado.`);
-  };
-
-  const handleBarcodeScan = async (barcode: string) => {
-    if (lastScannedBarcodeRef.current === barcode) return;
-    lastScannedBarcodeRef.current = barcode;
-    window.setTimeout(() => {
-      lastScannedBarcodeRef.current = null;
-    }, 1500);
-
-    const lookup = await lookupStockMovementProductByBarcode(barcode);
-    if (lookup.status === "found") {
-      appendScannedProduct(lookup.product);
-      return;
-    }
-    if (lookup.status === "not-found") {
-      showMissingProductToast(barcode);
-      return;
-    }
-    toast.error(lookup.message);
-  };
-
-  const showMissingProductToast = (barcode: string) => {
-    if (!selectedMovementType) {
-      toast.error(`Produto com código ${barcode} não existe.`);
-      return;
-    }
-
-    const canCreateInline = MANUAL_IN_MOVEMENT_TYPES.includes(
-      selectedMovementType as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
-    );
-    if (!canCreateInline) {
-      toast.error(`Produto com código ${barcode} não existe.`);
-      return;
-    }
-
-    setMissingProductBarcode(barcode);
-  };
-
-  const handleMissingProductModalOpenChange = (open: boolean): void => {
-    if (!open) {
-      setMissingProductBarcode(null);
-    }
-  };
-
-  const handleCreateProductFromMissingModal = async (): Promise<void> => {
-    if (!missingProductBarcode) return;
-    await navigateToInlineProductWithBarcode(missingProductBarcode);
-    setMissingProductBarcode(null);
-  };
-
   const onSubmit = async (data: CreateStockMovementSchema) => {
     if (!selectedMovementType) {
       toast.warning("Selecione o tipo de movimentação antes de continuar.");
@@ -717,33 +467,24 @@ export function useCreateStockMovementModel({
     onProductClear: handleProductClear,
     onQuantityChange: setItemQuantity,
     onAddItem: handleAddItem,
-    onCreateNewProduct: handleCreateNewProduct,
-    onEditNewProductItem: handleEditNewProductItem,
-    onEditExistingProductBatchData: handleEditExistingProductBatchData,
-    onScannerOpenChange: setIsScannerOpen,
-    onBarcodeScan: handleBarcodeScan,
+    onCreateNewProduct,
+    onEditNewProductItem,
+    onEditExistingProductBatchData,
+    onScannerOpenChange: setScannerOpen,
+    onBarcodeScan,
     onRemoveItem: remove,
     existingProductBatchForm,
-    onExistingProductBatchOpenChange: handleExistingProductBatchOpenChange,
-    onExistingProductBatchQuantityChange: (quantity: string) =>
-      updateExistingProductBatchForm({ quantity }),
-    onExistingProductBatchQuantityIncrement:
-      handleExistingProductBatchQuantityIncrement,
-    onExistingProductBatchQuantityDecrement:
-      handleExistingProductBatchQuantityDecrement,
-    onExistingProductBatchManufacturedDateChange: (manufacturedDate: string) =>
-      updateExistingProductBatchForm({ manufacturedDate }),
-    onExistingProductBatchExpirationDateChange: (expirationDate: string) =>
-      updateExistingProductBatchForm({ expirationDate }),
-    onExistingProductBatchCostPriceChange: (costPrice?: number) =>
-      updateExistingProductBatchForm({ costPrice }),
-    onExistingProductBatchSellingPriceChange: (sellingPrice?: number) =>
-      updateExistingProductBatchForm({ sellingPrice }),
-    onApplyExistingProductCostPriceSuggestion:
-      handleApplyExistingProductCostPriceSuggestion,
-    onApplyExistingProductSalePriceSuggestion:
-      handleApplyExistingProductSalePriceSuggestion,
-    onConfirmExistingProductBatchData: handleConfirmExistingProductBatchData,
+    onExistingProductBatchOpenChange,
+    onExistingProductBatchQuantityChange,
+    onExistingProductBatchQuantityIncrement,
+    onExistingProductBatchQuantityDecrement,
+    onExistingProductBatchManufacturedDateChange,
+    onExistingProductBatchExpirationDateChange,
+    onExistingProductBatchCostPriceChange,
+    onExistingProductBatchSellingPriceChange,
+    onApplyExistingProductCostPriceSuggestion,
+    onApplyExistingProductSalePriceSuggestion,
+    onConfirmExistingProductBatchData,
     existingProductCostPriceSuggestion,
     existingProductSalePriceSuggestion,
     isExistingProductPriceSuggestionLoading: isLoadingProductBatches,
@@ -752,7 +493,7 @@ export function useCreateStockMovementModel({
     existingProductProfitSummary,
     items: fields,
     missingProductBarcode,
-    onMissingProductModalOpenChange: handleMissingProductModalOpenChange,
-    onCreateProductFromMissingModal: handleCreateProductFromMissingModal,
+    onMissingProductModalOpenChange,
+    onCreateProductFromMissingModal,
   };
 }
diff --git a/app/(pages)/stock-movements/create/use-existing-product-batch-form.model.ts b/app/(pages)/stock-movements/create/use-existing-product-batch-form.model.ts
new file mode 100644
index 0000000..425919d
--- /dev/null
+++ b/app/(pages)/stock-movements/create/use-existing-product-batch-form.model.ts
@@ -0,0 +1,219 @@
+import { useCallback, useState } from "react";
+import type { MutableRefObject } from "react";
+
+import type {
+  CreateStockMovementSchema,
+} from "./create-stock-movement.schema";
+import type {
+  ExistingProductBatchFormState,
+} from "./create-stock-movement.types";
+import { resolveExistingProductBatchQuantity } from "./create-stock-movement.payload";
+import { getOptionalText, validateExistingProductBatchForm } from "./stock-movement-batch-form-validation";
+import {
+  buildRepeatedProductBatchWarning,
+  hasExistingProductInItems,
+} from "./stock-movement-draft-guards";
+
+const EMPTY_EXISTING_BATCH_FORM: ExistingProductBatchFormState = {
+  isOpen: false,
+  productId: "",
+  productName: "",
+  quantity: "",
+  manufacturedDate: "",
+  expirationDate: "",
+  editingIndex: null,
+  error: null,
+};
+
+interface PriceSuggestion {
+  priceCents: number;
+}
+
+interface UseExistingProductBatchFormParams {
+  formItems: CreateStockMovementSchema["items"];
+  append: (item: CreateStockMovementSchema["items"][number]) => void;
+  update: (index: number, item: CreateStockMovementSchema["items"][number]) => void;
+  onItemConfirmed: () => void;
+  salePriceSuggestionRef: MutableRefObject<PriceSuggestion | undefined>;
+  costPriceSuggestionRef: MutableRefObject<PriceSuggestion | undefined>;
+}
+
+interface ExistingProductBatchFormReturn {
+  existingProductBatchForm: ExistingProductBatchFormState;
+  onExistingProductBatchOpenChange: (open: boolean) => void;
+  onExistingProductBatchQuantityChange: (quantity: string) => void;
+  onExistingProductBatchQuantityIncrement: () => void;
+  onExistingProductBatchQuantityDecrement: () => void;
+  onExistingProductBatchManufacturedDateChange: (manufacturedDate: string) => void;
+  onExistingProductBatchExpirationDateChange: (expirationDate: string) => void;
+  onExistingProductBatchCostPriceChange: (costPrice?: number) => void;
+  onExistingProductBatchSellingPriceChange: (sellingPrice?: number) => void;
+  onApplyExistingProductCostPriceSuggestion: () => void;
+  onApplyExistingProductSalePriceSuggestion: () => void;
+  onConfirmExistingProductBatchData: () => void;
+  openExistingProductBatchForm: (params: Omit<ExistingProductBatchFormState, "isOpen" | "error">) => void;
+  closeExistingProductBatchForm: () => void;
+}
+
+export function useExistingProductBatchForm({
+  formItems,
+  append,
+  update,
+  onItemConfirmed,
+  salePriceSuggestionRef,
+  costPriceSuggestionRef,
+}: UseExistingProductBatchFormParams): ExistingProductBatchFormReturn {
+  const [existingProductBatchForm, setExistingProductBatchForm] =
+    useState<ExistingProductBatchFormState>(EMPTY_EXISTING_BATCH_FORM);
+
+  const buildBatchRepeatedProductWarning = useCallback(
+    (
+      params: Pick<ExistingProductBatchFormState, "productId" | "productName" | "editingIndex">,
+    ): string | null => {
+      if (params.editingIndex !== null) return null;
+      if (!hasExistingProductInItems(formItems, params.productId)) {
+        return null;
+      }
+      return buildRepeatedProductBatchWarning(params.productName);
+    },
+    [formItems],
+  );
+
+  const closeExistingProductBatchForm = useCallback((): void => {
+    setExistingProductBatchForm(EMPTY_EXISTING_BATCH_FORM);
+  }, []);
+
+  const openExistingProductBatchForm = useCallback(
+    (params: Omit<ExistingProductBatchFormState, "isOpen" | "error">): void => {
+      setExistingProductBatchForm({
+        ...params,
+        isOpen: true,
+        error: null,
+        repeatedProductWarning: buildBatchRepeatedProductWarning(params),
+      });
+    },
+    [buildBatchRepeatedProductWarning],
+  );
+
+  const updateExistingProductBatchForm = useCallback(
+    (patch: Partial<ExistingProductBatchFormState>): void => {
+      setExistingProductBatchForm((current) => ({
+        ...current,
+        ...patch,
+        error: patch.error ?? null,
+      }));
+    },
+    [],
+  );
+
+  const updateExistingProductBatchQuantity = useCallback(
+    (calculateNextQuantity: (quantity: number) => number): void => {
+      setExistingProductBatchForm((current) => {
+        const currentQuantity = resolveExistingProductBatchQuantity(
+          current.quantity,
+        );
+        const nextQuantity = Math.max(calculateNextQuantity(currentQuantity), 0);
+        return {
+          ...current,
+          quantity: nextQuantity > 0 ? String(nextQuantity) : "",
+          error: null,
+        };
+      });
+    },
+    [],
+  );
+
+  const handleExistingProductBatchQuantityIncrement = useCallback((): void => {
+    updateExistingProductBatchQuantity((quantity) => quantity + 1);
+  }, [updateExistingProductBatchQuantity]);
+
+  const handleExistingProductBatchQuantityDecrement = useCallback((): void => {
+    updateExistingProductBatchQuantity((quantity) => quantity - 1);
+  }, [updateExistingProductBatchQuantity]);
+
+  const handleApplyExistingProductSalePriceSuggestion = useCallback((): void => {
+    const suggestion = salePriceSuggestionRef.current;
+    if (!suggestion) return;
+    updateExistingProductBatchForm({
+      sellingPrice: suggestion.priceCents,
+    });
+  }, [salePriceSuggestionRef, updateExistingProductBatchForm]);
+
+  const handleApplyExistingProductCostPriceSuggestion = useCallback((): void => {
+    const suggestion = costPriceSuggestionRef.current;
+    if (!suggestion) return;
+    updateExistingProductBatchForm({
+      costPrice: suggestion.priceCents,
+    });
+  }, [costPriceSuggestionRef, updateExistingProductBatchForm]);
+
+  const buildExistingProductBatchItem = useCallback(
+    (): CreateStockMovementSchema["items"][number] => ({
+      productId: existingProductBatchForm.productId,
+      productName: existingProductBatchForm.productName,
+      quantity: Number(existingProductBatchForm.quantity),
+      manufacturedDate: getOptionalText(existingProductBatchForm.manufacturedDate),
+      expirationDate: getOptionalText(existingProductBatchForm.expirationDate),
+      costPrice: existingProductBatchForm.costPrice,
+      sellingPrice: existingProductBatchForm.sellingPrice,
+    }),
+    [existingProductBatchForm],
+  );
+
+  const handleConfirmExistingProductBatchData = useCallback((): void => {
+    const validationError = validateExistingProductBatchForm(
+      existingProductBatchForm,
+    );
+    if (validationError) {
+      updateExistingProductBatchForm({ error: validationError });
+      return;
+    }
+
+    const item = buildExistingProductBatchItem();
+    if (existingProductBatchForm.editingIndex !== null) {
+      update(existingProductBatchForm.editingIndex, item);
+    } else {
+      append(item);
+      onItemConfirmed();
+    }
+    closeExistingProductBatchForm();
+  }, [
+    existingProductBatchForm,
+    updateExistingProductBatchForm,
+    buildExistingProductBatchItem,
+    update,
+    append,
+    onItemConfirmed,
+    closeExistingProductBatchForm,
+  ]);
+
+  const handleExistingProductBatchOpenChange = useCallback((open: boolean): void => {
+    if (open) {
+      setExistingProductBatchForm((current) => ({ ...current, isOpen: true }));
+      return;
+    }
+    closeExistingProductBatchForm();
+  }, [closeExistingProductBatchForm]);
+
+  return {
+    existingProductBatchForm,
+    onExistingProductBatchOpenChange: handleExistingProductBatchOpenChange,
+    onExistingProductBatchQuantityChange: (quantity: string) =>
+      updateExistingProductBatchForm({ quantity }),
+    onExistingProductBatchQuantityIncrement: handleExistingProductBatchQuantityIncrement,
+    onExistingProductBatchQuantityDecrement: handleExistingProductBatchQuantityDecrement,
+    onExistingProductBatchManufacturedDateChange: (manufacturedDate: string) =>
+      updateExistingProductBatchForm({ manufacturedDate }),
+    onExistingProductBatchExpirationDateChange: (expirationDate: string) =>
+      updateExistingProductBatchForm({ expirationDate }),
+    onExistingProductBatchCostPriceChange: (costPrice?: number) =>
+      updateExistingProductBatchForm({ costPrice }),
+    onExistingProductBatchSellingPriceChange: (sellingPrice?: number) =>
+      updateExistingProductBatchForm({ sellingPrice }),
+    onApplyExistingProductCostPriceSuggestion: handleApplyExistingProductCostPriceSuggestion,
+    onApplyExistingProductSalePriceSuggestion: handleApplyExistingProductSalePriceSuggestion,
+    onConfirmExistingProductBatchData: handleConfirmExistingProductBatchData,
+    openExistingProductBatchForm,
+    closeExistingProductBatchForm,
+  };
+}
diff --git a/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
new file mode 100644
index 0000000..1da022f
--- /dev/null
+++ b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
@@ -0,0 +1,246 @@
+import { useRef, useState } from "react";
+import type { UseFormReturn } from "react-hook-form";
+import { toast } from "sonner";
+import type { AppRouterInstance } from "next/dist/shared/lib/app-router-context.shared-runtime";
+
+import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
+import type { StockMovementProductOption } from "./create-stock-movement.types";
+import type { ManualMovementType } from "../stock-movements.constants";
+import { MANUAL_IN_MOVEMENT_TYPES } from "../stock-movements.constants";
+import { getPendingInlineProductBarcodeConflictError, hasExistingProductInItems } from "./stock-movement-draft-guards";
+import { lookupStockMovementProductByBarcode } from "./stock-movement-product-lookup";
+
+type OpenBatchFormFn = (params: {
+  productId: string;
+  productName: string;
+  quantity: string;
+  manufacturedDate: string;
+  expirationDate: string;
+  costPrice: number | undefined;
+  sellingPrice: number | undefined;
+  editingIndex: number | null;
+}) => void;
+
+interface UseStockMovementScannerParams {
+  selectedMovementType: ManualMovementType | undefined;
+  router: AppRouterInstance;
+  form: UseFormReturn<CreateStockMovementSchema>;
+  append: (item: CreateStockMovementSchema["items"][number]) => void;
+  persistCurrentDraft: (inlineProductBarcode?: string) => Promise<void>;
+  inlineProductBarcodeRef: React.MutableRefObject<string | undefined>;
+  itemQuantity: string;
+  openExistingProductBatchForm: OpenBatchFormFn;
+  setAddItemError: (error: string | null) => void;
+}
+
+interface StockMovementScannerReturn {
+  isScannerOpen: boolean;
+  setScannerOpen: (open: boolean) => void;
+  onBarcodeScan: (barcode: string) => Promise<void>;
+  missingProductBarcode: string | null;
+  onMissingProductModalOpenChange: (open: boolean) => void;
+  onCreateProductFromMissingModal: () => Promise<void>;
+  onCreateNewProduct: () => Promise<void>;
+  onEditNewProductItem: (index: number) => Promise<void>;
+  onEditExistingProductBatchData: (index: number) => void;
+  appendScannedProduct: (product: StockMovementProductOption) => void;
+}
+
+export const isSelectedInMovement = (type: ManualMovementType | undefined): boolean => {
+  if (!type) return false;
+  return MANUAL_IN_MOVEMENT_TYPES.includes(
+    type as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
+  );
+};
+
+export function useStockMovementScanner({
+  selectedMovementType,
+  router,
+  form,
+  append,
+  persistCurrentDraft,
+  inlineProductBarcodeRef,
+  itemQuantity,
+  openExistingProductBatchForm,
+  setAddItemError,
+}: UseStockMovementScannerParams): StockMovementScannerReturn {
+  const lastScannedBarcodeRef = useRef<string | null>(null);
+  const [isScannerOpen, setIsScannerOpen] = useState(false);
+  const [missingProductBarcode, setMissingProductBarcode] = useState<string | null>(null);
+
+  const findScannedProductBarcodeConflict = (
+    barcode: string | null | undefined,
+  ): string | null => {
+    return getPendingInlineProductBarcodeConflictError(
+      form.getValues("items"),
+      barcode,
+    );
+  };
+
+  const resolveScannerQuantity = (): number => {
+    const qty = Number(itemQuantity);
+    return qty > 0 ? qty : 1;
+  };
+
+  const navigateToInlineProductWithBarcode = async (
+    barcode: string,
+  ): Promise<void> => {
+    if (!selectedMovementType) return;
+
+    inlineProductBarcodeRef.current = barcode;
+    await persistCurrentDraft(barcode);
+    setIsScannerOpen(false);
+    router.push(`/stock-movements/create/new-product?type=${selectedMovementType}`);
+  };
+
+  const appendScannedProduct = (product: StockMovementProductOption) => {
+    const barcodeConflictError = findScannedProductBarcodeConflict(product.barcode);
+    if (barcodeConflictError) {
+      toast.error(barcodeConflictError);
+      return;
+    }
+
+    if (isSelectedInMovement(selectedMovementType)) {
+      setIsScannerOpen(false);
+      openExistingProductBatchForm({
+        productId: product.id,
+        productName: product.name,
+        quantity: "",
+        manufacturedDate: "",
+        expirationDate: "",
+        costPrice: undefined,
+        sellingPrice: undefined,
+        editingIndex: null,
+      });
+      return;
+    }
+
+    if (hasExistingProductInItems(form.getValues("items"), product.id)) {
+      toast.warning(`${product.name} já está na movimentação.`);
+      return;
+    }
+
+    append({
+      productId: product.id,
+      productName: product.name,
+      quantity: resolveScannerQuantity(),
+    });
+    toast.success(`${product.name} foi adicionado.`);
+  };
+
+  const showMissingProductToast = (barcode: string) => {
+    if (!selectedMovementType) {
+      toast.error(`Produto com código ${barcode} não existe.`);
+      return;
+    }
+
+    const canCreateInline = MANUAL_IN_MOVEMENT_TYPES.includes(
+      selectedMovementType as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
+    );
+    if (!canCreateInline) {
+      toast.error(`Produto com código ${barcode} não existe.`);
+      return;
+    }
+
+    setMissingProductBarcode(barcode);
+  };
+
+  const handleBarcodeScan = async (barcode: string) => {
+    if (lastScannedBarcodeRef.current === barcode) return;
+    lastScannedBarcodeRef.current = barcode;
+    window.setTimeout(() => {
+      lastScannedBarcodeRef.current = null;
+    }, 1500);
+
+    const lookup = await lookupStockMovementProductByBarcode(barcode);
+    if (lookup.status === "found") {
+      appendScannedProduct(lookup.product);
+      return;
+    }
+    if (lookup.status === "not-found") {
+      showMissingProductToast(barcode);
+      return;
+    }
+    toast.error(lookup.message);
+  };
+
+  const handleMissingProductModalOpenChange = (open: boolean): void => {
+    if (!open) {
+      setMissingProductBarcode(null);
+    }
+  };
+
+  const handleCreateProductFromMissingModal = async (): Promise<void> => {
+    if (!missingProductBarcode) return;
+    await navigateToInlineProductWithBarcode(missingProductBarcode);
+    setMissingProductBarcode(null);
+  };
+
+  const handleCreateNewProduct = async (): Promise<void> => {
+    setAddItemError(null);
+
+    if (!selectedMovementType) {
+      toast.warning("Selecione o tipo de movimentação antes de continuar.");
+      router.replace("/stock-movements");
+      return;
+    }
+
+    if (
+      !MANUAL_IN_MOVEMENT_TYPES.includes(
+        selectedMovementType as (typeof MANUAL_IN_MOVEMENT_TYPES)[number],
+      )
+    ) {
+      setAddItemError(
+        "Novos produtos só podem ser criados em movimentações de entrada.",
+      );
+      return;
+    }
+
+    inlineProductBarcodeRef.current = undefined;
+    await persistCurrentDraft(undefined);
+    router.push(`/stock-movements/create/new-product?type=${selectedMovementType}`);
+  };
+
+  const handleEditNewProductItem = async (index: number): Promise<void> => {
+    if (!selectedMovementType) return;
+
+    const item = form.getValues("items")[index];
+    if (!item?.newProductData) return;
+
+    inlineProductBarcodeRef.current = undefined;
+    await persistCurrentDraft(undefined);
+    router.push(
+      `/stock-movements/create/new-product?type=${selectedMovementType}&editItem=${index}`,
+    );
+  };
+
+  const handleEditExistingProductBatchData = (index: number): void => {
+    if (!isSelectedInMovement(selectedMovementType)) return;
+    const item = form.getValues("items")[index];
+    if (!item?.productId || item.newProductData) return;
+
+    openExistingProductBatchForm({
+      productId: item.productId,
+      productName: item.productName || "Produto",
+      quantity: String(item.quantity),
+      manufacturedDate: item.manufacturedDate || "",
+      expirationDate: item.expirationDate || "",
+      costPrice: item.costPrice,
+      sellingPrice: item.sellingPrice,
+      editingIndex: index,
+    });
+  };
+
+  return {
+    isScannerOpen,
+    setScannerOpen: setIsScannerOpen,
+    onBarcodeScan: handleBarcodeScan,
+    missingProductBarcode,
+    onMissingProductModalOpenChange: handleMissingProductModalOpenChange,
+    onCreateProductFromMissingModal: handleCreateProductFromMissingModal,
+    onCreateNewProduct: handleCreateNewProduct,
+    onEditNewProductItem: handleEditNewProductItem,
+    onEditExistingProductBatchData: handleEditExistingProductBatchData,
+    appendScannedProduct,
+  };
+}

From ce4fe4de0391561212c4f98df49a5e4d60e694a9 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 11 Jun 2026 16:24:35 -0300
Subject: [PATCH 17/32] fix(stock-movement): recognize inline product barcode
 in scanner

When scanning a barcode that returns 404 from the product lookup API,
check if the barcode already exists in a pending inline product within
the movement draft before opening the 'missing product' modal.

Previously the scanner only queried the remote API and ignored locally
created inline products, causing a false 'product not found' dialog
even when the product had just been created inline.
---
 .../create-stock-movement.model.test.ts       | 29 +++++++++++++++++++
 .../use-stock-movement-scanner.model.ts       | 13 +++++++++
 2 files changed, 42 insertions(+)

diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index a1480c9..c609900 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -1170,6 +1170,35 @@ describe("useCreateStockMovementModel", () => {
     expect(fakeToast.error).not.toHaveBeenCalled();
   });
 
+  it("não abre modal de produto não encontrado quando barcode pertence a produto inline pendente", async () => {
+    const { result } = renderHook(() =>
+      useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }),
+    );
+
+    act(() => {
+      result.current.form.setValue("items", [
+        {
+          quantity: 1,
+          productName: "Produto Inline",
+          newProductData: {
+            name: "Produto Inline",
+            barcode: "7891009999999",
+          },
+        },
+      ]);
+    });
+
+    await act(async () => {
+      await result.current.onBarcodeScan("7891009999999");
+    });
+
+    expect(result.current.missingProductBarcode).toBeNull();
+    expect(fakeToast.warning).toHaveBeenCalledWith(
+      "Produto Inline já está na movimentação como produto novo.",
+    );
+    expect(fakeToast.error).not.toHaveBeenCalled();
+  });
+
   it("mostra aviso sem ação para tipo de saída", async () => {
     fakeSearchParams.setType("USAGE");
     const { result } = renderHook(() => useCreateStockMovementModel({ typeParam: fakeSearchParams.get("type") }));
diff --git a/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
index 1da022f..89abb1c 100644
--- a/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
+++ b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
@@ -145,6 +145,18 @@ export function useStockMovementScanner({
     setMissingProductBarcode(barcode);
   };
 
+  const showPendingInlineProductToast = (barcode: string): boolean => {
+    const inlineItem = form.getValues("items").find((item) => {
+      return item.newProductData?.barcode === barcode;
+    });
+    if (!inlineItem) return false;
+
+    const productName =
+      inlineItem.productName || inlineItem.newProductData?.name || "Produto";
+    toast.warning(`${productName} já está na movimentação como produto novo.`);
+    return true;
+  };
+
   const handleBarcodeScan = async (barcode: string) => {
     if (lastScannedBarcodeRef.current === barcode) return;
     lastScannedBarcodeRef.current = barcode;
@@ -158,6 +170,7 @@ export function useStockMovementScanner({
       return;
     }
     if (lookup.status === "not-found") {
+      if (showPendingInlineProductToast(barcode)) return;
       showMissingProductToast(barcode);
       return;
     }

From 9006ec795ede3b6f6bdf7dcbce720422ce995a4b Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 11 Jun 2026 16:25:31 -0300
Subject: [PATCH 18/32] fix(i18n): translate toast messages and use correct
 severity levels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Translate English terms to pt-BR across all modules:
- 'batch' -> 'lote' in success/error messages
- 'warehouse/armazém' -> 'estoque' in user-facing messages
- 'Warehouse created/deleted' -> 'Estoque criado/deletado'

Use toast.warning instead of toast.error for non-blocking validation:
- missing warehouse selection
- incomplete custom attributes
- image still processing
- empty cart on checkout
- unsupported browser share
---
 .../batches/[id]/edit/batches-edit.model.test.ts |  8 ++++----
 .../batches/[id]/edit/batches-edit.model.ts      |  4 ++--
 .../batches/create/batches-create.model.test.ts  |  9 +++++----
 .../batches/create/batches-create.model.ts       |  6 +++---
 .../[id]/edit/products-edit.model.test.ts        | 10 +++++-----
 .../products/[id]/edit/products-edit.model.ts    | 12 ++++++------
 .../[id]/prompts/product-prompts.model.ts        |  4 ++--
 .../create/products-create.model.test.ts         |  9 +++++----
 .../products/create/products-create.model.ts     |  8 ++++----
 app/(pages)/products/products.model.ts           |  2 +-
 app/(pages)/sales/pdv/pdv.model.test.ts          |  6 ++++--
 app/(pages)/sales/pdv/pdv.model.ts               |  4 ++--
 .../transfers/new/new-transfer.model.test.ts     |  3 ++-
 app/(pages)/transfers/new/new-transfer.model.ts  |  2 +-
 app/warehouses/warehouses.model.test.ts          | 12 ++++++------
 app/warehouses/warehouses.model.ts               | 16 ++++++++--------
 16 files changed, 60 insertions(+), 55 deletions(-)

diff --git a/app/(pages)/batches/[id]/edit/batches-edit.model.test.ts b/app/(pages)/batches/[id]/edit/batches-edit.model.test.ts
index 1bf74d3..d71b130 100644
--- a/app/(pages)/batches/[id]/edit/batches-edit.model.test.ts
+++ b/app/(pages)/batches/[id]/edit/batches-edit.model.test.ts
@@ -242,7 +242,7 @@ describe("useBatchEditModel", () => {
     expect(fakeApi.put).toHaveBeenCalledWith("batches/batch-1", {
       json: values,
     });
-    expect(fakeToast.success).toHaveBeenCalledWith("Batch atualizado");
+    expect(fakeToast.success).toHaveBeenCalledWith("Lote atualizado");
     expect(fakeRouter.push).toHaveBeenCalledWith("/batches/batch-1");
   });
 
@@ -258,11 +258,11 @@ describe("useBatchEditModel", () => {
       await result.current.onSubmit(baseFormValues);
     });
 
-    expect(fakeToast.error).toHaveBeenCalledWith("Erro ao atualizar batch");
+    expect(fakeToast.error).toHaveBeenCalledWith("Erro ao atualizar lote");
   });
 
   it("exibe mensagem de erro retornada pela API na atualização", async () => {
-    const updateError = new Error("Falha ao atualizar batch");
+    const updateError = new Error("Falha ao atualizar lote");
     fakeApi.put.mockReturnValueOnce({
       json: vi.fn(async () => {
         throw updateError;
@@ -274,6 +274,6 @@ describe("useBatchEditModel", () => {
       await result.current.onSubmit(baseFormValues);
     });
 
-    expect(fakeToast.error).toHaveBeenCalledWith("Falha ao atualizar batch");
+    expect(fakeToast.error).toHaveBeenCalledWith("Falha ao atualizar lote");
   });
 });
diff --git a/app/(pages)/batches/[id]/edit/batches-edit.model.ts b/app/(pages)/batches/[id]/edit/batches-edit.model.ts
index b27bf41..7b37237 100644
--- a/app/(pages)/batches/[id]/edit/batches-edit.model.ts
+++ b/app/(pages)/batches/[id]/edit/batches-edit.model.ts
@@ -65,10 +65,10 @@ export const useBatchEditModel = (batchId: string) => {
     try {
       const { api } = await import("@/lib/api");
       await api.put(`batches/${batchId}`, { json: values }).json();
-      toast.success("Batch atualizado");
+      toast.success("Lote atualizado");
       router.push(`/batches/${batchId}`);
     } catch (err) {
-      const message = err instanceof Error ? err.message : "Erro ao atualizar batch";
+      const message = err instanceof Error ? err.message : "Erro ao atualizar lote";
       toast.error(message);
     }
   };
diff --git a/app/(pages)/batches/create/batches-create.model.test.ts b/app/(pages)/batches/create/batches-create.model.test.ts
index 7e6df4f..faceaad 100644
--- a/app/(pages)/batches/create/batches-create.model.test.ts
+++ b/app/(pages)/batches/create/batches-create.model.test.ts
@@ -105,6 +105,7 @@ const fakeToast = vi.hoisted(() => {
   class FakeBatchCreateToast {
     public readonly success = vi.fn<(message: string) => void>();
     public readonly error = vi.fn<(message: string) => void>();
+    public readonly warning = vi.fn<(message: string) => void>();
   }
 
   return new FakeBatchCreateToast();
@@ -543,8 +544,8 @@ describe("useBatchCreateModel", () => {
       await result.current.onSubmit(validSubmitData);
     });
 
-    expect(fakeToast.error).toHaveBeenCalledWith(
-      "Selecione um warehouse ativo para criar o batch",
+    expect(fakeToast.warning).toHaveBeenCalledWith(
+      "Selecione um estoque ativo para criar o lote",
     );
     expect(fakeApi.post).not.toHaveBeenCalled();
   });
@@ -596,7 +597,7 @@ describe("useBatchCreateModel", () => {
     expect(fakeApi.post).toHaveBeenCalledWith("batches", {
       json: buildBatchPayload(validSubmitData, "wh-1"),
     });
-    expect(fakeToast.success).toHaveBeenCalledWith("Batch criado com sucesso");
+    expect(fakeToast.success).toHaveBeenCalledWith("Lote criado com sucesso");
     expect(fakeRouter.push).toHaveBeenCalledWith("/batches/batch-2026");
   });
 
@@ -627,6 +628,6 @@ describe("useBatchCreateModel", () => {
       await result.current.onSubmit(validSubmitData);
     });
 
-    expect(fakeToast.error).toHaveBeenCalledWith("Erro ao criar batch");
+    expect(fakeToast.error).toHaveBeenCalledWith("Erro ao criar lote");
   });
 });
diff --git a/app/(pages)/batches/create/batches-create.model.ts b/app/(pages)/batches/create/batches-create.model.ts
index 34a8e36..5beed8f 100644
--- a/app/(pages)/batches/create/batches-create.model.ts
+++ b/app/(pages)/batches/create/batches-create.model.ts
@@ -308,7 +308,7 @@ export const useBatchCreateModel = () => {
 
   const onSubmit = async (data: BatchCreateFormData) => {
     if (!warehouseId) {
-      toast.error("Selecione um warehouse ativo para criar o batch");
+      toast.warning("Selecione um estoque ativo para criar o lote");
       return;
     }
 
@@ -320,11 +320,11 @@ export const useBatchCreateModel = () => {
         .json<BatchCreateResponse>();
 
       if (response.success) {
-        toast.success("Batch criado com sucesso");
+        toast.success("Lote criado com sucesso");
         router.push(`/batches/${response.data.id}`);
       }
     } catch (err) {
-      const message = err instanceof Error ? err.message : "Erro ao criar batch";
+      const message = err instanceof Error ? err.message : "Erro ao criar lote";
       toast.error(message);
     }
   };
diff --git a/app/(pages)/products/[id]/edit/products-edit.model.test.ts b/app/(pages)/products/[id]/edit/products-edit.model.test.ts
index b73a5a2..63d2629 100644
--- a/app/(pages)/products/[id]/edit/products-edit.model.test.ts
+++ b/app/(pages)/products/[id]/edit/products-edit.model.test.ts
@@ -31,7 +31,7 @@ vi.mock("next/navigation", () => ({
 }));
 
 vi.mock("sonner", () => ({
-  toast: { success: vi.fn(), error: vi.fn() },
+  toast: { success: vi.fn(), error: vi.fn(), warning: vi.fn() },
 }));
 
 vi.mock("@/components/breadcrumb", () => ({
@@ -328,7 +328,7 @@ describe("useProductEditModel batches drawer", () => {
       });
     });
 
-    expect(toast.error).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
+    expect(toast.warning).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
     expect(api.put).not.toHaveBeenCalledWith("products/prod-1", expect.anything());
   });
 
@@ -361,7 +361,7 @@ describe("useProductEditModel batches drawer", () => {
     });
 
     expect(api.put).not.toHaveBeenCalledWith("products/prod-1", expect.anything());
-    expect(toast.error).toHaveBeenCalledWith(
+    expect(toast.warning).toHaveBeenCalledWith(
       "Aguarde a imagem terminar de processar antes de salvar.",
     );
   });
@@ -462,13 +462,13 @@ describe("useProductEditModel batches drawer", () => {
     });
 
     vi.mocked(api.put).mockImplementationOnce(() => {
-      throw new Error("Batch falhou");
+      throw new Error("Lote falhou");
     });
 
     await act(async () => {
       await result.current.batchesDrawer.onSave(0);
     });
 
-    expect(toast.error).toHaveBeenCalledWith("Batch falhou");
+    expect(toast.error).toHaveBeenCalledWith("Lote falhou");
   });
 });
diff --git a/app/(pages)/products/[id]/edit/products-edit.model.ts b/app/(pages)/products/[id]/edit/products-edit.model.ts
index 4030bb5..766acda 100644
--- a/app/(pages)/products/[id]/edit/products-edit.model.ts
+++ b/app/(pages)/products/[id]/edit/products-edit.model.ts
@@ -354,7 +354,7 @@ export const useProductEditModel = (productId: string) => {
     for (let i = 0; i < customAttributes.length; i++) {
       const attr = customAttributes[i];
       if (!attr.key.trim() || !attr.value.trim()) {
-        toast.error(`Atributo ${i + 1}: Nome e valor são obrigatórios`);
+        toast.warning(`Atributo ${i + 1}: Nome e valor são obrigatórios`);
         return false;
       }
     }
@@ -362,7 +362,7 @@ export const useProductEditModel = (productId: string) => {
     const keys = customAttributes.map((a) => a.key.trim().toLowerCase());
     const duplicates = keys.filter((key, index) => keys.indexOf(key) !== index);
     if (duplicates.length > 0) {
-      toast.error(`Já existe um atributo com o nome "${duplicates[0]}"`);
+      toast.warning(`Já existe um atributo com o nome "${duplicates[0]}"`);
       return false;
     }
 
@@ -394,7 +394,7 @@ export const useProductEditModel = (productId: string) => {
     }
 
     if (isImageProcessing) {
-      toast.error("Aguarde a imagem terminar de processar antes de salvar.");
+      toast.warning("Aguarde a imagem terminar de processar antes de salvar.");
       return;
     }
 
@@ -478,13 +478,13 @@ export const useProductEditModel = (productId: string) => {
       await api.put(`batches/${batch.id}`, { json: payload }).json();
 
       mutate(`batches/product/${productId}`);
-      toast.success("Batch atualizado com sucesso!");
+      toast.success("Lote atualizado com sucesso!");
     } catch (error) {
       console.error("Erro ao atualizar batch:", error);
       if (error instanceof Error) {
-        toast.error(error.message || "Erro ao atualizar batch");
+        toast.error(error.message || "Erro ao atualizar lote");
       } else {
-        toast.error("Erro ao atualizar batch");
+        toast.error("Erro ao atualizar lote");
       }
     } finally {
       setUpdatingBatchId(null);
diff --git a/app/(pages)/products/[id]/prompts/product-prompts.model.ts b/app/(pages)/products/[id]/prompts/product-prompts.model.ts
index 8960aba..bc1424c 100644
--- a/app/(pages)/products/[id]/prompts/product-prompts.model.ts
+++ b/app/(pages)/products/[id]/prompts/product-prompts.model.ts
@@ -397,10 +397,10 @@ function notifyProductPromptUnsupportedShare(
   copyResult: ProductPromptTextCopyResult
 ): void {
   if (copyResult === "text") {
-    toast.error("Prompt copiado, mas este navegador não permite compartilhar imagens.");
+    toast.warning("Prompt copiado, mas este navegador não permite compartilhar imagens.");
     return;
   }
-  toast.error("Este navegador não permite compartilhar imagens automaticamente.");
+  toast.warning("Este navegador não permite compartilhar imagens automaticamente.");
 }
 
 function notifyProductPromptShareFailure(copyResult: ProductPromptTextCopyResult): void {
diff --git a/app/(pages)/products/create/products-create.model.test.ts b/app/(pages)/products/create/products-create.model.test.ts
index b2a5b5a..2279b8d 100644
--- a/app/(pages)/products/create/products-create.model.test.ts
+++ b/app/(pages)/products/create/products-create.model.test.ts
@@ -40,6 +40,7 @@ vi.mock("sonner", () => ({
   toast: {
     success: vi.fn(),
     error: vi.fn(),
+    warning: vi.fn(),
   },
 }));
 
@@ -143,7 +144,7 @@ describe("useProductCreateModel - multipart submit", () => {
     });
 
     expect(mockPost).not.toHaveBeenCalled();
-    expect(toast.error).toHaveBeenCalledWith(
+    expect(toast.warning).toHaveBeenCalledWith(
       "Aguarde a imagem terminar de processar antes de salvar.",
     );
   });
@@ -189,7 +190,7 @@ describe("useProductCreateModel - multipart submit", () => {
     });
 
     expect(mockPost).not.toHaveBeenCalled();
-    expect(toast.error).toHaveBeenCalledWith("Selecione um warehouse para criar o produto");
+    expect(toast.warning).toHaveBeenCalledWith("Selecione um estoque para criar o produto");
   });
 
   it("blocks submit when custom attribute is incomplete or duplicated", async () => {
@@ -203,7 +204,7 @@ describe("useProductCreateModel - multipart submit", () => {
       await result.current.onSubmit(baseFormData);
     });
 
-    expect(toast.error).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
+    expect(toast.warning).toHaveBeenCalledWith("Atributo 1: Nome e valor são obrigatórios");
 
     act(() => {
       result.current.updateCustomAttribute(0, "key", "color");
@@ -220,7 +221,7 @@ describe("useProductCreateModel - multipart submit", () => {
       await result.current.onSubmit(baseFormData);
     });
 
-    expect(toast.error).toHaveBeenCalledWith('Já existe um atributo com o nome "color"');
+    expect(toast.warning).toHaveBeenCalledWith('Já existe um atributo com o nome "color"');
     expect(mockPost).not.toHaveBeenCalled();
   });
 
diff --git a/app/(pages)/products/create/products-create.model.ts b/app/(pages)/products/create/products-create.model.ts
index bfa1a40..3c1805d 100644
--- a/app/(pages)/products/create/products-create.model.ts
+++ b/app/(pages)/products/create/products-create.model.ts
@@ -177,7 +177,7 @@ export const useProductCreateModel = () => {
     for (let i = 0; i < customAttributes.length; i++) {
       const attr = customAttributes[i];
       if (!attr.key.trim() || !attr.value.trim()) {
-        toast.error(`Atributo ${i + 1}: Nome e valor são obrigatórios`);
+        toast.warning(`Atributo ${i + 1}: Nome e valor são obrigatórios`);
         return false;
       }
     }
@@ -186,7 +186,7 @@ export const useProductCreateModel = () => {
     const keys = customAttributes.map((a) => a.key.trim().toLowerCase());
     const duplicates = keys.filter((key, index) => keys.indexOf(key) !== index);
     if (duplicates.length > 0) {
-      toast.error(`Já existe um atributo com o nome "${duplicates[0]}"`);
+      toast.warning(`Já existe um atributo com o nome "${duplicates[0]}"`);
       return false;
     }
 
@@ -255,12 +255,12 @@ export const useProductCreateModel = () => {
     }
 
     if (!warehouseId) {
-      toast.error("Selecione um warehouse para criar o produto");
+      toast.warning("Selecione um estoque para criar o produto");
       return;
     }
 
     if (isImageProcessing) {
-      toast.error("Aguarde a imagem terminar de processar antes de salvar.");
+      toast.warning("Aguarde a imagem terminar de processar antes de salvar.");
       return;
     }
 
diff --git a/app/(pages)/products/products.model.ts b/app/(pages)/products/products.model.ts
index 1a4639f..f0a0b74 100644
--- a/app/(pages)/products/products.model.ts
+++ b/app/(pages)/products/products.model.ts
@@ -264,7 +264,7 @@ export const useProductsModel = () => {
         `batches/warehouses/${warehouseId}/products/${deleteProduct.id}/batches`;
       await api.delete(deleteBatchesEndpoint).json();
 
-      toast.success("Produto removido do armazém com sucesso");
+      toast.success("Produto removido do estoque com sucesso");
       mutate();
       mutateGlobal((key) =>
         typeof key === "string" &&
diff --git a/app/(pages)/sales/pdv/pdv.model.test.ts b/app/(pages)/sales/pdv/pdv.model.test.ts
index 85bbe67..9d75732 100644
--- a/app/(pages)/sales/pdv/pdv.model.test.ts
+++ b/app/(pages)/sales/pdv/pdv.model.test.ts
@@ -11,6 +11,7 @@ const mockSWR = vi.fn();
 const toastError = vi.fn();
 const toastSuccess = vi.fn();
 const toastInfo = vi.fn();
+const toastWarning = vi.fn();
 const routerPush = vi.fn();
 
 let activeWarehouseId: string | null = "warehouse-1";
@@ -77,6 +78,7 @@ vi.mock("sonner", () => ({
     success: (...args: unknown[]) => toastSuccess(...args),
     error: (...args: unknown[]) => toastError(...args),
     info: (...args: unknown[]) => toastInfo(...args),
+    warning: (...args: unknown[]) => toastWarning(...args),
   },
 }));
 
@@ -326,7 +328,7 @@ describe("usePdvModel", () => {
       await result.current.onBarcodeScanned("000999");
     });
 
-    expect(toastError).toHaveBeenCalledWith("Nenhum armazém selecionado");
+    expect(toastError).toHaveBeenCalledWith("Nenhum estoque selecionado");
     expect(mockGet).not.toHaveBeenCalled();
   });
 
@@ -478,7 +480,7 @@ describe("usePdvModel", () => {
       await result.current.onSubmit(submitData());
     });
 
-    expect(toastError).toHaveBeenCalledWith("Adicione pelo menos um produto ao carrinho");
+    expect(toastWarning).toHaveBeenCalledWith("Adicione pelo menos um produto ao carrinho");
     expect(mockPost).not.toHaveBeenCalled();
     expect(result.current.cart).toHaveLength(0);
   });
diff --git a/app/(pages)/sales/pdv/pdv.model.ts b/app/(pages)/sales/pdv/pdv.model.ts
index 86c707a..d8c325b 100644
--- a/app/(pages)/sales/pdv/pdv.model.ts
+++ b/app/(pages)/sales/pdv/pdv.model.ts
@@ -256,7 +256,7 @@ export function usePdvModel(): PdvViewProps {
   const onSubmit = useCallback(
     async (data: PdvSchema) => {
       if (cart.length === 0 || !warehouseId) {
-        toast.error("Adicione pelo menos um produto ao carrinho");
+        toast.warning("Adicione pelo menos um produto ao carrinho");
         return;
       }
       setIsSubmitting(true);
@@ -344,7 +344,7 @@ export function usePdvModel(): PdvViewProps {
   const onBarcodeScanned = useCallback(
     async (barcode: string) => {
       if (!warehouseId) {
-        toast.error("Nenhum armazém selecionado");
+        toast.error("Nenhum estoque selecionado");
         return;
       }
 
diff --git a/app/(pages)/transfers/new/new-transfer.model.test.ts b/app/(pages)/transfers/new/new-transfer.model.test.ts
index 7476c96..564cfc2 100644
--- a/app/(pages)/transfers/new/new-transfer.model.test.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.test.ts
@@ -118,6 +118,7 @@ const fakeToast = vi.hoisted(() => {
   class FakeToast {
     public readonly success = vi.fn<(message: string) => void>();
     public readonly error = vi.fn<(message: string) => void>();
+    public readonly warning = vi.fn<(message: string) => void>();
   }
 
   return new FakeToast();
@@ -687,7 +688,7 @@ describe("useNewTransferModel", () => {
       await result.current.onSubmit(payload);
     });
 
-    expect(fakeToast.error).toHaveBeenCalledWith("Selecione um warehouse de origem.");
+    expect(fakeToast.warning).toHaveBeenCalledWith("Selecione um estoque de origem.");
     expect(fakeApi.post).not.toHaveBeenCalled();
   });
 
diff --git a/app/(pages)/transfers/new/new-transfer.model.ts b/app/(pages)/transfers/new/new-transfer.model.ts
index 934f962..5f75faa 100644
--- a/app/(pages)/transfers/new/new-transfer.model.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.ts
@@ -471,7 +471,7 @@ export function useNewTransferModel(): NewTransferViewProps {
 
   const onSubmit = async (data: NewTransferSchema): Promise<void> => {
     if (!currentWarehouseId) {
-      toast.error("Selecione um warehouse de origem.");
+      toast.warning("Selecione um estoque de origem.");
       return;
     }
 
diff --git a/app/warehouses/warehouses.model.test.ts b/app/warehouses/warehouses.model.test.ts
index 533537c..936c8b5 100644
--- a/app/warehouses/warehouses.model.test.ts
+++ b/app/warehouses/warehouses.model.test.ts
@@ -323,7 +323,7 @@ describe("useWarehousesModel", () => {
     });
 
     expect(api.post).toHaveBeenCalledWith("warehouses", { json: payload });
-    expect(toast.success).toHaveBeenCalledWith("Warehouse created successfully");
+    expect(toast.success).toHaveBeenCalledWith("Estoque criado com sucesso");
 
     act(() => {
       result.current.openEditModal(result.current.warehouses[0]);
@@ -334,7 +334,7 @@ describe("useWarehousesModel", () => {
     });
 
     expect(api.put).toHaveBeenCalledWith("warehouses/1", { json: payload });
-    expect(toast.success).toHaveBeenCalledWith("Warehouse updated successfully");
+    expect(toast.success).toHaveBeenCalledWith("Estoque atualizado com sucesso");
   });
 
   it("should show save fallback error when submit fails", async () => {
@@ -353,7 +353,7 @@ describe("useWarehousesModel", () => {
       });
     });
 
-    expect(toast.error).toHaveBeenCalledWith("Erro ao salvar armazém. Tente novamente.");
+    expect(toast.error).toHaveBeenCalledWith("Erro ao salvar estoque. Tente novamente.");
   });
 
   it("should select warehouse and handle selection errors", async () => {
@@ -366,7 +366,7 @@ describe("useWarehousesModel", () => {
     expect(api.post).toHaveBeenCalledWith("auth/switch-warehouse", {
       json: { warehouseId: "2" },
     });
-    expect(toast.success).toHaveBeenCalledWith("Warehouse created successfully");
+    expect(toast.success).toHaveBeenCalledWith("Estoque selecionado");
 
     vi.mocked(api.post).mockImplementationOnce(() => {
       throw { response: { data: { message: "Sem acesso" } } };
@@ -391,7 +391,7 @@ describe("useWarehousesModel", () => {
     });
 
     expect(api.delete).toHaveBeenCalledWith("warehouses/1");
-    expect(toast.success).toHaveBeenCalledWith("Warehouse deleted successfully");
+    expect(toast.success).toHaveBeenCalledWith("Estoque deletado com sucesso");
     expect(result.current.isDeleting).toBe(false);
 
     vi.mocked(api.delete).mockImplementationOnce(() => {
@@ -412,7 +412,7 @@ describe("useWarehousesModel", () => {
     });
 
     expect(toast.error).toHaveBeenCalledWith(
-      "warehouse has stock. Desative o armazém ou transfira o estoque primeiro.",
+      "warehouse has stock. Desative o estoque ou transfira o estoque primeiro.",
     );
     expect(result.current.isDeleting).toBe(false);
   });
diff --git a/app/warehouses/warehouses.model.ts b/app/warehouses/warehouses.model.ts
index 35c289a..9abdaed 100644
--- a/app/warehouses/warehouses.model.ts
+++ b/app/warehouses/warehouses.model.ts
@@ -176,13 +176,13 @@ export const useWarehousesModel = () => {
 
       if (response.success) {
         setWarehouseId(id);
-        toast.success(response.message || "Armazém selecionado");
+        toast.success("Estoque selecionado");
       }
     } catch (err) {
       const error = err as { response?: { data?: { message?: string } } };
       const errorMessage =
         error.response?.data?.message ||
-        "Erro ao selecionar armazém. Tente novamente.";
+        "Erro ao selecionar estoque. Tente novamente.";
 
       toast.error(errorMessage);
     }
@@ -198,7 +198,7 @@ export const useWarehousesModel = () => {
           .json<UpdateWarehouseResponse>();
 
         if (response.success) {
-          toast.success(response.message || "Armazém atualizado com sucesso");
+          toast.success("Estoque atualizado com sucesso");
           mutate();
           closeModal();
         }
@@ -209,7 +209,7 @@ export const useWarehousesModel = () => {
           .json<CreateWarehouseResponse>();
 
         if (response.success) {
-          toast.success(response.message || "Armazém criado com sucesso");
+          toast.success("Estoque criado com sucesso");
           mutate();
           closeModal();
         }
@@ -218,7 +218,7 @@ export const useWarehousesModel = () => {
       const error = err as { response?: { data?: { message?: string } } };
       const errorMessage =
         error.response?.data?.message ||
-        "Erro ao salvar armazém. Tente novamente.";
+        "Erro ao salvar estoque. Tente novamente.";
 
       toast.error(errorMessage);
     }
@@ -243,18 +243,18 @@ export const useWarehousesModel = () => {
         .json<DeleteWarehouseResponse>();
 
       if (response.success) {
-        toast.success(response.message || "Armazém deletado com sucesso");
+        toast.success("Estoque deletado com sucesso");
         mutate();
         closeDeleteDialog();
       }
     } catch (err) {
       const error = err as { response?: { status?: number; data?: { message?: string } } };
-      const errorMessage = error.response?.data?.message || "Erro ao deletar armazém";
+      const errorMessage = error.response?.data?.message || "Erro ao deletar estoque";
 
       // Check if deletion is blocked by stock
       if (error.response?.status === 400 && errorMessage.includes("stock")) {
         toast.error(
-          `${errorMessage}. Desative o armazém ou transfira o estoque primeiro.`
+          `${errorMessage}. Desative o estoque ou transfira o estoque primeiro.`
         );
       } else {
         toast.error(errorMessage);

From be5ddc2ef8a5af0afc24307af0c6803ee694e9d2 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 11 Jun 2026 16:25:52 -0300
Subject: [PATCH 19/32] feat(toast): style sonner toasts with brutalist design
 system

Apply dark brutalist theme to toast notifications:
- Surface #171717 with neutral-800 borders and 4px radius
- Success: emerald #059669 with white text
- Error: rose #E11D48 with white text
- Warning: amber #F59E0B with black text
- Info: blue #2563EB with white text
- Position: top-center
- No box-shadow (consistent with design system)
---
 app/globals.css          | 52 ++++++++++++++++++++++++++++++++++++++++
 components/ui/sonner.tsx | 21 +++++++++++++---
 2 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/app/globals.css b/app/globals.css
index abb2f43..6802c6c 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -137,4 +137,56 @@
   .animate-shimmer {
     animation: shimmer 3s ease-in-out infinite;
   }
+}
+
+.toaster {
+  --normal-bg: #171717;
+  --normal-text: #FAFAFA;
+  --normal-border: #262626;
+}
+
+.toaster [data-sonner-toast] {
+  border-radius: 4px;
+  box-shadow: none;
+  border: 1px solid var(--normal-border);
+  background: var(--normal-bg);
+  color: var(--normal-text);
+}
+
+.toaster .toast-success {
+  background: #059669;
+  border-color: #059669;
+  color: #FFFFFF;
+}
+
+.toaster .toast-error {
+  background: #E11D48;
+  border-color: #E11D48;
+  color: #FFFFFF;
+}
+
+.toaster .toast-warning {
+  background: #F59E0B;
+  border-color: #F59E0B;
+  color: #000000;
+}
+
+.toaster .toast-info {
+  background: #2563EB;
+  border-color: #2563EB;
+  color: #FFFFFF;
+}
+
+.toaster .toast-description {
+  color: inherit;
+  opacity: 0.9;
+}
+
+.toaster .toast-close-button {
+  color: inherit;
+  opacity: 0.7;
+}
+
+.toaster .toast-close-button:hover {
+  opacity: 1;
 }
\ No newline at end of file
diff --git a/components/ui/sonner.tsx b/components/ui/sonner.tsx
index 1eb0a26..0e8833b 100644
--- a/components/ui/sonner.tsx
+++ b/components/ui/sonner.tsx
@@ -6,12 +6,27 @@ const Toaster = ({ ...props }: ToasterProps) => {
   return (
     <Sonner
       theme="dark"
+      position="top-center"
       className="toaster group"
+      toastOptions={{
+        classNames: {
+          toast: "group toast",
+          description: "toast-description",
+          actionButton: "toast-action-button",
+          cancelButton: "toast-cancel-button",
+          closeButton: "toast-close-button",
+          success: "toast-success",
+          error: "toast-error",
+          warning: "toast-warning",
+          info: "toast-info",
+        },
+      }}
       style={
         {
-          "--normal-bg": "var(--popover)",
-          "--normal-text": "var(--popover-foreground)",
-          "--normal-border": "var(--border)",
+          "--normal-bg": "#171717",
+          "--normal-text": "#FAFAFA",
+          "--normal-border": "#262626",
+          "--border-radius": "4px",
         } as React.CSSProperties
       }
       {...props}

From a66809df88e9035f0534bf2a60337cd8c320618e Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 20:53:21 -0300
Subject: [PATCH 20/32] feat(nuqs): persist product search query in URL across
 navigations

- Add nuqs ^2.8.9 dependency for URL-based state management
- Wrap RootLayout with NuqsAdapter (Next.js App Router adapter)
- Split ProductFilters into URL-persisted searchQuery (nuqs) and local tableFilters (useState)
- Replace single setFilters with a composed setFilters that routes searchQuery to the URL
- Update direct filter mutations (pagination, sort, KPI clicks) to use setTableFilters
- Reset search query via setSearchQuery in clear/reset handlers
- Wrap test renderHook with NuqsTestingAdapter for test compatibility

Co-Authored-By: Claude <noreply@anthropic.com>
---
 app/(pages)/products/products.model.test.ts | 24 ++++---
 app/(pages)/products/products.model.ts      | 69 ++++++++++++++-------
 app/layout.tsx                              | 17 ++---
 package.json                                |  1 +
 pnpm-lock.yaml                              | 36 +++++++++++
 5 files changed, 109 insertions(+), 38 deletions(-)

diff --git a/app/(pages)/products/products.model.test.ts b/app/(pages)/products/products.model.test.ts
index 0dbaff7..d51ceef 100644
--- a/app/(pages)/products/products.model.test.ts
+++ b/app/(pages)/products/products.model.test.ts
@@ -1,8 +1,16 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import { renderHook, act, waitFor } from "@testing-library/react";
+import { createElement, type ReactNode } from "react";
+import { NuqsTestingAdapter } from "nuqs/adapters/testing";
 import { useProductsModel } from "./products.model";
 import { toast } from "sonner";
 
+const renderModel = () =>
+  renderHook(() => useProductsModel(), {
+    wrapper: ({ children }: { children: ReactNode }) =>
+      createElement(NuqsTestingAdapter, null, children),
+  });
+
 const mockMutate = vi.fn();
 const mockGlobalMutate = vi.fn();
 const mockGet = vi.fn();
@@ -138,7 +146,7 @@ describe("useProductsModel - delete flow", () => {
       })),
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
@@ -179,7 +187,7 @@ describe("useProductsModel - delete flow", () => {
       })),
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
@@ -234,7 +242,7 @@ describe("useProductsModel - delete flow", () => {
       })),
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
@@ -252,7 +260,7 @@ describe("useProductsModel - delete flow", () => {
   });
 
   it("updates pagination, search and sort filters", () => {
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     act(() => {
       result.current.onPageChange(2);
@@ -272,7 +280,7 @@ describe("useProductsModel - delete flow", () => {
   });
 
   it("filters products without stock from KPI action", () => {
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     act(() => {
       result.current.onPageChange(2);
@@ -301,7 +309,7 @@ describe("useProductsModel - delete flow", () => {
       })),
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
@@ -326,7 +334,7 @@ describe("useProductsModel - delete flow", () => {
       throw { response: { data: { message: "Falha ao verificar" } } };
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
@@ -357,7 +365,7 @@ describe("useProductsModel - delete flow", () => {
       throw {};
     });
 
-    const { result } = renderHook(() => useProductsModel());
+    const { result } = renderModel();
 
     await act(async () => {
       await result.current.onOpenDeleteDialog(result.current.products[0]);
diff --git a/app/(pages)/products/products.model.ts b/app/(pages)/products/products.model.ts
index f0a0b74..3362a4e 100644
--- a/app/(pages)/products/products.model.ts
+++ b/app/(pages)/products/products.model.ts
@@ -1,4 +1,6 @@
-import { useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import { useQueryState, parseAsString } from "nuqs";
 import useSWR, { mutate as mutateGlobal } from "swr";
 import { api } from "@/lib/api";
 import { toast } from "sonner";
@@ -20,7 +22,9 @@ interface BatchesResponse {
   data: Batch[];
 }
 
-const DEFAULT_FILTERS: Omit<ProductFilters, "searchQuery"> = {
+type TableFilters = Omit<ProductFilters, "searchQuery">;
+
+const DEFAULT_FILTERS: TableFilters = {
   sortBy: "name",
   sortOrder: "asc",
   stockStatus: "all",
@@ -29,6 +33,10 @@ const DEFAULT_FILTERS: Omit<ProductFilters, "searchQuery"> = {
   pageSize: 20,
 };
 
+// Key for the search query persisted in the URL via nuqs, so it survives
+// navigating into a product detail and coming back.
+const SEARCH_QUERY_PARAM = "q";
+
 const DEFAULT_DRAFT: ProductFilterDraft = {
   stockStatus: "all",
   activeStatus: "all",
@@ -70,10 +78,30 @@ const filterByActiveStatus = (product: Product, status: ActiveStatus) => {
 export const useProductsModel = () => {
   const { warehouseId } = useSelectedWarehouse();
 
-  const [filters, setFilters] = useState<ProductFilters>({
-    searchQuery: "",
-    ...DEFAULT_FILTERS,
-  });
+  const [searchQuery, setSearchQuery] = useQueryState(
+    SEARCH_QUERY_PARAM,
+    parseAsString.withDefault("")
+  );
+  const [tableFilters, setTableFilters] =
+    useState<TableFilters>(DEFAULT_FILTERS);
+
+  const filters = useMemo<ProductFilters>(
+    () => ({ ...tableFilters, searchQuery }),
+    [tableFilters, searchQuery]
+  );
+
+  // Mirrors the original Dispatch<SetStateAction<ProductFilters>> contract,
+  // routing searchQuery to the URL and the remaining filters to local state.
+  const setFilters = useCallback<Dispatch<SetStateAction<ProductFilters>>>(
+    (update) => {
+      const next = typeof update === "function" ? update(filters) : update;
+      const { searchQuery: nextSearch, ...rest } = next;
+      if (nextSearch !== searchQuery) setSearchQuery(nextSearch);
+      setTableFilters(rest);
+    },
+    [filters, searchQuery, setSearchQuery]
+  );
+
   const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
   const [secondConfirmOpen, setSecondConfirmOpen] = useState(false);
   const [deleteProduct, setDeleteProduct] = useState<Product | null>(null);
@@ -143,23 +171,24 @@ export const useProductsModel = () => {
       };
 
   const onPageChange = (page: number) => {
-    setFilters((prev) => ({ ...prev, page }));
+    setTableFilters((prev) => ({ ...prev, page }));
   };
 
   const onPageSizeChange = (pageSize: number) => {
-    setFilters((prev) => ({ ...prev, pageSize, page: 0 }));
+    setTableFilters((prev) => ({ ...prev, pageSize, page: 0 }));
   };
 
-  const onSearchChange = (searchQuery: string) => {
-    setFilters((prev) => ({ ...prev, searchQuery, page: 0 }));
+  const onSearchChange = (nextSearch: string) => {
+    setSearchQuery(nextSearch);
+    setTableFilters((prev) => ({ ...prev, page: 0 }));
   };
 
   const onSortChange = (sortBy: SortField, sortOrder: SortOrder) => {
-    setFilters((prev) => ({ ...prev, sortBy, sortOrder, page: 0 }));
+    setTableFilters((prev) => ({ ...prev, sortBy, sortOrder, page: 0 }));
   };
 
   const onOutOfStockKpiClick = () => {
-    setFilters((prev) => ({
+    setTableFilters((prev) => ({
       ...prev,
       stockStatus: "outOfStock",
       page: 0,
@@ -181,7 +210,7 @@ export const useProductsModel = () => {
   };
 
   const onApplyMobileFilters = () => {
-    setFilters((prev) => ({
+    setTableFilters((prev) => ({
       ...prev,
       stockStatus: mobileFiltersDraft.stockStatus,
       activeStatus: mobileFiltersDraft.activeStatus,
@@ -192,19 +221,13 @@ export const useProductsModel = () => {
   };
 
   const onClearFilters = () => {
-    setFilters((prev) => ({
-      ...prev,
-      searchQuery: "",
-      ...DEFAULT_FILTERS,
-    }));
+    setSearchQuery("");
+    setTableFilters(DEFAULT_FILTERS);
   };
 
   const onClearMobileFilters = () => {
-    const nextFilters = {
-      searchQuery: "",
-      ...DEFAULT_FILTERS,
-    };
-    setFilters(nextFilters);
+    setSearchQuery("");
+    setTableFilters(DEFAULT_FILTERS);
     setMobileFiltersDraft(DEFAULT_DRAFT);
   };
 
diff --git a/app/layout.tsx b/app/layout.tsx
index b099c13..fe7a8a0 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -7,6 +7,7 @@ import { AuthProvider } from "@/lib/contexts/auth-context";
 import { LayoutContent } from "@/components/layout/layout-content";
 import { MobileMenuProvider } from "@/components/layout/mobile-menu-context";
 import { Toaster } from "@/components/ui/sonner";
+import { NuqsAdapter } from "nuqs/adapters/next/app";
 
 const geistSans = Geist({
   variable: "--font-geist-sans",
@@ -174,13 +175,15 @@ export default function RootLayout({
       <body
         className={`${geistSans.variable} ${geistMono.variable} antialiased dark`}
       >
-        <AuthProvider>
-          <WarehouseProvider>
-            <MobileMenuProvider>
-              <LayoutContent>{children}</LayoutContent>
-            </MobileMenuProvider>
-          </WarehouseProvider>
-        </AuthProvider>
+        <NuqsAdapter>
+          <AuthProvider>
+            <WarehouseProvider>
+              <MobileMenuProvider>
+                <LayoutContent>{children}</LayoutContent>
+              </MobileMenuProvider>
+            </WarehouseProvider>
+          </AuthProvider>
+        </NuqsAdapter>
         <Toaster />
         {SHOULD_LOAD_CLARITY && (
           <Script
diff --git a/package.json b/package.json
index a065669..956f509 100644
--- a/package.json
+++ b/package.json
@@ -58,6 +58,7 @@
     "lucide-react": "^0.545.0",
     "next": "15.5.9",
     "next-themes": "^0.4.6",
+    "nuqs": "^2.8.9",
     "react": "19.1.0",
     "react-day-picker": "^9.11.0",
     "react-dom": "19.1.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 162cec4..9541035 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -131,6 +131,9 @@ importers:
       next-themes:
         specifier: ^0.4.6
         version: 0.4.6(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+      nuqs:
+        specifier: ^2.8.9
+        version: 2.8.9(next@15.5.9(@playwright/test@1.58.1)(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0)
       react:
         specifier: 19.1.0
         version: 19.1.0
@@ -1564,6 +1567,9 @@ packages:
   '@rushstack/eslint-patch@1.15.0':
     resolution: {integrity: sha512-ojSshQPKwVvSMR8yT2L/QtUkV5SXi/IfDiJ4/8d6UbTPjiHVmxZzUAzGD8Tzks1b9+qQkZa0isUOvYObedITaw==}
 
+  '@standard-schema/spec@1.0.0':
+    resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==}
+
   '@standard-schema/utils@0.3.0':
     resolution: {integrity: sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==}
 
@@ -3088,6 +3094,27 @@ packages:
       sass:
         optional: true
 
+  nuqs@2.8.9:
+    resolution: {integrity: sha512-8ou6AEwsxMWSYo2qkfZtYFVzngwbKmg4c00HVxC1fF6CEJv3Fwm6eoZmfVPALB+vw8Udo7KL5uy96PFcYe1BIQ==}
+    peerDependencies:
+      '@remix-run/react': '>=2'
+      '@tanstack/react-router': ^1
+      next: '>=14.2.0'
+      react: '>=18.2.0 || ^19.0.0-0'
+      react-router: ^5 || ^6 || ^7
+      react-router-dom: ^5 || ^6 || ^7
+    peerDependenciesMeta:
+      '@remix-run/react':
+        optional: true
+      '@tanstack/react-router':
+        optional: true
+      next:
+        optional: true
+      react-router:
+        optional: true
+      react-router-dom:
+        optional: true
+
   object-assign@4.1.1:
     resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
     engines: {node: '>=0.10.0'}
@@ -5020,6 +5047,8 @@ snapshots:
 
   '@rushstack/eslint-patch@1.15.0': {}
 
+  '@standard-schema/spec@1.0.0': {}
+
   '@standard-schema/utils@0.3.0': {}
 
   '@swc/helpers@0.5.15':
@@ -6701,6 +6730,13 @@ snapshots:
       - '@babel/core'
       - babel-plugin-macros
 
+  nuqs@2.8.9(next@15.5.9(@playwright/test@1.58.1)(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0):
+    dependencies:
+      '@standard-schema/spec': 1.0.0
+      react: 19.1.0
+    optionalDependencies:
+      next: 15.5.9(@playwright/test@1.58.1)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+
   object-assign@4.1.1: {}
 
   object-inspect@1.13.4: {}

From 7c15ad550a02648d8869025adf923e5a643f2f66 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 20:53:28 -0300
Subject: [PATCH 21/32] feat(products): add clear button to search input

- Add X icon button visible when search query is non-empty
- Add pr-10 right padding on input to accommodate the clear button
- Sets search query to empty string on click

Co-Authored-By: Claude <noreply@anthropic.com>
---
 app/(pages)/products/products.view.tsx | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/app/(pages)/products/products.view.tsx b/app/(pages)/products/products.view.tsx
index cbb923a..5966e20 100644
--- a/app/(pages)/products/products.view.tsx
+++ b/app/(pages)/products/products.view.tsx
@@ -57,6 +57,7 @@ import {
   PowerOff,
   LayoutList,
   ArrowDownUp,
+  X,
 } from "lucide-react";
 import Link from "next/link";
 import type { ReactNode } from "react";
@@ -594,8 +595,18 @@ const ProductsSearchInput = ({ props }: { props: ProductsViewProps }) => (
       placeholder="Pesquisar no inventário (nome, SKU, código)..."
       value={props.filters.searchQuery}
       onChange={(event) => props.onSearchChange(event.target.value)}
-      className="w-full rounded-[4px] border-neutral-800 bg-[#171717] pl-10 text-sm text-neutral-200 placeholder:text-neutral-600 transition-all hover:border-neutral-700 focus:border-blue-600 focus:ring-0"
+      className="w-full rounded-[4px] border-neutral-800 bg-[#171717] pl-10 pr-10 text-sm text-neutral-200 placeholder:text-neutral-600 transition-all hover:border-neutral-700 focus:border-blue-600 focus:ring-0"
     />
+    {props.filters.searchQuery && (
+      <button
+        type="button"
+        onClick={() => props.onSearchChange("")}
+        aria-label="Limpar pesquisa"
+        className="absolute right-3 flex items-center justify-center text-neutral-500 transition-colors hover:text-neutral-200"
+      >
+        <X className="size-4" strokeWidth={2.5} />
+      </button>
+    )}
   </div>
 );
 

From ceaeafec24b178764333c2d2d25986b8e73c1269 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 20:54:00 -0300
Subject: [PATCH 22/32] feat(stock-movement): replace inline duplicate toast
 with warning drawer

Replace transient toast notifications with a persistent bottom drawer when a
scanned barcode collides with an inline (new) product already in the movement.

- Add InlineDuplicateWarningDrawer shared component with amber styling
- Add findScannedInlineProductDuplicateWarning guard function + tests
- Replace toast.warning with drawer state in useStockMovementScanner
- Wire inlineDuplicateWarning/onInlineDuplicateWarningOpenChange through
  create-stock-movement model, types, and view
- Use drawer + new guard in useNewProductInlineModel barcode scan handler
- Add guard-on-submit check rejecting duplicate inline barcode on save
- Render InlineDuplicateWarningDrawer in ProductFormShell overlays
- Update tests to assert drawer state instead of toast calls

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../products/components/product-form.types.ts |  4 +
 .../products/components/product-form.view.tsx |  7 ++
 .../create-stock-movement.model.test.ts       |  8 +-
 .../create/create-stock-movement.model.ts     |  4 +
 .../create/create-stock-movement.types.ts     |  2 +
 .../create/create-stock-movement.view.tsx     |  7 ++
 .../new-product-inline.model.test.ts          | 76 +++++++++++++++++++
 .../new-product/new-product-inline.model.ts   | 28 ++++++-
 .../stock-movement-draft-guards.test.ts       | 22 ++++++
 .../create/stock-movement-draft-guards.ts     | 16 ++++
 .../use-stock-movement-scanner.model.ts       | 17 ++++-
 .../inline-duplicate-warning-drawer.tsx       | 61 +++++++++++++++
 12 files changed, 245 insertions(+), 7 deletions(-)
 create mode 100644 components/stock-movement/inline-duplicate-warning-drawer.tsx

diff --git a/app/(pages)/products/components/product-form.types.ts b/app/(pages)/products/components/product-form.types.ts
index a910da8..d4f4194 100644
--- a/app/(pages)/products/components/product-form.types.ts
+++ b/app/(pages)/products/components/product-form.types.ts
@@ -131,6 +131,10 @@ export interface ProductFormProps {
   onExistingProductModalOpenChange?: (open: boolean) => void;
   onCreateBatchForExistingProduct?: () => void | Promise<void>;
 
+  // Inline duplicate barcode warning drawer (new-product page)
+  inlineDuplicateWarning?: string | null;
+  onInlineDuplicateWarningOpenChange?: (open: boolean) => void;
+
   // Batch overlay (new-product page)
   batchForm?: ExistingProductBatchFormState;
   onBatchOpenChange?: (open: boolean) => void;
diff --git a/app/(pages)/products/components/product-form.view.tsx b/app/(pages)/products/components/product-form.view.tsx
index dac9d51..e9a2d60 100644
--- a/app/(pages)/products/components/product-form.view.tsx
+++ b/app/(pages)/products/components/product-form.view.tsx
@@ -22,6 +22,7 @@ import {
   DrawerHeader,
   DrawerTitle,
 } from "@/components/ui/drawer";
+import { InlineDuplicateWarningDrawer } from "@/components/stock-movement/inline-duplicate-warning-drawer";
 import {
   Accordion,
   AccordionContent,
@@ -225,6 +226,12 @@ const ProductFormShell = ({
       onScan={productForm.handleBarcodeScan}
     />
     <ExistingProductFoundModal productForm={productForm} />
+    {productForm.onInlineDuplicateWarningOpenChange && (
+      <InlineDuplicateWarningDrawer
+        message={productForm.inlineDuplicateWarning}
+        onOpenChange={productForm.onInlineDuplicateWarningOpenChange}
+      />
+    )}
     <main className="mx-auto w-full max-w-7xl px-4 py-8 md:px-6 lg:px-8">
       <ProductAiModal productForm={productForm} viewState={viewState} />
       <ProductFormBody productForm={productForm} viewState={viewState} />
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index c609900..1c98d9f 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -1193,10 +1193,16 @@ describe("useCreateStockMovementModel", () => {
     });
 
     expect(result.current.missingProductBarcode).toBeNull();
-    expect(fakeToast.warning).toHaveBeenCalledWith(
+    expect(result.current.inlineDuplicateWarning).toBe(
       "Produto Inline já está na movimentação como produto novo.",
     );
+    expect(fakeToast.warning).not.toHaveBeenCalled();
     expect(fakeToast.error).not.toHaveBeenCalled();
+
+    act(() => {
+      result.current.onInlineDuplicateWarningOpenChange(false);
+    });
+    expect(result.current.inlineDuplicateWarning).toBeNull();
   });
 
   it("mostra aviso sem ação para tipo de saída", async () => {
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index 71faf73..88d2107 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -173,6 +173,8 @@ export function useCreateStockMovementModel({
     onCreateNewProduct,
     onEditNewProductItem,
     onEditExistingProductBatchData,
+    inlineDuplicateWarning,
+    onInlineDuplicateWarningOpenChange,
   } = useStockMovementScanner({
     selectedMovementType,
     router,
@@ -495,5 +497,7 @@ export function useCreateStockMovementModel({
     missingProductBarcode,
     onMissingProductModalOpenChange,
     onCreateProductFromMissingModal,
+    inlineDuplicateWarning,
+    onInlineDuplicateWarningOpenChange,
   };
 }
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.types.ts b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
index e7e8ba1..08aed70 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.types.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.types.ts
@@ -157,6 +157,8 @@ export interface CreateStockMovementViewProps {
   missingProductBarcode: string | null;
   onMissingProductModalOpenChange: (open: boolean) => void;
   onCreateProductFromMissingModal: () => void;
+  inlineDuplicateWarning: string | null;
+  onInlineDuplicateWarningOpenChange: (open: boolean) => void;
   items: Array<{
     id: string;
     productId?: string;
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
index b0a6a68..d9c98e3 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
+++ b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
@@ -33,6 +33,7 @@ import { PermissionGate } from "@/components/permission-gate";
 import { cn } from "@/lib/utils";
 import { CreateStockMovementViewProps } from "./create-stock-movement.types";
 import { StockMovementScanner } from "./stock-movement-scanner.view";
+import { InlineDuplicateWarningDrawer } from "@/components/stock-movement/inline-duplicate-warning-drawer";
 import { StockMovementBatchDataModal } from "./stock-movement-batch-data-modal.view";
 import { StockMovementItemsList } from "./stock-movement-items-list.view";
 import {
@@ -145,6 +146,8 @@ function StockMovementCreateOverlays({
     onScannerOpenChange,
     shouldShowMissingCostPriceSuggestion,
     shouldShowMissingSalePriceSuggestion,
+    inlineDuplicateWarning,
+    onInlineDuplicateWarningOpenChange,
   } = viewState;
 
   return (
@@ -179,6 +182,10 @@ function StockMovementCreateOverlays({
         onOpenChange={onMissingProductModalOpenChange}
         onCreateProduct={onCreateProductFromMissingModal}
       />
+      <InlineDuplicateWarningDrawer
+        message={inlineDuplicateWarning}
+        onOpenChange={onInlineDuplicateWarningOpenChange}
+      />
     </>
   );
 }
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
index d6e8730..59e86f0 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.test.ts
@@ -759,6 +759,82 @@ describe("useNewProductInlineModel", () => {
     expect(mockWriteDraft).not.toHaveBeenCalled();
   });
 
+  it("avisa e não preenche barcode ao escanear produto novo já presente no inline", async () => {
+    currentDraft = createDraft({
+      items: [
+        {
+          quantity: 1,
+          productName: "Produto Inline",
+          newProductData: { name: "Produto Inline", barcode: "555000111" },
+        },
+      ],
+    });
+    mockGet.mockReset();
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => {
+        throw notFoundApiError();
+      }),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("555000111");
+    });
+
+    expect(result.current.inlineDuplicateWarning).toBe(
+      'O produto "Produto Inline" já está na lista de produtos da movimentação como um novo produto e não pode ser adicionado novamente.',
+    );
+    expect(toastWarning).not.toHaveBeenCalled();
+    expect(result.current.form.getValues("barcode")).not.toBe("555000111");
+    expect(result.current.scannedExistingProduct).toBeNull();
+
+    act(() => {
+      result.current.onInlineDuplicateWarningOpenChange?.(false);
+    });
+    expect(result.current.inlineDuplicateWarning).toBeNull();
+  });
+
+  it("acusa falha ao insistir em adicionar produto inline já escaneado", async () => {
+    currentDraft = createDraft({
+      items: [
+        {
+          quantity: 1,
+          productName: "Produto Inline",
+          newProductData: { name: "Produto Inline", barcode: "555000111" },
+        },
+      ],
+    });
+    mockGet.mockReset();
+    mockGet.mockImplementation(() => ({
+      json: vi.fn(async () => {
+        throw notFoundApiError();
+      }),
+    }));
+
+    const { result } = renderHook(() =>
+      useNewProductInlineModel({ movementType, editItem: editItemQuery }),
+    );
+
+    await act(async () => {
+      await result.current.handleBarcodeScan("555000111");
+    });
+    expect(result.current.inlineDuplicateWarning).not.toBeNull();
+
+    await act(async () => {
+      await result.current.onSubmit(
+        buildFormData({ name: "Outro Nome", barcode: "555000111" }),
+      );
+    });
+
+    expect(toastError).toHaveBeenCalledWith(
+      'O código 555000111 já está em uso pelo produto "Produto Inline" nesta movimentação.',
+    );
+    expect(mockWriteDraft).not.toHaveBeenCalled();
+  });
+
   it("bloqueia lote de produto existente quando há produto novo pendente com o mesmo barcode", async () => {
     currentDraft = createDraft({
       items: [
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
index 5e32d3c..f87df05 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
@@ -45,6 +45,7 @@ import { validateExistingProductBatchForm } from "../stock-movement-batch-form-v
 import {
   buildRepeatedProductBatchWarning,
   findDuplicateInlineProductError,
+  findScannedInlineProductDuplicateWarning,
   getPendingInlineProductBarcodeConflictError,
   hasExistingProductInItems,
 } from "../stock-movement-draft-guards";
@@ -220,6 +221,7 @@ export const useNewProductInlineModel = ({
   const [isScannerOpen, setIsScannerOpen] = useState(false);
   const [isAiModalOpen, setIsAiModalOpen] = useState(false);
   const [scannedExistingProduct, setScannedExistingProduct] = useState<ExistingProductInfo | null>(null);
+  const [inlineDuplicateWarning, setInlineDuplicateWarning] = useState<string | null>(null);
   const [existingProductBatchForm, setExistingProductBatchForm] = useState<ExistingProductBatchFormState>(EMPTY_BATCH_FORM);
   const nameInputRef = useRef<HTMLInputElement>(null);
   const { warehouseId } = useSelectedWarehouse();
@@ -465,11 +467,29 @@ export const useNewProductInlineModel = ({
       });
       return;
     }
-    if (lookup.status === "not-found") {
-      form.setValue("barcode", barcode);
+    if (lookup.status === "error") {
+      toast.error(lookup.message);
       return;
     }
-    toast.error(lookup.message);
+
+    // Product is not in stock (online catalog): make sure it isn't already in
+    // the movement as an inline (new) product before filling the barcode field.
+    const draft = await readStockMovementDraft();
+    const duplicateWarning = findScannedInlineProductDuplicateWarning(
+      draft?.items ?? [],
+      barcode,
+      editItemIndex,
+    );
+    if (duplicateWarning) {
+      setInlineDuplicateWarning(duplicateWarning);
+      return;
+    }
+
+    form.setValue("barcode", barcode);
+  };
+
+  const handleInlineDuplicateWarningOpenChange = (open: boolean): void => {
+    if (!open) setInlineDuplicateWarning(null);
   };
 
   const handleExistingProductModalOpenChange = (open: boolean): void => {
@@ -689,6 +709,8 @@ export const useNewProductInlineModel = ({
     scannedExistingProduct,
     onExistingProductModalOpenChange: handleExistingProductModalOpenChange,
     onCreateBatchForExistingProduct: handleCreateBatchForExistingProduct,
+    inlineDuplicateWarning,
+    onInlineDuplicateWarningOpenChange: handleInlineDuplicateWarningOpenChange,
     batchForm: existingProductBatchForm,
     onBatchOpenChange: handleBatchOpenChange,
     onBatchQuantityChange: (quantity: string) => updateBatchForm({ quantity }),
diff --git a/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts b/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
index 6dd4f29..afa1cf1 100644
--- a/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
+++ b/app/(pages)/stock-movements/create/stock-movement-draft-guards.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   buildRepeatedProductBatchWarning,
   findDuplicateInlineProductError,
+  findScannedInlineProductDuplicateWarning,
   getPendingInlineProductBarcodeConflictError,
   hasExistingProductInItems,
 } from "./stock-movement-draft-guards";
@@ -82,6 +83,27 @@ describe("getPendingInlineProductBarcodeConflictError", () => {
   });
 });
 
+describe("findScannedInlineProductDuplicateWarning", () => {
+  it("avisa quando barcode escaneado já pertence a produto novo do draft", () => {
+    expect(
+      findScannedInlineProductDuplicateWarning(draftItems, "789100000001"),
+    ).toBe(
+      'O produto "Produto Novo A" já está na lista de produtos da movimentação como um novo produto e não pode ser adicionado novamente.',
+    );
+  });
+
+  it("ignora o item em edição, barcode vazio e produto existente", () => {
+    expect(
+      findScannedInlineProductDuplicateWarning(draftItems, "789100000001", 0),
+    ).toBeNull();
+    expect(findScannedInlineProductDuplicateWarning(draftItems, null)).toBeNull();
+    expect(findScannedInlineProductDuplicateWarning(draftItems, "  ")).toBeNull();
+    expect(
+      findScannedInlineProductDuplicateWarning(draftItems, "789100000999"),
+    ).toBeNull();
+  });
+});
+
 describe("hasExistingProductInItems", () => {
   it("encontra item pelo productId", () => {
     expect(hasExistingProductInItems(draftItems, "p-1")).toBe(true);
diff --git a/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts b/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
index 36b66d6..145f03d 100644
--- a/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
+++ b/app/(pages)/stock-movements/create/stock-movement-draft-guards.ts
@@ -48,6 +48,22 @@ export const getPendingInlineProductBarcodeConflictError = (
   return `O código ${barcode} já pertence ao produto novo "${conflictingItem.productName}" nesta movimentação. Remova-o antes de adicionar o produto existente.`;
 };
 
+export const findScannedInlineProductDuplicateWarning = (
+  items: StockMovementDraftItem[],
+  barcode: string | null | undefined,
+  ignoredIndex: number | null = null,
+): string | null => {
+  const normalizedBarcode = barcode?.trim();
+  if (!normalizedBarcode) return null;
+  const conflictingItem = withoutIgnoredIndex(items, ignoredIndex).find(
+    (item) => item.newProductData?.barcode === normalizedBarcode,
+  );
+  if (!conflictingItem) return null;
+  const productName =
+    conflictingItem.newProductData?.name ?? conflictingItem.productName ?? "";
+  return `O produto "${productName}" já está na lista de produtos da movimentação como um novo produto e não pode ser adicionado novamente.`;
+};
+
 export const hasExistingProductInItems = (
   items: StockMovementDraftItem[],
   productId: string,
diff --git a/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
index 89abb1c..3e3c721 100644
--- a/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
+++ b/app/(pages)/stock-movements/create/use-stock-movement-scanner.model.ts
@@ -39,6 +39,8 @@ interface StockMovementScannerReturn {
   onBarcodeScan: (barcode: string) => Promise<void>;
   missingProductBarcode: string | null;
   onMissingProductModalOpenChange: (open: boolean) => void;
+  inlineDuplicateWarning: string | null;
+  onInlineDuplicateWarningOpenChange: (open: boolean) => void;
   onCreateProductFromMissingModal: () => Promise<void>;
   onCreateNewProduct: () => Promise<void>;
   onEditNewProductItem: (index: number) => Promise<void>;
@@ -67,6 +69,7 @@ export function useStockMovementScanner({
   const lastScannedBarcodeRef = useRef<string | null>(null);
   const [isScannerOpen, setIsScannerOpen] = useState(false);
   const [missingProductBarcode, setMissingProductBarcode] = useState<string | null>(null);
+  const [inlineDuplicateWarning, setInlineDuplicateWarning] = useState<string | null>(null);
 
   const findScannedProductBarcodeConflict = (
     barcode: string | null | undefined,
@@ -145,7 +148,7 @@ export function useStockMovementScanner({
     setMissingProductBarcode(barcode);
   };
 
-  const showPendingInlineProductToast = (barcode: string): boolean => {
+  const showPendingInlineProductWarning = (barcode: string): boolean => {
     const inlineItem = form.getValues("items").find((item) => {
       return item.newProductData?.barcode === barcode;
     });
@@ -153,10 +156,16 @@ export function useStockMovementScanner({
 
     const productName =
       inlineItem.productName || inlineItem.newProductData?.name || "Produto";
-    toast.warning(`${productName} já está na movimentação como produto novo.`);
+    setInlineDuplicateWarning(
+      `${productName} já está na movimentação como produto novo.`,
+    );
     return true;
   };
 
+  const handleInlineDuplicateWarningOpenChange = (open: boolean): void => {
+    if (!open) setInlineDuplicateWarning(null);
+  };
+
   const handleBarcodeScan = async (barcode: string) => {
     if (lastScannedBarcodeRef.current === barcode) return;
     lastScannedBarcodeRef.current = barcode;
@@ -170,7 +179,7 @@ export function useStockMovementScanner({
       return;
     }
     if (lookup.status === "not-found") {
-      if (showPendingInlineProductToast(barcode)) return;
+      if (showPendingInlineProductWarning(barcode)) return;
       showMissingProductToast(barcode);
       return;
     }
@@ -250,6 +259,8 @@ export function useStockMovementScanner({
     onBarcodeScan: handleBarcodeScan,
     missingProductBarcode,
     onMissingProductModalOpenChange: handleMissingProductModalOpenChange,
+    inlineDuplicateWarning,
+    onInlineDuplicateWarningOpenChange: handleInlineDuplicateWarningOpenChange,
     onCreateProductFromMissingModal: handleCreateProductFromMissingModal,
     onCreateNewProduct: handleCreateNewProduct,
     onEditNewProductItem: handleEditNewProductItem,
diff --git a/components/stock-movement/inline-duplicate-warning-drawer.tsx b/components/stock-movement/inline-duplicate-warning-drawer.tsx
new file mode 100644
index 0000000..dc0ee9c
--- /dev/null
+++ b/components/stock-movement/inline-duplicate-warning-drawer.tsx
@@ -0,0 +1,61 @@
+"use client";
+
+import { AlertCircle } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import {
+  Drawer,
+  DrawerContent,
+  DrawerDescription,
+  DrawerHeader,
+  DrawerTitle,
+} from "@/components/ui/drawer";
+
+interface InlineDuplicateWarningDrawerProps {
+  message: string | null | undefined;
+  onOpenChange: (open: boolean) => void;
+}
+
+/**
+ * Bottom drawer shown when a scanned barcode belongs to a product that is
+ * already in the movement as a new (inline) product and therefore cannot be
+ * added again. Shared by the stock movement creation flow and the inline
+ * new-product form.
+ */
+export const InlineDuplicateWarningDrawer = ({
+  message,
+  onOpenChange,
+}: InlineDuplicateWarningDrawerProps) => (
+  <Drawer open={Boolean(message)} onOpenChange={onOpenChange} direction="bottom">
+    <DrawerContent className="border-neutral-800 bg-[#171717]">
+      <div className="mx-auto w-full max-w-md">
+        <DrawerHeader className="px-4 pb-2 pt-4 text-left">
+          <div className="flex items-center gap-2">
+            <div className="flex size-8 items-center justify-center rounded-[4px] border border-amber-900/40 bg-amber-950/20">
+              <AlertCircle className="size-4 text-amber-500" />
+            </div>
+            <DrawerTitle className="text-sm font-bold uppercase tracking-wide text-white">
+              Produto já na movimentação
+            </DrawerTitle>
+          </div>
+        </DrawerHeader>
+        <div className="px-4 pb-2">
+          <div className="rounded-[4px] border border-amber-900/30 bg-amber-950/10 px-4 py-3">
+            <DrawerDescription className="text-xs leading-relaxed text-amber-400/90">
+              {message}
+            </DrawerDescription>
+          </div>
+        </div>
+        <div className="flex flex-col gap-2 p-4">
+          <Button
+            type="button"
+            onClick={() => onOpenChange(false)}
+            className="h-10 w-full rounded-[4px] bg-blue-600 text-xs font-bold uppercase tracking-wide text-white hover:bg-blue-700"
+          >
+            Entendi
+          </Button>
+        </div>
+      </div>
+    </DrawerContent>
+  </Drawer>
+);

From 5ff2ba9e9d1e7937f0cee22134dafdc1d972dd0a Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 20:54:07 -0300
Subject: [PATCH 23/32] feat(sidebar): add exploratory tests navigation link

Add 'Testes' nav item with ClipboardCheck icon linking to /exploratory-tests.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 components/layout/app-sidebar.tsx | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/components/layout/app-sidebar.tsx b/components/layout/app-sidebar.tsx
index aeaff61..f3cdd9b 100644
--- a/components/layout/app-sidebar.tsx
+++ b/components/layout/app-sidebar.tsx
@@ -11,6 +11,7 @@ import {
   ArrowLeftRight,
   Activity,
   ShoppingCart,
+  ClipboardCheck,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { useAuth } from "@/lib/contexts/auth-context";
@@ -66,6 +67,11 @@ const navItems: NavItem[] = [
     Icon: Folder,
     requiredPermission: "categories:read",
   },
+  {
+    href: "/exploratory-tests",
+    label: "Testes",
+    Icon: ClipboardCheck,
+  },
 ];
 
 export const AppSidebar = ({ onNavigate }: { onNavigate?: () => void }) => {

From 07355c8a4bb67aab2d3f59d4caa6f2ffe851f6f5 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 21:52:05 -0300
Subject: [PATCH 24/32] refactor(footer): extract useFooterVisibility hook from
 duplicate scroll logic

Three pages (stock-movement create, new-transfer, product-form) had
identical scroll-driven footer visibility logic duplicated inline.

- Add shouldShowFooter pure function with tests
- Add useFooterVisibility hook (wraps scroll listener + shouldShowFooter)
- Replace inline useState/useRef/useEffect in create-stock-movement,
  new-transfer, and product-form models with the shared hook
- Remove dead shouldShowStockMovementFooter and shouldShowTransferFooter
  exports and their tests
- Add transition-transform + motion-reduce:transition-none to all
  sticky footer bars for smooth show/hide
- Add pointer-events-none when footer is hidden so invisible footer
  doesn't block clicks on content behind it
- Add onInvalidSubmit prop to ProductFormProps (wired later by
  scroll-to-error feature)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../products/components/product-form.types.ts |   1 +
 .../products/components/product-form.view.tsx |  32 ++---
 .../create-stock-movement.model.test.ts       |  32 -----
 .../create/create-stock-movement.model.ts     |  24 +---
 .../create/create-stock-movement.view.tsx     |   2 +-
 .../create/stock-movement-product-options.ts  |  17 ---
 .../transfers/new/new-transfer.model.test.ts  |  32 -----
 .../transfers/new/new-transfer.model.ts       |  41 +-----
 .../transfers/new/new-transfer.view.tsx       |   2 +-
 .../should-show-footer.test.ts                | 126 ++++++++++++++++++
 hooks/footer-visibility/should-show-footer.ts |  30 +++++
 .../use-footer-visibility.test.ts             | 118 ++++++++++++++++
 .../use-footer-visibility.ts                  |  55 ++++++++
 13 files changed, 347 insertions(+), 165 deletions(-)
 create mode 100644 hooks/footer-visibility/should-show-footer.test.ts
 create mode 100644 hooks/footer-visibility/should-show-footer.ts
 create mode 100644 hooks/footer-visibility/use-footer-visibility.test.ts
 create mode 100644 hooks/footer-visibility/use-footer-visibility.ts

diff --git a/app/(pages)/products/components/product-form.types.ts b/app/(pages)/products/components/product-form.types.ts
index d4f4194..14516ec 100644
--- a/app/(pages)/products/components/product-form.types.ts
+++ b/app/(pages)/products/components/product-form.types.ts
@@ -93,6 +93,7 @@ export interface NewProductBatchOverlay {
 export interface ProductFormProps {
   mode: 'create' | 'edit' | 'inline';
   onSubmit: (data: ProductCreateFormData) => void;
+  onInvalidSubmit?: () => void; // Called when submit fails validation (e.g. to scroll to the first errored field)
   isSubmitting: boolean;
   form: UseFormReturn<ProductCreateFormData>;
 
diff --git a/app/(pages)/products/components/product-form.view.tsx b/app/(pages)/products/components/product-form.view.tsx
index e9a2d60..05b3d35 100644
--- a/app/(pages)/products/components/product-form.view.tsx
+++ b/app/(pages)/products/components/product-form.view.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import Image from "next/image";
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useState } from "react";
 import { CustomAttributesBuilder } from "@/components/product/custom-attributes-builder";
 import { BarcodeScannerModal } from "@/components/product/barcode-scanner-modal";
 import { ProductAiFillModal } from "@/components/product/product-ai-fill-modal";
@@ -72,6 +72,7 @@ import {
 } from "lucide-react";
 import Link from "next/link";
 import { PermissionGate } from "@/components/permission-gate";
+import { useFooterVisibility } from "@/hooks/footer-visibility/use-footer-visibility";
 import type { BatchesDrawerProps, ProductFormProps } from "./product-form.types";
 import { cn } from "@/lib/utils";
 
@@ -152,32 +153,16 @@ export const ProductForm = (productForm: ProductFormProps) => {
   const isInlineEdit = Boolean(productForm.isInlineEdit);
   const profit = sellingPrice - costPrice;
   const margin = costPrice > 0 ? (profit / costPrice) * 100 : 0;
-  const [isFooterVisible, setIsFooterVisible] = useState(true);
+  const { isFooterVisible } = useFooterVisibility();
   const [showMobileBatchModeToggle, setShowMobileBatchModeToggle] = useState(
     isInlineMode && !isInlineEdit && continuousMode,
   );
-  const lastScrollYRef = useRef(0);
 
   useEffect(() => {
     if (!isInlineMode || isInlineEdit || !continuousMode) return;
     setShowMobileBatchModeToggle(true);
   }, [continuousMode, isInlineEdit, isInlineMode]);
 
-  useEffect(() => {
-    const handleScroll = (): void => {
-      const currentScrollY = window.scrollY;
-      const maxScrollY = document.documentElement.scrollHeight - window.innerHeight;
-      const isAtPageEnd = currentScrollY >= maxScrollY - 8;
-      const isScrollingUp = currentScrollY < lastScrollYRef.current;
-      setIsFooterVisible(isScrollingUp || isAtPageEnd || currentScrollY < 8);
-      lastScrollYRef.current = Math.max(currentScrollY, 0);
-    };
-
-    handleScroll();
-    window.addEventListener("scroll", handleScroll, { passive: true });
-    return () => window.removeEventListener("scroll", handleScroll);
-  }, []);
-
   const viewState: ProductFormViewState = {
     batchesDrawerState: mode === "edit" ? productForm.batchesDrawer : undefined,
     continuousMode,
@@ -331,7 +316,12 @@ const ProductFormBody = ({
   viewState: ProductFormViewState;
 }) => (
   <Form {...productForm.form}>
-    <form onSubmit={productForm.form.handleSubmit(productForm.onSubmit)}>
+    <form
+      onSubmit={productForm.form.handleSubmit(
+        productForm.onSubmit,
+        productForm.onInvalidSubmit,
+      )}
+    >
       <div className="grid grid-cols-1 gap-6 lg:grid-cols-3">
         <ProductMainColumn productForm={productForm} viewState={viewState} />
         <ProductSidebar productForm={productForm} viewState={viewState} />
@@ -1149,10 +1139,10 @@ const ProductFooterActionBar = ({
 }) => (
   <div
     className={cn(
-      "fixed bottom-0 left-0 right-0 z-40 border-t border-neutral-800 bg-[#0A0A0A]/95 p-4 backdrop-blur-sm md:ml-[var(--sidebar-width)]",
+      "fixed bottom-0 left-0 right-0 z-40 border-t border-neutral-800 bg-[#0A0A0A]/95 p-4 backdrop-blur-sm transition-transform duration-200 ease-in-out motion-reduce:transition-none md:ml-[var(--sidebar-width)]",
       viewState.isFooterVisible
         ? "translate-y-0"
-        : "translate-y-[calc(100%+1rem)]",
+        : "pointer-events-none translate-y-[calc(100%+1rem)]",
     )}
   >
     <div className="mx-auto flex w-full max-w-7xl flex-col items-center gap-3 px-4 md:flex-row md:justify-end md:px-6 lg:px-8">
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
index 1c98d9f..2ff8438 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.test.ts
@@ -6,7 +6,6 @@ import {
   buildStockMovementProductSearchUrl,
   formatStockMovementProductLabel,
   mapStockMovementProductOptions,
-  shouldShowStockMovementFooter,
 } from "./stock-movement-product-options";
 import type { CreateStockMovementSchema } from "./create-stock-movement.schema";
 import type {
@@ -525,37 +524,6 @@ describe("helpers de produto", () => {
       sellingPrice: 2490,
     });
   });
-
-  it("exibe footer no fim da pagina ou quando usuario rola para cima", () => {
-    expect(
-      shouldShowStockMovementFooter({
-        currentScrollY: 200,
-        lastScrollY: 100,
-        maxScrollY: 1000,
-      }),
-    ).toBe(false);
-    expect(
-      shouldShowStockMovementFooter({
-        currentScrollY: 995,
-        lastScrollY: 900,
-        maxScrollY: 1000,
-      }),
-    ).toBe(true);
-    expect(
-      shouldShowStockMovementFooter({
-        currentScrollY: 600,
-        lastScrollY: 700,
-        maxScrollY: 1000,
-      }),
-    ).toBe(true);
-    expect(
-      shouldShowStockMovementFooter({
-        currentScrollY: 0,
-        lastScrollY: 0,
-        maxScrollY: 0,
-      }),
-    ).toBe(true);
-  });
 });
 
 describe("useCreateStockMovementModel", () => {
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.model.ts b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
index 88d2107..87d6a85 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.model.ts
+++ b/app/(pages)/stock-movements/create/create-stock-movement.model.ts
@@ -43,9 +43,9 @@ import {
   formatStockMovementProductLabel,
   mapStockMovementProductOptions,
   PRODUCT_SEARCH_LIMIT,
-  shouldShowStockMovementFooter,
   type ProductListResponse,
 } from "./stock-movement-product-options";
+import { useFooterVisibility } from "@/hooks/footer-visibility/use-footer-visibility";
 import { useStockMovementDraftPersistence } from "./use-stock-movement-draft-persistence.model";
 import { useExistingProductBatchForm } from "./use-existing-product-batch-form.model";
 import { isSelectedInMovement, useStockMovementScanner } from "./use-stock-movement-scanner.model";
@@ -70,8 +70,7 @@ export function useCreateStockMovementModel({
   const [isProductOptionsOpen, setIsProductOptionsOpen] = useState(false);
   const [itemQuantity, setItemQuantity] = useState("");
   const [addItemError, setAddItemError] = useState<string | null>(null);
-  const [isFooterVisible, setIsFooterVisible] = useState(false);
-  const lastScrollYRef = useRef(0);
+  const { isFooterVisible } = useFooterVisibility();
   const productSearchBlurTimeoutRef =
     useRef<ReturnType<typeof setTimeout> | null>(null);
   const selectedMovementType = isManualMovementType(typeParam)
@@ -255,25 +254,6 @@ export function useCreateStockMovementModel({
     };
   }, []);
 
-  useEffect(() => {
-    const handleScroll = (): void => {
-      const currentScrollY = window.scrollY;
-      const maxScrollY = document.documentElement.scrollHeight - window.innerHeight;
-      setIsFooterVisible(
-        shouldShowStockMovementFooter({
-          currentScrollY,
-          lastScrollY: lastScrollYRef.current,
-          maxScrollY,
-        }),
-      );
-      lastScrollYRef.current = Math.max(currentScrollY, 0);
-    };
-
-    handleScroll();
-    window.addEventListener("scroll", handleScroll, { passive: true });
-    return () => window.removeEventListener("scroll", handleScroll);
-  }, []);
-
   const productOptions = productSearchUrl
     ? mapStockMovementProductOptions(productSearchData).slice(
         0,
diff --git a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
index d9c98e3..60e3abb 100644
--- a/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
+++ b/app/(pages)/stock-movements/create/create-stock-movement.view.tsx
@@ -589,7 +589,7 @@ function StockMovementSubmitBar({
   return (
     <FixedBottomBar
       className={cn(
-        "bg-[#0A0A0A]/95 backdrop-blur-sm",
+        "bg-[#0A0A0A]/95 backdrop-blur-sm transition-transform duration-200 ease-in-out motion-reduce:transition-none",
         isFooterVisible
           ? "pointer-events-auto translate-y-0"
           : "pointer-events-none translate-y-[calc(100%+1rem)]",
diff --git a/app/(pages)/stock-movements/create/stock-movement-product-options.ts b/app/(pages)/stock-movements/create/stock-movement-product-options.ts
index 4cb4764..65d80ca 100644
--- a/app/(pages)/stock-movements/create/stock-movement-product-options.ts
+++ b/app/(pages)/stock-movements/create/stock-movement-product-options.ts
@@ -9,23 +9,6 @@ export interface ProductListResponse {
 
 export const PRODUCT_SEARCH_LIMIT = 5;
 
-interface FooterVisibilityParams {
-  currentScrollY: number;
-  lastScrollY: number;
-  maxScrollY: number;
-}
-
-export const shouldShowStockMovementFooter = ({
-  currentScrollY,
-  lastScrollY,
-  maxScrollY,
-}: FooterVisibilityParams): boolean => {
-  const isShortPage = maxScrollY <= 8;
-  const isAtPageEnd = currentScrollY >= maxScrollY - 8;
-  const isScrollingUp = currentScrollY < lastScrollY;
-  return isShortPage || isAtPageEnd || isScrollingUp;
-};
-
 export const formatStockMovementProductLabel = (
   product: StockMovementProductOption,
 ): string => (product.sku ? `${product.name} (${product.sku})` : product.name);
diff --git a/app/(pages)/transfers/new/new-transfer.model.test.ts b/app/(pages)/transfers/new/new-transfer.model.test.ts
index 564cfc2..d2cf345 100644
--- a/app/(pages)/transfers/new/new-transfer.model.test.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.test.ts
@@ -7,7 +7,6 @@ import {
   formatTransferProductLabel,
   formatTransferProductQuantityLabel,
   getWarehouseBatchQuantityByProduct,
-  shouldShowTransferFooter,
   useNewTransferModel,
 } from "./new-transfer.model";
 import type { NewTransferSchema } from "./new-transfer.schema";
@@ -385,37 +384,6 @@ describe("helpers de nova transferência", () => {
     expect(clampTransferBatchQuantity("8", 5)).toBe("5");
     expect(clampTransferBatchQuantity("8")).toBe("8");
   });
-
-  it("mostra footer no fim da página ou quando usuário rola para cima", () => {
-    expect(
-      shouldShowTransferFooter({
-        currentScrollY: 200,
-        lastScrollY: 100,
-        maxScrollY: 1000,
-      }),
-    ).toBe(false);
-    expect(
-      shouldShowTransferFooter({
-        currentScrollY: 995,
-        lastScrollY: 900,
-        maxScrollY: 1000,
-      }),
-    ).toBe(true);
-    expect(
-      shouldShowTransferFooter({
-        currentScrollY: 600,
-        lastScrollY: 700,
-        maxScrollY: 1000,
-      }),
-    ).toBe(true);
-    expect(
-      shouldShowTransferFooter({
-        currentScrollY: 0,
-        lastScrollY: 0,
-        maxScrollY: 0,
-      }),
-    ).toBe(true);
-  });
 });
 
 describe("useNewTransferModel", () => {
diff --git a/app/(pages)/transfers/new/new-transfer.model.ts b/app/(pages)/transfers/new/new-transfer.model.ts
index 5f75faa..f7bb5a4 100644
--- a/app/(pages)/transfers/new/new-transfer.model.ts
+++ b/app/(pages)/transfers/new/new-transfer.model.ts
@@ -7,6 +7,7 @@ import { toast } from "sonner";
 
 import { useBreadcrumb } from "@/components/breadcrumb";
 import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
+import { useFooterVisibility } from "@/hooks/footer-visibility/use-footer-visibility";
 import { api } from "@/lib/api";
 import { newTransferSchema, type NewTransferSchema } from "./new-transfer.schema";
 import type {
@@ -134,23 +135,6 @@ export const getWarehouseBatchQuantityByProduct = (
   }, new Map<string, number>());
 };
 
-interface TransferFooterVisibilityParams {
-  currentScrollY: number;
-  lastScrollY: number;
-  maxScrollY: number;
-}
-
-export const shouldShowTransferFooter = ({
-  currentScrollY,
-  lastScrollY,
-  maxScrollY,
-}: TransferFooterVisibilityParams): boolean => {
-  const isShortPage = maxScrollY <= 8;
-  const isAtPageEnd = currentScrollY >= maxScrollY - 8;
-  const isScrollingUp = currentScrollY < lastScrollY;
-  return isShortPage || isAtPageEnd || isScrollingUp;
-};
-
 const resolvePositiveQuantity = (value: string): number => {
   const quantity = Number(value);
   return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
@@ -171,14 +155,13 @@ export function useNewTransferModel(): NewTransferViewProps {
   const [batchDrawer, setBatchDrawer] =
     useState<TransferBatchDrawerState>(EMPTY_BATCH_DRAWER);
   const [addItemError, setAddItemError] = useState<string | null>(null);
-  const [isFooterVisible, setIsFooterVisible] = useState(true);
+  const { isFooterVisible } = useFooterVisibility();
   const productSearchBlurTimeoutRef =
     useRef<ReturnType<typeof setTimeout> | null>(null);
   const lastScannedBarcodeRef = useRef<string | null>(null);
   const barcodeResetTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(
     null,
   );
-  const lastScrollYRef = useRef(0);
 
   useBreadcrumb({
     title: "Nova Transferência",
@@ -240,26 +223,6 @@ export function useNewTransferModel(): NewTransferViewProps {
     };
   }, []);
 
-  useEffect(() => {
-    const handleScroll = (): void => {
-      const currentScrollY = window.scrollY;
-      const maxScrollY =
-        document.documentElement.scrollHeight - window.innerHeight;
-      setIsFooterVisible(
-        shouldShowTransferFooter({
-          currentScrollY,
-          lastScrollY: lastScrollYRef.current,
-          maxScrollY,
-        }),
-      );
-      lastScrollYRef.current = Math.max(currentScrollY, 0);
-    };
-
-    handleScroll();
-    window.addEventListener("scroll", handleScroll, { passive: true });
-    return () => window.removeEventListener("scroll", handleScroll);
-  }, []);
-
   const warehouses = (warehousesData?.data || []).flatMap((warehouse) =>
     warehouse.id === currentWarehouseId
       ? []
diff --git a/app/(pages)/transfers/new/new-transfer.view.tsx b/app/(pages)/transfers/new/new-transfer.view.tsx
index 2f8e1c7..a04ca90 100644
--- a/app/(pages)/transfers/new/new-transfer.view.tsx
+++ b/app/(pages)/transfers/new/new-transfer.view.tsx
@@ -316,7 +316,7 @@ function TransferSubmitBar({
   return (
     <FixedBottomBar
       className={cn(
-        "bg-[#0A0A0A]/95 backdrop-blur-sm transition-transform duration-200 ease-in-out",
+        "bg-[#0A0A0A]/95 backdrop-blur-sm transition-transform duration-200 ease-in-out motion-reduce:transition-none",
         isFooterVisible
           ? "translate-y-0"
           : "pointer-events-none translate-y-[calc(100%+1rem)]",
diff --git a/hooks/footer-visibility/should-show-footer.test.ts b/hooks/footer-visibility/should-show-footer.test.ts
new file mode 100644
index 0000000..3e50342
--- /dev/null
+++ b/hooks/footer-visibility/should-show-footer.test.ts
@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { shouldShowFooter, FOOTER_SCROLL_THRESHOLD } from "./should-show-footer";
+
+describe("shouldShowFooter", () => {
+  it("mostra footer em página curta sem espaço para rolar", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 0,
+        lastScrollY: 0,
+        maxScrollY: 0,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 4,
+        lastScrollY: 2,
+        maxScrollY: FOOTER_SCROLL_THRESHOLD,
+      }),
+    ).toBe(true);
+  });
+
+  it("mostra footer no fim da página mesmo rolando para baixo", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 995,
+        lastScrollY: 900,
+        maxScrollY: 1000,
+      }),
+    ).toBe(true);
+  });
+
+  it("mostra footer no topo de página longa", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 4,
+        lastScrollY: 50,
+        maxScrollY: 1000,
+      }),
+    ).toBe(true);
+  });
+
+  it("oculta footer rolando para baixo no meio da página", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 200,
+        lastScrollY: 100,
+        maxScrollY: 1000,
+      }),
+    ).toBe(false);
+  });
+
+  it("mostra footer rolando para cima no meio da página", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 600,
+        lastScrollY: 700,
+        maxScrollY: 1000,
+      }),
+    ).toBe(true);
+  });
+
+  it("preserva estado anterior em micro-rolagens abaixo do limiar", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 500,
+        lastScrollY: 502,
+        maxScrollY: 1000,
+        previousVisible: false,
+      }),
+    ).toBe(false);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 500,
+        lastScrollY: 498,
+        maxScrollY: 1000,
+        previousVisible: true,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 500,
+        lastScrollY: 506,
+        maxScrollY: 1000,
+        previousVisible: true,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 500,
+        lastScrollY: 494,
+        maxScrollY: 1000,
+        previousVisible: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("respeita limiar customizado quando fornecido", () => {
+    expect(
+      shouldShowFooter({
+        currentScrollY: 515,
+        lastScrollY: 500,
+        maxScrollY: 1000,
+        previousVisible: true,
+        scrollThreshold: 20,
+      }),
+    ).toBe(true);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 525,
+        lastScrollY: 500,
+        maxScrollY: 1000,
+        previousVisible: true,
+        scrollThreshold: 20,
+      }),
+    ).toBe(false);
+    expect(
+      shouldShowFooter({
+        currentScrollY: 500,
+        lastScrollY: 525,
+        maxScrollY: 1000,
+        previousVisible: false,
+        scrollThreshold: 20,
+      }),
+    ).toBe(true);
+  });
+});
diff --git a/hooks/footer-visibility/should-show-footer.ts b/hooks/footer-visibility/should-show-footer.ts
new file mode 100644
index 0000000..6c3df1c
--- /dev/null
+++ b/hooks/footer-visibility/should-show-footer.ts
@@ -0,0 +1,30 @@
+export const FOOTER_SCROLL_THRESHOLD = 8;
+
+export interface FooterVisibilityParams {
+  currentScrollY: number;
+  lastScrollY: number;
+  maxScrollY: number;
+  previousVisible?: boolean;
+  scrollThreshold?: number;
+}
+
+export const shouldShowFooter = ({
+  currentScrollY,
+  lastScrollY,
+  maxScrollY,
+  previousVisible = true,
+  scrollThreshold = FOOTER_SCROLL_THRESHOLD,
+}: FooterVisibilityParams): boolean => {
+  const isShortPage = maxScrollY <= scrollThreshold;
+  if (isShortPage) return true;
+
+  const isAtPageEnd = currentScrollY >= maxScrollY - scrollThreshold;
+  if (isAtPageEnd) return true;
+
+  if (currentScrollY <= scrollThreshold) return true;
+
+  const scrollDelta = currentScrollY - lastScrollY;
+  if (Math.abs(scrollDelta) < scrollThreshold) return previousVisible;
+
+  return scrollDelta < 0;
+};
diff --git a/hooks/footer-visibility/use-footer-visibility.test.ts b/hooks/footer-visibility/use-footer-visibility.test.ts
new file mode 100644
index 0000000..aa5c86d
--- /dev/null
+++ b/hooks/footer-visibility/use-footer-visibility.test.ts
@@ -0,0 +1,118 @@
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useFooterVisibility } from "./use-footer-visibility";
+
+type ScrollMetrics = {
+  scrollY: number;
+  scrollHeight: number;
+  innerHeight: number;
+};
+
+const setScrollMetrics = ({ scrollY, scrollHeight, innerHeight }: ScrollMetrics): void => {
+  Object.defineProperty(window, "scrollY", {
+    configurable: true,
+    value: scrollY,
+  });
+  Object.defineProperty(window, "innerHeight", {
+    configurable: true,
+    value: innerHeight,
+  });
+  Object.defineProperty(document.documentElement, "scrollHeight", {
+    configurable: true,
+    value: scrollHeight,
+  });
+};
+
+const fireScroll = (): void => {
+  act(() => {
+    window.dispatchEvent(new Event("scroll"));
+  });
+};
+
+const resetScrollMetrics = (): void => {
+  setScrollMetrics({ scrollY: 0, scrollHeight: 0, innerHeight: 0 });
+};
+
+describe("useFooterVisibility", () => {
+  beforeEach(() => {
+    resetScrollMetrics();
+  });
+
+  afterEach(() => {
+    resetScrollMetrics();
+    vi.restoreAllMocks();
+  });
+
+  it("inicia visível por padrão em página curta", () => {
+    const { result } = renderHook(() => useFooterVisibility());
+    expect(result.current.isFooterVisible).toBe(true);
+  });
+
+  it("mantém initialVisible false em página longa antes de qualquer scroll", () => {
+    setScrollMetrics({ scrollY: 300, scrollHeight: 1000, innerHeight: 200 });
+    const { result } = renderHook(() =>
+      useFooterVisibility({ initialVisible: false }),
+    );
+    expect(result.current.isFooterVisible).toBe(false);
+  });
+
+  it("oculta footer ao rolar para baixo no meio da página", () => {
+    setScrollMetrics({ scrollY: 0, scrollHeight: 1000, innerHeight: 200 });
+    const { result } = renderHook(() => useFooterVisibility());
+
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(true);
+
+    setScrollMetrics({ scrollY: 300, scrollHeight: 1000, innerHeight: 200 });
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(false);
+  });
+
+  it("mostra footer ao rolar para cima no meio da página", () => {
+    setScrollMetrics({ scrollY: 300, scrollHeight: 1000, innerHeight: 200 });
+    const { result } = renderHook(() => useFooterVisibility());
+
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(false);
+
+    setScrollMetrics({ scrollY: 200, scrollHeight: 1000, innerHeight: 200 });
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(true);
+  });
+
+  it("mostra footer ao atingir o fim da página", () => {
+    setScrollMetrics({ scrollY: 400, scrollHeight: 1000, innerHeight: 200 });
+    const { result } = renderHook(() => useFooterVisibility());
+
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(false);
+
+    setScrollMetrics({ scrollY: 795, scrollHeight: 1000, innerHeight: 200 });
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(true);
+  });
+
+  it("preserva estado em micro-rolagens abaixo do limiar", () => {
+    setScrollMetrics({ scrollY: 500, scrollHeight: 1000, innerHeight: 200 });
+    const { result } = renderHook(() => useFooterVisibility());
+
+    fireScroll();
+    const estadoAposPrimeiraLeitura = result.current.isFooterVisible;
+
+    setScrollMetrics({ scrollY: 503, scrollHeight: 1000, innerHeight: 200 });
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(estadoAposPrimeiraLeitura);
+
+    setScrollMetrics({ scrollY: 499, scrollHeight: 1000, innerHeight: 200 });
+    fireScroll();
+    expect(result.current.isFooterVisible).toBe(estadoAposPrimeiraLeitura);
+  });
+
+  it("remove listener de scroll ao desmontar", () => {
+    const removeSpy = vi.spyOn(window, "removeEventListener");
+    const { unmount } = renderHook(() => useFooterVisibility());
+
+    unmount();
+    expect(removeSpy).toHaveBeenCalledWith("scroll", expect.any(Function));
+  });
+});
diff --git a/hooks/footer-visibility/use-footer-visibility.ts b/hooks/footer-visibility/use-footer-visibility.ts
new file mode 100644
index 0000000..892b2bc
--- /dev/null
+++ b/hooks/footer-visibility/use-footer-visibility.ts
@@ -0,0 +1,55 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import {
+  shouldShowFooter,
+  type FooterVisibilityParams,
+} from "./should-show-footer";
+
+export interface UseFooterVisibilityOptions {
+  initialVisible?: boolean;
+  scrollThreshold?: number;
+}
+
+export interface FooterVisibilityState {
+  isFooterVisible: boolean;
+}
+
+const resolveScrollMetrics = (): Pick<
+  FooterVisibilityParams,
+  "currentScrollY" | "maxScrollY"
+> => ({
+  currentScrollY: window.scrollY,
+  maxScrollY:
+    document.documentElement.scrollHeight - window.innerHeight,
+});
+
+export const useFooterVisibility = ({
+  initialVisible = true,
+  scrollThreshold,
+}: UseFooterVisibilityOptions = {}): FooterVisibilityState => {
+  const [isFooterVisible, setIsFooterVisible] = useState(initialVisible);
+  const lastScrollYRef = useRef(0);
+
+  useEffect(() => {
+    const handleScroll = (): void => {
+      const { currentScrollY, maxScrollY } = resolveScrollMetrics();
+      setIsFooterVisible((prevVisible) =>
+        shouldShowFooter({
+          currentScrollY,
+          lastScrollY: lastScrollYRef.current,
+          maxScrollY,
+          previousVisible: prevVisible,
+          scrollThreshold,
+        }),
+      );
+      lastScrollYRef.current = Math.max(currentScrollY, 0);
+    };
+
+    handleScroll();
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => window.removeEventListener("scroll", handleScroll);
+  }, [scrollThreshold]);
+
+  return { isFooterVisible };
+};

From 5ddd5523186db6e52546589e4c587116dc44d197 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 21:52:23 -0300
Subject: [PATCH 25/32] feat(new-product): extract custom attribute validation
 and scroll-to-error

- Extract customAttributeFieldId and findCustomAttributeError from inline
  model into custom-attribute-validation module + tests
- Extract scrollToFieldById and scrollToFirstInvalidField into
  scroll-to-first-invalid-field module + tests
- Replace inline custom attribute validation in useNewProductInlineModel
  with findCustomAttributeError + scrollToFieldById
- Add handleInvalidSubmit callback that scrolls to the first
  react-hook-form invalid field on submit failure (deferred via rAF)
- Wire onInvalidSubmit through product-form via the prop added earlier
- findCustomAttributeError returns structured error {index, field, message}
  instead of raw toast calls, enabling targeted scroll behavior

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../custom-attribute-validation.test.ts       |  69 ++++++++++
 .../custom-attribute-validation.ts            |  48 +++++++
 .../new-product/new-product-inline.model.ts   |  34 +++--
 .../scroll-to-first-invalid-field.test.ts     | 129 ++++++++++++++++++
 .../scroll-to-first-invalid-field.ts          |  43 ++++++
 5 files changed, 308 insertions(+), 15 deletions(-)
 create mode 100644 app/(pages)/stock-movements/create/new-product/custom-attribute-validation.test.ts
 create mode 100644 app/(pages)/stock-movements/create/new-product/custom-attribute-validation.ts
 create mode 100644 app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.test.ts
 create mode 100644 app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.ts

diff --git a/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.test.ts b/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.test.ts
new file mode 100644
index 0000000..d37e97f
--- /dev/null
+++ b/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import {
+  customAttributeFieldId,
+  findCustomAttributeError,
+} from "./custom-attribute-validation";
+import type { CustomAttribute } from "@/components/product/custom-attributes-builder";
+
+const attribute = (
+  id: string,
+  key: string,
+  value: string,
+): CustomAttribute => ({ id, key, value });
+
+describe("findCustomAttributeError", () => {
+  it("returns null when every row has a name and a value", () => {
+    const attributes = [attribute("a", "cor", "azul"), attribute("b", "peso", "1kg")];
+
+    expect(findCustomAttributeError(attributes)).toBeNull();
+  });
+
+  it("points at the empty name field of the first incomplete row", () => {
+    const attributes = [attribute("a", "cor", "azul"), attribute("b", "", "1kg")];
+
+    expect(findCustomAttributeError(attributes)).toEqual({
+      index: 1,
+      field: "key",
+      message: "Atributo 2: Nome e valor são obrigatórios",
+    });
+  });
+
+  it("points at the value field when only the value is missing", () => {
+    const attributes = [attribute("a", "cor", "")];
+
+    expect(findCustomAttributeError(attributes)).toEqual({
+      index: 0,
+      field: "value",
+      message: "Atributo 1: Nome e valor são obrigatórios",
+    });
+  });
+
+  it("flags a duplicate name on the second occurrence, case-insensitively", () => {
+    const attributes = [
+      attribute("a", "Cor", "azul"),
+      attribute("b", "cor", "verde"),
+    ];
+
+    expect(findCustomAttributeError(attributes)).toEqual({
+      index: 1,
+      field: "key",
+      message: 'Já existe um atributo com o nome "cor"',
+    });
+  });
+
+  it("reports incomplete rows before duplicates", () => {
+    const attributes = [
+      attribute("a", "cor", "azul"),
+      attribute("b", "cor", ""),
+    ];
+
+    expect(findCustomAttributeError(attributes)?.field).toBe("value");
+  });
+});
+
+describe("customAttributeFieldId", () => {
+  it("builds the DOM id used by CustomAttributesBuilder", () => {
+    expect(customAttributeFieldId(2, "key")).toBe("attr-key-2");
+    expect(customAttributeFieldId(0, "value")).toBe("attr-value-0");
+  });
+});
diff --git a/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.ts b/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.ts
new file mode 100644
index 0000000..2d6d0b9
--- /dev/null
+++ b/app/(pages)/stock-movements/create/new-product/custom-attribute-validation.ts
@@ -0,0 +1,48 @@
+import type { CustomAttribute } from "@/components/product/custom-attributes-builder";
+
+export interface CustomAttributeError {
+  index: number;
+  field: "key" | "value";
+  message: string;
+}
+
+/** DOM id of a custom attribute input, mirroring CustomAttributesBuilder. */
+export const customAttributeFieldId = (
+  index: number,
+  field: "key" | "value",
+): string => `attr-${field}-${index}`;
+
+/**
+ * Returns the first blocking error among the custom attribute rows — an
+ * incomplete row first, then a duplicate name — or null when all rows are
+ * valid. The returned `index`/`field` point at the input to scroll to.
+ */
+export const findCustomAttributeError = (
+  attributes: CustomAttribute[],
+): CustomAttributeError | null => {
+  const incompleteIndex = attributes.findIndex(
+    (attr) => !attr.key.trim() || !attr.value.trim(),
+  );
+  if (incompleteIndex >= 0) {
+    const attribute = attributes[incompleteIndex];
+    return {
+      index: incompleteIndex,
+      field: attribute.key.trim() ? "value" : "key",
+      message: `Atributo ${incompleteIndex + 1}: Nome e valor são obrigatórios`,
+    };
+  }
+
+  const keys = attributes.map((attr) => attr.key.trim().toLowerCase());
+  const duplicateIndex = keys.findIndex(
+    (key, index) => keys.indexOf(key) !== index,
+  );
+  if (duplicateIndex >= 0) {
+    return {
+      index: duplicateIndex,
+      field: "key",
+      message: `Já existe um atributo com o nome "${keys[duplicateIndex]}"`,
+    };
+  }
+
+  return null;
+};
diff --git a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
index f87df05..f606bcd 100644
--- a/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
+++ b/app/(pages)/stock-movements/create/new-product/new-product-inline.model.ts
@@ -50,6 +50,14 @@ import {
   hasExistingProductInItems,
 } from "../stock-movement-draft-guards";
 import { lookupStockMovementProductByBarcode } from "../stock-movement-product-lookup";
+import {
+  scrollToFieldById,
+  scrollToFirstInvalidField,
+} from "./scroll-to-first-invalid-field";
+import {
+  customAttributeFieldId,
+  findCustomAttributeError,
+} from "./custom-attribute-validation";
 
 const buildReturnHref = (type: string | null): string => {
   if (!isManualMovementType(type)) return "/stock-movements/create";
@@ -405,22 +413,12 @@ export const useNewProductInlineModel = ({
   };
 
   const validateCustomAttributes = (): boolean => {
-    const invalidIndex = customAttributes.findIndex((attr) => {
-      return !attr.key.trim() || !attr.value.trim();
-    });
-    if (invalidIndex >= 0) {
-      toast.warning(`Atributo ${invalidIndex + 1}: Nome e valor são obrigatórios`);
-      return false;
-    }
+    const error = findCustomAttributeError(customAttributes);
+    if (!error) return true;
 
-    const keys = customAttributes.map((attr) => attr.key.trim().toLowerCase());
-    const duplicate = keys.find((key, index) => keys.indexOf(key) !== index);
-    if (duplicate) {
-      toast.warning(`Já existe um atributo com o nome "${duplicate}"`);
-      return false;
-    }
-
-    return true;
+    toast.warning(error.message);
+    scrollToFieldById(customAttributeFieldId(error.index, error.field));
+    return false;
   };
 
   const mergeAttributes = (data: ProductCreateFormData): Record<string, string> | undefined => {
@@ -645,6 +643,11 @@ export const useNewProductInlineModel = ({
     router.push(cancelHref);
   };
 
+  const handleInvalidSubmit = (): void => {
+    // Defer one frame so react-hook-form has committed `aria-invalid` to the DOM.
+    requestAnimationFrame(() => scrollToFirstInvalidField());
+  };
+
   const onSubmit = async (data: ProductCreateFormData): Promise<void> => {
     if (!validateCustomAttributes()) return;
 
@@ -681,6 +684,7 @@ export const useNewProductInlineModel = ({
     mode: "inline",
     form,
     onSubmit,
+    onInvalidSubmit: handleInvalidSubmit,
     isSubmitting,
     categories: categoriesData?.data || [],
     isLoadingCategories,
diff --git a/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.test.ts b/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.test.ts
new file mode 100644
index 0000000..586047e
--- /dev/null
+++ b/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.test.ts
@@ -0,0 +1,129 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  findFirstInvalidField,
+  scrollToFieldById,
+  scrollToFirstInvalidField,
+} from "./scroll-to-first-invalid-field";
+
+const rectAt = (top: number, height = 40): DOMRect =>
+  ({
+    top,
+    bottom: top + height,
+    height,
+    left: 0,
+    right: 0,
+    width: 0,
+    x: 0,
+    y: top,
+    toJSON: () => ({}),
+  }) as DOMRect;
+
+// jsdom's default viewport height is 768px.
+const OFFSCREEN_RECT = rectAt(2000);
+const VISIBLE_RECT = rectAt(100);
+
+const buildField = (
+  id: string,
+  invalid: boolean,
+  rect: DOMRect = OFFSCREEN_RECT,
+): HTMLInputElement => {
+  const input = document.createElement("input");
+  input.id = id;
+  if (invalid) input.setAttribute("aria-invalid", "true");
+  input.getBoundingClientRect = () => rect;
+  document.body.appendChild(input);
+  return input;
+};
+
+afterEach(() => {
+  document.body.innerHTML = "";
+  vi.restoreAllMocks();
+});
+
+describe("findFirstInvalidField", () => {
+  it("returns the topmost field flagged aria-invalid", () => {
+    buildField("name", false);
+    const quantity = buildField("quantity", true);
+    buildField("price", true);
+
+    expect(findFirstInvalidField()).toBe(quantity);
+  });
+
+  it("returns null when no field is invalid", () => {
+    buildField("name", false);
+
+    expect(findFirstInvalidField()).toBeNull();
+  });
+});
+
+describe("scrollToFirstInvalidField", () => {
+  it("centers the first off-screen invalid field in the viewport", () => {
+    buildField("name", false);
+    const quantity = buildField("quantity", true);
+    const scrollIntoView = vi.fn();
+    quantity.scrollIntoView = scrollIntoView;
+
+    scrollToFirstInvalidField();
+
+    expect(scrollIntoView).toHaveBeenCalledWith({
+      block: "center",
+      behavior: "smooth",
+    });
+  });
+
+  it("leaves an already fully visible invalid field untouched", () => {
+    const quantity = buildField("quantity", true, VISIBLE_RECT);
+    const scrollIntoView = vi.fn();
+    quantity.scrollIntoView = scrollIntoView;
+
+    scrollToFirstInvalidField();
+
+    expect(scrollIntoView).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when there is no invalid field", () => {
+    const valid = buildField("name", false);
+    const scrollIntoView = vi.fn();
+    valid.scrollIntoView = scrollIntoView;
+
+    scrollToFirstInvalidField();
+
+    expect(scrollIntoView).not.toHaveBeenCalled();
+  });
+});
+
+describe("scrollToFieldById", () => {
+  it("centers the off-screen field with the matching id", () => {
+    buildField("attr-key-0", false);
+    const target = buildField("attr-value-1", false);
+    const scrollIntoView = vi.fn();
+    target.scrollIntoView = scrollIntoView;
+
+    scrollToFieldById("attr-value-1");
+
+    expect(scrollIntoView).toHaveBeenCalledWith({
+      block: "center",
+      behavior: "smooth",
+    });
+  });
+
+  it("leaves an already fully visible field untouched", () => {
+    const target = buildField("attr-value-1", false, VISIBLE_RECT);
+    const scrollIntoView = vi.fn();
+    target.scrollIntoView = scrollIntoView;
+
+    scrollToFieldById("attr-value-1");
+
+    expect(scrollIntoView).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when no field matches the id", () => {
+    const field = buildField("attr-key-0", false);
+    const scrollIntoView = vi.fn();
+    field.scrollIntoView = scrollIntoView;
+
+    scrollToFieldById("attr-key-9");
+
+    expect(scrollIntoView).not.toHaveBeenCalled();
+  });
+});
diff --git a/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.ts b/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.ts
new file mode 100644
index 0000000..d937b84
--- /dev/null
+++ b/app/(pages)/stock-movements/create/new-product/scroll-to-first-invalid-field.ts
@@ -0,0 +1,43 @@
+const INVALID_FIELD_SELECTOR = '[aria-invalid="true"]';
+
+/** Whether the field sits fully within the viewport's vertical bounds. */
+const isFieldFullyVisible = (field: HTMLElement): boolean => {
+  const { top, bottom } = field.getBoundingClientRect();
+  const viewportHeight =
+    window.innerHeight || document.documentElement.clientHeight;
+  return top >= 0 && bottom <= viewportHeight;
+};
+
+/**
+ * Centers a field in the viewport, but only when it is off-screen — a field
+ * already fully visible is left untouched.
+ */
+const scrollFieldIntoView = (field: HTMLElement): void => {
+  if (isFieldFullyVisible(field)) return;
+  field.scrollIntoView({ block: "center", behavior: "smooth" });
+};
+
+/**
+ * Finds the first form control flagged invalid by react-hook-form's
+ * `aria-invalid` attribute, following DOM (top-to-bottom) order.
+ */
+export const findFirstInvalidField = (
+  root: ParentNode = document,
+): HTMLElement | null => root.querySelector<HTMLElement>(INVALID_FIELD_SELECTOR);
+
+/** Scrolls the first `aria-invalid` field into view when it is off-screen. */
+export const scrollToFirstInvalidField = (root: ParentNode = document): void => {
+  const field = findFirstInvalidField(root);
+  if (!field) return;
+  scrollFieldIntoView(field);
+};
+
+/**
+ * Scrolls the field with the given id into view when it is off-screen.
+ * Used for inputs that carry no `aria-invalid` (e.g. custom attribute rows).
+ */
+export const scrollToFieldById = (id: string, root: Document = document): void => {
+  const field = root.getElementById(id);
+  if (!(field instanceof HTMLElement)) return;
+  scrollFieldIntoView(field);
+};

From 2ef059b0a29d3604dd2dd90d4c6fb0734961d26c Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Wed, 17 Jun 2026 21:52:31 -0300
Subject: [PATCH 26/32] feat(sidebar): hide dev-only nav items in production

Add devOnly flag to NavItem type. Filter out items with devOnly: true
when NODE_ENV is not 'development'. Mark 'Testes' link as devOnly so
the exploratory-tests page is only visible in local dev.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 components/layout/app-sidebar.tsx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/components/layout/app-sidebar.tsx b/components/layout/app-sidebar.tsx
index f3cdd9b..b6c4353 100644
--- a/components/layout/app-sidebar.tsx
+++ b/components/layout/app-sidebar.tsx
@@ -22,8 +22,11 @@ type NavItem = {
   Icon: typeof Package;
   requiredPermission?: string;
   adminOnly?: boolean;
+  devOnly?: boolean;
 };
 
+const IS_DEV = process.env.NODE_ENV === "development";
+
 const navItems: NavItem[] = [
   {
     href: "/products",
@@ -71,6 +74,7 @@ const navItems: NavItem[] = [
     href: "/exploratory-tests",
     label: "Testes",
     Icon: ClipboardCheck,
+    devOnly: true,
   },
 ];
 
@@ -79,6 +83,7 @@ export const AppSidebar = ({ onNavigate }: { onNavigate?: () => void }) => {
   const { isAdmin, hasPermission } = useAuth();
 
   const visibleNavItems = navItems.filter((item) => {
+    if (item.devOnly && !IS_DEV) return false;
     if (item.adminOnly && !isAdmin) return false;
     if (!item.requiredPermission) return true;
     return hasPermission(item.requiredPermission);

From ac46c4b59e9b77dd20c696b07c3a422640c39c37 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:01:00 -0300
Subject: [PATCH 27/32] refactor: extract shared BRL currency formatter to
 lib/currency

Collapse the three duplicated cents->BRL formatters (products, sales, batches-detail) into a single lib/currency helper. formatCentsToBRL takes a configurable fallback label ("-" by default, "Sem preco" in products). sales.types and batches-detail re-export it so existing imports stay stable.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../batches/[id]/batches-detail.model.ts      | 10 ++----
 app/(pages)/sales/sales.types.ts              |  7 +----
 lib/currency.test.ts                          | 31 +++++++++++++++++++
 lib/currency.ts                               | 15 +++++++++
 4 files changed, 49 insertions(+), 14 deletions(-)
 create mode 100644 lib/currency.test.ts
 create mode 100644 lib/currency.ts

diff --git a/app/(pages)/batches/[id]/batches-detail.model.ts b/app/(pages)/batches/[id]/batches-detail.model.ts
index f27211c..b4e47b2 100644
--- a/app/(pages)/batches/[id]/batches-detail.model.ts
+++ b/app/(pages)/batches/[id]/batches-detail.model.ts
@@ -11,6 +11,7 @@ import {
   parseISO,
 } from "date-fns";
 import { ptBR } from "date-fns/locale";
+import { formatCentsToBRL } from "@/lib/currency";
 import { useBreadcrumb } from "@/components/breadcrumb";
 import type {
   BatchDetail,
@@ -64,10 +65,6 @@ const STATUS_MAP: Record<BatchStatusKind, BatchStatusView> = {
   },
 };
 
-const BATCH_DETAIL_CURRENCY_FORMATTER = new Intl.NumberFormat("pt-BR", {
-  style: "currency",
-  currency: "BRL",
-});
 
 /* ─── Pure Functions ─── */
 
@@ -96,10 +93,7 @@ export const computeBatchStatus = (
   return STATUS_MAP.ok;
 };
 
-export const formatCentsToBRL = (cents: number | null | undefined): string => {
-  if (cents === null || cents === undefined) return "-";
-  return BATCH_DETAIL_CURRENCY_FORMATTER.format(cents / 100);
-};
+export { formatCentsToBRL };
 
 export const formatCentsTotal = (
   unitCents: number | null | undefined,
diff --git a/app/(pages)/sales/sales.types.ts b/app/(pages)/sales/sales.types.ts
index eb0b357..0f6bc1a 100644
--- a/app/(pages)/sales/sales.types.ts
+++ b/app/(pages)/sales/sales.types.ts
@@ -133,9 +133,4 @@ export const SALE_STATUS_LABELS: Record<SaleStatus, string> = {
   CANCELLED: "Cancelada",
 };
 
-export function formatCents(cents: number): string {
-  return (cents / 100).toLocaleString("pt-BR", {
-    style: "currency",
-    currency: "BRL",
-  });
-}
+export { formatCents } from "@/lib/currency";
diff --git a/lib/currency.test.ts b/lib/currency.test.ts
new file mode 100644
index 0000000..9211a5f
--- /dev/null
+++ b/lib/currency.test.ts
@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { formatCents, formatCentsToBRL } from "./currency";
+
+describe("formatCents", () => {
+  it("formats cents into BRL currency", () => {
+    expect(formatCents(2000)).toMatch(/R\$\s?20,00/);
+  });
+
+  it("formats zero", () => {
+    expect(formatCents(0)).toMatch(/R\$\s?0,00/);
+  });
+});
+
+describe("formatCentsToBRL", () => {
+  it("formats cents into BRL currency", () => {
+    expect(formatCentsToBRL(1050)).toMatch(/R\$\s?10,50/);
+  });
+
+  it("returns the default fallback for null cents", () => {
+    expect(formatCentsToBRL(null)).toBe("-");
+  });
+
+  it("returns the default fallback for undefined cents", () => {
+    expect(formatCentsToBRL(undefined)).toBe("-");
+  });
+
+  it("returns a custom fallback when provided", () => {
+    expect(formatCentsToBRL(null, "Sem preço")).toBe("Sem preço");
+    expect(formatCentsToBRL(undefined, "Sem preço")).toBe("Sem preço");
+  });
+});
diff --git a/lib/currency.ts b/lib/currency.ts
new file mode 100644
index 0000000..5224e80
--- /dev/null
+++ b/lib/currency.ts
@@ -0,0 +1,15 @@
+const CURRENCY_FORMATTER = new Intl.NumberFormat("pt-BR", {
+  style: "currency",
+  currency: "BRL",
+});
+
+export const formatCents = (cents: number): string =>
+  CURRENCY_FORMATTER.format(cents / 100);
+
+export const formatCentsToBRL = (
+  cents: number | null | undefined,
+  fallback = "-",
+): string => {
+  if (cents === null || cents === undefined) return fallback;
+  return formatCents(cents);
+};

From 616c193a4e6d9d51b56f038bac603dd3a1d4c65f Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:01:00 -0300
Subject: [PATCH 28/32] feat: add deterministic category color util

lib/category-color derives a stable dark (lightness 30%) hex color from a category name for badges, with colocated unit tests.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 lib/category-color.test.ts | 32 +++++++++++++++++++++++++++++
 lib/category-color.ts      | 42 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)
 create mode 100644 lib/category-color.test.ts
 create mode 100644 lib/category-color.ts

diff --git a/lib/category-color.test.ts b/lib/category-color.test.ts
new file mode 100644
index 0000000..40a0951
--- /dev/null
+++ b/lib/category-color.test.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { categoryNameToHexColor } from "./category-color";
+
+describe("categoryNameToHexColor", () => {
+  it("returns a deterministic hex color for the same category name", () => {
+    const first = categoryNameToHexColor("Bebidas");
+    const second = categoryNameToHexColor("Bebidas");
+    expect(first).toBe(second);
+    expect(first).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+
+  it("returns different colors for different category names", () => {
+    const beverages = categoryNameToHexColor("Bebidas");
+    const electronics = categoryNameToHexColor("Eletrônicos");
+    expect(beverages).not.toBe(electronics);
+  });
+
+  it("returns dark colors suitable for dark mode badges with white text", () => {
+    const hex = categoryNameToHexColor("Perfume Feminino");
+    const r = Number.parseInt(hex.slice(1, 3), 16);
+    const g = Number.parseInt(hex.slice(3, 5), 16);
+    const b = Number.parseInt(hex.slice(5, 7), 16);
+    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    expect(luminance).toBeLessThan(0.55);
+  });
+
+  it("returns fallback color for empty or null name", () => {
+    expect(categoryNameToHexColor(null)).toBe("#404040");
+    expect(categoryNameToHexColor("")).toBe("#404040");
+    expect(categoryNameToHexColor("   ")).toBe("#404040");
+  });
+});
diff --git a/lib/category-color.ts b/lib/category-color.ts
new file mode 100644
index 0000000..efe68cd
--- /dev/null
+++ b/lib/category-color.ts
@@ -0,0 +1,42 @@
+const CATEGORY_FALLBACK_COLOR = "#404040";
+
+const hslToHex = (hue: number, saturation: number, lightness: number): string => {
+  const s = saturation / 100;
+  const l = lightness / 100;
+  const chroma = (1 - Math.abs(2 * l - 1)) * s;
+  const x = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
+  const m = l - chroma / 2;
+  const segments: ReadonlyArray<readonly [number, number, number]> = [
+    [chroma, x, 0],
+    [x, chroma, 0],
+    [0, chroma, x],
+    [0, x, chroma],
+    [x, 0, chroma],
+    [chroma, 0, x],
+  ];
+  const [r, g, b] = segments[Math.floor(hue / 60) % 6];
+  const toHexChannel = (value: number) =>
+    Math.round((value + m) * 255)
+      .toString(16)
+      .padStart(2, "0");
+  return `#${toHexChannel(r)}${toHexChannel(g)}${toHexChannel(b)}`;
+};
+
+const hashStringToInt = (value: string): number => {
+  let hash = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    hash = (hash * 31 + value.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash);
+};
+
+// Deterministic, dark (lightness 30%) badge color derived from a category name,
+// suitable as a background for white text in the dark theme.
+export const categoryNameToHexColor = (
+  name: string | null | undefined,
+): string => {
+  const trimmed = name?.trim();
+  if (!trimmed) return CATEGORY_FALLBACK_COLOR;
+  const hue = hashStringToInt(trimmed) % 360;
+  return hslToHex(hue, 55, 30);
+};

From e3d736d586bd24bdb135c93e50184e7c83ffa2c3 Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:01:00 -0300
Subject: [PATCH 29/32] feat(products): add mobile product card with image,
 category badge and batch price

The mobile list renders a compact card per product showing its photo (fetched per-product when the warehouse list omits imageUrl), a colored category badge and the latest priced batch's selling price next to stock. Latest-price selection skips price-less batches and guards against invalid createdAt values; warehouse batches no longer revalidate on focus.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 app/(pages)/products/products.model.test.ts | 158 +++++++++++++++++++-
 app/(pages)/products/products.model.ts      | 141 ++++++++++++++++-
 app/(pages)/products/products.types.ts      |  26 ++++
 app/(pages)/products/products.view.test.tsx | 108 +++++++++++++
 app/(pages)/products/products.view.tsx      |  88 ++++++++---
 5 files changed, 495 insertions(+), 26 deletions(-)

diff --git a/app/(pages)/products/products.model.test.ts b/app/(pages)/products/products.model.test.ts
index d51ceef..163eb73 100644
--- a/app/(pages)/products/products.model.test.ts
+++ b/app/(pages)/products/products.model.test.ts
@@ -2,7 +2,13 @@ import { describe, it, expect, beforeEach, vi } from "vitest";
 import { renderHook, act, waitFor } from "@testing-library/react";
 import { createElement, type ReactNode } from "react";
 import { NuqsTestingAdapter } from "nuqs/adapters/testing";
-import { useProductsModel } from "./products.model";
+import {
+  buildLatestBatchPrice,
+  buildLatestBatchPriceByProduct,
+  findMostRecentBatch,
+  useProductsModel,
+} from "./products.model";
+import type { ProductBatchPriceSource } from "./products.types";
 import { toast } from "sonner";
 
 const renderModel = () =>
@@ -23,6 +29,7 @@ const baseProduct = {
   barcode: "123",
   barcodeType: "EAN13",
   description: null,
+  imageUrl: null,
   categoryId: null,
   categoryName: null,
   brand: null,
@@ -55,9 +62,25 @@ let swrData: {
   };
 } | undefined;
 
+let warehouseBatchesData:
+  | { success: boolean; data: ProductBatchPriceSource[] }
+  | undefined;
+
+let productImagesData: Record<string, string | null> | undefined;
+
+const resolveSwrData = (key: unknown) => {
+  if (typeof key === "string" && key.startsWith("batches/warehouse/")) {
+    return warehouseBatchesData;
+  }
+  if (typeof key === "string" && key.startsWith("product-images-")) {
+    return productImagesData;
+  }
+  return swrData;
+};
+
 vi.mock("swr", () => ({
-  default: vi.fn(() => ({
-    data: swrData,
+  default: vi.fn((key: unknown) => ({
+    data: resolveSwrData(key),
     error: null,
     isLoading: false,
     mutate: mockMutate,
@@ -108,6 +131,8 @@ describe("useProductsModel - delete flow", () => {
         empty: false,
       },
     };
+    warehouseBatchesData = { success: true, data: [] };
+    productImagesData = {};
   });
 
   it("loads selected warehouse batches with positive stock", async () => {
@@ -389,4 +414,131 @@ describe("useProductsModel - delete flow", () => {
     );
     expect(result.current.isDeletingProduct).toBe(false);
   });
+
+  it("exposes latest batch selling price per product from warehouse batches", async () => {
+    warehouseBatchesData = {
+      success: true,
+      data: [
+        {
+          id: "batch-old",
+          productId: "prod-1",
+          sellingPrice: 1500,
+          costPrice: 1000,
+          createdAt: "2025-01-01T00:00:00Z",
+        },
+        {
+          id: "batch-new",
+          productId: "prod-1",
+          sellingPrice: 2500,
+          costPrice: 1800,
+          createdAt: "2025-06-01T00:00:00Z",
+        },
+      ],
+    };
+
+    const { result } = renderModel();
+
+    await waitFor(() => {
+      expect(result.current.latestBatchPriceByProduct["prod-1"]).not.toBeNull();
+    });
+
+    expect(result.current.latestBatchPriceByProduct["prod-1"]).toMatchObject({
+      batchId: "batch-new",
+      sellingPriceCents: 2500,
+    });
+  });
+
+  it("fetches missing product images and merges them into filtered products", async () => {
+    productImagesData = { "prod-1": "https://example.com/prod-1.png" };
+
+    const { result } = renderModel();
+
+    await waitFor(() => {
+      expect(result.current.filteredProducts[0]?.imageUrl).toBe(
+        "https://example.com/prod-1.png"
+      );
+    });
+  });
+});
+
+describe("findMostRecentBatch", () => {
+  const batches: ProductBatchPriceSource[] = [
+    { id: "b1", productId: "p1", sellingPrice: 100, costPrice: 50, createdAt: "2025-01-01T00:00:00Z" },
+    { id: "b2", productId: "p1", sellingPrice: 200, costPrice: 80, createdAt: "2025-06-01T00:00:00Z" },
+  ];
+
+  it("returns the batch with the latest createdAt", () => {
+    expect(findMostRecentBatch(batches)?.id).toBe("b2");
+  });
+
+  it("returns null for an empty list", () => {
+    expect(findMostRecentBatch([])).toBeNull();
+  });
+
+  it("does not let an invalid first date poison selection of valid batches", () => {
+    const withInvalidFirst: ProductBatchPriceSource[] = [
+      { id: "bad", productId: "p1", sellingPrice: 100, costPrice: 50, createdAt: "not-a-date" },
+      { id: "good", productId: "p1", sellingPrice: 200, costPrice: 80, createdAt: "2025-06-01T00:00:00Z" },
+    ];
+    expect(findMostRecentBatch(withInvalidFirst)?.id).toBe("good");
+  });
+});
+
+describe("buildLatestBatchPrice", () => {
+  it("builds price info from a batch", () => {
+    const batch: ProductBatchPriceSource = {
+      id: "b1",
+      productId: "p1",
+      sellingPrice: 2500,
+      costPrice: 1800,
+      createdAt: "2025-06-01T00:00:00Z",
+    };
+    expect(buildLatestBatchPrice(batch)).toMatchObject({
+      batchId: "b1",
+      sellingPriceCents: 2500,
+    });
+  });
+
+  it("returns null when batch is null", () => {
+    expect(buildLatestBatchPrice(null)).toBeNull();
+  });
+});
+
+describe("buildLatestBatchPriceByProduct", () => {
+  it("groups batches by product and keeps only the most recent per product", () => {
+    const batches: ProductBatchPriceSource[] = [
+      { id: "b1", productId: "p1", sellingPrice: 100, costPrice: 50, createdAt: "2025-01-01T00:00:00Z" },
+      { id: "b2", productId: "p1", sellingPrice: 200, costPrice: 80, createdAt: "2025-06-01T00:00:00Z" },
+      { id: "b3", productId: "p2", sellingPrice: 300, costPrice: 150, createdAt: "2025-03-01T00:00:00Z" },
+    ];
+
+    const map = buildLatestBatchPriceByProduct(batches);
+
+    expect(map["p1"]?.batchId).toBe("b2");
+    expect(map["p1"]?.sellingPriceCents).toBe(200);
+    expect(map["p2"]?.batchId).toBe("b3");
+  });
+
+  it("returns an empty map for an empty batch list", () => {
+    expect(buildLatestBatchPriceByProduct([])).toEqual({});
+  });
+
+  it("skips price-less batches so an earlier priced batch still wins", () => {
+    const batches: ProductBatchPriceSource[] = [
+      { id: "older", productId: "p1", sellingPrice: 1500, costPrice: 1000, createdAt: "2025-01-01T00:00:00Z" },
+      { id: "newer", productId: "p1", sellingPrice: null, costPrice: null, createdAt: "2025-06-01T00:00:00Z" },
+    ];
+
+    const map = buildLatestBatchPriceByProduct(batches);
+
+    expect(map["p1"]).toMatchObject({ batchId: "older", sellingPriceCents: 1500 });
+  });
+
+  it("returns null when a product has only price-less batches", () => {
+    const batches: ProductBatchPriceSource[] = [
+      { id: "b1", productId: "p1", sellingPrice: null, costPrice: null, createdAt: "2025-06-01T00:00:00Z" },
+    ];
+
+    expect(buildLatestBatchPriceByProduct(batches)["p1"]).toBeNull();
+  });
 });
diff --git a/app/(pages)/products/products.model.ts b/app/(pages)/products/products.model.ts
index 3362a4e..4b57d66 100644
--- a/app/(pages)/products/products.model.ts
+++ b/app/(pages)/products/products.model.ts
@@ -4,10 +4,14 @@ import { useQueryState, parseAsString } from "nuqs";
 import useSWR, { mutate as mutateGlobal } from "swr";
 import { api } from "@/lib/api";
 import { toast } from "sonner";
+import { formatCentsToBRL } from "@/lib/currency";
 import { useSelectedWarehouse } from "@/hooks/use-selected-warehouse";
 import {
   Batch,
+  LatestBatchPrice,
   Product,
+  ProductBatchPriceSource,
+  ProductImageResponse,
   ProductsResponse,
   ProductFilters,
   ProductFilterDraft,
@@ -15,6 +19,7 @@ import {
   SortOrder,
   StockStatus,
   ActiveStatus,
+  WarehouseBatchesResponse,
 } from "./products.types";
 
 interface BatchesResponse {
@@ -44,6 +49,54 @@ const DEFAULT_DRAFT: ProductFilterDraft = {
   sortOrder: "asc",
 };
 
+export const findMostRecentBatch = (
+  batches: readonly ProductBatchPriceSource[],
+): ProductBatchPriceSource | null => {
+  return batches.reduce<ProductBatchPriceSource | null>((latest, batch) => {
+    if (!latest) return batch;
+    const batchTime = new Date(batch.createdAt).getTime();
+    const latestTime = new Date(latest.createdAt).getTime();
+    if (!Number.isFinite(batchTime)) return latest;
+    if (!Number.isFinite(latestTime)) return batch;
+    return batchTime > latestTime ? batch : latest;
+  }, null);
+};
+
+export const buildLatestBatchPrice = (
+  batch: ProductBatchPriceSource | null,
+): LatestBatchPrice | null => {
+  if (!batch) return null;
+  return {
+    batchId: batch.id,
+    sellingPriceCents: batch.sellingPrice,
+    sellingPriceLabel: formatCentsToBRL(batch.sellingPrice, "Sem preço"),
+  };
+};
+
+const groupBatchesByProduct = (
+  batches: readonly ProductBatchPriceSource[],
+): Map<string, ProductBatchPriceSource[]> =>
+  batches.reduce<Map<string, ProductBatchPriceSource[]>>((groups, batch) => {
+    const existing = groups.get(batch.productId) ?? [];
+    existing.push(batch);
+    groups.set(batch.productId, existing);
+    return groups;
+  }, new Map());
+
+export const buildLatestBatchPriceByProduct = (
+  batches: readonly ProductBatchPriceSource[],
+): Record<string, LatestBatchPrice | null> => {
+  const groups = groupBatchesByProduct(batches);
+  const result: Record<string, LatestBatchPrice | null> = {};
+  for (const [productId, productBatches] of groups) {
+    // Ignore batches without a price so a newer price-less batch never hides
+    // the known price of an earlier batch.
+    const priced = productBatches.filter((batch) => batch.sellingPrice !== null);
+    result[productId] = buildLatestBatchPrice(findMostRecentBatch(priced));
+  }
+  return result;
+};
+
 const buildFilterDraft = (filters: ProductFilters): ProductFilterDraft => ({
   stockStatus: filters.stockStatus,
   activeStatus: filters.activeStatus,
@@ -75,6 +128,51 @@ const filterByActiveStatus = (product: Product, status: ActiveStatus) => {
   }
 };
 
+const fetchProductImage = async (
+  id: string,
+): Promise<{ id: string; imageUrl: string | null }> => {
+  try {
+    const response = await api
+      .get(`products/${id}`)
+      .json<ProductImageResponse>();
+    return { id, imageUrl: response.data.imageUrl ?? null };
+  } catch {
+    return { id, imageUrl: null };
+  }
+};
+
+const fetchProductImages = async (
+  productIds: string[],
+): Promise<Record<string, string | null>> => {
+  const results = await Promise.all(productIds.map(fetchProductImage));
+  return Object.fromEntries(results.map((result) => [result.id, result.imageUrl]));
+};
+
+const buildProductImagesKey = (
+  products: readonly Product[],
+): string | null => {
+  const ids = products
+    .filter((product) => !product.imageUrl)
+    .map((product) => product.id)
+    .sort();
+  if (ids.length === 0) return null;
+  return `product-images-${ids.join(",")}`;
+};
+
+const parseProductImageIds = (key: string): string[] =>
+  key.replace("product-images-", "").split(",");
+
+const mergeProductImages = (
+  products: Product[],
+  images: Record<string, string | null> | undefined,
+): Product[] => {
+  if (!images) return products;
+  return products.map((product) => ({
+    ...product,
+    imageUrl: product.imageUrl ?? images[product.id] ?? null,
+  }));
+};
+
 export const useProductsModel = () => {
   const { warehouseId } = useSelectedWarehouse();
 
@@ -143,17 +241,55 @@ export const useProductsModel = () => {
     }
   );
 
+  // Fetch batches for the warehouse to derive the most recent batch selling
+  // price per product. Used by the mobile product card.
+  const warehouseBatchesUrl = warehouseId ? `batches/warehouse/${warehouseId}` : null;
+  const { data: warehouseBatchesData } = useSWR<WarehouseBatchesResponse>(
+    warehouseBatchesUrl,
+    async (requestUrl: string) => {
+      try {
+        return await api.get(requestUrl).json<WarehouseBatchesResponse>();
+      } catch (err) {
+        console.error("Erro ao carregar lotes do armazém:", err);
+        return { success: true, data: [] };
+      }
+    },
+    { revalidateOnFocus: false }
+  );
+
   // Client-side filtering for stock status and active status
   const products = useMemo(() => data?.data.content ?? [], [data]);
 
+  // The warehouse products list may not return imageUrl. Fetch missing
+  // images individually so the mobile card can show the product photo.
+  const productImagesKey = useMemo(
+    () => buildProductImagesKey(products),
+    [products]
+  );
+  const { data: productImagesData } = useSWR<Record<string, string | null>>(
+    productImagesKey,
+    async (key: string) => fetchProductImages(parseProductImageIds(key)),
+    { revalidateOnFocus: false }
+  );
+
+  const productsWithImages = useMemo(
+    () => mergeProductImages(products, productImagesData),
+    [products, productImagesData]
+  );
+
+  const latestBatchPriceByProduct = useMemo(
+    () => buildLatestBatchPriceByProduct(warehouseBatchesData?.data ?? []),
+    [warehouseBatchesData]
+  );
+
   const filteredProducts = useMemo(
     () =>
-      products.filter(
+      productsWithImages.filter(
         (p) =>
           filterByStockStatus(p, filters.stockStatus) &&
           filterByActiveStatus(p, filters.activeStatus)
       ),
-    [products, filters.stockStatus, filters.activeStatus]
+    [productsWithImages, filters.stockStatus, filters.activeStatus]
   );
 
   const pagination = data?.data
@@ -323,6 +459,7 @@ export const useProductsModel = () => {
   return {
     products,
     filteredProducts,
+    latestBatchPriceByProduct,
     isLoading,
     error: error || null,
     requiresWarehouse: !warehouseId,
diff --git a/app/(pages)/products/products.types.ts b/app/(pages)/products/products.types.ts
index 3ee73af..c6dde6d 100644
--- a/app/(pages)/products/products.types.ts
+++ b/app/(pages)/products/products.types.ts
@@ -15,6 +15,7 @@ export interface Product {
   barcode: string | null;
   barcodeType: string | null;
   description: string | null;
+  imageUrl: string | null;
   categoryId: string | null;
   categoryName: string | null;
   brand: Brand | null;
@@ -37,6 +38,30 @@ export interface Batch {
   expirationDate: string | null;
 }
 
+export interface ProductBatchPriceSource {
+  id: string;
+  productId: string;
+  sellingPrice: number | null;
+  costPrice: number | null;
+  createdAt: string;
+}
+
+export interface WarehouseBatchesResponse {
+  success: boolean;
+  data: ProductBatchPriceSource[];
+}
+
+export interface ProductImageResponse {
+  success: boolean;
+  data: { imageUrl: string | null };
+}
+
+export interface LatestBatchPrice {
+  batchId: string;
+  sellingPriceCents: number | null;
+  sellingPriceLabel: string;
+}
+
 interface ProductsPageable {
   pageNumber: number;
   pageSize: number;
@@ -84,6 +109,7 @@ export interface ProductFilterDraft {
 export interface ProductsViewProps {
   products: Product[];
   filteredProducts: Product[];
+  latestBatchPriceByProduct: Record<string, LatestBatchPrice | null>;
   isLoading: boolean;
   error: Error | null;
   requiresWarehouse: boolean;
diff --git a/app/(pages)/products/products.view.test.tsx b/app/(pages)/products/products.view.test.tsx
index 3d7b37d..b7edbd4 100644
--- a/app/(pages)/products/products.view.test.tsx
+++ b/app/(pages)/products/products.view.test.tsx
@@ -39,6 +39,7 @@ afterEach(() => cleanup());
 const baseProps = {
   products: [],
   filteredProducts: [],
+  latestBatchPriceByProduct: {},
   isLoading: false,
   error: null,
   requiresWarehouse: false,
@@ -96,6 +97,7 @@ const productItem = {
   barcode: "123",
   barcodeType: "EAN13",
   description: null,
+  imageUrl: null,
   categoryId: null,
   categoryName: null,
   brand: null,
@@ -214,4 +216,110 @@ describe("ProductsView - delete action", () => {
 
     expect(screen.getByText(/confirmação final/i)).toBeTruthy();
   });
+
+  it("renders compact mobile card with photo, name, quantity, category badge and latest batch price", () => {
+    const productWithCategoryAndImage = {
+      ...productItem,
+      id: "prod-cafe",
+      name: "Café Torrado 1kg",
+      imageUrl: "https://example.com/cafe.png",
+      categoryName: "Bebidas",
+      totalQuantity: 12,
+    };
+
+    render(
+      <ProductsView
+        {...baseProps}
+        products={[productWithCategoryAndImage]}
+        filteredProducts={[productWithCategoryAndImage]}
+        latestBatchPriceByProduct={{
+          "prod-cafe": {
+            batchId: "batch-1",
+            sellingPriceCents: 2000,
+            sellingPriceLabel: "R$ 20,00",
+          },
+        }}
+      />
+    );
+
+    expect(screen.getAllByText("Café Torrado 1kg").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("Bebidas").length).toBeGreaterThan(0);
+    expect(screen.getByText("R$ 20,00 • 12 Unids")).toBeTruthy();
+    expect(screen.getByRole("img", { name: /foto de café torrado/i })).toBeTruthy();
+  });
+
+  it("renders product image placeholder when product has no photo", () => {
+    const productWithoutImage = {
+      ...productItem,
+      id: "prod-sem-foto",
+      name: "Produto Sem Foto",
+      categoryName: "Outros",
+      totalQuantity: 5,
+    };
+
+    render(
+      <ProductsView
+        {...baseProps}
+        products={[productWithoutImage]}
+        filteredProducts={[productWithoutImage]}
+      />
+    );
+
+    expect(screen.getByRole("img", { name: /produto sem foto/i })).toBeTruthy();
+  });
+
+  it("hides category badge when product has no category", () => {
+    render(
+      <ProductsView
+        {...baseProps}
+        products={[productItem]}
+        filteredProducts={[productItem]}
+      />
+    );
+
+    expect(screen.queryByText(/sem categoria/i)).toBeNull();
+  });
+
+  it("shows fallback price label when product has no latest batch", () => {
+    const productWithoutBatch = {
+      ...productItem,
+      id: "prod-no-batch",
+      name: "Produto Sem Lote",
+      totalQuantity: 3,
+    };
+
+    render(
+      <ProductsView
+        {...baseProps}
+        products={[productWithoutBatch]}
+        filteredProducts={[productWithoutBatch]}
+        latestBatchPriceByProduct={{}}
+      />
+    );
+
+    expect(screen.getByText(/Sem preço.*Unids/)).toBeTruthy();
+  });
+
+  it("truncates long product names in the mobile card", () => {
+    const productWithLongName = {
+      ...productItem,
+      id: "prod-longo",
+      name: "Perfume Importado Eau de Parfum 100ml Edição Limitada",
+      categoryName: "Perfumes Importados Femininos",
+      totalQuantity: 7,
+    };
+
+    const { container } = render(
+      <ProductsView
+        {...baseProps}
+        products={[productWithLongName]}
+        filteredProducts={[productWithLongName]}
+      />
+    );
+
+    const card = container.querySelector('[data-testid="product-mobile-card"]');
+    const name = card?.querySelector("h3");
+
+    expect(name?.classList.contains("truncate")).toBe(true);
+  });
 });
diff --git a/app/(pages)/products/products.view.tsx b/app/(pages)/products/products.view.tsx
index 5966e20..2009ccc 100644
--- a/app/(pages)/products/products.view.tsx
+++ b/app/(pages)/products/products.view.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import Image from "next/image";
 import { Button } from "@/components/ui/button";
 import {
   Table,
@@ -71,7 +72,9 @@ import {
   StockStatus,
   ActiveStatus,
   ProductFilters,
+  LatestBatchPrice,
 } from "./products.types";
+import { categoryNameToHexColor } from "@/lib/category-color";
 import { cn } from "@/lib/utils";
 
 const STOCK_FILTER_OPTIONS: Array<{
@@ -966,11 +969,12 @@ const ProductTableActions = ({
 );
 
 const ProductsMobileCards = ({ props }: { props: ProductsViewProps }) => (
-  <div className="grid gap-3 md:hidden">
+  <div className="grid gap-2 md:hidden">
     {props.filteredProducts.map((product) => (
       <ProductMobileCard
         key={product.id}
         product={product}
+        latestBatchPrice={props.latestBatchPriceByProduct[product.id] ?? null}
         onOpenDeleteDialog={props.onOpenDeleteDialog}
       />
     ))}
@@ -979,38 +983,80 @@ const ProductsMobileCards = ({ props }: { props: ProductsViewProps }) => (
 
 const ProductMobileCard = ({
   product,
+  latestBatchPrice,
   onOpenDeleteDialog,
 }: {
   product: Product;
+  latestBatchPrice: LatestBatchPrice | null;
   onOpenDeleteDialog: (product: Product) => void;
 }) => {
-  const stockStatus = getStockStatus(product.totalQuantity);
+  const priceLabel = latestBatchPrice?.sellingPriceLabel ?? "Sem preço";
 
   return (
-    <div className="relative flex flex-col gap-3 rounded-[4px] border border-neutral-800 bg-[#171717] p-4 transition-colors hover:border-neutral-700">
-      <div className="flex items-start justify-between">
-        <div className="min-w-0 flex-1 pr-2">
-          <h3 className="font-semibold text-white">{product.name}</h3>
-          <div className="mt-1 flex items-center gap-2 text-xs text-neutral-500">
-            <span className="min-w-0 truncate font-mono">
-              {product.barcode || "SEM COD. BARRAS"}
-            </span>
-            <span>•</span>
-            <span>{product.categoryName}</span>
-          </div>
-        </div>
-        <div className="flex items-start gap-3">
-          <ProductStockBadge
-            label={`${product.totalQuantity} un`}
-            stockStatus={stockStatus}
-          />
-          <ProductActions product={product} onOpenDeleteDialog={onOpenDeleteDialog} />
-        </div>
+    <div
+      data-testid="product-mobile-card"
+      className="flex max-w-full items-start gap-2.5 overflow-hidden rounded-[4px] border border-neutral-800 bg-[#171717] p-2.5 transition-colors hover:border-neutral-700"
+    >
+      <ProductCardImage product={product} />
+      <div className="flex min-w-0 flex-1 flex-col gap-1">
+        <h3 className="truncate text-sm font-semibold text-white">
+          {product.name}
+        </h3>
+        <ProductCategoryBadge name={product.categoryName} />
+        <span className="font-mono text-xs font-medium text-neutral-300">
+          {priceLabel} • {product.totalQuantity} Unids
+        </span>
+      </div>
+      <div className="flex shrink-0 self-start">
+        <ProductActions product={product} onOpenDeleteDialog={onOpenDeleteDialog} />
       </div>
     </div>
   );
 };
 
+const ProductCardImage = ({ product }: { product: Product }) => {
+  if (product.imageUrl) {
+    return (
+      <span className="relative block w-10 h-15 shrink-0 overflow-hidden rounded-[4px] border border-neutral-800 bg-neutral-900">
+        <Image
+          src={product.imageUrl}
+          alt={`Foto de ${product.name}`}
+          fill
+          sizes="68px"
+          unoptimized
+          className="object-cover"
+        />
+      </span>
+    );
+  }
+
+  return (
+    <span
+      role="img"
+      aria-label="Produto sem foto"
+      className="flex size-10 shrink-0 items-center justify-center rounded-[4px] border border-neutral-800 bg-neutral-900 text-neutral-600"
+    >
+      <Package className="size-4" strokeWidth={2} />
+    </span>
+  );
+};
+
+const ProductCategoryBadge = ({ name }: { name: string | null }) => {
+  const trimmedName = name?.trim();
+  if (!trimmedName) return null;
+  // categoryNameToHexColor always returns a dark (lightness 30%) color, so
+  // white text is always the readable choice.
+  const backgroundColor = categoryNameToHexColor(trimmedName);
+  return (
+    <span
+      className="w-fit break-words rounded-[4px] px-1.5 py-0.5 text-[9px] font-bold uppercase tracking-wider leading-tight text-white"
+      style={{ backgroundColor }}
+    >
+      {trimmedName}
+    </span>
+  );
+};
+
 const ProductActions = ({
   product,
   onOpenDeleteDialog,

From 6ecbec5dbc8d519a088abff8e701bf99750d8e8e Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:01:00 -0300
Subject: [PATCH 30/32] feat(exploratory-tests): add IndexedDB-backed test
 checklist

Dev-only page (404s outside development) tracking manual exploratory test progress in IndexedDB, with an in-memory fallback when IndexedDB is unavailable and per-category grouping.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../exploratory-tests.constants.ts            | 462 ++++++++++++++++++
 .../exploratory-tests.model.ts                |  68 +++
 .../exploratory-tests.storage.ts              | 119 +++++
 .../exploratory-tests.types.ts                |  14 +
 .../exploratory-tests.view.tsx                | 198 ++++++++
 app/(pages)/exploratory-tests/page.client.tsx |   9 +
 app/(pages)/exploratory-tests/page.tsx        |  16 +
 7 files changed, 886 insertions(+)
 create mode 100644 app/(pages)/exploratory-tests/exploratory-tests.constants.ts
 create mode 100644 app/(pages)/exploratory-tests/exploratory-tests.model.ts
 create mode 100644 app/(pages)/exploratory-tests/exploratory-tests.storage.ts
 create mode 100644 app/(pages)/exploratory-tests/exploratory-tests.types.ts
 create mode 100644 app/(pages)/exploratory-tests/exploratory-tests.view.tsx
 create mode 100644 app/(pages)/exploratory-tests/page.client.tsx
 create mode 100644 app/(pages)/exploratory-tests/page.tsx

diff --git a/app/(pages)/exploratory-tests/exploratory-tests.constants.ts b/app/(pages)/exploratory-tests/exploratory-tests.constants.ts
new file mode 100644
index 0000000..6ea440a
--- /dev/null
+++ b/app/(pages)/exploratory-tests/exploratory-tests.constants.ts
@@ -0,0 +1,462 @@
+export interface ExploratoryTest {
+  id: string;
+  category: string;
+  title: string;
+  howToTest: string;
+  pageUrl: string;
+  pageLabel: string;
+}
+
+export interface ExploratoryTestCategory {
+  key: string;
+  label: string;
+  priority: "ALTA" | "MÉDIA" | "BAIXA";
+}
+
+export const EXPLORATORY_TEST_CATEGORIES: ExploratoryTestCategory[] = [
+  { key: "scanner", label: "Scanner de Código de Barras", priority: "ALTA" },
+  { key: "rascunho", label: "Rascunho IndexedDB", priority: "ALTA" },
+  { key: "inline-lote", label: "Produto Inline + Lote", priority: "ALTA" },
+  { key: "transferencias", label: "Transferências", priority: "ALTA" },
+  { key: "prompts", label: "Geração de Prompts com IA", priority: "MÉDIA" },
+  { key: "produto-form", label: "Formulário de Produto", priority: "MÉDIA" },
+  { key: "api", label: "API — Retry com Refresh de Token", priority: "MÉDIA" },
+  { key: "toasts", label: "Toasts — Estilo + Traduções", priority: "BAIXA" },
+  { key: "warehouse", label: "Warehouse — Hidratação Síncrona", priority: "BAIXA" },
+];
+
+export const EXPLORATORY_TESTS: ExploratoryTest[] = [
+  // === Scanner ===
+  {
+    id: "scanner-scan-normal",
+    category: "scanner",
+    title: "Scan de produto existente",
+    howToTest: "Vá para a página de criar movimentação. Clique no ícone de scanner. Aponte a câmera para um código de barras de um produto que já existe no sistema. O produto deve ser encontrado e adicionado.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-rescan-debounce",
+    category: "scanner",
+    title: "Mesmo código em menos de 1,5 segundos",
+    howToTest: "Escaneie o mesmo código de barras duas vezes bem rápido (menos de 1,5s entre os scans). O segundo scan deve ser ignorado.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-permission-denied",
+    category: "scanner",
+    title: "Permissão de câmera negada",
+    howToTest: "Abra o scanner. Quando o navegador pedir permissão da câmera, clique em 'Bloquear'. Deve aparecer um modal de erro com um botão 'Copiar Conteúdo'.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-no-camera",
+    category: "scanner",
+    title: "Dispositivo sem câmera",
+    howToTest: "Em um computador sem webcam, tente abrir o scanner. Deve aparecer o modal de erro com as informações do erro em formato JSON.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-multi-camera",
+    category: "scanner",
+    title: "Rotação entre câmeras (múltiplas câmeras)",
+    howToTest: "Em um celular ou tablet com câmera frontal e traseira, abra o scanner. O sistema deve alternar entre as câmeras automaticamente se uma falhar.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-ios-pwa",
+    category: "scanner",
+    title: "Scanner no PWA do iOS",
+    howToTest: "Abra o aplicativo como PWA no iPhone/iPad (adicione à tela de início). Use o scanner. Deve funcionar com a câmera.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "scanner-inline-not-found",
+    category: "scanner",
+    title: "Produto inline — código não encontrado",
+    howToTest: "Na página de criar movimentação, selecione um tipo de entrada (Compra ou Ajuste de Entrada). Escaneie um código de barras que não existe. Deve aparecer um modal perguntando se deseja criar o produto.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  // === Rascunho IndexedDB ===
+  {
+    id: "rascunho-reload",
+    category: "rascunho",
+    title: "Rascunho persiste ao recarregar a página",
+    howToTest: "Na página de criar movimentação, preencha alguns campos (tipo, quantidade, adicione um produto). Aperte F5 para recarregar. Os dados devem voltar e um toast verde 'Rascunho da movimentação restaurado' deve aparecer.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-close-tab",
+    category: "rascunho",
+    title: "Rascunho sobrevive ao fechar a aba",
+    howToTest: "Preencha parte da movimentação. Feche a aba completamente. Abra uma nova aba e volte para a página de criar movimentação. O rascunho deve ser restaurado com o toast.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-image-blob",
+    category: "rascunho",
+    title: "Imagem do produto inline preservada no rascunho",
+    howToTest: "Adicione um produto inline com uma imagem. Recarregue a página (F5). A imagem deve continuar aparecendo no formulário.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-two-tabs",
+    category: "rascunho",
+    title: "Duas abas simultâneas",
+    howToTest: "Abra duas abas na mesma página de criar movimentação. Altere dados na primeira aba, depois na segunda. O sistema deve detectar conflito de versão.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-anonimo",
+    category: "rascunho",
+    title: "IndexedDB indisponível (guia anônima)",
+    howToTest: "Abra o aplicativo em uma janela anônima/privada. Preencha a movimentação e recarregue. Os dados serão perdidos (sem IndexedDB).",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-warehouse-trocada",
+    category: "rascunho",
+    title: "Warehouse trocada entre sessões",
+    howToTest: "Selecione o warehouse A. Crie um rascunho de movimentação. Troque para o warehouse B no menu superior. Recarregue a página. O rascunho NÃO deve ser restaurado.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "rascunho-submit-progress",
+    category: "rascunho",
+    title: "Barra de progresso ao finalizar",
+    howToTest: "Crie uma movimentação com vários itens inline (com imagens). Clique em 'Finalizar'. Deve aparecer uma barra com os passos: 'Preparando dados...', 'Fazendo upload das imagens...', 'Ajustando preços...', 'Finalizando...'.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  // === Produto Inline + Lote ===
+  {
+    id: "inline-existing-modal",
+    category: "inline-lote",
+    title: "Scan de código que já existe — modal aparece",
+    howToTest: "Na página de criar produto (dentro da movimentação), escaneie um código de barras de um produto que já existe. Deve aparecer um modal 'Produto já existe' com as opções 'Cancelar' e 'Adicionar Lote'.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  {
+    id: "inline-existing-cancel",
+    category: "inline-lote",
+    title: "Cancelar modal de produto existente",
+    howToTest: "No modal 'Produto já existe', clique em 'Cancelar'. O modal deve fechar e o formulário deve continuar como estava.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  {
+    id: "inline-existing-add-batch",
+    category: "inline-lote",
+    title: "Adicionar lote ao produto existente",
+    howToTest: "No modal 'Produto já existe', clique em 'Adicionar Lote'. Preencha quantidade, datas e preços. Confirme. O item deve aparecer na lista da movimentação.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  {
+    id: "inline-price-suggestion",
+    category: "inline-lote",
+    title: "Sugestão de preço do último lote",
+    howToTest: "Ao adicionar um lote para um produto que já tem histórico, os campos de preço de custo e venda devem vir preenchidos com os valores do último lote.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "inline-duplicate-name",
+    category: "inline-lote",
+    title: "Produto inline duplicado (mesmo nome)",
+    howToTest: "Adicione um produto inline chamado 'Produto A'. Tente adicionar outro produto inline também chamado 'Produto A'. Deve mostrar erro de duplicata.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  {
+    id: "inline-duplicate-barcode",
+    category: "inline-lote",
+    title: "Produto inline duplicado (mesmo código)",
+    howToTest: "Adicione um produto inline com código '123'. Tente adicionar outro produto inline com o mesmo código '123'. Deve mostrar erro de conflito.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  {
+    id: "inline-existing-barcode-conflict",
+    category: "inline-lote",
+    title: "Inline + produto existente com mesmo código",
+    howToTest: "Adicione um produto inline com código 'ABC'. Depois use o scanner para ler um produto existente que tem o código 'ABC'. Deve mostrar aviso de conflito e bloquear.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  // === Transferências ===
+  {
+    id: "transfer-full-flow",
+    category: "transferencias",
+    title: "Fluxo completo de transferência",
+    howToTest: "Vá para a página de nova transferência. Selecione o armazém de origem e destino. Busque um produto. Selecione um lote. Ajuste a quantidade. Confirme. Envie a transferência.",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  {
+    id: "transfer-scanner",
+    category: "transferencias",
+    title: "Scanner na transferência",
+    howToTest: "Na página de nova transferência, clique no ícone de scanner. Escaneie um produto. O produto deve ser encontrado e o drawer de lote deve abrir.",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  {
+    id: "transfer-no-batches",
+    category: "transferencias",
+    title: "Produto sem lotes disponíveis",
+    howToTest: "Na transferência, busque um produto que não tenha lotes cadastrados. O drawer de lote deve aparecer vazio.",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  {
+    id: "transfer-same-warehouse",
+    category: "transferencias",
+    title: "Mesmo armazém origem e destino",
+    howToTest: "Tente selecionar o mesmo armazém como origem e destino. O sistema deve bloquear essa ação.",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  {
+    id: "transfer-multiple-items",
+    category: "transferencias",
+    title: "Múltiplos itens na transferência",
+    howToTest: "Adicione 5 ou mais itens diferentes. Verifique se a lista mostra todos corretamente (cards no celular, tabela no desktop).",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  {
+    id: "transfer-remove-item",
+    category: "transferencias",
+    title: "Remover item da lista",
+    howToTest: "Adicione um item. Clique no botão de remover (ícone de lixeira). O item deve sumir da lista imediatamente.",
+    pageUrl: "/transfers/new",
+    pageLabel: "Nova Transferência",
+  },
+  // === Prompts ===
+  {
+    id: "prompts-create",
+    category: "prompts",
+    title: "Criar um prompt",
+    howToTest: "Na página de detalhes do produto, clique na aba 'Prompts'. Clique em 'Criar prompt'. Faça upload de uma imagem de fundo. Dê um nome. Salve.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-generate-auto-price",
+    category: "prompts",
+    title: "Gerar com preço automático do lote",
+    howToTest: "Abra um prompt de um produto que tenha lotes. O campo de preço deve vir preenchido automaticamente com o valor do último lote.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-generate-manual-price",
+    category: "prompts",
+    title: "Gerar com preço manual",
+    howToTest: "No prompt, altere o preço manualmente para um valor diferente do sugerido. Clique em 'Gerar'. O sistema deve usar o valor que você digitou.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-cash-offer",
+    category: "prompts",
+    title: "Opção de oferta à vista",
+    howToTest: "Na página de gerar prompt, ative 'Oferta à vista'. Escolha entre 'Preço final' ou '% de desconto'. O preço à vista deve ser calculado.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-installments",
+    category: "prompts",
+    title: "Parcelamento",
+    howToTest: "Na página de gerar prompt, ative o parcelamento. Defina o número de parcelas. O valor da parcela deve ser calculado automaticamente.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-share-android",
+    category: "prompts",
+    title: "Compartilhar no Android/Desktop",
+    howToTest: "Gere um prompt e clique em 'Gerar imagem'. Deve abrir a janela de compartilhamento nativa do sistema.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-share-ios-pwa",
+    category: "prompts",
+    title: "Compartilhar no iOS PWA",
+    howToTest: "Abra o app como PWA no iPhone. Gere um prompt. O sistema deve mostrar uma mensagem informando que o compartilhamento de arquivos é bloqueado no iOS PWA.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-cancel-share",
+    category: "prompts",
+    title: "Cancelar compartilhamento",
+    howToTest: "Gere um prompt. Quando a janela de compartilhar abrir, cancele. O app deve voltar para a lista de prompts.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-no-logo",
+    category: "prompts",
+    title: "Empresa sem logo",
+    howToTest: "Gere um prompt para uma empresa que não tem logo cadastrada. A imagem deve ser gerada sem o logo (sem quebrar).",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  {
+    id: "prompts-double-click",
+    category: "prompts",
+    title: "Clique rápido em Gerar",
+    howToTest: "Na página de gerar prompt, clique duas vezes bem rápido no botão 'Gerar imagem'. O sistema deve bloquear o segundo clique.",
+    pageUrl: "/products",
+    pageLabel: "Lista de Produtos",
+  },
+  // === Formulário de Produto ===
+  {
+    id: "produto-form-large-image",
+    category: "produto-form",
+    title: "Upload de imagem muito grande (acima de 5MB)",
+    howToTest: "Na página de criar/editar produto, tente fazer upload de uma imagem com mais de 5MB. O sistema deve rejeitar.",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "produto-form-processing-lock",
+    category: "produto-form",
+    title: "Lock de processamento de imagem",
+    howToTest: "Faça upload de uma imagem válida. Enquanto a imagem estiver processando, o botão de salvar deve ficar desabilitado e mostrar 'Imagem...' com um spinner.",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "produto-form-submit-processing",
+    category: "produto-form",
+    title: "Tentar salvar durante processamento",
+    howToTest: "Faça upload de uma imagem e imediatamente tente clicar em salvar. Deve aparecer um toast avisando: 'Aguarde a imagem terminar de processar antes de salvar.'",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "produto-form-continuous",
+    category: "produto-form",
+    title: "Produto inline contínuo",
+    howToTest: "Ao criar um produto inline dentro de uma movimentação, após salvar o formulário deve resetar e permanecer na mesma página para adicionar outro.",
+    pageUrl: "/stock-movements/create/new-product",
+    pageLabel: "Novo Produto (inline)",
+  },
+  // === API ===
+  {
+    id: "api-token-expired",
+    category: "api",
+    title: "Token expirado durante uso",
+    howToTest: "Mantenha a sessão aberta por várias horas (ou use ferramentas de desenvolvimento para simular). Quando o token expirar, a próxima requisição deve renovar automaticamente sem redirecionar para o login.",
+    pageUrl: "/stock-movements",
+    pageLabel: "Movimentações",
+  },
+  {
+    id: "api-multiple-401",
+    category: "api",
+    title: "Múltiplas chamadas com token expirado",
+    howToTest: "Carregue uma página com várias requisições ao mesmo tempo (ex: dashboard). Se o token estiver expirado, apenas uma renovação deve ocorrer e todas as chamadas devem ser repetidas.",
+    pageUrl: "/stock-movements",
+    pageLabel: "Movimentações",
+  },
+  {
+    id: "api-refresh-fails",
+    category: "api",
+    title: "Refresh de token falha",
+    howToTest: "Simule um token inválido (logout em outra aba). A aplicação deve redirecionar para a página de login.",
+    pageUrl: "/stock-movements",
+    pageLabel: "Movimentações",
+  },
+  {
+    id: "api-403-forbidden",
+    category: "api",
+    title: "Erro 403 sem tentar refresh",
+    howToTest: "Tente acessar um recurso que você não tem permissão. O sistema deve mostrar o erro 403 diretamente, sem tentar renovar o token.",
+    pageUrl: "/system",
+    pageLabel: "Sistema",
+  },
+  // === Toasts ===
+  {
+    id: "toasts-style",
+    category: "toasts",
+    title: "Aparência dos toasts no tema brutalista",
+    howToTest: "Disparar qualquer toast (ex: salvar um produto, erro de validação). Verifique se o fundo é escuro (#171717), borda cinza, texto claro (#FAFAFA), bordas retas (4px).",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "toasts-position",
+    category: "toasts",
+    title: "Posição dos toasts",
+    howToTest: "Disparar qualquer toast. Ele deve aparecer no topo central da tela.",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "toasts-language",
+    category: "toasts",
+    title: "Mensagens em português",
+    howToTest: "Cause diferentes ações que gerem toasts (salvar, erro, validação). Todas as mensagens devem estar em português do Brasil.",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  {
+    id: "toasts-long-text",
+    category: "toasts",
+    title: "Toast com texto longo",
+    howToTest: "Se encontrar um toast com mensagem longa, verifique se o texto não quebra o layout nem corta palavras.",
+    pageUrl: "/stock-movements/create",
+    pageLabel: "Nova Movimentação",
+  },
+  {
+    id: "toasts-stacking",
+    category: "toasts",
+    title: "Empilhamento de múltiplos toasts",
+    howToTest: "Disparar 3 toasts em sequência rápida. Eles devem empilhar um abaixo do outro sem se sobrepor.",
+    pageUrl: "/products/create",
+    pageLabel: "Criar Produto",
+  },
+  // === Warehouse ===
+  {
+    id: "warehouse-instant-load",
+    category: "warehouse",
+    title: "Warehouse carrega instantaneamente",
+    howToTest: "Com um warehouse já selecionado, recarregue a página (F5). O nome do warehouse deve aparecer imediatamente no topo, sem flicker ou atraso.",
+    pageUrl: "/products",
+    pageLabel: "Produtos",
+  },
+  {
+    id: "warehouse-no-selection",
+    category: "warehouse",
+    title: "Primeiro acesso (sem warehouse)",
+    howToTest: "Limpe o armazenamento local (localStorage) do navegador. Acesse o app. Nenhum warehouse deve estar selecionado e as páginas devem lidar com isso.",
+    pageUrl: "/products",
+    pageLabel: "Produtos",
+  },
+  {
+    id: "warehouse-stable-navigation",
+    category: "warehouse",
+    title: "Warehouse estável na navegação",
+    howToTest: "Selecione um warehouse. Navegue entre 3 ou 4 páginas diferentes (Produtos, Vendas, Movimentações). O warehouse selecionado deve permanecer o mesmo.",
+    pageUrl: "/products",
+    pageLabel: "Produtos",
+  },
+];
diff --git a/app/(pages)/exploratory-tests/exploratory-tests.model.ts b/app/(pages)/exploratory-tests/exploratory-tests.model.ts
new file mode 100644
index 0000000..46d4659
--- /dev/null
+++ b/app/(pages)/exploratory-tests/exploratory-tests.model.ts
@@ -0,0 +1,68 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { toast } from "sonner";
+import { EXPLORATORY_TESTS, EXPLORATORY_TEST_CATEGORIES } from "./exploratory-tests.constants";
+import { readProgress, writeProgress, clearProgress } from "./exploratory-tests.storage";
+import type { ExploratoryTestsViewProps } from "./exploratory-tests.types";
+
+export function useExploratoryTestsModel(): ExploratoryTestsViewProps {
+  const [completedTestIds, setCompletedTestIds] = useState<Set<string>>(new Set());
+  const [isLoaded, setIsLoaded] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    readProgress().then((progress) => {
+      if (cancelled) return;
+      setCompletedTestIds(new Set(progress.completedTestIds));
+      setIsLoaded(true);
+    }).catch(() => {
+      if (!cancelled) setIsLoaded(true);
+    });
+    return () => { cancelled = true; };
+  }, []);
+
+  const toggleTest = useCallback((testId: string) => {
+    setCompletedTestIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(testId)) {
+        next.delete(testId);
+      } else {
+        next.add(testId);
+      }
+      const ids = Array.from(next);
+      writeProgress(ids).catch(() => {});
+      return next;
+    });
+  }, []);
+
+  const resetAll = useCallback(() => {
+    setCompletedTestIds(new Set());
+    clearProgress().catch(() => {});
+    toast.success("Progresso de testes resetado.");
+  }, []);
+
+  const completedPercentage = useMemo(() => {
+    const total = EXPLORATORY_TESTS.length;
+    if (total === 0) return 0;
+    return Math.round((completedTestIds.size / total) * 100);
+  }, [completedTestIds.size]);
+
+  const testsByCategory = useMemo(() => {
+    const map = new Map<string, typeof EXPLORATORY_TESTS>();
+    for (const category of EXPLORATORY_TEST_CATEGORIES) {
+      map.set(category.key, EXPLORATORY_TESTS.filter((t) => t.category === category.key));
+    }
+    return map;
+  }, []);
+
+  return {
+    tests: isLoaded ? EXPLORATORY_TESTS : [],
+    categories: EXPLORATORY_TEST_CATEGORIES,
+    completedTestIds,
+    completedPercentage,
+    testsByCategory,
+    toggleTest,
+    resetAll,
+  };
+}
diff --git a/app/(pages)/exploratory-tests/exploratory-tests.storage.ts b/app/(pages)/exploratory-tests/exploratory-tests.storage.ts
new file mode 100644
index 0000000..7df1629
--- /dev/null
+++ b/app/(pages)/exploratory-tests/exploratory-tests.storage.ts
@@ -0,0 +1,119 @@
+import type { ExploratoryTestProgress } from "./exploratory-tests.types";
+
+const DATABASE_NAME = "stockshift_testing";
+const DATABASE_VERSION = 1;
+const STORE_NAME = "exploratoryTestProgress";
+const STORAGE_KEY = "current";
+
+const getBrowserIndexedDb = (): IDBFactory | null => {
+  if (typeof window === "undefined") return null;
+  return window.indexedDB ?? null;
+};
+
+const logStorageError = (operation: string, error: unknown): void => {
+  console.error(`[exploratory-tests] Falha ao ${operation}`, error);
+};
+
+const openDatabase = (): Promise<IDBDatabase> => {
+  const indexedDb = getBrowserIndexedDb();
+  if (!indexedDb) {
+    return Promise.reject(new Error("IndexedDB indisponível."));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDb.open(DATABASE_NAME, DATABASE_VERSION);
+    request.onerror = () => reject(new Error(`Falha ao abrir IndexedDB: ${request.error?.message}`));
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(STORE_NAME)) {
+        database.createObjectStore(STORE_NAME);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+  });
+};
+
+const emptyProgress = (): ExploratoryTestProgress => ({
+  completedTestIds: [],
+  updatedAt: "",
+});
+
+let fallbackProgress: ExploratoryTestProgress = emptyProgress();
+
+export const readProgress = async (): Promise<ExploratoryTestProgress> => {
+  try {
+    const database = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.get(STORAGE_KEY);
+      request.onerror = () => reject(new Error(`Falha ao ler progresso: ${request.error?.message}`));
+      request.onsuccess = () => {
+        const raw = request.result;
+        if (raw && typeof raw === "object" && Array.isArray((raw as ExploratoryTestProgress).completedTestIds)) {
+          fallbackProgress = raw as ExploratoryTestProgress;
+          resolve(fallbackProgress);
+        } else {
+          resolve(emptyProgress());
+        }
+      };
+      transaction.oncomplete = () => database.close();
+      transaction.onabort = () => {
+        database.close();
+        reject(new Error("Transação de leitura abortada."));
+      };
+    });
+  } catch (error) {
+    logStorageError("ler progresso", error);
+    return fallbackProgress;
+  }
+};
+
+export const writeProgress = async (completedTestIds: string[]): Promise<void> => {
+  const progress: ExploratoryTestProgress = {
+    completedTestIds,
+    updatedAt: new Date().toISOString(),
+  };
+  fallbackProgress = progress;
+  try {
+    const database = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.put(progress, STORAGE_KEY);
+      request.onerror = () => reject(new Error(`Falha ao gravar progresso: ${request.error?.message}`));
+      transaction.oncomplete = () => {
+        database.close();
+        resolve();
+      };
+      transaction.onabort = () => {
+        database.close();
+        reject(new Error("Transação de gravação abortada."));
+      };
+    });
+  } catch (error) {
+    logStorageError("gravar progresso", error);
+  }
+};
+
+export const clearProgress = async (): Promise<void> => {
+  fallbackProgress = emptyProgress();
+  try {
+    const database = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.delete(STORAGE_KEY);
+      request.onerror = () => reject(new Error(`Falha ao limpar progresso: ${request.error?.message}`));
+      transaction.oncomplete = () => {
+        database.close();
+        resolve();
+      };
+      transaction.onabort = () => {
+        database.close();
+        reject(new Error("Transação de exclusão abortada."));
+      };
+    });
+  } catch (error) {
+    logStorageError("limpar progresso", error);
+  }
+};
diff --git a/app/(pages)/exploratory-tests/exploratory-tests.types.ts b/app/(pages)/exploratory-tests/exploratory-tests.types.ts
new file mode 100644
index 0000000..06b0734
--- /dev/null
+++ b/app/(pages)/exploratory-tests/exploratory-tests.types.ts
@@ -0,0 +1,14 @@
+export interface ExploratoryTestProgress {
+  completedTestIds: string[];
+  updatedAt: string;
+}
+
+export interface ExploratoryTestsViewProps {
+  tests: import("./exploratory-tests.constants").ExploratoryTest[];
+  categories: import("./exploratory-tests.constants").ExploratoryTestCategory[];
+  completedTestIds: Set<string>;
+  completedPercentage: number;
+  testsByCategory: Map<string, import("./exploratory-tests.constants").ExploratoryTest[]>;
+  toggleTest: (testId: string) => void;
+  resetAll: () => void;
+}
diff --git a/app/(pages)/exploratory-tests/exploratory-tests.view.tsx b/app/(pages)/exploratory-tests/exploratory-tests.view.tsx
new file mode 100644
index 0000000..a5e0798
--- /dev/null
+++ b/app/(pages)/exploratory-tests/exploratory-tests.view.tsx
@@ -0,0 +1,198 @@
+"use client";
+
+import Link from "next/link";
+import { ExternalLink, RotateCcw, CheckSquare, Square } from "lucide-react";
+import { PageContainer } from "@/components/ui/page-container";
+import { PageHeader } from "@/components/ui/page-header";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+import type { ExploratoryTestsViewProps } from "./exploratory-tests.types";
+import type { ExploratoryTest, ExploratoryTestCategory } from "./exploratory-tests.constants";
+
+const PRIORITY_COLORS: Record<string, string> = {
+  ALTA: "text-red-400 border-red-500/40",
+  MÉDIA: "text-amber-400 border-amber-500/40",
+  BAIXA: "text-neutral-400 border-neutral-500/40",
+};
+
+export function ExploratoryTestsView({
+  tests,
+  categories,
+  completedTestIds,
+  completedPercentage,
+  testsByCategory,
+  toggleTest,
+  resetAll,
+}: ExploratoryTestsViewProps) {
+  const progressColor = completedPercentage === 100
+    ? "text-green-400"
+    : completedPercentage >= 50
+      ? "text-amber-400"
+      : "text-neutral-400";
+
+  return (
+    <PageContainer bottomPadding="default">
+      <PageHeader
+        title="Testes Exploratórios"
+        subtitle="Branch indexdb"
+        actions={
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={resetAll}
+            className="border-red-500/30 text-red-400 hover:bg-red-500/10"
+          >
+            <RotateCcw className="mr-2 h-4 w-4" />
+            Resetar
+          </Button>
+        }
+      />
+
+      <div className="mb-8 flex items-center gap-4 rounded-sm border border-neutral-800 bg-[#171717] p-4">
+        <div className={cn("text-3xl font-bold", progressColor)}>
+          {completedPercentage}%
+        </div>
+        <div className="flex-1">
+          <p className="text-sm font-semibold text-white">Progresso dos testes</p>
+          <p className="text-xs text-neutral-400">
+            {completedTestIds.size} de {tests.length} testes concluídos
+          </p>
+          <div className="mt-2 h-2 w-full overflow-hidden rounded-sm bg-neutral-800">
+            <div
+              className={cn("h-full rounded-sm transition-all duration-300", {
+                "bg-green-500": completedPercentage === 100,
+                "bg-amber-500": completedPercentage >= 50 && completedPercentage < 100,
+                "bg-blue-500": completedPercentage > 0 && completedPercentage < 50,
+                "bg-neutral-700": completedPercentage === 0,
+              })}
+              style={{ width: `${completedPercentage}%` }}
+            />
+          </div>
+        </div>
+      </div>
+
+      <div className="space-y-10">
+        {categories.map((category) => (
+          <CategorySection
+            key={category.key}
+            category={category}
+            tests={testsByCategory.get(category.key) ?? []}
+            completedTestIds={completedTestIds}
+            toggleTest={toggleTest}
+          />
+        ))}
+      </div>
+
+      <div className="mt-10 text-center">
+        <p className="text-xs text-neutral-600">
+          O progresso é salvo automaticamente no navegador.
+          Ao limpar os dados do site, o progresso será perdido.
+        </p>
+      </div>
+    </PageContainer>
+  );
+}
+
+function CategorySection({
+  category,
+  tests,
+  completedTestIds,
+  toggleTest,
+}: {
+  category: ExploratoryTestCategory;
+  tests: ExploratoryTest[];
+  completedTestIds: Set<string>;
+  toggleTest: (testId: string) => void;
+}) {
+  const categoryCompleted = tests.filter((t) => completedTestIds.has(t.id)).length;
+  const categoryTotal = tests.length;
+
+  return (
+    <section>
+      <div className="mb-3 flex items-center gap-2">
+        <span
+          className={cn(
+            "rounded-sm border px-2 py-0.5 text-[10px] font-bold uppercase tracking-widest",
+            PRIORITY_COLORS[category.priority],
+          )}
+        >
+          {category.priority}
+        </span>
+        <h2 className="text-lg font-semibold text-white">{category.label}</h2>
+        <span className="text-xs text-neutral-500">
+          {categoryCompleted}/{categoryTotal}
+        </span>
+      </div>
+
+      <div className="space-y-2">
+        {tests.map((test) => (
+          <TestCard
+            key={test.id}
+            test={test}
+            isCompleted={completedTestIds.has(test.id)}
+            onToggle={() => toggleTest(test.id)}
+          />
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function TestCard({
+  test,
+  isCompleted,
+  onToggle,
+}: {
+  test: ExploratoryTest;
+  isCompleted: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <div
+      className={cn(
+        "rounded-sm border border-neutral-800 bg-[#171717] transition-colors",
+        isCompleted && "border-green-500/30 bg-green-500/5",
+      )}
+    >
+      <div className="flex items-start gap-3 p-3">
+        <button
+          type="button"
+          onClick={onToggle}
+          className="mt-0.5 flex-shrink-0 text-neutral-400 hover:text-white"
+          aria-label={isCompleted ? "Desmarcar como concluído" : "Marcar como concluído"}
+        >
+          {isCompleted ? (
+            <CheckSquare className="h-5 w-5 text-green-400" />
+          ) : (
+            <Square className="h-5 w-5" />
+          )}
+        </button>
+
+        <div className="min-w-0 flex-1">
+          <div className="flex items-start justify-between gap-2">
+            <p
+              className={cn(
+                "text-sm font-semibold",
+                isCompleted ? "text-green-300 line-through" : "text-white",
+              )}
+            >
+              {test.title}
+            </p>
+            <Link
+              href={test.pageUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="flex-shrink-0 inline-flex items-center gap-1 rounded-sm border border-neutral-700 px-2 py-1 text-[11px] font-bold uppercase tracking-wide text-neutral-400 hover:border-neutral-500 hover:text-white"
+            >
+              {test.pageLabel}
+              <ExternalLink className="h-3 w-3" />
+            </Link>
+          </div>
+          <p className="mt-1 text-xs leading-relaxed text-neutral-400">
+            {test.howToTest}
+          </p>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/app/(pages)/exploratory-tests/page.client.tsx b/app/(pages)/exploratory-tests/page.client.tsx
new file mode 100644
index 0000000..4ab2f15
--- /dev/null
+++ b/app/(pages)/exploratory-tests/page.client.tsx
@@ -0,0 +1,9 @@
+"use client";
+
+import { useExploratoryTestsModel } from "./exploratory-tests.model";
+import { ExploratoryTestsView } from "./exploratory-tests.view";
+
+export function PageClient() {
+  const model = useExploratoryTestsModel();
+  return <ExploratoryTestsView {...model} />;
+}
diff --git a/app/(pages)/exploratory-tests/page.tsx b/app/(pages)/exploratory-tests/page.tsx
new file mode 100644
index 0000000..55daf95
--- /dev/null
+++ b/app/(pages)/exploratory-tests/page.tsx
@@ -0,0 +1,16 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { PageClient } from "./page.client";
+
+export const metadata: Metadata = {
+  title: "Testes Exploratórios | StockShift",
+  description: "Checklist de testes exploratórios da branch indexdb.",
+};
+
+export default function Page() {
+  // The exploratory tests page is a development-only tool and must not be
+  // reachable in production builds.
+  if (process.env.NODE_ENV !== "development") notFound();
+
+  return <PageClient />;
+}

From 195dead4d81fd086d023bf425ff40a483499be9c Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:15:02 -0300
Subject: [PATCH 31/32] fix(ui): increase toast CSS specificity to beat sonner
 injected styles

Sonner v2 injects [data-sonner-toast][data-styled=true] at runtime, which ties
at specificity 0,2,0 with .toaster .toast-{type}. Since sonner's CSS is injected
later, it wins and backgrounds stay dark.

Prepend [data-sonner-toast] to the type selectors raising specificity to 0,3,0.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 app/globals.css | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/app/globals.css b/app/globals.css
index 6802c6c..851f983 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -153,25 +153,25 @@
   color: var(--normal-text);
 }
 
-.toaster .toast-success {
+.toaster [data-sonner-toast].toast-success {
   background: #059669;
   border-color: #059669;
   color: #FFFFFF;
 }
 
-.toaster .toast-error {
+.toaster [data-sonner-toast].toast-error {
   background: #E11D48;
   border-color: #E11D48;
   color: #FFFFFF;
 }
 
-.toaster .toast-warning {
+.toaster [data-sonner-toast].toast-warning {
   background: #F59E0B;
   border-color: #F59E0B;
   color: #000000;
 }
 
-.toaster .toast-info {
+.toaster [data-sonner-toast].toast-info {
   background: #2563EB;
   border-color: #2563EB;
   color: #FFFFFF;

From c98c9768040b646f9ef46faba8d4d0307b6a28db Mon Sep 17 00:00:00 2001
From: lexmarcos <marcosuel.vieira@hotmail.com>
Date: Thu, 18 Jun 2026 00:15:08 -0300
Subject: [PATCH 32/32] feat(category-color): generate light base colors and
 extract badge style builder

Switch categoryNameToHexColor from dark (lightness 30%) to vibrant (lightness 65%)
colors that read well as text on dark surfaces. Add hexToRgba helper and a new
buildCategoryBadgeStyle() that derives translucent bg/border and solid text from
the same hue, so the badge stays legible without white-on-color guesswork.

Update ProductCardImage to use buildCategoryBadgeStyle instead of inline color.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 app/(pages)/products/products.view.tsx |  9 ++----
 lib/category-color.test.ts             | 44 +++++++++++++++++++-------
 lib/category-color.ts                  | 33 ++++++++++++++++---
 3 files changed, 65 insertions(+), 21 deletions(-)

diff --git a/app/(pages)/products/products.view.tsx b/app/(pages)/products/products.view.tsx
index 2009ccc..4f5f905 100644
--- a/app/(pages)/products/products.view.tsx
+++ b/app/(pages)/products/products.view.tsx
@@ -74,7 +74,7 @@ import {
   ProductFilters,
   LatestBatchPrice,
 } from "./products.types";
-import { categoryNameToHexColor } from "@/lib/category-color";
+import { buildCategoryBadgeStyle } from "@/lib/category-color";
 import { cn } from "@/lib/utils";
 
 const STOCK_FILTER_OPTIONS: Array<{
@@ -1044,13 +1044,10 @@ const ProductCardImage = ({ product }: { product: Product }) => {
 const ProductCategoryBadge = ({ name }: { name: string | null }) => {
   const trimmedName = name?.trim();
   if (!trimmedName) return null;
-  // categoryNameToHexColor always returns a dark (lightness 30%) color, so
-  // white text is always the readable choice.
-  const backgroundColor = categoryNameToHexColor(trimmedName);
   return (
     <span
-      className="w-fit break-words rounded-[4px] px-1.5 py-0.5 text-[9px] font-bold uppercase tracking-wider leading-tight text-white"
-      style={{ backgroundColor }}
+      className="w-fit break-words rounded-[4px] border px-1.5 py-0.5 text-[9px] font-bold uppercase tracking-wider leading-tight"
+      style={buildCategoryBadgeStyle(trimmedName)}
     >
       {trimmedName}
     </span>
diff --git a/lib/category-color.test.ts b/lib/category-color.test.ts
index 40a0951..5358e16 100644
--- a/lib/category-color.test.ts
+++ b/lib/category-color.test.ts
@@ -1,5 +1,12 @@
 import { describe, it, expect } from "vitest";
-import { categoryNameToHexColor } from "./category-color";
+import { buildCategoryBadgeStyle, categoryNameToHexColor } from "./category-color";
+
+const luminanceOf = (hex: string): number => {
+  const r = Number.parseInt(hex.slice(1, 3), 16);
+  const g = Number.parseInt(hex.slice(3, 5), 16);
+  const b = Number.parseInt(hex.slice(5, 7), 16);
+  return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+};
 
 describe("categoryNameToHexColor", () => {
   it("returns a deterministic hex color for the same category name", () => {
@@ -15,18 +22,33 @@ describe("categoryNameToHexColor", () => {
     expect(beverages).not.toBe(electronics);
   });
 
-  it("returns dark colors suitable for dark mode badges with white text", () => {
-    const hex = categoryNameToHexColor("Perfume Feminino");
-    const r = Number.parseInt(hex.slice(1, 3), 16);
-    const g = Number.parseInt(hex.slice(3, 5), 16);
-    const b = Number.parseInt(hex.slice(5, 7), 16);
-    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
-    expect(luminance).toBeLessThan(0.55);
+  it("returns light base colors readable as solid text on dark surfaces", () => {
+    expect(luminanceOf(categoryNameToHexColor("Perfume Feminino"))).toBeGreaterThan(0.4);
+    expect(luminanceOf(categoryNameToHexColor("Bebidas"))).toBeGreaterThan(0.4);
+    expect(luminanceOf(categoryNameToHexColor("Eletrônicos"))).toBeGreaterThan(0.4);
   });
 
   it("returns fallback color for empty or null name", () => {
-    expect(categoryNameToHexColor(null)).toBe("#404040");
-    expect(categoryNameToHexColor("")).toBe("#404040");
-    expect(categoryNameToHexColor("   ")).toBe("#404040");
+    expect(categoryNameToHexColor(null)).toBe("#A3A3A3");
+    expect(categoryNameToHexColor("")).toBe("#A3A3A3");
+    expect(categoryNameToHexColor("   ")).toBe("#A3A3A3");
+  });
+});
+
+describe("buildCategoryBadgeStyle", () => {
+  it("uses the solid base color for text and translucent variants for bg/border", () => {
+    const base = categoryNameToHexColor("Bebidas");
+    const style = buildCategoryBadgeStyle("Bebidas");
+
+    expect(style.color).toBe(base);
+    expect(style.backgroundColor).toMatch(/^rgba\(\d+, \d+, \d+, 0\.12\)$/);
+    expect(style.borderColor).toMatch(/^rgba\(\d+, \d+, \d+, 0\.4\)$/);
+  });
+
+  it("derives bg and border from the same rgb as the base color", () => {
+    const style = buildCategoryBadgeStyle("Bebidas");
+    const rgb = (value: string) => value.match(/\d+, \d+, \d+/)?.[0];
+
+    expect(rgb(style.backgroundColor)).toBe(rgb(style.borderColor));
   });
 });
diff --git a/lib/category-color.ts b/lib/category-color.ts
index efe68cd..fefa9bc 100644
--- a/lib/category-color.ts
+++ b/lib/category-color.ts
@@ -1,4 +1,4 @@
-const CATEGORY_FALLBACK_COLOR = "#404040";
+const CATEGORY_FALLBACK_COLOR = "#A3A3A3";
 
 const hslToHex = (hue: number, saturation: number, lightness: number): string => {
   const s = saturation / 100;
@@ -30,13 +30,38 @@ const hashStringToInt = (value: string): number => {
   return Math.abs(hash);
 };
 
-// Deterministic, dark (lightness 30%) badge color derived from a category name,
-// suitable as a background for white text in the dark theme.
+const hexToRgba = (hex: string, alpha: number): string => {
+  const r = Number.parseInt(hex.slice(1, 3), 16);
+  const g = Number.parseInt(hex.slice(3, 5), 16);
+  const b = Number.parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+};
+
+// Deterministic, vibrant (lightness 65%) base color derived from a category
+// name, light enough to be read as solid text on the dark theme surfaces.
 export const categoryNameToHexColor = (
   name: string | null | undefined,
 ): string => {
   const trimmed = name?.trim();
   if (!trimmed) return CATEGORY_FALLBACK_COLOR;
   const hue = hashStringToInt(trimmed) % 360;
-  return hslToHex(hue, 55, 30);
+  return hslToHex(hue, 65, 65);
+};
+
+export interface CategoryBadgeStyle {
+  color: string;
+  backgroundColor: string;
+  borderColor: string;
+}
+
+// From a single base color: translucent fill, semi-opaque border and solid text.
+export const buildCategoryBadgeStyle = (
+  name: string | null | undefined,
+): CategoryBadgeStyle => {
+  const base = categoryNameToHexColor(name);
+  return {
+    color: base,
+    backgroundColor: hexToRgba(base, 0.12),
+    borderColor: hexToRgba(base, 0.4),
+  };
 };