@miravia_test/miravia-publish-skill 0.1.6 → 0.1.8

package/dist/scripts/publish_module.py

@@ -486,10 +486,10 @@ class PublishModule:
             logger.debug("Could not fetch category attributes: %s", e)
             definitions = []
 
-        # Check EAN code - mandatory for nail polish category
+        # Check EAN code via the unified rule (API is_mandatory / postToInactive)
         skus = (product_payload.get("Skus") or {}).get("Sku") or []
         has_ean = any(sku.get("ean_code") for sku in skus)
-        ean_mandatory = self._is_category_attribute_mandatory(definitions, "ean_code")
+        ean_mandatory = self._field_is_required("ean_code", definitions)
         if ean_mandatory and not has_ean:
             post_to_inactive_missing.append(
                 "EAN code is required for this category but not filled. "
@@ -660,15 +660,30 @@ class PublishModule:
             ) or ""
             unit_count_val = getattr(self.args, "unit_count", None)
 
-        # Also check payload attributes as fallback
+        # Also check payload as fallback. In manual mode SKU-level PPU fields
+        # (unit_count_type / Unit_Count) are auto-extracted out of Attributes and
+        # merged into each SKU, so the product-level Attributes dict is empty for
+        # them — we must also scan the SKU objects or the value is "lost" and PPU
+        # is wrongly reported as missing (Nail Polish 62198445 bug).
+        payload_skus = (product_payload.get("Skus") or {}).get("Sku") or []
+
+        def _first_present(keys: tuple) -> Any:
+            for src in [attributes] + list(payload_skus):
+                if not isinstance(src, dict):
+                    continue
+                for key in keys:
+                    val = src.get(key)
+                    if val is not None and str(val).strip() != "":
+                        return val
+            return None
+
         if not unit_type:
             unit_type = (
-                attributes.get("unit_count_type")
-                or attributes.get("standard_unit_type")
+                _first_present(("unit_count_type", "standard_unit_type", "Unit_Count_Type"))
                 or ""
             )
         if unit_count_val is None:
-            unit_count_val = attributes.get("unit_count")
+            unit_count_val = _first_present(("unit_count", "Unit_Count"))
 
         unit_count_str = str(unit_count_val).strip() if unit_count_val is not None else ""
 
@@ -786,23 +801,35 @@ class PublishModule:
         *,
         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.
+        """Resolve ``Attributes.deliverySof`` and enforce DBM package limits.
+
+        Miravia ``/product/create`` expects ``Attributes.deliverySof`` to be
+        ``"DBM"`` or ``"DBS"``. When the seller did not choose one it is
+        defaulted here: generally DBM, but DBS when the seller has DBS
+        permission. If the effective method is DBM but the package exceeds the
+        DBM limits (weight <= 40KG, L+W+H <= 300cm, volumetric weight
+        L*W*H/6000 <= 40), it is switched to DBS when permitted, otherwise the
+        caller blocks. Returns a result dict, or None when nothing to do.
         """
-        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":
+        attrs = product_payload.setdefault("Attributes", {})
+        delivery_method = str(attrs.get("deliverySof") or "").strip().upper()
+        downgraded_from_dbs = False
+
+        if delivery_method not in ("DBM", "DBS"):
+            # No explicit entry: default to DBS when the seller is permitted,
+            # otherwise DBM.
+            delivery_method = "DBS" if has_dbs_permission else "DBM"
+            attrs["deliverySof"] = delivery_method
+        elif delivery_method == "DBS" and not has_dbs_permission:
+            # Seller explicitly chose DBS but the account has no DBS permission:
+            # never grant DBS without permission — fall back to DBM and still
+            # enforce the DBM package limits below.
+            delivery_method = "DBM"
+            attrs["deliverySof"] = "DBM"
+            downgraded_from_dbs = True
+
+        # Only DBM carries package limits.
+        if delivery_method != "DBM":
             return None
 
         skus = (product_payload.get("Skus") or {}).get("Sku") or []
@@ -837,17 +864,17 @@ class PublishModule:
             )
 
         if not exceeded:
+            if downgraded_from_dbs:
+                return {
+                    "downgraded_to_dbm": True,
+                    "message": i18n._("pub_dbs_no_permission_downgrade"),
+                }
             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"
