@miravia_test/miravia-publish-skill 0.1.2 → 0.1.3

package/dist/scripts/{modules/publish_module.py → publish_module.py}

@@ -29,7 +29,7 @@ import telemetry
 from miravia_client import MiraviaClient, MiraviaError
 from product_client import ProductClient, _normalize_variation_name
 
-from modules.extraction_engine import (
+from extraction_engine import (
     CRITICAL_FIELDS,
     ExtractionEngine,
     LLMClient,
@@ -37,7 +37,7 @@ from modules.extraction_engine import (
     check_missing,
     validate_title,
 )
-from modules.file_reader import extract_text, read_sources
+from file_reader import extract_text, read_sources, get_excel_row_count
 
 logger = logging.getLogger("miravia.product.publish")
 
@@ -67,6 +67,11 @@ _MAX_DIMENSION_CM = 300
 _MAX_IMAGE_SIZE_MB = 5
 _VALID_IMAGE_FORMATS = {".jpg", ".jpeg", ".png", ".webp"}
 
+# DBM (Drop by Miravia) limits — packages exceeding these auto-switch to DBS
+_DBM_MAX_WEIGHT_KG = 40
+_DBM_MAX_DIM_SUM_CM = 300
+_DBM_MAX_VOLUME_WEIGHT = 40  # L*W*H/6000
+
 
 _BRAND_PERMISSION_CODES = frozenset(("BRAND_PENDING", "BRAND_PERMISSION_DENIED"))
 
@@ -273,6 +278,10 @@ class PublishModule:
         if skus:
             product_payload["Skus"] = {"Sku": skus}
 
+        # Draft mode — set Status to inactive
+        if draft_requested:
+            product_payload["Status"] = "inactive"
+
         # Inject safety warning from CLI flags into Attributes
         safety_warning_arg = getattr(self.args, "safety_warning", None)
         if safety_warning_arg is not None:
@@ -398,7 +407,27 @@ class PublishModule:
                 for m in gpsr_missing:
                     draft_issues.append(f"NOTE: {m}")
 
-        # Check postToInactive fields (EAN, compliance_documents, unit_count, food_attributes)
+        # Stage 3b: unified compliance check (Safety Warning + compliance docs)
+        compliance_check = self._check_compliance_fields(
+            product_payload,
+            category_id=category_id,
+            draft_requested=draft_requested,
+            draft_issues=draft_issues,
+        )
+        if compliance_check:
+            return compliance_check
+
+        # Stage 3c: special category rules (PPU / ISBN / food attributes)
+        special_check = self._check_special_category_rules(
+            product_payload,
+            category_id=category_id,
+            draft_requested=draft_requested,
+            draft_issues=draft_issues,
+        )
+        if special_check:
+            return special_check
+
+        # Check postToInactive fields (EAN only; PPU/food moved to Stage 3c)
         post_to_inactive_result = self._check_post_to_inactive_fields(
             product_payload, str(category_id), draft_requested, draft_issues
         )
@@ -450,37 +479,6 @@ class PublishModule:
                 "Please fill it or publish to Draft."
             )
 
-        # Check compliance_documents
-        compliance_docs = getattr(self.args, "compliance_documents", None) or []
-        compliance_mandatory = self._is_category_attribute_mandatory(
-            definitions, "compliance_documents"
-        )
-        if compliance_mandatory and not compliance_docs:
-            post_to_inactive_missing.append(
-                "Compliance documents are required for this category but not filled. "
-                "Please fill them or publish to Draft."
-            )
-
-        # Check unit_count - mandatory for nail polish category
-        unit_count = getattr(self.args, "unit_count", None)
-        unit_count_mandatory = self._is_category_attribute_mandatory(
-            definitions, "unit_count"
-        )
-        if unit_count_mandatory and not unit_count:
-            post_to_inactive_missing.append(
-                "Unit count is required for this category but not filled. "
-                "Please fill it or publish to Draft."
-            )
-
-        # Check food_attributes - mandatory for food category
-        food_attrs = getattr(self.args, "sku_attributes_food_health", None) or {}
-        food_mandatory = self._category_looks_like_food_health(definitions)
-        if food_mandatory and not food_attrs:
-            post_to_inactive_missing.append(
-                "Food & health attributes are required for this category but not filled. "
-                "Please fill them or publish to Draft."
-            )
-
         # Handle postToInactive missing fields
         if post_to_inactive_missing:
             if not draft_requested:
@@ -499,6 +497,354 @@ class PublishModule:
 
         return None
 
+    def _check_compliance_fields(
+        self,
+        product_payload: Dict[str, Any],
+        category_attributes: Optional[List[Dict[str, Any]]] = None,
+        *,
+        category_id: Optional[Any] = None,
+        schema: Optional[Any] = None,
+        draft_requested: bool = False,
+        draft_issues: Optional[List[str]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Unified compliance validation after payload is built.
+
+        Checks:
+        1. GPSR (manufacturer + EU responsible) — for AI flow
+        2. Safety Warning linkage (Yes → content required)
+        3. Compliance documents (category-mandatory → required)
+
+        Returns a ``compliance_missing_suggest_draft`` response when any
+        compliance field is missing, or ``None`` when all are satisfied.
+        """
+        compliance_issues: List[str] = []
+        attributes = product_payload.get("Attributes") or {}
+
+        # Fetch category attributes if not provided (manual flow)
+        if category_attributes is None and category_id is not None:
+            lang = self.args.lang if self.args.lang not in (None, "auto") else "en_US"
+            try:
+                category_attributes = self.product.get_category_attributes(
+                    str(category_id), language_code=lang
+                )
+            except Exception:
+                category_attributes = []
+        if category_attributes is None:
+            category_attributes = []
+
+        # --- 1. GPSR check (mainly for AI flow; manual flow has inline check) ---
+        mfr_name = ""
+        eurp_name = ""
+        if schema:
+            mfr_name = schema.manufacturer_name or ""
+            eurp_name = schema.eu_responsible_person_name or ""
+        else:
+            mfr_name = getattr(self.args, "manufacturer_name", None) or ""
+            eurp_name = getattr(self.args, "eu_responsible_person_name", None) or ""
+
+        if not mfr_name and not eurp_name:
+            compliance_issues.append(
+                i18n._("pub_compliance_manufacturer_eurp_both_empty")
+            )
+        elif mfr_name and not eurp_name:
+            compliance_issues.append(
+                i18n._("pub_compliance_eurp_missing_with_manufacturer")
+            )
+
+        # --- 2. Safety Warning linkage ---
+        safety_val = (
+            attributes.get("Does this product have a safety warning")
+            or attributes.get("Does_this_product_have_a_safety_warning")
+            or ""
+        )
+        if safety_val == "Yes":
+            safety_content = attributes.get("Safety_warning_content") or ""
+            if not safety_content.strip():
+                compliance_issues.append(
+                    i18n._("pub_safety_warning_content_missing")
+                )
+
+        # --- 3. Compliance documents (category-mandatory) ---
+        compliance_docs = None
+        if schema:
+            compliance_docs = schema.compliance_documents or None
+        else:
+            compliance_docs = getattr(self.args, "compliance_documents", None) or None
+
+        compliance_mandatory = self._is_category_attribute_mandatory(
+            category_attributes, "compliance_documents"
+        )
+        if compliance_mandatory and not compliance_docs:
+            compliance_issues.append(
+                i18n._("pub_compliance_docs_missing")
+            )
+
+        if not compliance_issues:
+            return None
+
+        if not draft_requested:
+            return {
+                "status": "compliance_missing_suggest_draft",
+                "message": i18n._("pub_compliance_missing_message"),
+                "compliance_issues": compliance_issues,
+                "next_actions": [
+                    i18n._("pub_compliance_fill_or_draft"),
+                    i18n._("pub_draft_option_hint"),
+                ],
+            }
+        else:
+            if draft_issues is not None:
+                for issue in compliance_issues:
+                    draft_issues.append(f"NOTE: {issue}")
+            return None
+
+    def _check_special_category_rules(
+        self,
+        product_payload: Dict[str, Any],
+        category_attributes: Optional[List[Dict[str, Any]]] = None,
+        *,
+        category_id: Optional[Any] = None,
+        schema: Optional[Any] = None,
+        draft_requested: bool = False,
+        draft_issues: Optional[List[str]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Validate special category rules: PPU, ISBN, food attributes.
+
+        Returns:
+        - ``special_category_block`` for hard errors (invalid PPU value, ISBN missing for books)
+        - ``special_category_suggest_draft`` for missing fields (PPU missing, food attrs missing)
+        - ``None`` when all rules are satisfied.
+        """
+        attributes = product_payload.get("Attributes") or {}
+
+        # Fetch category attributes if not provided
+        if category_attributes is None and category_id is not None:
+            lang = self.args.lang if self.args.lang not in (None, "auto") else "en_US"
+            try:
+                category_attributes = self.product.get_category_attributes(
+                    str(category_id), language_code=lang
+                )
+            except Exception:
+                category_attributes = []
+        if category_attributes is None:
+            category_attributes = []
+
+        # --- 1. PPU (Price Per Unit): standard_unit_type + unit_count ---
+        ppu_missing: List[str] = []
+        ppu_invalid: List[str] = []
+
+        # Get values from schema or CLI args
+        if schema:
+            unit_type = schema.standard_unit_type or ""
+            unit_count_val = schema.unit_count
+        else:
+            unit_type = getattr(self.args, "standard_unit_type", None) or getattr(
+                self.args, "unit_count_type", None
+            ) or ""
+            unit_count_val = getattr(self.args, "unit_count", None)
+
+        # Also check payload attributes as fallback
+        if not unit_type:
+            unit_type = (
+                attributes.get("unit_count_type")
+                or attributes.get("standard_unit_type")
+                or ""
+            )
+        if unit_count_val is None:
+            unit_count_val = attributes.get("unit_count")
+
+        unit_count_str = str(unit_count_val).strip() if unit_count_val is not None else ""
+
+        # Check if PPU is category-mandatory
+        ppu_mandatory = (
+            self._is_category_attribute_mandatory(category_attributes, "unit_count")
+            or self._is_category_attribute_mandatory(
+                category_attributes, "unit_count_type"
+            )
+        )
+
+        if ppu_mandatory or unit_type or unit_count_str:
+            # Check missing
+            if not unit_type and not unit_count_str:
+                ppu_missing.append(
+                    i18n._("pub_ppu_both_missing")
+                )
+            elif not unit_type:
+                ppu_missing.append(
+                    i18n._("pub_ppu_type_missing")
+                )
+            elif not unit_count_str:
+                ppu_missing.append(
+                    i18n._("pub_ppu_count_missing")
+                )
+            else:
+                # Both present — validate unit_count value
+                try:
+                    uc = float(unit_count_str)
+                    if uc <= 0:
+                        ppu_invalid.append(
+                            i18n._("pub_ppu_count_invalid", value=unit_count_str)
+                        )
+                except (TypeError, ValueError):
+                    ppu_invalid.append(
+                        i18n._("pub_ppu_count_not_number", value=unit_count_str)
+                    )
+
+        # --- 2. ISBN for book categories ---
+        isbn_missing = False
+        isbn_mandatory = self._is_category_attribute_mandatory(
+            category_attributes, "isbn"
+        )
+        if isbn_mandatory:
+            isbn_val = None
+            if schema:
+                isbn_val = schema.isbn
+            else:
+                isbn_val = getattr(self.args, "isbn", None)
+            if not isbn_val:
+                # Also check payload attributes
+                isbn_val = attributes.get("isbn")
+            if not isbn_val:
+                isbn_missing = True
+
+        # --- 3. Food & health attributes ---
+        food_missing = False
+        food_mandatory = self._category_looks_like_food_health(category_attributes)
+        if food_mandatory:
+            food_val = None
+            if schema:
+                food_val = schema.sku_attributes_food_health
+            else:
+                food_val = getattr(self.args, "sku_attributes_food_health", None) or None
+            if not food_val:
+                food_missing = True
+
+        # --- Build response ---
+        # Hard blocks first (invalid values, ISBN missing for books)
+        if ppu_invalid:
+            return {
+                "status": "special_category_block",
+                "message": i18n._("pub_ppu_validation_failed"),
+                "block_issues": ppu_invalid,
+                "next_actions": [i18n._("pub_ppu_fix_and_rerun")],
+            }
+
+        if isbn_missing:
+            return {
+                "status": "special_category_block",
+                "message": i18n._("pub_isbn_required_for_books"),
+                "block_issues": [i18n._("pub_isbn_missing")],
+                "next_actions": [i18n._("pub_isbn_fix_and_rerun")],
+            }
+
+        # Draft suggestions (missing fields)
+        draft_issues_list: List[str] = []
+        if ppu_missing:
+            draft_issues_list.extend(ppu_missing)
+        if food_missing:
+            draft_issues_list.append(i18n._("pub_food_attrs_missing"))
+
+        if not draft_issues_list:
+            return None
+
+        if not draft_requested:
+            return {
+                "status": "special_category_suggest_draft",
+                "message": i18n._("pub_special_category_missing_message"),
+                "missing_fields": draft_issues_list,
+                "next_actions": [
+                    i18n._("pub_special_category_fill_or_draft"),
+                    i18n._("pub_draft_option_hint"),
+                ],
+            }
+        else:
+            if draft_issues is not None:
+                for issue in draft_issues_list:
+                    draft_issues.append(f"NOTE: {issue}")
+            return None
+
+    def _check_dbm_limits(
+        self,
+        product_payload: Dict[str, Any],
+        *,
+        has_dbs_permission: bool = False,
+    ) -> Optional[Dict[str, Any]]:
+        """Check if package exceeds DBM limits and auto-switch to DBS.
+
+        DBM limits:
+        - Weight <= 40KG
+        - L+W+H <= 300cm
+        - Volumetric weight (L*W*H/6000) <= 40
+
+        If any limit is exceeded and delivery_method is DBM:
+        - Seller has DBS permission → auto-switch to DBS
+        - Seller has no DBS permission → return error (block)
+        Returns a dict with result, None if within limits.
+        """
+        attrs = product_payload.get("Attributes") or {}
+        delivery_method = attrs.get("delivery_method") or attrs.get("Delivery_method") or ""
+
+        # Only check if delivery method is DBM
+        if delivery_method.upper() != "DBM":
+            return None
+
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+        if not skus:
+            return None
+
+        # Check first SKU (DBM/DBS is product-level, same for all SKUs)
+        sku = skus[0]
+        weight = float(sku.get("package_weight") or 0)
+        length = float(sku.get("package_length") or 0)
+        width = float(sku.get("package_width") or 0)
+        height = float(sku.get("package_height") or 0)
+
+        if not (weight and length and width and height):
+            return None
+
+        dim_sum = length + width + height
+        volume_weight = (length * width * height) / 6000
+
+        exceeded: List[str] = []
+        if weight > _DBM_MAX_WEIGHT_KG:
+            exceeded.append(
+                i18n._("pub_dbm_weight_exceeded", weight=f"{weight}kg", limit=_DBM_MAX_WEIGHT_KG)
+            )
+        if dim_sum > _DBM_MAX_DIM_SUM_CM:
+            exceeded.append(
+                i18n._("pub_dbm_dim_sum_exceeded", dim_sum=f"{dim_sum}cm", limit=_DBM_MAX_DIM_SUM_CM)
+            )
+        if volume_weight > _DBM_MAX_VOLUME_WEIGHT:
+            exceeded.append(
+                i18n._("pub_dbm_volume_exceeded", volume=f"{volume_weight:.1f}", limit=_DBM_MAX_VOLUME_WEIGHT)
+            )
+
+        if not exceeded:
+            return None
+
+        # Exceeded DBM limits — check DBS permission
+        if has_dbs_permission:
+            # Auto-switch to DBS
+            attrs["delivery_method"] = "DBS"
+            attrs["Delivery_method"] = "DBS"
+            # Also update SKU-level if present
+            for s in skus:
+                if s.get("delivery_method"):
+                    s["delivery_method"] = "DBS"
+            return {
+                "switched_to_dbs": True,
+                "reasons": exceeded,
+                "message": i18n._("pub_dbm_auto_switch_to_dbs"),
+            }
+        else:
+            # No DBS permission — block with error
+            return {
+                "switched_to_dbs": False,
+                "blocked": True,
+                "reasons": exceeded,
+                "message": i18n._("pub_dbm_no_dbs_permission"),
+            }
+
     def _finalize_create(
         self,
         product_payload: Dict[str, Any],
@@ -511,6 +857,26 @@ class PublishModule:
         """Validate, preview, pre-validate, and execute product creation."""
         _validate_create_payload(product_payload)
 
+        # Check DBM limits — auto-switch to DBS if exceeded (requires DBS permission)
+        has_dbs = self.product.get_shipping_permission()
+        dbm_result = self._check_dbm_limits(product_payload, has_dbs_permission=has_dbs)
+        if dbm_result:
+            if dbm_result.get("blocked"):
+                # No DBS permission and exceeds DBM limits — block
+                return {
+                    "status": "dbm_limit_exceeded_no_dbs",
+                    "message": dbm_result["message"],
+                    "reasons": dbm_result.get("reasons", []),
+                    "next_actions": [
+                        i18n._("pub_dbm_fix_or_apply_dbs"),
+                    ],
+                }
+            if dbm_result.get("switched_to_dbs"):
+                if draft_issues is not None:
+                    draft_issues.append(dbm_result["message"])
+                    for reason in dbm_result.get("reasons", []):
+                        draft_issues.append(f"  - {reason}")
+
         # Run pre-validate early so errors are visible in the preview
         prevalidate_result = self._run_prevalidate(product_payload)
         prevalidate_errors = []
@@ -594,6 +960,17 @@ class PublishModule:
                         i18n._("pub_brand_permission_draft_suggestion", code=exc.code),
                     ],
                 }
+            # SKU already exists — concurrency conflict or duplicate SKU
+            if exc.code == "SKU_ALREADY_EXISTS":
+                return {
+                    "status": "sku_already_exists",
+                    "message": i18n._("pub_sku_already_exists"),
+                    "code": exc.code,
+                    "hint": exc.hint,
+                    "next_actions": [
+                        i18n._("pub_sku_already_exists_next"),
+                    ],
+                }
             # Code 4234: draft product created but missing required fields
             if exc.code == "4234" and draft:
                 err_data = (exc.payload.get("data") or {}) if exc.payload else {}
@@ -630,16 +1007,112 @@ class PublishModule:
     # AI-assisted create flow
     # ==================================================================
 
+    def _extract_product_summaries(
+        self, content_items: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Extract basic product info from each Excel row for display.
+
+        Returns a list of dicts with index, title, price, sku fields.
+        """
+        summaries: List[Dict[str, Any]] = []
+        idx = 1
+        for item in content_items:
+            if item.get("type") != "table":
+                continue
+            content = item.get("content")
+            if not content:
+                continue
+            tables = content if isinstance(content, list) else [content]
+            for table in tables:
+                rows = []
+                if isinstance(table, dict) and "rows" in table:
+                    rows = table.get("rows", [])
+                elif isinstance(table, list):
+                    rows = table
+                for row in rows:
+                    # Try to extract common product fields
+                    title = (
+                        row.get("product_title")
+                        or row.get("title")
+                        or row.get("name")
+                        or row.get("product_name")
+                        or ""
+                    )
+                    price = (
+                        row.get("general_price")
+                        or row.get("price")
+                        or row.get("original_price")
+                        or ""
+                    )
+                    sku = (
+                        row.get("seller_sku")
+                        or row.get("SellerSku")
+                        or row.get("sku")
+                        or ""
+                    )
+                    summaries.append({
+                        "index": idx,
+                        "title": str(title) if title else "",
+                        "price": str(price) if price else "",
+                        "sku": str(sku) if sku else "",
+                    })
+                    idx += 1
+        return summaries
+
     def _run_create_from_source(self) -> Dict[str, Any]:
         """AI posting: read files/URLs, extract fields, confirm, and publish."""
         sources = getattr(self.args, "source", []) or []
         if not sources:
             raise ValueError(i18n._("pub_ai_post_requires_source"))
 
-        content_items = read_sources(sources)
+        try:
+            content_items = read_sources(sources)
+        except ValueError as exc:
+            msg = str(exc)
+            # Map file_reader ValueError messages to i18n status codes
+            if "Unsupported file format" in msg:
+                return {
+                    "status": "unsupported_format",
+                    "message": i18n._("pub_unsupported_format", source=sources[0]),
+                    "next_actions": [i18n._("pub_ai_post_requires_source")],
+                }
+            if "empty" in msg.lower() or "corrupted" in msg.lower():
+                return {
+                    "status": "file_empty_or_corrupted",
+                    "message": i18n._("pub_file_empty_or_corrupted", source=sources[0]),
+                    "next_actions": [i18n._("pub_ai_post_requires_source")],
+                }
+            if "Failed to fetch URL" in msg or "fetch" in msg.lower():
+                return {
+                    "status": "invalid_url",
+                    "message": i18n._("pub_url_fetch_failed", source=sources[0], error=msg),
+                    "next_actions": [i18n._("pub_ai_post_requires_source")],
+                }
+            # Fallback: return the raw error message
+            return {
+                "status": "file_read_error",
+                "message": msg,
+                "next_actions": [i18n._("pub_ai_post_requires_source")],
+            }
         if not content_items:
             raise ValueError(i18n._("pub_ai_post_no_content"))
 
+        # Check for multiple products in Excel
+        row_count = get_excel_row_count(content_items)
+        if row_count > 1:
+            # Extract basic info from each row for display
+            product_summaries = self._extract_product_summaries(content_items)
+            return {
+                "status": "multiple_products_detected",
+                "message": i18n._("pub_multiple_products_detected", count=row_count),
+                "product_summaries": product_summaries,
+                "next_actions": [
+                    i18n._("pub_multiple_products_select_index"),
+                    i18n._("pub_multiple_products_select_all"),
+                    i18n._("pub_multiple_products_cancel"),
+                ],
+            }
+
         source_text = extract_text(content_items)
         engine = ExtractionEngine(LLMClient())
         schema = engine.extract(source_text)
@@ -669,7 +1142,12 @@ class PublishModule:
 
         title_err = validate_title(schema.product_title)
         if title_err:
-            raise ValueError(title_err)
+            return {
+                "status": "title_invalid",
+                "message": title_err,
+                "format_suggestion": i18n._("pub_title_format_suggestion"),
+                "next_actions": [i18n._("pub_ai_post_requires_source")],
+            }
 
         ctb_preview = {
             "stage": "ctb",
@@ -702,7 +1180,7 @@ class PublishModule:
         if compliance_result.get("status"):
             return compliance_result
 
-        images, failed_images = self._process_images_for_schema(schema)
+        images, failed_images, image_warnings = self._process_images_for_schema(schema)
         if failed_images:
             return {
                 "status": "need_images",
@@ -724,6 +1202,14 @@ class PublishModule:
 
         draft_requested = getattr(self.args, "draft", False)
 
+        # Sanitize HTML in long description before building payload
+        html_cleaned = False
+        if schema.product_long_description:
+            sanitized, was_cleaned = _sanitize_html(schema.product_long_description)
+            if was_cleaned:
+                html_cleaned = True
+                schema.product_long_description = sanitized
+
         product_payload = self.product.build_create_product_payload(
             schema.to_dict(),
             category_id=category_id,
@@ -732,11 +1218,33 @@ class PublishModule:
             draft=draft_requested,
         )
 
+        # Stage 3b: unified compliance check (GPSR + Safety Warning + compliance docs)
+        draft_issues: list = []
+        compliance_check = self._check_compliance_fields(
+            product_payload,
+            category_attributes,
+            schema=schema,
+            draft_requested=draft_requested,
+            draft_issues=draft_issues,
+        )
+        if compliance_check:
+            return compliance_check
+
+        # Stage 3c: special category rules (PPU / ISBN / food attributes)
+        special_check = self._check_special_category_rules(
+            product_payload,
+            category_attributes,
+            schema=schema,
+            draft_requested=draft_requested,
+            draft_issues=draft_issues,
+        )
+        if special_check:
+            return special_check
+
         # Stage 4a: check category-specific mandatory attributes
         cat_attr_result = self._check_category_mandatory_attributes(
             product_payload, category_attributes, category_id
         )
-        draft_issues: list = []
         if cat_attr_result:
             if draft_requested:
                 for attr in cat_attr_result.get("missing_attributes", []):
@@ -768,6 +1276,10 @@ class PublishModule:
             schema, product_payload, compliance_result, category_attributes
         )
         country_price_note = self._check_country_price_recommendation(schema)
+
+        # Check for >2 sales attributes (variation_3+)
+        variation_warnings = self._check_extra_variations(schema)
+
         fs_preview = {
             "stage": "field_summary",
             "category_id": int(category_id),
@@ -775,6 +1287,10 @@ class PublishModule:
             "brand_id": brand_id,
             "key_missing": sorted(key_missing),
             "draft": draft_requested,
+            "image_warnings": image_warnings,
+            "variation_warnings": variation_warnings,
+            "html_cleaned": html_cleaned,
+            "description_empty": not schema.product_long_description,
         }
         expected_fs_token = _make_publish_preview_token(fs_preview)
         provided_fs_token = getattr(self.args, "field_summary_token", None)
@@ -801,81 +1317,175 @@ class PublishModule:
     # ------------------------------------------------------------------
 
     _TRACKED_FIELDS = [
-        ("product_title", "Product title"),
-        ("product_images", "Product images"),
-        ("category_id", "Category"),
-        ("brand_id", "Brand"),
-        ("general_price", "General price"),
-        ("italy_price", "Italy price"),
-        ("seller_sku", "Seller SKU"),
-        ("ean_code", "EAN code"),
-        ("weight_kg", "Weight"),
-        ("length_cm", "Length"),
-        ("width_cm", "Width"),
-        ("height_cm", "Height"),
-        ("manufacturer", "Manufacturer"),
-        ("eu_responsible_person", "EU responsible person"),
-        ("safety_warning", "Safety warning"),
-        ("package_photos", "Package photos"),
-        ("compliance_documents", "Compliance documents"),
+        # Mandatory fields — missing blocks publish entirely
+        ("product_title", "Product title", "mandatory"),
+        ("product_images", "Product images", "mandatory"),
+        ("category_id", "Category", "mandatory"),
+        ("brand_id", "Brand", "mandatory"),
+        ("general_price", "General price", "mandatory"),
+        ("stock", "Stock", "mandatory"),
+        ("seller_sku", "Seller SKU", "mandatory"),
+        ("weight_kg", "Weight", "mandatory"),
+        ("length_cm", "Length", "mandatory"),
+        ("width_cm", "Width", "mandatory"),
+        ("height_cm", "Height", "mandatory"),
+        ("delivery_method", "Delivery method", "mandatory"),
+        # Conditional fields — missing suggests Draft
+        ("italy_price", "Italy price", "conditional"),
+        ("ean_code", "EAN code", "conditional"),
+        ("manufacturer", "Manufacturer", "conditional"),
+        ("eu_responsible_person", "EU responsible person", "conditional"),
+        ("safety_warning", "Safety warning", "conditional"),
+        ("package_photos", "Package photos", "conditional"),
+        ("compliance_documents", "Compliance documents", "conditional"),
+        ("standard_unit_type", "Unit count type", "conditional"),
+        ("unit_count", "Unit count", "conditional"),
+        ("sku_attributes_food_health", "Food & health attributes", "conditional"),
+        ("isbn", "ISBN", "conditional"),
     ]
 
     def _resolve_category_for_schema(
         self, schema: MiraviaListingSchema
     ) -> Dict[str, Any]:
-        """Resolve category from extracted name/ID or CLI args."""
-        confirmed_category_id = getattr(self.args, "confirmed_category_id", None)
-        if confirmed_category_id:
-            return {"category_id": int(confirmed_category_id)}
+        """Resolve category from extracted name/ID, CLI args, or recommendation.
 
-        if self.args.category_id:
-            return {"category_id": int(self.args.category_id)}
+        Priority:
+        1. --confirmed-category-id: validated against tree
+        2. --category-id / schema.category_id: validated against tree
+        3. schema.category_name: keyword search
+        4. Recommend API: title/images → Top1/TopN/empty
+        5. Fallback: full category tree
 
-        if schema.category_id:
-            return {"category_id": int(schema.category_id)}
+        All "invalid" paths try recommend API before falling back to tree.
+        """
+        # Fetch category tree once — used for validation and fallback display
+        lang = self.args.lang if self.args.lang not in (None, "auto") else "en"
+        category_tree: Dict[str, Any] = {}
+        valid_ids: set = set()
+        category_permissions: Dict[int, bool] = {}
+        try:
+            category_tree = self.product.get_category_tree(language_code=lang)
+            valid_ids = _collect_category_ids(category_tree)
+            category_permissions = _collect_category_permissions(category_tree)
+        except MiraviaError as exc:
+            logger.warning("Failed to fetch category tree: %s", exc)
 
-        category_name = schema.category_name
-        if not category_name:
-            return {
+        def _need_category_response(
+            reason_msg: str,
+            choices: Optional[List[Dict[str, Any]]] = None,
+        ) -> Dict[str, Any]:
+            resp: Dict[str, Any] = {
                 "status": "need_category",
-                "message": i18n._("pub_ai_post_need_category"),
+                "message": reason_msg,
+                "category_tree": category_tree,
+                "category_permissions": category_permissions,
                 "next_actions": [i18n._("pub_ai_post_provide_category")],
             }
+            if choices:
+                resp["choices"] = choices
+                resp["next_actions"] = [
+                    i18n._(
+                        "pub_category_confirm_next", category_id=c.get("category_id")
+                    )
+                    for c in choices
+                ]
+            return resp
+
+        def _try_recommend_or_tree(
+            fallback_msg: str,
+        ) -> Dict[str, Any]:
+            """Try recommend API first, fallback to category tree."""
+            title = schema.product_title
+            image_urls = schema.image_urls or []
+            if title or image_urls:
+                try:
+                    recommendations = self.product.recommend_category(
+                        title=title, image_urls=image_urls if image_urls else None
+                    )
+                    if recommendations:
+                        # Top1: auto-select
+                        if len(recommendations) == 1:
+                            rec = recommendations[0]
+                            cid = rec.get("category_id") or rec.get("id")
+                            if cid:
+                                return {"category_id": int(cid)}
+                        # TopN: show candidates
+                        return _need_category_response(
+                            i18n._(
+                                "pub_ai_post_category_recommend",
+                                count=len(recommendations),
+                            ),
+                            choices=recommendations,
+                        )
+                except MiraviaError as exc:
+                    logger.warning("Category recommendation failed: %s", exc)
+            # Fallback: show full tree
+            return _need_category_response(fallback_msg)
+
+        def _validate_category_id(cid: int) -> Optional[Dict[str, Any]]:
+            """Validate category ID. If invalid, try recommend then tree."""
+            if valid_ids and cid not in valid_ids:
+                return _try_recommend_or_tree(
+                    i18n._("pub_ai_post_category_id_invalid", category_id=cid)
+                )
+            return None
 
-        candidates = self.product.search_category_by_keyword(category_name)
-        if not candidates:
-            return {
-                "status": "need_category",
-                "message": i18n._(
-                    "pub_ai_post_category_not_found", name=category_name
-                ),
-                "next_actions": [i18n._("pub_ai_post_provide_category")],
-            }
+        # 1. --confirmed-category-id: validate
+        confirmed_category_id = getattr(self.args, "confirmed_category_id", None)
+        if confirmed_category_id:
+            cid = int(confirmed_category_id)
+            err = _validate_category_id(cid)
+            if err:
+                return err
+            return {"category_id": cid}
 
-        name_lower = category_name.strip().lower()
-        exact = [
-            c
-            for c in candidates
-            if (c.get("name") or "").strip().lower() == name_lower
-        ]
-        display_candidates = exact if exact else candidates
+        # 2. --category-id: validate
+        if self.args.category_id:
+            cid = int(self.args.category_id)
+            err = _validate_category_id(cid)
+            if err:
+                return err
+            return {"category_id": cid}
 
-        if len(display_candidates) == 1:
-            return {"category_id": display_candidates[0].get("category_id")}
+        # 3. schema.category_id: validate
+        if schema.category_id:
+            cid = int(schema.category_id)
+            err = _validate_category_id(cid)
+            if err:
+                return err
+            return {"category_id": cid}
 
-        return {
-            "status": "need_category",
-            "message": i18n._(
-                "pub_ai_post_category_multiple", count=len(display_candidates)
-            ),
-            "choices": display_candidates,
-            "next_actions": [
-                i18n._(
-                    "pub_category_confirm_next", category_id=c.get("category_id")
+        # 4. schema.category_name: keyword search
+        category_name = schema.category_name
+        if category_name:
+            candidates = self.product.search_category_by_keyword(category_name)
+            if candidates:
+                name_lower = category_name.strip().lower()
+                exact = [
+                    c
+                    for c in candidates
+                    if (c.get("name") or "").strip().lower() == name_lower
+                ]
+                display_candidates = exact if exact else candidates
+
+                if len(display_candidates) == 1:
+                    return {"category_id": display_candidates[0].get("category_id")}
+
+                return _need_category_response(
+                    i18n._(
+                        "pub_ai_post_category_multiple", count=len(display_candidates)
+                    ),
+                    choices=display_candidates,
                 )
-                for c in display_candidates
-            ],
-        }
+            # Keyword search failed → try recommend then tree
+            return _try_recommend_or_tree(
+                i18n._("pub_ai_post_category_not_found", name=category_name)
+            )
+
+        # 5. No category info at all → try recommend then tree
+        return _try_recommend_or_tree(
+            i18n._("pub_ai_post_need_category")
+        )
 
     def _resolve_brand_for_schema(
         self, schema: MiraviaListingSchema
@@ -1122,6 +1732,10 @@ class PublishModule:
         if not has_price:
             missing.append("General price")
 
+        has_stock = any(sku.get("quantity") for sku in skus)
+        if not has_stock:
+            missing.append("Stock")
+
         package_dims = ("package_weight", "package_length", "package_width", "package_height")
         for idx, sku in enumerate(skus, start=1):
             if not sku.get("SellerSku"):
@@ -1152,47 +1766,51 @@ class PublishModule:
         compliance_result: Dict[str, Any],
         category_attributes: List[Dict[str, Any]],
     ) -> List[str]:
-        """Return key fields that are missing but can be skipped in draft mode."""
+        """Return internal keys of fields that are missing but can be skipped in draft mode.
+
+        Keys match ``_TRACKED_FIELDS`` internal names so the summary preview
+        can correctly mark them as missing.
+        """
         missing: List[str] = []
         skus = (product_payload.get("Skus") or {}).get("Sku") or []
         has_ean = any(sku.get("ean_code") for sku in skus) or bool(schema.ean_codes)
         if not has_ean:
-            missing.append("EAN code")
+            missing.append("ean_code")
 
         if self._check_italy_price_mandatory(schema):
-            missing.append("Italy price")
+            missing.append("italy_price")
 
         if schema.standard_unit_type and not schema.unit_count:
-            missing.append("Unit count")
+            missing.append("unit_count")
         elif self._is_category_attribute_mandatory(category_attributes, "unit_count") and not schema.unit_count:
-            missing.append("Unit count")
+            missing.append("unit_count")
 
         if not schema.sku_attributes_food_health and self._category_looks_like_food_health(
             category_attributes
         ):
-            missing.append("Food & health SKU attributes")
+            missing.append("sku_attributes_food_health")
 
         if compliance_result.get("manufacturer_mismatch") or (
             not schema.manufacturer_id and not schema.manufacturer_name
         ):
-            missing.append("Manufacturer")
+            missing.append("manufacturer")
         if compliance_result.get("eurp_mismatch") or (
             not schema.eu_responsible_person_id
             and not schema.eu_responsible_person_name
         ):
-            missing.append("EU responsible person")
+            missing.append("eu_responsible_person")
 
         if schema.safety_warning is None:
-            missing.append("Safety warning")
+            missing.append("safety_warning")
 
         if not schema.package_photos:
-            missing.append("Package photos")
+            missing.append("package_photos")
 
         if self._is_category_attribute_mandatory(category_attributes, "compliance_documents") and not schema.compliance_documents:
-            missing.append("Compliance documents")
+            missing.append("compliance_documents")
 
         if not any(sku.get("SellerSku") for sku in skus):
-            missing.append("Seller SKU")
+            missing.append("seller_sku")
 
         return missing
 
@@ -1244,32 +1862,105 @@ class PublishModule:
             return True
         return False
 
+    def _check_extra_variations(self, schema: MiraviaListingSchema) -> List[str]:
+        """Check if raw_skus contain variation_3+ fields (Miravia supports max 2).
+
+        Returns a list of warning messages if extra variations are detected.
+        """
+        warnings: List[str] = []
+        extra_vars: set = set()
+
+        for raw in schema.raw_skus:
+            if not isinstance(raw, dict):
+                continue
+            for key in raw.keys():
+                # Check for variation_3, variation_4, etc.
+                if key.startswith("variation_"):
+                    try:
+                        num = int(key.split("_")[1])
+                        if num > 2:
+                            extra_vars.add(key)
+                    except (IndexError, ValueError):
+                        pass
+
+        if extra_vars:
+            sorted_vars = sorted(extra_vars)
+            warnings.append(
+                i18n._(
+                    "pub_too_many_variations",
+                    count=len(sorted_vars),
+                    variations=", ".join(sorted_vars),
+                )
+            )
+
+        return warnings
+
     def _make_field_summary_preview(
         self,
         fs_preview: Dict[str, Any],
         key_missing: List[str],
         country_price_note: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Return the field extraction summary and draft/continue prompt."""
+        """Return the field extraction summary and draft/continue prompt.
+
+        Fields are grouped by Mandatory vs Conditional. Missing mandatory
+        fields block publish; missing conditional fields suggest Draft.
+        """
         token = _make_publish_preview_token(fs_preview)
-        lines: List[str] = []
-        for key, label in self._TRACKED_FIELDS:
+
+        mandatory_lines: List[str] = []
+        conditional_lines: List[str] = []
+        for key, label, category in self._TRACKED_FIELDS:
             status = (
                 i18n._("pub_field_status_missing")
                 if key in key_missing
                 else i18n._("pub_field_status_filled")
             )
-            lines.append(f"- {label}: {status}")
+            line = f"  {label}: {status}"
+            if category == "mandatory":
+                mandatory_lines.append(line)
+            else:
+                conditional_lines.append(line)
+
+        # Build summary with section headers
+        summary: List[str] = []
+        summary.append(i18n._("pub_summary_mandatory_section"))
+        summary.extend(mandatory_lines)
+        summary.append("")
+        summary.append(i18n._("pub_summary_conditional_section"))
+        summary.extend(conditional_lines)
+
+        # Separate mandatory vs conditional missing
+        mandatory_missing = [
+            label for key, label, cat in self._TRACKED_FIELDS
+            if cat == "mandatory" and key in key_missing
+        ]
+        conditional_missing = [
+            label for key, label, cat in self._TRACKED_FIELDS
+            if cat == "conditional" and key in key_missing
+        ]
 
         actions = [i18n._("pub_final_confirm_next", token=token)]
-        if key_missing:
-            actions.insert(0, i18n._("pub_key_fields_missing_draft_question"))
+        if mandatory_missing:
+            # Mandatory missing — block with clear message
+            actions.insert(0, i18n._(
+                "pub_mandatory_missing_block",
+                fields=", ".join(mandatory_missing),
+            ))
+        elif conditional_missing:
+            # Conditional missing — suggest Draft
+            actions.insert(0, i18n._(
+                "pub_conditional_missing_draft",
+                fields=", ".join(conditional_missing),
+            ))
 
         payload: Dict[str, Any] = {
             "status": "need_field_summary",
             "title": i18n._("pub_field_summary_title"),
             "message": i18n._("pub_field_summary_description"),
-            "summary": lines,
+            "summary": summary,
+            "mandatory_missing": mandatory_missing,
+            "conditional_missing": conditional_missing,
             "key_missing": key_missing,
             "field_summary_token": token,
             "next_actions": actions,
@@ -1438,8 +2129,12 @@ class PublishModule:
 
     def _process_images_for_schema(
         self, schema: MiraviaListingSchema
-    ) -> Tuple[List[str], List[str]]:
-        """Migrate URLs and upload local image files, returning CDN URLs."""
+    ) -> Tuple[List[str], List[str], List[str]]:
+        """Migrate URLs and upload local image files, returning CDN URLs.
+
+        Returns:
+            Tuple of (migrated_urls, failed_urls, warnings)
+        """
         from pathlib import Path
 
         all_images: List[str] = []
@@ -1462,7 +2157,14 @@ class PublishModule:
 
         migrated: List[str] = []
         failed: List[str] = []
-        for img in unique_images:
+        warnings: List[str] = []
+        for idx, img in enumerate(unique_images, start=1):
+            # Check white background for local files (non-blocking warning)
+            if not _check_white_background(img):
+                warnings.append(
+                    i18n._("pub_white_background_warning", idx=idx)
+                )
+
             if _is_miravia_cdn(img):
                 migrated.append(img)
             elif img.startswith("http://") or img.startswith("https://"):
@@ -1479,7 +2181,7 @@ class PublishModule:
                     failed.append(img)
             else:
                 failed.append(img)
-        return migrated, failed
+        return migrated, failed, warnings
 
     def _build_sku_list_from_schema(
         self, schema: MiraviaListingSchema
@@ -1597,6 +2299,31 @@ class PublishModule:
                     errors.extend(vr.get("errors", []))
 
             if errors:
+                # Check for category permission errors first
+                has_category_permission_error = any(
+                    "category" in str(e.get("field", "")).lower()
+                    and ("permission" in str(e.get("msg", "")).lower()
+                         or "not allow" in str(e.get("msg", "")).lower()
+                         or "no access" in str(e.get("msg", "")).lower())
+                    for e in errors
+                )
+                if has_category_permission_error:
+                    category_id = product_payload.get("Attributes", {}).get("PrimaryCategory", "")
+                    return {
+                        "status": "need_category_permission",
+                        "title": i18n._("pub_category_permission_title"),
+                        "message": i18n._(
+                            "pub_category_permission_message",
+                            category_name=str(category_id),
+                            category_id=str(category_id),
+                        ),
+                        "apply_link": i18n._("pub_category_permission_apply_link"),
+                        "next_actions": [
+                            i18n._("pub_category_permission_draft_next"),
+                            i18n._("pub_category_permission_change_next"),
+                        ],
+                    }
+
                 guides = self._field_definition_guides(errors)
                 next_actions: List[str] = [
                     i18n._("pub_ai_post_prevalidate_fix"),
@@ -2067,6 +2794,60 @@ class PublishModule:
 # ---------------------------------------------------------------------------
 
 
+def _collect_category_ids(tree: Any) -> set:
+    """Recursively collect all category IDs from a category tree structure.
+
+    Handles both dict and list structures, extracting category_id / id fields.
+    Returns an empty set if the tree is empty or malformed.
+    """
+    ids: set = set()
+    if isinstance(tree, dict):
+        # Try common tree root keys
+        categories = tree.get("categories") or tree.get("data") or tree.get("children") or []
+        if isinstance(categories, list):
+            for cat in categories:
+                ids |= _collect_category_ids(cat)
+        else:
+            # Single category node
+            cid = tree.get("category_id") or tree.get("id")
+            if cid:
+                ids.add(int(cid))
+            children = tree.get("children") or tree.get("sub_categories") or []
+            if isinstance(children, list):
+                ids |= _collect_category_ids(children)
+    elif isinstance(tree, list):
+        for item in tree:
+            ids |= _collect_category_ids(item)
+    return ids
+
+
+def _collect_category_permissions(tree: Any) -> Dict[int, bool]:
+    """Recursively collect category permission info from tree.
+
+    Returns a dict mapping category_id -> has_permission (bool).
+    Permission field values: "yes" -> True, "no" -> False.
+    """
+    permissions: Dict[int, bool] = {}
+    if isinstance(tree, dict):
+        categories = tree.get("categories") or tree.get("data") or tree.get("children") or []
+        if isinstance(categories, list):
+            for cat in categories:
+                permissions.update(_collect_category_permissions(cat))
+        else:
+            # Single category node
+            cid = tree.get("category_id") or tree.get("id")
+            if cid:
+                perm = tree.get("permission", "").lower()
+                permissions[int(cid)] = perm == "yes"
+            children = tree.get("children") or tree.get("sub_categories") or []
+            if isinstance(children, list):
+                permissions.update(_collect_category_permissions(children))
+    elif isinstance(tree, list):
+        for item in tree:
+            permissions.update(_collect_category_permissions(item))
+    return permissions
+
+
 def _is_miravia_cdn(url: str) -> bool:
     """Check whether a URL is already on Miravia CDN."""
     url_lower = url.lower()
@@ -2122,6 +2903,11 @@ def _validate_create_payload(payload: Dict[str, Any]) -> None:
     if len(ean_codes) != len(set(ean_codes)):
         raise ValueError(i18n._("pub_ean_duplicate_in_product"))
 
+    # Check Seller SKU duplicate within same product
+    seller_skus = [sku.get("SellerSku") for sku in skus if sku.get("SellerSku")]
+    if len(seller_skus) != len(set(seller_skus)):
+        raise ValueError(i18n._("pub_seller_sku_duplicate_in_product"))
+
     for idx, sku in enumerate(skus, start=1):
         if not sku.get("SellerSku"):
             raise ValueError(i18n._("pub_seller_sku_required", idx=idx))
@@ -2140,9 +2926,22 @@ def _validate_create_payload(payload: Dict[str, Any]) -> None:
             _validate_ean(ean, idx)
 
         # Per-SKU package dimensions/weight
-        _validate_dimension(sku.get("package_weight"), "weight", _MAX_WEIGHT_KG)
-        for dim in ("package_length", "package_width", "package_height"):
-            _validate_dimension(sku.get(dim), dim, _MAX_DIMENSION_CM)
+        weight = sku.get("package_weight")
+        length = sku.get("package_length")
+        width = sku.get("package_width")
+        height = sku.get("package_height")
+
+        # Check: if weight is present, L/W/H must also be present
+        if weight and not (length and width and height):
+            raise ValueError(i18n._("pub_dimension_incomplete", idx=idx))
+
+        _validate_dimension(weight, "weight", _MAX_WEIGHT_KG)
+        for dim_name, dim_value in (
+            ("package_length", length),
+            ("package_width", width),
+            ("package_height", height),
+        ):
+            _validate_dimension(dim_value, dim_name, _MAX_DIMENSION_CM)
 
     safety = attributes.get("safety_warning")
     if safety and safety not in ("Yes", "No"):
@@ -2235,13 +3034,138 @@ def _validate_image_format(image_url: str, idx: int) -> None:
                 )
 
 
+def _check_white_background(image_url: str) -> bool:
+    """Check if image has white background.
+
+    Samples pixels from corners and edges. Returns True if background
+    appears to be white (RGB >= 240), False otherwise.
+    Only works for local files; returns True for remote URLs (skip check).
+    """
+    from pathlib import Path
+
+    # Only check local files
+    if not (image_url.startswith("/") or image_url.startswith("file://")):
+        return True  # Skip check for remote URLs
+
+    local_path = image_url.replace("file://", "")
+    path = Path(local_path)
+    if not path.exists():
+        return True  # Skip if file not found
+
+    try:
+        from PIL import Image
+
+        img = Image.open(path)
+        width, height = img.size
+        if width < 10 or height < 10:
+            return True  # Too small to check
+
+        # Convert to RGB if necessary
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+
+        # Sample pixels from corners and edges
+        sample_points = [
+            (0, 0),  # Top-left
+            (width - 1, 0),  # Top-right
+            (0, height - 1),  # Bottom-left
+            (width - 1, height - 1),  # Bottom-right
+            (width // 2, 0),  # Top-center
+            (width // 2, height - 1),  # Bottom-center
+            (0, height // 2),  # Left-center
+            (width - 1, height // 2),  # Right-center
+        ]
+
+        white_count = 0
+        for x, y in sample_points:
+            pixel = img.getpixel((x, y))
+            # Check if pixel is white or near-white (RGB >= 240)
+            if all(c >= 240 for c in pixel[:3]):
+                white_count += 1
+
+        # If 6+ out of 8 sample points are white, consider it white background
+        return white_count >= 6
+
+    except Exception:
+        return True  # Skip check if PIL not available or error occurs
+
+
+# Unit conversion constants
+_WEIGHT_TO_KG = {
+    "kg": 1.0,
+    "g": 0.001,
+    "t": 1000.0,
+    "oz": 0.02835,
+    "lb": 0.453592,
+}
+
+_LENGTH_TO_CM = {
+    "cm": 1.0,
+    "mm": 0.1,
+    "m": 100.0,
+    "in": 2.54,
+    "ft": 30.48,
+}
+
+
+def _convert_weight(value: str) -> float:
+    """Convert weight string to kg.
+
+    Handles: '1000 oz', '500g', '1t', '2.5 kg', etc.
+    Returns value in kg.
+    """
+    import re
+
+    text = str(value).strip().lower()
+    match = re.match(r"([\d.]+)\s*(kg|g|t|oz|lb)?", text)
+    if not match:
+        raise ValueError(f"Invalid weight format: {value}")
+    number = float(match.group(1))
+    unit = match.group(2) or "kg"
+    if unit not in _WEIGHT_TO_KG:
+        raise ValueError(f"Unknown weight unit: {unit}")
+    return number * _WEIGHT_TO_KG[unit]
+
+
+def _convert_length(value: str) -> float:
+    """Convert length string to cm.
+
+    Handles: '10 in', '155 mm', '1.1m', '1ft', '25.4 cm', etc.
+    Returns value in cm.
+    """
+    import re
+
+    text = str(value).strip().lower()
+    match = re.match(r"([\d.]+)\s*(cm|mm|m|in|ft)?", text)
+    if not match:
+        raise ValueError(f"Invalid length format: {value}")
+    number = float(match.group(1))
+    unit = match.group(2) or "cm"
+    if unit not in _LENGTH_TO_CM:
+        raise ValueError(f"Unknown length unit: {unit}")
+    return number * _LENGTH_TO_CM[unit]
+
+
 def _validate_dimension(value: Any, name: str, maximum: int) -> None:
+    """Validate dimension value after unit conversion.
+
+    For weight: converts to kg, checks 0 < value <= _MAX_WEIGHT_KG
+    For dimensions: converts to cm, checks 0 < value <= _MAX_DIMENSION_CM
+    """
     if value is None:
         return
     try:
-        number = float(value)
-    except (TypeError, ValueError) as exc:
-        raise ValueError(i18n._("pub_invalid_dimension", name=name, value=value)) from exc
+        # Try unit conversion first
+        if name == "weight":
+            number = _convert_weight(value)
+        else:
+            number = _convert_length(value)
+    except (TypeError, ValueError, AttributeError) as exc:
+        # Fallback to simple float conversion
+        try:
+            number = float(value)
+        except (TypeError, ValueError) as exc2:
+            raise ValueError(i18n._("pub_invalid_dimension", name=name, value=value)) from exc2
     if number <= 0 or number > maximum:
         raise ValueError(
             i18n._(
@@ -2253,6 +3177,77 @@ def _validate_dimension(value: Any, name: str, maximum: int) -> None:
         )
 
 
+# Safe HTML tags for product descriptions (Miravia product editor supports these)
+_SAFE_HTML_TAGS = frozenset({
+    "p", "br", "b", "strong", "i", "em", "u",
+    "ul", "ol", "li",
+    "h1", "h2", "h3", "h4", "h5", "h6",
+    "table", "tr", "td", "th", "thead", "tbody",
+    "a", "img",
+})
+
+
+def _sanitize_html(html: str) -> tuple:
+    """Sanitize HTML content for product description.
+
+    Keeps only safe tags (p, br, b, ul, li, etc.) and removes:
+    - <script>, <iframe>, <object>, <embed> and similar
+    - style attributes, onclick/onerror handlers
+    - <div> with style attributes
+
+    Returns:
+        Tuple of (cleaned_html, was_cleaned: bool)
+    """
+    import re
+
+    if not html:
+        return html, False
+
+    original = html
+    cleaned = html
+
+    # Remove dangerous tags entirely (including content)
+    dangerous_tags = ["script", "iframe", "object", "embed", "applet", "form", "input"]
+    for tag in dangerous_tags:
+        cleaned = re.sub(
+            rf"<{tag}[^>]*>.*?</{tag}>",
+            "",
+            cleaned,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        # Also remove self-closing or unclosed dangerous tags
+        cleaned = re.sub(
+            rf"<{tag}[^>]*/?>",
+            "",
+            cleaned,
+            flags=re.IGNORECASE,
+        )
+
+    # Remove style attributes from all tags
+    cleaned = re.sub(r'\s+style\s*=\s*["\'][^"\']*["\']', "", cleaned, flags=re.IGNORECASE)
+
+    # Remove event handlers (onclick, onerror, onload, etc.)
+    cleaned = re.sub(r'\s+on\w+\s*=\s*["\'][^"\']*["\']', "", cleaned, flags=re.IGNORECASE)
+
+    # Remove <div> tags but keep content (div is not in safe list but content is useful)
+    cleaned = re.sub(r"</?div[^>]*>", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove any tags not in the safe list
+    def _replace_unsafe_tag(match):
+        full_match = match.group(0)
+        tag_match = re.match(r"</?([a-zA-Z][a-zA-Z0-9]*)", full_match)
+        if tag_match:
+            tag_name = tag_match.group(1).lower()
+            if tag_name not in _SAFE_HTML_TAGS:
+                return ""  # Remove unsafe tag
+        return full_match  # Keep safe tag
+
+    cleaned = re.sub(r"</?[a-zA-Z][a-zA-Z0-9]*[^>]*>", _replace_unsafe_tag, cleaned)
+
+    was_cleaned = cleaned != original
+    return cleaned, was_cleaned
+
+
 def _load_preview_secret() -> bytes:
     """Return a machine-local secret for publish preview tokens.