+            attrs["deliverySof"] = "DBS"
             return {
                 "switched_to_dbs": True,
                 "reasons": exceeded,
@@ -870,13 +897,30 @@ class PublishModule:
         missing: Optional[Dict[str, str]] = None,
         draft: bool = False,
         draft_issues: Optional[List[str]] = None,
+        category_attributes: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Validate, preview, pre-validate, and execute product creation."""
-        _validate_create_payload(product_payload)
+        # Decide SellerSku mandatory-ness from the category attribute API via the
+        # unified rule, so this pre-submit check matches every other layer
+        # (empty SellerSku is allowed and auto-generated when not mandatory).
+        if category_attributes is None:
+            cat_id = (preview_summary or {}).get("category_id")
+            lang = self.args.lang if getattr(self.args, "lang", None) not in (None, "auto") else "en_US"
+            try:
+                category_attributes = self.product.get_category_attributes(
+                    str(cat_id), language_code=lang
+                )
+            except Exception:
+                category_attributes = []
+        seller_sku_required = self._field_is_required(
+            "SellerSku", category_attributes or []
+        )
+        _validate_create_payload(product_payload, seller_sku_required=seller_sku_required)
 
         # 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)
+        dbm_notes: List[str] = []
         if dbm_result:
             if dbm_result.get("blocked"):
                 # No DBS permission and exceeds DBM limits — block
@@ -889,10 +933,12 @@ class PublishModule:
                     ],
                 }
             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}")
+                dbm_notes.append(dbm_result["message"])
+                dbm_notes.extend(f"  - {r}" for r in dbm_result.get("reasons", []))
+            if dbm_result.get("downgraded_to_dbm"):
+                # Seller asked for DBS but has no DBS permission — explain the
+                # fallback so the delivery-method change is not silent.
+                dbm_notes.append(dbm_result["message"])
 
         # Run pre-validate early so errors are visible in the preview
         prevalidate_result = self._run_prevalidate(product_payload)
@@ -905,6 +951,7 @@ class PublishModule:
 
         # Merge all issues for preview
         all_issues = list(draft_issues or [])
+        all_issues.extend(dbm_notes)
         if prevalidate_errors:
             all_issues.extend(prevalidate_errors)
 
@@ -988,26 +1035,34 @@ class PublishModule:
                         i18n._("pub_sku_already_exists_next"),
                     ],
                 }
-            # Code 4234: draft product created but missing required fields
+            # Code 4234 in draft mode: only a success when the API actually
+            # returned an item_id — without one, the draft was NOT created and
+            # the error must be surfaced with full diagnostics.
             if exc.code == "4234" and draft:
                 err_data = (exc.payload.get("data") or {}) if exc.payload else {}
                 item_id = err_data.get("item_id")
-                pdp_url = self._make_pdp_url(item_id)
-                return {
-                    "status": "draft_created_with_issues",
-                    "message": i18n._("pub_draft_created_with_issues"),
-                    "item_id": item_id,
-                    "pdp_url": pdp_url,
-                    "api_message": exc.msg,
-                    "draft": True,
-                    "next_actions": [
-                        i18n._("pub_draft_update_hint"),
-                    ],
-                }
+                if item_id:
+                    pdp_url = self._make_pdp_url(item_id)
+                    return {
+                        "status": "draft_created_with_issues",
+                        "message": i18n._("pub_draft_created_with_issues"),
+                        "item_id": item_id,
+                        "pdp_url": pdp_url,
+                        "api_message": exc.msg,
+                        "draft": True,
+                        "next_actions": [
+                            i18n._("pub_draft_update_hint"),
+                        ],
+                    }
+            else:
+                return self._make_create_failed_response(exc, draft)
             raise
         data = result.get("data", {}) or {}
 
         item_id = data.get("item_id")
+        if not item_id:
+            # No item_id ⇒ creation failed even though code was 0.
+            return self._make_create_failed_response(exc=None, draft=draft, data=data)
         pdp_url = self._make_pdp_url(item_id)
         return {
             "status": "success",
@@ -1020,6 +1075,49 @@ class PublishModule:
             "next_actions": [i18n._("pub_create_success_next")],
         }
 
+    def _make_create_failed_response(
+        self,
+        exc: Optional[MiraviaError],
+        draft: bool,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Build a structured ``create_failed`` response with API diagnostics.
+
+        A create call without ``item_id`` in the payload means the product
+        (draft or active) was NOT created — never report it as success.
+        ``request_id`` / ``_trace_id_`` are echoed back so the seller can
+        locate the root cause in logs or with platform support.
+        """
+        payload = (exc.payload if exc else None) or {}
+        err_type = str(payload.get("type") or "")
+        request_id = str(payload.get("request_id") or payload.get("requestId") or "")
+        trace_id = str(payload.get("_trace_id_") or payload.get("trace_id") or "")
+        next_actions: List[str] = [
+            i18n._("pub_create_failed_check_and_rerun"),
+        ]
+        if trace_id or request_id:
+            next_actions.append(
+                i18n._("pub_create_failed_trace_hint", trace_id=trace_id, request_id=request_id)
+            )
+        return {
+            "status": "create_failed",
+            "title": i18n._("pub_create_failed_title"),
+            "message": i18n._(
+                "pub_create_failed_message",
+                code=(exc.code if exc else "0"),
+                reason=(exc.msg if exc else i18n._("pub_create_failed_no_item_id")),
+            ),
+            "code": (exc.code if exc else "0"),
+            "error_type": err_type,
+            "api_message": (exc.msg if exc else ""),
+            "hint": (exc.hint if exc else ""),
+            "request_id": request_id,
+            "trace_id": trace_id,
+            "draft": draft,
+            "item_id": None,
+            "next_actions": next_actions,
+        }
+
     # ==================================================================
     # AI-assisted create flow
     # ==================================================================
@@ -1215,7 +1313,9 @@ class PublishModule:
             logger.debug("CRO requirement API is not available yet")
 
         # Stage 3: resolve compliance (manufacturer / EURP)
-        compliance_result = self._resolve_compliance_info_with_check(schema)
+        compliance_result = self._resolve_compliance_info_with_check(
+            schema, draft=getattr(self.args, "draft", False)
+        )
         if compliance_result.get("status"):
             return compliance_result
 
@@ -1257,6 +1357,26 @@ class PublishModule:
             draft=draft_requested,
         )
 
+        # Explicit --attribute-data must reach the AI payload too (it used to be
+        # honored only in the manual flow, so AI-mode values were silently
+        # dropped). Applied before unmatched-column binding so explicit values win.
+        self._apply_attribute_data_override(product_payload)
+
+        # Bind extra Excel/CSV columns that the whitelist did not recognize,
+        # using the category attribute definitions fetched above.
+        unmapped_cols = self._apply_unmatched_category_attributes(
+            product_payload, schema, category_attributes
+        )
+        self._unmapped_columns = unmapped_cols
+
+        # If a provided column could not be confidently matched but plausibly
+        # maps to one or more category attributes, ask the seller to confirm the
+        # mapping instead of silently dropping it (which would otherwise surface
+        # later as a cryptic batchValidate "missing attribute" error).
+        mapping_check = self._check_unmapped_columns(unmapped_cols, product_payload)
+        if mapping_check:
+            return mapping_check
+
         # Stage 3b: unified compliance check (GPSR + Safety Warning + compliance docs)
         draft_issues: list = []
         compliance_check = self._check_compliance_fields(
@@ -1298,8 +1418,26 @@ class PublishModule:
                 return cat_attr_result
 
         # Stage 4b: mandatory field checks (cannot continue if missing)
-        mandatory_result = self._check_mandatory_fields(product_payload, schema)
+        mandatory_result = self._check_mandatory_fields(
+            product_payload, schema, category_attributes
+        )
         if mandatory_result.get("status") == "need_mandatory_fields":
+            hard_missing = mandatory_result.get("hard_missing_fields") or []
+            if hard_missing:
+                # Platform hard requirement (e.g. main image): /product/create
+                # rejects it with 4224 even for Draft, so block unconditionally and
+                # do NOT offer or fall back to draft mode.
+                mandatory_result["missing_fields"] = (
+                    hard_missing + mandatory_result.get("missing_fields", [])
+                )
+                mandatory_result["message"] = i18n._(
+                    "pub_image_required_no_draft", fields=", ".join(hard_missing)
+                )
+                mandatory_result["next_actions"] = [
+                    i18n._("pub_add_images_and_rerun")
+                ]
+                mandatory_result["draft_mode_available"] = False
+                return mandatory_result
             if draft_requested:
                 for field in mandatory_result.get("missing_fields", []):
                     draft_issues.append(f"Missing mandatory field: {field}")
@@ -1311,7 +1449,7 @@ class PublishModule:
                 return mandatory_result
 
         # Stage 5: field summary and draft/continue confirmation
-        key_missing = self._build_key_missing_list(
+        key_missing, api_optional = self._build_key_missing_list(
             schema, product_payload, compliance_result, category_attributes
         )
         country_price_note = self._check_country_price_recommendation(schema)
@@ -1335,7 +1473,8 @@ class PublishModule:
         provided_fs_token = getattr(self.args, "field_summary_token", None)
         if provided_fs_token != expected_fs_token:
             return self._make_field_summary_preview(
-                fs_preview, key_missing, country_price_note
+                fs_preview, key_missing, country_price_note,
+                api_optional=api_optional,
             )
 
         # Stage 6: finalize (pre-validate + create)
@@ -1349,6 +1488,7 @@ class PublishModule:
             missing={k: k for k in key_missing},
             draft=draft_requested,
             draft_issues=draft_issues or None,
+            category_attributes=category_attributes,
         )
 
     # ------------------------------------------------------------------
@@ -1363,7 +1503,6 @@ class PublishModule:
         ("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"),
@@ -1371,6 +1510,8 @@ class PublishModule:
         ("delivery_method", "Delivery method", "mandatory"),
         # Conditional fields — missing suggests Draft
         ("italy_price", "Italy price", "conditional"),
+        # Seller SKU is optional (create API auto-generates when empty)
+        ("seller_sku", "Seller SKU", "conditional"),
         ("ean_code", "EAN code", "conditional"),
         ("manufacturer", "Manufacturer", "conditional"),
         ("eu_responsible_person", "EU responsible person", "conditional"),
@@ -1383,6 +1524,33 @@ class PublishModule:
         ("isbn", "ISBN", "conditional"),
     ]
 
+    # Conditional fields WE always require regardless of category (GPSR law,
+    # Miravia site-pricing rule, etc.) — missing them always prompts the user.
+    _HARD_REQUIRED_CONDITIONAL_KEYS = frozenset(
+        {
+            "manufacturer",
+            "eu_responsible_person",
+            "italy_price",
+            "standard_unit_type",
+        }
+    )
+
+    # Structural fields Miravia always requires for any product (not category
+    # attributes, so the API never governs them) — always blocking. NOTE:
+    # delivery method (Attributes.deliverySof) is intentionally NOT here — it is
+    # auto-defaulted (DBM, or DBS when the seller has DBS permission) rather
+    # than hard-collected; see _check_dbm_limits.
+    _CORE_MANDATORY_KEYS = frozenset(
+        {
+            "product_title",
+            "product_images",
+            "category_id",
+            "brand_id",
+            "general_price",
+            "stock",
+        }
+    )
+
     def _resolve_category_for_schema(
         self, schema: MiraviaListingSchema
     ) -> Dict[str, Any]:
@@ -1435,7 +1603,7 @@ class PublishModule:
         ) -> Dict[str, Any]:
             """Try recommend API first, fallback to category tree."""
             title = schema.product_title
-            image_urls = schema.image_urls or []
+            image_urls = schema.product_images or []
             if title or image_urls:
                 try:
                     recommendations = self.product.recommend_category(
@@ -1535,15 +1703,19 @@ class PublishModule:
         """
         confirmed_brand_id = getattr(self.args, "confirmed_brand_id", None)
         if confirmed_brand_id:
+            # Honor an explicitly passed --brand-name too (aligns with the
+            # manual flow's _resolve_brand_interactive). Otherwise a seller who
+            # confirms by ID but whose source lacks the brand name would have
+            # the brand silently dropped from the payload.
             return {
                 "brand_id": int(confirmed_brand_id),
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
             }
 
         if schema.brand_id:
             return {
                 "brand_id": int(schema.brand_id),
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
             }
 
         brand_name = self.args.brand_name or schema.brand_name
@@ -1584,10 +1756,14 @@ class PublishModule:
                 "pub_brand_not_found_message", brand_name=brand_name
             ),
             "brand_name": brand_name,
+            "brand_list_link": (
+                "https://sellercenter.miravia.es/apps/setting/seller/brandlist"
+            ),
             "create_brand_link": (
                 "https://sellercenter.miravia.es/apps/product/publish/brand"
             ),
             "next_actions": [
+                i18n._("pub_brand_list_link"),
                 i18n._("pub_brand_create_link"),
                 i18n._("pub_brand_create_next"),
                 i18n._("pub_brand_reconfirm_or_choose"),
@@ -1617,9 +1793,15 @@ class PublishModule:
         }
 
     def _resolve_compliance_info_with_check(
-        self, schema: MiraviaListingSchema
+        self, schema: MiraviaListingSchema, draft: bool = False
     ) -> Dict[str, Any]:
-        """Resolve manufacturer / EURP IDs and surface mismatches."""
+        """Resolve manufacturer / EURP IDs and surface mismatches.
+
+        In draft mode an unmatched manufacturer / EU responsible person is not a
+        hard blocker: the IDs are left empty and the seller completes them in the
+        Seller Center draft, so the flow continues instead of returning
+        ``need_compliance``.
+        """
         result: Dict[str, Any] = {}
         choices: List[Dict[str, Any]] = []
 
@@ -1667,6 +1849,11 @@ class PublishModule:
                 logger.warning("Failed to query EU responsible person: %s", exc)
 
         if result.get("manufacturer_mismatch") or result.get("eurp_mismatch"):
+            if draft:
+                logger.info(
+                    "Draft mode: deferring unmatched manufacturer/EURP to Seller Center"
+                )
+                return {}
             return {
                 "status": "need_compliance",
                 "message": i18n._("pub_manufacturer_eurp_mismatch"),
@@ -1701,14 +1888,28 @@ class PublishModule:
             return None
 
         payload_attrs = product_payload.get("Attributes") or {}
+        payload_skus = (product_payload.get("Skus") or {}).get("Sku") or []
+
+        def _present_in(container: Dict[str, Any], attr: Dict[str, Any]) -> bool:
+            for key in (attr.get("name"), attr.get("en_name")):
+                if key and str(container.get(key) or "").strip():
+                    return True
+            return False
+
         missing_attrs: List[Dict[str, Any]] = []
         for attr in mandatory:
-            # Check by en_name or name key in payload attributes
-            en_name = (attr.get("en_name") or attr.get("name") or "").strip()
-            if not en_name:
+            if not (attr.get("en_name") or attr.get("name")):
                 continue
-            val = payload_attrs.get(en_name)
-            if val is None or (isinstance(val, str) and not val.strip()):
+            if (attr.get("attribute_type") or "normal") == "sku":
+                # SKU-level attribute: must be filled on every SKU.
+                if payload_skus and all(
+                    _present_in(sku, attr) for sku in payload_skus
+                ):
+                    continue
+                missing_attrs.append(attr)
+            else:
+                if _present_in(payload_attrs, attr):
+                    continue
                 missing_attrs.append(attr)
 
         if not missing_attrs:
@@ -1754,32 +1955,59 @@ class PublishModule:
         }
 
     def _check_mandatory_fields(
-        self, product_payload: Dict[str, Any], schema: MiraviaListingSchema
+        self,
+        product_payload: Dict[str, Any],
+        schema: MiraviaListingSchema,
+        category_attributes: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Check required fields that block continuation when missing.
 
-        Per the Miravia ``/product/create`` documentation, package
-        dimensions/weight and ``SellerSku`` are required at the SKU level.
+        Uses the same ``_field_is_required`` rule as every other layer:
+        - Structural fields (images / general price / stock) are always blocking.
+        - Package weight/dimensions are SKU-level category attributes, so they
+          only block when the API marks them ``is_mandatory`` for this category
+          (batchValidate remains the authoritative backstop).
+        - ``SellerSku`` is never blocking: the create API auto-generates it.
         """
+        category_attributes = category_attributes or []
         missing: List[str] = []
-        images = (product_payload.get("Images") or {}).get("Image") or []
-        if not images:
-            missing.append(i18n._("label_image_url"))
+        hard_missing: List[str] = []
 
         skus = (product_payload.get("Skus") or {}).get("Sku") or []
-        has_price = any(sku.get("price") for sku in skus)
-        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")
+        # Main image is a platform-level hard requirement: /product/create rejects
+        # an imageless product with 4224 MAIN_IMAGE_OR_SKU_IMAGE_EMPTY even for
+        # Draft, so it must BLOCK and can never be routed to Draft. Miravia accepts
+        # either an SPU-level image or any SKU-level image, so only block when both
+        # are empty.
+        images = (product_payload.get("Images") or {}).get("Image") or []
+        has_sku_image = any((s.get("Images") or {}).get("Image") for s in skus)
+        if (
+            self._field_is_required("product_images", category_attributes)
+            and not images
+            and not has_sku_image
+        ):
+            hard_missing.append(i18n._("label_image_url"))
+
+        if self._field_is_required("general_price", category_attributes):
+            if not any(sku.get("price") for sku in skus):
+                missing.append("General price")
+
+        if self._field_is_required("stock", category_attributes):
+            if not any(sku.get("quantity") for sku in skus):
+                missing.append("Stock")
 
         package_dims = ("package_weight", "package_length", "package_width", "package_height")
+        # Weight/Dimensions are mandatory by default (Miravia needs them for
+        # shipping); a dimension is only skipped when the category API EXPLICITLY
+        # marks it optional (is_mandatory=0). A missing attribute or API failure
+        # keeps it blocking (fail safe toward blocking).
+        required_dims = [
+            dim for dim in package_dims
+            if not self._field_explicitly_optional(dim, category_attributes)
+        ]
         for idx, sku in enumerate(skus, start=1):
-            if not (sku.get("SellerSku") or sku.get("seller_sku")):
-                missing.append(f"Seller SKU (SKU #{idx})")
-            for dim in package_dims:
+            for dim in required_dims:
                 val = sku.get(dim)
                 try:
                     if val is None or float(val) <= 0:
@@ -1787,13 +2015,14 @@ class PublishModule:
                 except (TypeError, ValueError):
                     missing.append(f"{dim.replace('_', ' ').title()} (SKU #{idx})")
 
-        if missing:
+        if missing or hard_missing:
             return {
                 "status": "need_mandatory_fields",
                 "message": i18n._(
-                    "pub_mandatory_fields_missing", fields=", ".join(missing)
+                    "pub_mandatory_fields_missing", fields=", ".join(hard_missing + missing)
                 ),
                 "missing_fields": missing,
+                "hard_missing_fields": hard_missing,
                 "next_actions": [i18n._("interactive_preview_next")],
             }
         return {}
@@ -1804,24 +2033,64 @@ class PublishModule:
         product_payload: Dict[str, Any],
         compliance_result: Dict[str, Any],
         category_attributes: List[Dict[str, Any]],
-    ) -> List[str]:
-        """Return internal keys of fields that are missing but can be skipped in draft mode.
+    ) -> "tuple[List[str], List[str]]":
+        """Return internal keys of fields that are missing but can be skipped in draft mode,
+        plus keys the category API explicitly marks as optional (not to be flagged).
 
         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 []
+
+        # Conditional fields not in our own hard-requirement list follow the
+        # category attribute API (is_mandatory). e.g. EAN code is optional for
+        # jeans, so an empty EAN must NOT be flagged as missing.
+        api_optional: List[str] = []
+
+        # Delivery method (Attributes.deliverySof) is NOT a hard-collect field:
+        # Miravia defaults it when absent (DBM, or DBS if the seller has DBS
+        # permission — see _check_dbm_limits), so an empty value shows as
+        # "Optional" here and never blocks.
+        if not (getattr(schema, "delivery_method", None) or "").strip():
+            api_optional.append("delivery_method")
         has_ean = any(sku.get("ean_code") for sku in skus) or bool(schema.ean_codes)
         if not has_ean:
-            missing.append("ean_code")
+            if self._field_is_required("ean_code", category_attributes):
+                missing.append("ean_code")
+            else:
+                api_optional.append("ean_code")
 
         if self._check_italy_price_mandatory(schema):
             missing.append("italy_price")
 
-        if schema.standard_unit_type and not schema.unit_count:
+        def _payload_has(keys: "tuple[str, ...]") -> bool:
+            """True when any non-empty value for the given key variants exists in
+            the bound SKU payload or product-level Attributes. Covers the
+            category-attribute-binding path where Unit_Count lands in the SKU
+            even though schema.unit_count stays None."""
+            cand = {self._squash_attr_name(k) for k in keys}
+            for sku in skus:
+                for k, v in sku.items():
+                    if self._squash_attr_name(str(k)) in cand and str(v or "").strip():
+                        return True
+            for k, v in (product_payload.get("Attributes") or {}).items():
+                if self._squash_attr_name(str(k)) in cand and str(v or "").strip():
+                    return True
+            return False
+
+        unit_count_present = bool(
+            (schema.unit_count is not None and str(schema.unit_count).strip())
+            or _payload_has(("unit_count", "Unit_Count"))
+        )
+        unit_type_present = bool(
+            (schema.standard_unit_type and str(schema.standard_unit_type).strip())
+            or _payload_has(("unit_count_type", "standard_unit_type", "Unit_Count_Type"))
+        )
+
+        if unit_type_present and not unit_count_present:
             missing.append("unit_count")
-        elif self._is_category_attribute_mandatory(category_attributes, "unit_count") and not schema.unit_count:
+        elif self._is_category_attribute_mandatory(category_attributes, "unit_count") and not unit_count_present:
             missing.append("unit_count")
 
         if not schema.sku_attributes_food_health and self._category_looks_like_food_health(
@@ -1840,18 +2109,29 @@ class PublishModule:
             missing.append("eu_responsible_person")
 
         if schema.safety_warning is None:
-            missing.append("safety_warning")
+            if self._field_is_required("safety_warning", category_attributes):
+                missing.append("safety_warning")
+            else:
+                api_optional.append("safety_warning")
 
         if not schema.package_photos:
-            missing.append("package_photos")
+            if self._field_is_required("package_photos", category_attributes):
+                missing.append("package_photos")
+            else:
+                api_optional.append("package_photos")
 
-        if self._is_category_attribute_mandatory(category_attributes, "compliance_documents") and not schema.compliance_documents:
+        if not schema.compliance_documents and self._is_category_attribute_mandatory(
+            category_attributes, "compliance_documents"
+        ):
             missing.append("compliance_documents")
 
+        # Seller SKU is optional: when empty the create API auto-generates a
+        # unique value. Never block or suggest Draft for it — just show as
+        # Optional in the summary when not provided.
         if not any(sku.get("SellerSku") or sku.get("seller_sku") for sku in skus):
-            missing.append("seller_sku")
+            api_optional.append("seller_sku")
 
-        return missing
+        return missing, api_optional
 
     def _category_looks_like_food_health(
         self, category_attributes: List[Dict[str, Any]]
@@ -1865,14 +2145,309 @@ class PublishModule:
             for kw in ("food", "health", "nutrition", "allergen", "ingredient")
         )
 
+    @staticmethod
+    def _normalize_attr_name(value: Any) -> str:
+        """Normalize an attribute/field name for fuzzy matching across layers."""
+        return re.sub(r"[^a-z0-9]+", "_", str(value).strip().lower()).strip("_")
+
+    @staticmethod
+    def _squash_attr_name(value: Any) -> str:
+        """Aggressively squash a name (drop all separators) for matching.
+
+        Lets ``SellerSku`` match an API attribute named ``seller_sku`` and
+        ``Unit Count`` match ``unit_count`` — variants that differ only by
+        underscores/spacing.
+        """
+        return re.sub(r"[^a-z0-9]+", "", str(value).strip().lower())
+
+    def _find_category_attribute(
+        self,
+        category_attributes: List[Dict[str, Any]],
+        candidates: tuple,
+    ) -> Optional[Dict[str, Any]]:
+        """Locate a category attribute definition by any of its name variants.
+
+        Matches on both the underscore-normalized form and the fully squashed
+        form so ``SellerSku``/``seller_sku`` and similar casing/spacing variants
+        resolve to the same attribute.
+        """
+        wanted = set()
+        for c in candidates:
+            wanted.add(self._normalize_attr_name(c))
+            wanted.add(self._squash_attr_name(c))
+        # Pass 1: exact match on any name variant (normalized or squashed).
+        for attr in category_attributes or []:
+            names = set()
+            for key in ("name", "en_name", "label", "attribute_name"):
+                if attr.get(key):
+                    names.add(self._normalize_attr_name(attr.get(key)))
+                    names.add(self._squash_attr_name(attr.get(key)))
+            if names & wanted:
+                return attr
+        # Pass 2: conservative substring — a candidate squashed name (>=4 chars)
+        # contained inside an attribute name variant. One-directional (candidate
+        # in attribute) so short/generic headers don't shadow real ones.
+        wanted_sq = {
+            self._squash_attr_name(c) for c in candidates if len(self._squash_attr_name(c)) >= 4
+        }
+        if wanted_sq:
+            for attr in category_attributes or []:
+                for key in ("name", "en_name", "label", "attribute_name"):
+                    if not attr.get(key):
+                        continue
+                    a_sq = self._squash_attr_name(attr.get(key))
+                    if any(w in a_sq for w in wanted_sq):
+                        return attr
+        return None
+
+    def _apply_unmatched_category_attributes(
+        self,
+        product_payload: Dict[str, Any],
+        schema: MiraviaListingSchema,
+        category_attributes: List[Dict[str, Any]],
+    ) -> List[str]:
+        """Bind non-whitelisted Excel/CSV columns to real category attributes.
+
+        ``schema.unmatched_columns`` holds every column header the rule
+        extractor could not map to a known field. For each, we look it up
+        against ``/category/attributes/get``; when it matches, we write the
+        value under the attribute's canonical key — into each SKU for
+        ``attribute_type == 'sku'``, otherwise into the product-level
+        ``Attributes``. Existing keys are never overwritten (whitelist/LLM
+        values win). Returns a list of ``{header, value, candidates}`` for the
+        headers that matched no category attribute confidently, so the caller can
+        ask the seller to confirm the mapping instead of silently dropping them.
+
+        We intentionally bind ONLY the non-whitelisted columns here. Columns
+        the whitelist already consumed (Title/Price/Image/Color/Stock/...) are
+        assembled by the core extractor into their canonical payload shape; if
+        we also re-bound them we would inject duplicate or case-colliding keys
+        into the SKU (e.g. lowercase ``images`` next to the ``Images`` object,
+        ``color_family`` next to ``color``), and ``/product/create`` rejects
+        such a payload with E005 Invalid Request Format even though
+        batchValidate tolerates the extra keys.
+        """
+        unmatched = getattr(schema, "unmatched_columns", {}) or {}
+        if not unmatched:
+            return []
+        attributes = product_payload.setdefault("Attributes", {})
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+        unmapped: List[Dict[str, Any]] = []
+        for header, value in unmatched.items():
+            attr = self._find_category_attribute(category_attributes, (header,))
+            if not attr:
+                # No confident match: collect the header with fuzzy candidates so
+                # the caller can ask the seller to confirm the intended attribute
+                # instead of silently dropping the column.
+                unmapped.append(
+                    {
+                        "header": header,
+                        "value": value,
+                        "candidates": [
+                            {
+                                "name": c.get("name"),
+                                "en_name": c.get("en_name"),
+                                "label": c.get("label") or c.get("en_name") or c.get("name"),
+                                "attribute_type": c.get("attribute_type") or "normal",
+                                "is_mandatory": str(c.get("is_mandatory", "0")),
+                            }
+                            for c in self._suggest_attribute_candidates(
+                                header, category_attributes
+                            )
+                        ],
+                    }
+                )
+                continue
+            key = attr.get("name") or attr.get("en_name") or header
+            if (attr.get("attribute_type") or "normal") == "sku":
+                for sku in skus:
+                    if key not in sku:
+                        sku[key] = value
+            else:
+                if key not in attributes:
+                    attributes[key] = value
+        if unmapped:
+            logger.info(
+                "Excel/CSV columns not confidently matched: %s",
+                ", ".join(u["header"] for u in unmapped),
+            )
+        return unmapped
+
+    def _suggest_attribute_candidates(
+        self,
+        header: str,
+        category_attributes: List[Dict[str, Any]],
+        max_candidates: int = 8,
+    ) -> List[Dict[str, Any]]:
+        """Fuzzy-suggest category attributes a free-text column header might map
+        to — for the confirmation prompt only, never auto-bound.
+
+        Uses a shared-prefix (stem) heuristic so e.g. header ``packaging``
+        suggests ``Package_Label_Photo_EU``. Deliberately looser than
+        ``_find_category_attribute`` because a human confirms the result.
+        """
+        def _words(text: Any) -> List[str]:
+            return [w for w in re.split(r"[^a-z0-9]+", str(text).lower()) if len(w) >= 4]
+
+        header_words = set(_words(header))
+        h_sq = self._squash_attr_name(header)
+        if h_sq:
+            header_words.add(h_sq)
+        out: List[Dict[str, Any]] = []
+        for attr in category_attributes or []:
+            attr_words: List[str] = []
+            for key in ("name", "en_name", "label", "attribute_name"):
+                if attr.get(key):
+                    attr_words.extend(_words(attr.get(key)))
+                    attr_words.append(self._squash_attr_name(attr.get(key)))
+            hit = False
+            for hw in header_words:
+                for aw in attr_words:
+                    if (
+                        len(hw) >= 5
+                        and len(aw) >= 5
+                        and hw[:5] == aw[:5]
+                    ) or hw in aw or aw in hw:
+                        hit = True
+                        break
+                if hit:
+                    break
+            if hit:
+                out.append(attr)
+                if len(out) >= max_candidates:
+                    break
+        return out
+
+    def _apply_attribute_data_override(self, product_payload: Dict[str, Any]) -> None:
+        """Merge ``--attribute-data`` into the AI-built payload.
+
+        The AI flow builds Attributes/Skus from the extracted schema and never
+        consulted ``--attribute-data``, so values passed there were silently
+        dropped. ``--attribute-data`` is the seller's own explicit input, so it
+        overrides extracted values; SKU-level keys are merged into every SKU.
+        """
+        raw = getattr(self.args, "attribute_data", None)
+        if not raw:
+            return
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"--attribute-data is not valid JSON: {exc}") from exc
+        if not isinstance(data, dict):
+            raise ValueError("--attribute-data must be a JSON object")
+        attributes = product_payload.setdefault("Attributes", {})
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+        for key, value in data.items():
+            if key in _SKU_LEVEL_ATTRIBUTE_NAMES:
+                for sku in skus:
+                    sku[key] = value
+            else:
+                attributes[key] = value
+
+    def _check_unmapped_columns(
+        self,
+        unmapped_cols: List[Dict[str, Any]],
+        product_payload: Dict[str, Any],
+    ) -> Optional[Dict[str, Any]]:
+        """Return a ``need_attribute_mapping`` prompt when an unmapped column
+        looks like a category attribute the seller intended, so they confirm the
+        mapping instead of us dropping it silently (which would later surface as
+        a cryptic batchValidate "missing attribute" error). Columns with no
+        plausible candidate — or whose candidates are already filled via
+        ``--attribute-data`` — are ignored.
+        """
+        attributes = product_payload.get("Attributes") or {}
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+
+        def _filled(cand: Dict[str, Any]) -> bool:
+            names = [cand.get("name"), cand.get("en_name")]
+
+            def _present(container: Dict[str, Any]) -> bool:
+                return any(n and str(container.get(n) or "").strip() for n in names)
+
+            if (cand.get("attribute_type") or "normal") == "sku":
+                return bool(skus) and all(_present(s) for s in skus)
+            return _present(attributes)
+
+        need: List[Dict[str, Any]] = []
+        for item in unmapped_cols or []:
+            open_cands = [c for c in (item.get("candidates") or []) if not _filled(c)]
+            if open_cands:
+                need.append({**item, "candidates": open_cands})
+        if not need:
+            return None
+        return {
+            "status": "need_attribute_mapping",
+            "title": i18n._("pub_need_attribute_mapping_title"),
+            "message": i18n._("pub_need_attribute_mapping_description"),
+            "unmapped_columns": need,
+            "next_actions": [i18n._("pub_need_attribute_mapping_next")],
+        }
+
+    def _field_is_required(
+        self,
+        field_key: str,
+        category_attributes: List[Dict[str, Any]],
+    ) -> bool:
+        """THE single source of truth for whether a field must be filled.
+
+        Priority: our own rules first, then the category attribute API.
+        1. Structural fields (title/images/price/stock/...) and hard-required
+           conditional fields (GPSR manufacturer/EURP, Italy price, unit type)
+           are always required — our rule hits regardless of category.
+        2. Everything else follows ``/category/attributes/get``: a matching
+           attribute with ``is_mandatory=1`` (or the postToInactive flag) means
+           required; a matching non-mandatory attribute, or no attribute at all,
+           means optional.
+
+        Every mandatory/conditional check in the flow must call this instead of
+        hard-coding per-field requirements, so AI-extract and manual paths stay
+        consistent.
+        """
+        if (
+            field_key in self._CORE_MANDATORY_KEYS
+            or field_key in self._HARD_REQUIRED_CONDITIONAL_KEYS
+        ):
+            return True
+        attr = self._find_category_attribute(category_attributes, (field_key,))
+        if attr is None:
+            return False
+        if str(attr.get("is_mandatory", "0")).strip() == "1":
+            return True
+        # Fall back to the explicit postToInactive flag when present
+        return str(attr.get("post_to_inactive", "0")).strip() == "1"
+
+    def _field_explicitly_optional(
+        self,
+        field_key: str,
+        category_attributes: List[Dict[str, Any]],
+    ) -> bool:
+        """True ONLY when the category attribute API returns a matching attribute
+        that is explicitly non-mandatory. Used for fields that default to
+        mandatory (package weight/dimensions, needed for shipping): they block
+        unless the API clearly says otherwise. A missing attribute (or an API
+        call failure / empty list) returns False, i.e. stays mandatory — fail
+        safe toward blocking."""
+        attr = self._find_category_attribute(category_attributes or [], (field_key,))
+        if not attr:
+            return False
+        if str(attr.get("post_to_inactive", "0")).strip() == "1":
+            return False
+        return str(attr.get("is_mandatory", "0")).strip() != "1"
+
     def _is_category_attribute_mandatory(
         self, category_attributes: List[Dict[str, Any]], attr_name: str
     ) -> bool:
-        """Check if a category attribute is marked as mandatory (is_mandatory=1)."""
-        for attr in category_attributes:
-            if attr.get("name") == attr_name:
-                return bool(attr.get("is_mandatory"))
-        return False
+        """Check if a category attribute is marked as mandatory (is_mandatory=1).
+
+        ``is_mandatory`` may arrive as int or string ("0"/"1") — ``bool("0")``
+        is True, so compare the normalized string instead. Name matching is
+        normalized across ``name``/``en_name``/``label`` variants.
+        """
+        attr = self._find_category_attribute(category_attributes, (attr_name,))
+        if attr is None:
+            return False
+        return str(attr.get("is_mandatory", "0")).strip() == "1"
 
     def _check_country_price_recommendation(
         self, schema: MiraviaListingSchema
@@ -1939,22 +2514,27 @@ class PublishModule:
         fs_preview: Dict[str, Any],
         key_missing: List[str],
         country_price_note: Optional[str] = None,
+        api_optional: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """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.
+        Conditional fields the category API explicitly marks as optional and
+        that are not filled show as ``Optional`` instead of ``MISSING``.
         """
         token = _make_publish_preview_token(fs_preview)
+        optional_set = set(api_optional or [])
 
         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")
-            )
+            if key in key_missing:
+                status = i18n._("pub_field_status_missing")
+            elif key in optional_set:
+                status = i18n._("pub_field_status_optional")
+            else:
+                status = i18n._("pub_field_status_filled")
             line = f"  {label}: {status}"
             if category == "mandatory":
                 mandatory_lines.append(line)
@@ -2090,7 +2670,7 @@ class PublishModule:
         confirmed_brand_id = getattr(self.args, "confirmed_brand_id", None)
         if confirmed_brand_id:
             return {
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
                 "brand_id": int(confirmed_brand_id),
             }
 
@@ -2229,7 +2809,11 @@ class PublishModule:
 
         Per the Miravia ``/product/create`` documentation:
 
-        - ``SellerSku`` is mandatory for every SKU.
+        - ``SellerSku`` is NOT hard-coded mandatory: whether it must be filled is
+          governed by the category attribute API and enforced once in
+          :meth:`_validate_create_payload` (via ``seller_sku_required``), which
+          applies to both Draft and online publishes. Here we simply omit an
+          empty SellerSku so ``/product/create`` can auto-generate a value.
         - Package dimensions/weight are per-SKU fields
           (``package_length/width/height/weight``).
         - Sales properties are flat SKU fields, not a nested ``Variation``
@@ -2258,11 +2842,11 @@ class PublishModule:
             seller_sku = raw.get("seller_sku") or (
                 schema.seller_skus[idx] if idx < len(schema.seller_skus) else None
             )
-            if not seller_sku:
-                raise ValueError(
-                    i18n._("pub_seller_sku_required", idx=idx + 1)
-                )
-            sku["SellerSku"] = seller_sku
+            # Do NOT hard-require SellerSku here. Its mandatory-ness comes from
+            # the category attribute API and is enforced in _validate_create_payload
+            # (not relaxed by draft). Omit empty values so create can auto-generate.
+            if seller_sku:
+                sku["SellerSku"] = seller_sku
 
             ean_code = raw.get("ean_code") or (
                 schema.ean_codes[idx] if idx < len(schema.ean_codes) else None
@@ -2281,16 +2865,18 @@ class PublishModule:
             if quantity is not None:
                 sku["quantity"] = int(quantity)
 
-            # Package dimensions & weight (per-SKU per Miravia docs)
-            for dim, schema_field in (
-                ("package_weight", "weight_kg"),
-                ("package_length", "length_cm"),
-                ("package_width", "width_cm"),
-                ("package_height", "height_cm"),
+            # Package dimensions & weight (per-SKU per Miravia docs).
+            # Normalize unit-suffixed strings to the bare number Miravia's
+            # /product/create requires: weight in kg, dimensions in cm.
+            for dim, schema_field, conv in (
+                ("package_weight", "weight_kg", _convert_weight),
+                ("package_length", "length_cm", _convert_length),
+                ("package_width", "width_cm", _convert_length),
+                ("package_height", "height_cm", _convert_length),
             ):
                 value = raw.get(dim) or getattr(schema, schema_field, None)
                 if value is not None:
-                    sku[dim] = str(value)
+                    sku[dim] = _format_measurement(value, conv)
 
             # Sales properties are flat SKU fields
             v1_name = _normalize_variation_name(schema.variation_name_1)
@@ -2771,10 +3357,11 @@ class PublishModule:
                 processed["SellerSku"] = processed.pop("seller_sku")
             elif "seller_sku" in processed:
                 processed.pop("seller_sku")  # SellerSku already set
+            # SellerSku is optional (governed by the category attribute API and
+            # enforced in _validate_create_payload, not relaxed by draft). When
+            # empty, drop the key so /product/create can auto-generate it.
             if not processed.get("SellerSku"):
-                raise ValueError(
-                    i18n._("pub_seller_sku_required", idx=idx + 1)
-                )
+                processed.pop("SellerSku", None)
             # Migrate SKU-level images
             sku_images = processed.get("Images", {}).get("Image", [])
             if sku_images:
@@ -2915,12 +3502,19 @@ def _validate_title(title: str) -> None:
         )
 
 
-def _validate_create_payload(payload: Dict[str, Any]) -> None:
+def _validate_create_payload(
+    payload: Dict[str, Any],
+    seller_sku_required: bool = False,
+) -> None:
     """Validate a Miravia ``/product/create`` Product payload.
 
     Enforces the field constraints from the Miravia ``/product/create``
     documentation. Package dimensions/weight and ``SellerSku`` are validated
     at the SKU level; the legacy ``Product.Package`` node is no longer used.
+
+    ``seller_sku_required`` is decided by the caller from the category attribute
+    API (``_field_is_required``): when False, an empty SellerSku is allowed and
+    the create API auto-generates a unique value.
     """
     attributes = payload.get("Attributes") or {}
     title = attributes.get("name")
@@ -2942,6 +3536,17 @@ def _validate_create_payload(payload: Dict[str, Any]) -> None:
             i18n._("pub_too_many_skus", max=_MAX_SKUS_PER_PRODUCT, count=len(skus))
         )
 
+    # Authoritative backstop: Miravia /product/create requires at least one image
+    # at SPU or SKU level and rejects an imageless product with 4224
+    # MAIN_IMAGE_OR_SKU_IMAGE_EMPTY even for Draft. Enforce it here so no path
+    # (manual mode, or a draft that slipped past the earlier stage) can submit an
+    # imageless product.
+    has_sku_image = any((s.get("Images") or {}).get("Image") for s in skus)
+    if not images and not has_sku_image:
+        raise ValueError(
+            i18n._("pub_image_required_no_draft", fields=i18n._("label_image_url"))
+        )
+
     # Check EAN duplicate within same product
     ean_codes = [sku.get("ean_code") for sku in skus if sku.get("ean_code")]
     if len(ean_codes) != len(set(ean_codes)):
@@ -2953,7 +3558,7 @@ def _validate_create_payload(payload: Dict[str, Any]) -> None:
         raise ValueError(i18n._("pub_seller_sku_duplicate_in_product"))
 
     for idx, sku in enumerate(skus, start=1):
-        if not sku.get("SellerSku"):
+        if seller_sku_required and not (sku.get("SellerSku") or sku.get("seller_sku")):
             raise ValueError(i18n._("pub_seller_sku_required", idx=idx))
 
         price = sku.get("price")
@@ -3190,6 +3795,32 @@ def _convert_length(value: str) -> float:
     return number * _LENGTH_TO_CM[unit]
 
 
+def _format_measurement(value: Any, converter) -> str:
+    """Normalize a possibly unit-suffixed measurement into a plain numeric
+    string in the target base unit.
+
+    ``converter`` is :func:`_convert_weight` (-> kg) or :func:`_convert_length`
+    (-> cm). Examples: ``"0.6kg" -> "0.6"``, ``"500g" -> "0.5"``,
+    ``"5cm" -> "5"``, ``"50mm" -> "5"``, ``30 -> "30"``.
+
+    Falls back to the cleaned numeric substring when the unit is unrecognized,
+    so we never crash on odd inputs; Miravia's ``/product/create`` requires a
+    bare number > 0 for package weight/dimensions, and leaving a unit suffix
+    like ``"0.6kg"`` in the payload makes batchValidate reject it with
+    ``"not valid, only a number"``.
+    """
+    try:
+        number = float(converter(value))
+    except (TypeError, ValueError, AttributeError):
+        m = re.search(r"(\d+(?:[.,]\d+)?)", str(value))
+        if not m:
+            return str(value).strip()
+        number = float(m.group(1).replace(",", "."))
+    if abs(number - round(number)) < 1e-9:
+        return str(int(round(number)))
+    return ("%.6f" % number).rstrip("0").rstrip(".")
+
+
 def _validate_dimension(value: Any, name: str, maximum: int) -> None:
     """Validate dimension value after unit conversion.