diff --git a/app/composables/useMachineHierarchy.ts b/app/composables/useMachineHierarchy.ts
index 8d883d1..bf09f94 100644
--- a/app/composables/useMachineHierarchy.ts
+++ b/app/composables/useMachineHierarchy.ts
@@ -5,7 +5,7 @@
  */
 
 import { resolveIdentifier, resolveProductReference, getProductDisplay } from '~/shared/utils/productDisplayUtils'
-import { resolveConstructeurs, uniqueConstructeurIds } from '~/shared/constructeurUtils'
+import { resolveConstructeurs, uniqueConstructeurIds, type ConstructeurSummary } from '~/shared/constructeurUtils'
 
 type AnyRecord = Record<string, unknown>
 
@@ -28,7 +28,9 @@ const collectConstructeurs = (
     })
     .filter(Boolean) as AnyRecord[][]
 
-  return resolveConstructeurs(ids, ...pools, allConstructeurs)
+  // ConstructeurSummary and AnyRecord are structurally compatible at runtime
+  const allPools = [...pools, allConstructeurs] as unknown as Array<ConstructeurSummary[]>
+  return resolveConstructeurs(ids, ...allPools) as unknown as AnyRecord[]
 }
 
 // ---------------------------------------------------------------------------
@@ -56,7 +58,7 @@ export function mergePieceLists(existing: AnyRecord[] = [], updates: AnyRecord[]
     return existing.map((piece) => ({ ...piece, constructeurs: piece.constructeurs || [] }))
   }
 
-  const updateMap = new Map(
+  const updateMap = new Map<unknown, AnyRecord>(
     updates.map((piece) => [piece.id, { ...piece, constructeurs: piece.constructeurs || [] }]),
   )
   const merged = existing.map((piece) => {
@@ -86,7 +88,7 @@ export function mergeComponentTrees(existing: AnyRecord[] = [], updates: AnyReco
   }
   if (!updates.length) return existing
 
-  const updateMap = new Map(
+  const updateMap = new Map<unknown, AnyRecord>(
     updates.map((component) => [
       component.id,
       {
@@ -100,7 +102,7 @@ export function mergeComponentTrees(existing: AnyRecord[] = [], updates: AnyReco
       },
     ]),
   )
-  const merged = existing.map((component) => {
+  const merged: AnyRecord[] = existing.map((component) => {
     const update = updateMap.get(component.id)
     if (!update) {
       return {
@@ -156,13 +158,15 @@ export const buildMachineHierarchyFromLinks = (
     const machinePieceLinkId = normalizePieceLinkId(link)
     const pieceId = resolveIdentifier(appliedPiece.id, appliedPiece.pieceId, link.pieceId)
 
+    const overrides = (link.overrides || null) as AnyRecord | null
+
     const basePiece: AnyRecord = {
       ...appliedPiece,
       id: appliedPiece.id || pieceId || machinePieceLinkId || `piece-${machinePieceLinkId}`,
       pieceId,
-      name: link.overrides?.name || appliedPiece.name || (appliedPiece.definition as AnyRecord)?.name || (appliedPiece.definition as AnyRecord)?.role || originalPiece?.name || 'Pièce',
-      reference: link.overrides?.reference || appliedPiece.reference || (appliedPiece.definition as AnyRecord)?.reference || originalPiece?.reference || null,
-      prix: link.overrides?.prix ?? appliedPiece.prix ?? originalPiece?.prix ?? null,
+      name: overrides?.name || appliedPiece.name || (appliedPiece.definition as AnyRecord)?.name || (appliedPiece.definition as AnyRecord)?.role || originalPiece?.name || 'Pièce',
+      reference: overrides?.reference || appliedPiece.reference || (appliedPiece.definition as AnyRecord)?.reference || originalPiece?.reference || null,
+      prix: overrides?.prix ?? appliedPiece.prix ?? originalPiece?.prix ?? null,
       constructeur: appliedPiece.constructeur || originalPiece?.constructeur || null,
       constructeurId: appliedPiece.constructeurId || (appliedPiece.constructeur as AnyRecord)?.id || originalPiece?.constructeurId || null,
       documents: Array.isArray(appliedPiece.documents) ? appliedPiece.documents : Array.isArray(originalPiece?.documents) ? originalPiece!.documents : [],
@@ -171,7 +175,7 @@ export const buildMachineHierarchyFromLinks = (
       typeMachinePieceRequirement: requirement,
       typeMachinePieceRequirementId: requirement?.id || null,
       requirementId: requirement?.id || null,
-      overrides: link.overrides || null,
+      overrides,
       originalPiece,
       machinePieceLink: link,
       machinePieceLinkId,
@@ -216,7 +220,9 @@ export const buildMachineHierarchyFromLinks = (
     const machineComponentLinkId = normalizeComponentLinkId(link)
     const composantId = resolveIdentifier(appliedComponent.id, appliedComponent.composantId, link.composantId)
 
-    const componentName = (link.overrides?.name || appliedComponent.name || (appliedComponent.definition as AnyRecord)?.alias || (appliedComponent.definition as AnyRecord)?.name || originalComponent?.name || 'Composant') as string
+    const compOverrides = (link.overrides || null) as AnyRecord | null
+
+    const componentName = (compOverrides?.name || appliedComponent.name || (appliedComponent.definition as AnyRecord)?.alias || (appliedComponent.definition as AnyRecord)?.name || originalComponent?.name || 'Composant') as string
 
     const pieces = Array.isArray(link.pieceLinks)
       ? (link.pieceLinks as AnyRecord[]).map((pl) => createPieceNode(pl, componentName)).filter(Boolean) as AnyRecord[]
@@ -234,8 +240,8 @@ export const buildMachineHierarchyFromLinks = (
       id: appliedComponent.id || composantId || machineComponentLinkId || `component-${machineComponentLinkId}`,
       composantId,
       name: componentName,
-      reference: link.overrides?.reference || appliedComponent.reference || (appliedComponent.definition as AnyRecord)?.reference || originalComponent?.reference || null,
-      prix: link.overrides?.prix ?? appliedComponent.prix ?? originalComponent?.prix ?? null,
+      reference: compOverrides?.reference || appliedComponent.reference || (appliedComponent.definition as AnyRecord)?.reference || originalComponent?.reference || null,
+      prix: compOverrides?.prix ?? appliedComponent.prix ?? originalComponent?.prix ?? null,
       constructeur: appliedComponent.constructeur || originalComponent?.constructeur || null,
       constructeurId: appliedComponent.constructeurId || (appliedComponent.constructeur as AnyRecord)?.id || originalComponent?.constructeurId || null,
       documents: Array.isArray(appliedComponent.documents) ? appliedComponent.documents : Array.isArray(originalComponent?.documents) ? originalComponent!.documents : [],
@@ -244,9 +250,9 @@ export const buildMachineHierarchyFromLinks = (
       typeMachineComponentRequirement: requirement,
       typeMachineComponentRequirementId: requirement?.id || null,
       requirementId: requirement?.id || null,
-      overrides: link.overrides || null,
-      machineComponentLinkOverrides: link.overrides || null,
-      definitionOverrides: link.overrides || null,
+      overrides: compOverrides,
+      machineComponentLinkOverrides: compOverrides,
+      definitionOverrides: compOverrides,
       originalComposant: originalComponent,
       machineComponentLink: link,
       machineComponentLinkId,
diff --git a/app/composables/useMachinePrint.ts b/app/composables/useMachinePrint.ts
index cd9252b..d62d0d3 100644
--- a/app/composables/useMachinePrint.ts
+++ b/app/composables/useMachinePrint.ts
@@ -88,7 +88,8 @@ export function useMachinePrint() {
   ) => {
     if (typeof window === 'undefined') return
 
-    const context = buildMachinePrintContext({
+    // machineReport.js has no type annotations; cast to avoid inferred never[] params
+    const context = (buildMachinePrintContext as unknown as (config: Record<string, unknown>) => Record<string, unknown>)({
       machine,
       machineName,
       machineReference,
diff --git a/app/pages/machine/[id].vue b/app/pages/machine/[id].vue
index b177531..5491abd 100644
--- a/app/pages/machine/[id].vue
+++ b/app/pages/machine/[id].vue
@@ -689,7 +689,7 @@
 </template>
 
 <script setup>
-import { ref, reactive, onMounted, computed, watch, nextTick } from 'vue'
+import { ref, reactive, onMounted, computed, watch } from 'vue'
 import { useRoute } from 'vue-router'
 import { useMachines } from '~/composables/useMachines'
 import { useComposants } from '~/composables/useComposants'
@@ -707,6 +707,32 @@ import {
   uniqueConstructeurIds,
   formatConstructeurContact as formatConstructeurContactSummary,
 } from '~/shared/constructeurUtils'
+import {
+  coerceValueForType,
+  formatCustomFieldValue,
+  shouldDisplayCustomField,
+  normalizeCustomFieldDefinitionEntry,
+  normalizeExistingCustomFieldDefinitions,
+  normalizeCustomFieldValueEntry,
+  mergeCustomFieldValuesWithDefinitions,
+  dedupeCustomFieldEntries,
+  summarizeCustomFields,
+} from '~/shared/utils/customFieldUtils'
+import {
+  resolveIdentifier,
+  resolveProductReference as _resolveProductReference,
+  getProductDisplay as _getProductDisplay,
+  getProductSuppliersLabel,
+  getProductPriceLabel,
+  extractParentLinkIdentifiers,
+} from '~/shared/utils/productDisplayUtils'
+import {
+  buildMachineHierarchyFromLinks,
+  resolveLinkArray,
+  mergePieceLists,
+  mergeComponentTrees,
+} from '~/composables/useMachineHierarchy'
+import { useMachinePrint } from '~/composables/useMachinePrint'
 import { canPreviewDocument, isImageDocument, isPdfDocument } from '~/utils/documentPreview'
 import ComponentHierarchy from '~/components/ComponentHierarchy.vue'
 import DocumentUpload from '~/components/DocumentUpload.vue'
@@ -716,7 +742,6 @@ import { useProducts } from '~/composables/useProducts'
 import DocumentPreviewModal from '~/components/DocumentPreviewModal.vue'
 import PageHero from '~/components/PageHero.vue'
 import MachinePrintSelectionModal from '~/components/MachinePrintSelectionModal.vue'
-import { buildMachinePrintContext, buildMachinePrintHtml } from '~/utils/printTemplates/machineReport'
 import IconLucideAlertTriangle from '~icons/lucide/alert-triangle'
 import IconLucideSquarePen from '~icons/lucide/square-pen'
 import IconLucideEye from '~icons/lucide/eye'
@@ -811,16 +836,16 @@ const machineDocumentsLoaded = ref(false)
 const machineCustomFields = ref([])
 const previewDocument = ref(null)
 const previewVisible = ref(false)
-const printModalOpen = ref(false)
-const printSelection = reactive({
-  machine: {
-    info: true,
-    customFields: true,
-    documents: true,
-  },
-  components: {},
-  pieces: {},
-})
+
+const {
+  printModalOpen,
+  printSelection,
+  ensurePrintSelectionEntries: _ensurePrintEntries,
+  setAllPrintSelection: _setAllPrint,
+  openPrintModal: _openPrintModal,
+  closePrintModal,
+  handlePrintConfirm: _handlePrintConfirm,
+} = useMachinePrint()
 
 const activeMachineView = ref('details')
 const isDetailsView = computed(() => activeMachineView.value === 'details')
@@ -900,299 +925,11 @@ const findProductById = (productId) => {
   return productById.value.get(productId) || null
 }
 
-const resolveProductReference = (source) => {
-  if (!source || typeof source !== 'object') {
-    return { product: null, productId: null }
-  }
-
-  const candidateKeys = [
-    null,
-    'productLink',
-    'machinePieceLink',
-    'machineComponentLink',
-    'machineProductLink',
-    'originalPiece',
-    'originalComposant',
-    'link',
-    'overrides',
-    'machineComponentLinkOverrides',
-    'requirement',
-    'selection',
-    'entry',
-  ]
-
-  let product = null
-  let productId = null
-
-  const inspect = (container) => {
-    if (!container || typeof container !== 'object') {
-      return
-    }
-    if (!product && container.product && typeof container.product === 'object') {
-      product = container.product
-    }
-    if (!productId) {
-      const candidate =
-        container.productId ||
-        (container.product && typeof container.product === 'object'
-          ? container.product.id || container.product.productId
-          : null) ||
-        null
-      if (candidate) {
-        productId = candidate
-      }
-    }
-  }
-
-  candidateKeys.forEach((key) => {
-    if (key === null) {
-      inspect(source)
-    } else {
-      inspect(source[key])
-    }
-  })
-
-  if (!product && productId) {
-    product = findProductById(productId) || null
-  }
-
-  if (!product && !productId && source.productName) {
-    const suppliersLabel = typeof source.constructeursLabel === 'string'
-      ? source.constructeursLabel
-      : typeof source.productSuppliers === 'string'
-        ? source.productSuppliers
-        : null
-
-    return {
-      product: {
-        name: source.productName,
-        reference: source.productReference || null,
-        typeProduct: source.productCategory
-          ? { name: source.productCategory }
-          : null,
-        constructeurs: suppliersLabel
-          ? suppliersLabel
-              .split(',')
-              .map((name) => name.trim())
-              .filter((name) => name.length > 0)
-              .map((name) => ({ name }))
-          : undefined,
-        supplierPrice:
-          source.productPrice ??
-          source.productPriceLabel ??
-          source.price ??
-          null,
-      },
-      productId: null,
-    }
-  }
-
-  if (productId && product && product.id && product.id !== productId) {
-    const resolved = findProductById(productId)
-    if (resolved) {
-      product = resolved
-    }
-  }
-
-  return { product: product || null, productId: productId || null }
-}
-
-const getProductSuppliersLabel = (product) => {
-  if (!product) {
-    return null
-  }
-  const suppliers = Array.isArray(product.constructeurs)
-    ? product.constructeurs.map((constructeur) => constructeur?.name).filter(Boolean)
-    : []
-  if (suppliers.length > 0) {
-    return suppliers.join(', ')
-  }
-  return null
-}
-
-const getProductPriceLabel = (product) => {
-  if (!product) {
-    return null
-  }
-  const priceValue =
-    product.supplierPrice ??
-    product.prix ??
-    product.price ??
-    null
-  if (priceValue === undefined || priceValue === null) {
-    return null
-  }
-  const numeric = Number(priceValue)
-  if (Number.isNaN(numeric)) {
-    return null
-  }
-  return `${numeric.toFixed(2)} €`
-}
-
-const resolveProductFromSource = (source) => resolveProductReference(source).product
-
-const getProductDisplay = (source) => {
-  if (!source || typeof source !== 'object') {
-    return null
-  }
-
-  const { product, productId } = resolveProductReference(source)
-
-  if (product) {
-    return {
-      name: product.name || product.reference || 'Produit catalogue',
-      reference: product.reference || null,
-      category: product.typeProduct?.name || null,
-      suppliers: getProductSuppliersLabel(product),
-      price: getProductPriceLabel(product),
-    }
-  }
-
-  let fallbackName =
-    source.productName ||
-    source.productLabel ||
-    source.typeProductLabel ||
-    source.typeProduct?.name ||
-    (productId ? `Produit ${productId}` : null)
-  let fallbackReference =
-    source.productReference ||
-    source.reference ||
-    null
-  let fallbackCategory =
-    source.productCategory ||
-    source.typeProductLabel ||
-    source.typeProduct?.name ||
-    null
-  let fallbackSuppliers =
-    source.productSuppliers ||
-    source.constructeursLabel ||
-    source.supplierLabel ||
-    null
-  let fallbackPrice =
-    source.productPriceLabel ||
-    source.productPrice ||
-    source.priceLabel ||
-    source.price ||
-    null
-
-  const structuralCandidates = [
-    source.products,
-    source.productSkeleton,
-    source.definition?.products,
-    source.definition?.productSkeleton,
-    source.definition?.structure?.products,
-    source.definition?.structure?.productSkeleton,
-    source.structure?.products,
-    source.structure?.productSkeleton,
-    source.requirement?.products,
-    source.requirement?.productSkeleton,
-    source.requirement?.structure?.products,
-    source.requirement?.structure?.productSkeleton,
-    source.requirement?.componentSkeleton?.products,
-    source.typeMachineComponentRequirement?.products,
-    source.typeMachineComponentRequirement?.productSkeleton,
-    source.typeMachineComponentRequirement?.structure?.products,
-    source.typeMachineComponentRequirement?.structure?.productSkeleton,
-    source.typeMachineComponentRequirement?.componentSkeleton?.products,
-    source.typeComposant?.products,
-    source.typeComposant?.productSkeleton,
-    source.typeComposant?.structure?.products,
-    source.typeComposant?.structure?.productSkeleton,
-    source.originalComposant?.products,
-    source.originalComposant?.productSkeleton,
-    source.originalComposant?.definition?.products,
-    source.originalComposant?.definition?.productSkeleton,
-    source.originalComposant?.definition?.structure?.products,
-    source.originalComposant?.definition?.structure?.productSkeleton,
-    source.originalComponent?.products,
-    source.originalComponent?.productSkeleton,
-    source.originalComponent?.definition?.products,
-    source.originalComponent?.definition?.productSkeleton,
-    source.originalComponent?.definition?.structure?.products,
-    source.originalComponent?.definition?.structure?.productSkeleton,
-  ]
-
-  const structuralProducts = structuralCandidates
-    .flatMap((candidate) => {
-      if (Array.isArray(candidate)) {
-        return candidate
-      }
-      if (candidate && typeof candidate === 'object' && Array.isArray(candidate.products)) {
-        return candidate.products
-      }
-      return []
-    })
-    .filter((entry) => entry && typeof entry === 'object')
-
-  const structuralProduct = structuralProducts.length ? structuralProducts[0] : null
-
-  const structuralFamilyCode =
-    (structuralProduct && typeof structuralProduct.familyCode === 'string'
-      ? structuralProduct.familyCode
-      : null) ||
-    (typeof source.familyCode === 'string' ? source.familyCode : null)
-
-  if (!fallbackName && structuralProduct) {
-    fallbackName =
-      structuralProduct.typeProductLabel ||
-      structuralProduct.typeProduct?.name ||
-      structuralProduct.reference ||
-      (structuralFamilyCode ? `Famille ${structuralFamilyCode}` : null) ||
-      null
-  }
-
-  if (!fallbackReference && structuralProduct?.reference) {
-    fallbackReference = structuralProduct.reference
-  }
-
-  if (!fallbackCategory) {
-    fallbackCategory =
-      structuralProduct?.typeProductLabel ||
-      structuralProduct?.typeProduct?.name ||
-      (structuralFamilyCode ? `Famille ${structuralFamilyCode}` : null) ||
-      null
-  }
-
-  if (!fallbackSuppliers && structuralProduct?.supplierLabel) {
-    fallbackSuppliers = structuralProduct.supplierLabel
-  }
-
-  if (!fallbackSuppliers && Array.isArray(structuralProduct?.constructeurs)) {
-    const supplierNames = structuralProduct.constructeurs
-      .map((constructeur) => constructeur?.name)
-      .filter((name) => typeof name === 'string' && name.trim().length > 0)
-    if (supplierNames.length) {
-      fallbackSuppliers = supplierNames.join(', ')
-    }
-  }
-
-  if (!fallbackPrice && structuralProduct?.priceLabel) {
-    fallbackPrice = structuralProduct.priceLabel
-  }
-  if (!fallbackPrice && structuralProduct?.price) {
-    fallbackPrice = structuralProduct.price
-  }
-
-  if (
-    fallbackName ||
-    fallbackReference ||
-    fallbackCategory ||
-    fallbackSuppliers ||
-    fallbackPrice
-  ) {
-    return {
-      name: fallbackName || 'Produit catalogue',
-      reference: fallbackReference,
-      category: fallbackCategory,
-      suppliers: fallbackSuppliers,
-      price: typeof fallbackPrice === 'number'
-        ? `${fallbackPrice.toFixed(2)} €`
-        : fallbackPrice || null,
-    }
-  }
-
-  return null
-}
+// Local wrappers that bind closures for imported functions
+const resolveProductReference = (source) => _resolveProductReference(source, findProductById)
+const getProductDisplay = (source) => _getProductDisplay(source, findProductById)
+// getProductSuppliersLabel → imported from productDisplayUtils
+// getProductPriceLabel → imported from productDisplayUtils
 
 const getProductOptionsForRequirement = (requirement) => {
   const requirementTypeId =
@@ -1235,64 +972,9 @@ const resolveProductRequirementTypeLabel = (requirement, entry) => {
 
 const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]'
 
-const resolveIdentifier = (...candidates) => {
-  for (const candidate of candidates) {
-    if (candidate !== undefined && candidate !== null && candidate !== '') {
-      return candidate
-    }
-  }
-  return null
-}
+// resolveIdentifier → imported from productDisplayUtils
 
-const extractParentLinkIdentifiers = (source) => {
-  if (!source || typeof source !== 'object') {
-    return {}
-  }
-
-  const identifiers = {}
-
-  const idKeys = [
-    'parentRequirementId',
-    'parentComponentRequirementId',
-    'parentPieceRequirementId',
-    'parentMachineComponentRequirementId',
-    'parentMachinePieceRequirementId',
-    'parentLinkId',
-    'parentComponentLinkId',
-    'parentPieceLinkId',
-    'parentComponentId',
-    'parentPieceId',
-  ]
-
-  idKeys.forEach((key) => {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const value = source[key]
-      if (value !== undefined && value !== null && value !== '') {
-        identifiers[key] = value
-      }
-    }
-  })
-
-  const objectKeys = [
-    'parentRequirement',
-    'parentComponentRequirement',
-    'parentPieceRequirement',
-    'parentMachineComponentRequirement',
-    'parentMachinePieceRequirement',
-  ]
-
-  objectKeys.forEach((key) => {
-    const value = source[key]
-    if (isPlainObject(value) && value.id !== undefined && value.id !== null && value.id !== '') {
-      const idKey = `${key}Id`
-      if (!Object.prototype.hasOwnProperty.call(identifiers, idKey)) {
-        identifiers[idKey] = value.id
-      }
-    }
-  })
-
-  return identifiers
-}
+// extractParentLinkIdentifiers → imported from productDisplayUtils
 
 const resolveComponentRequirementTypeLabel = (requirement, entry) => {
   const typeId = entry?.typeComposantId || requirement?.typeComposantId || null
@@ -2540,112 +2222,11 @@ const closePreview = () => {
   previewDocument.value = null
 }
 
-const ensurePrintSelectionEntries = () => {
-  printSelection.machine.info ??= true
-  printSelection.machine.customFields ??= true
-  printSelection.machine.documents ??= true
-
-  const ensureComponent = (component) => {
-    if (component?.id !== undefined && printSelection.components[component.id] === undefined) {
-      printSelection.components[component.id] = true
-    }
-    ;(component.pieces || []).forEach((piece) => {
-      if (piece?.id !== undefined && printSelection.pieces[piece.id] === undefined) {
-        printSelection.pieces[piece.id] = true
-      }
-    })
-    ;(component.subComponents || []).forEach(ensureComponent)
-  }
-
-  components.value.forEach(ensureComponent)
-  machinePieces.value.forEach((piece) => {
-    if (piece?.id !== undefined && printSelection.pieces[piece.id] === undefined) {
-      printSelection.pieces[piece.id] = true
-    }
-  })
-}
-
-const setAllPrintSelection = (value) => {
-  ensurePrintSelectionEntries()
-  printSelection.machine.info = value
-  printSelection.machine.customFields = value
-  printSelection.machine.documents = value
-  Object.keys(printSelection.components).forEach((key) => {
-    printSelection.components[key] = value
-  })
-  Object.keys(printSelection.pieces).forEach((key) => {
-    printSelection.pieces[key] = value
-  })
-}
-
-const openPrintModal = () => {
-  ensurePrintSelectionEntries()
-  printModalOpen.value = true
-}
-
-const closePrintModal = () => {
-  printModalOpen.value = false
-}
-
-const handlePrintConfirm = async () => {
-  closePrintModal()
-  await nextTick()
-  printMachine(printSelection)
-}
-
-
-const printMachine = (currentSelection = printSelection) => {
-  if (typeof window === 'undefined') return
-
-  const context = buildMachinePrintContext({
-    machine: machine.value,
-    machineName: machineName.value,
-    machineReference: machineReference.value,
-    machinePieces: machinePieces.value,
-    components: components.value,
-    selection: currentSelection,
-  })
-  const styles = Array.from(document.querySelectorAll('link[rel="stylesheet"], style'))
-    .map(node => node.outerHTML)
-    .join('')
-
-  const htmlContent = buildMachinePrintHtml(context, styles)
-
-  const iframe = document.createElement('iframe')
-  iframe.style.position = 'fixed'
-  iframe.style.right = '0'
-  iframe.style.bottom = '0'
-  iframe.style.width = '0'
-  iframe.style.height = '0'
-  iframe.style.border = '0'
-  iframe.setAttribute('title', 'print-frame')
-  document.body.appendChild(iframe)
-
-  const iframeWindow = iframe.contentWindow
-  const iframeDocument = iframe.contentDocument || iframeWindow?.document
-  if (!iframeDocument || !iframeWindow) {
-    iframe.remove()
-    return
-  }
-
-  iframeDocument.open()
-  iframeDocument.write(htmlContent)
-  iframeDocument.close()
-
-  const triggerPrint = () => {
-    iframeWindow.focus()
-    iframeWindow.print()
-    setTimeout(() => {
-      iframe.remove()
-    }, 1000)
-  }
-
-  if (iframeDocument.readyState === 'complete') {
-    setTimeout(triggerPrint, 50)
-  } else {
-    iframe.onload = () => setTimeout(triggerPrint, 50)
-  }
-}
+// Print functions → imported from useMachinePrint composable
+const ensurePrintSelectionEntries = () => _ensurePrintEntries(components.value, machinePieces.value)
+const setAllPrintSelection = (value) => _setAllPrint(value, components.value, machinePieces.value)
+const openPrintModal = () => _openPrintModal(components.value, machinePieces.value)
+const handlePrintConfirm = () => _handlePrintConfirm(machine.value, machineName.value, machineReference.value, machinePieces.value, components.value)
 
 const formatSize = (size) => {
   if (size === undefined || size === null) return '—'
@@ -2695,49 +2276,7 @@ const documentThumbnailClass = (document) => {
   return 'h-16 w-16'
 }
 
-const formatCustomFieldValue = (field) => {
-  if (!field) {
-    return 'Non défini'
-  }
-
-  const value = field.value ?? field.defaultValue ?? ''
-  if (value === '' || value === null || value === undefined) {
-    return 'Non défini'
-  }
-
-  if (field.type === 'boolean') {
-    const normalized = String(value).toLowerCase()
-    if (normalized === 'true' || normalized === '1') return 'Oui'
-    if (normalized === 'false' || normalized === '0') return 'Non'
-  }
-
-  return String(value)
-}
-
-const shouldDisplayCustomField = (field) => {
-  if (!field) {
-    return false
-  }
-
-  if (field.readOnly) {
-    return true
-  }
-
-  if (field.type === 'boolean') {
-    return field.value !== undefined && field.value !== null
-  }
-
-  const value = field.value
-  if (value === null || value === undefined) {
-    return false
-  }
-
-  if (typeof value === 'string') {
-    return value.trim().length > 0
-  }
-
-  return true
-}
+// formatCustomFieldValue, shouldDisplayCustomField → imported from customFieldUtils
 
 const visibleMachineCustomFields = computed(() => {
   const fields = Array.isArray(machineCustomFields.value) ? machineCustomFields.value : []
@@ -2747,204 +2286,27 @@ const visibleMachineCustomFields = computed(() => {
   return fields.filter((field) => shouldDisplayCustomField(field))
 })
 
-const summarizeCustomFields = (fields = []) => {
-  const seen = new Set()
-  return fields
-    .slice()
-    .sort((a, b) => {
-      const left = typeof a?.orderIndex === 'number' ? a.orderIndex : 0
-      const right = typeof b?.orderIndex === 'number' ? b.orderIndex : 0
-      return left - right
-    })
-    .filter(shouldDisplayCustomField)
-    .filter((field) => {
-      const key = field.customFieldId || field.id || field.name
-      if (!key) {
-        return true
-      }
-      if (seen.has(key)) {
-        return false
-      }
-      seen.add(key)
-      return true
-    })
-    .map((field, index) => ({
-      key: field.customFieldId || field.id || field.name || `custom-field-${index}`,
-      label: field.name || 'Champ',
-      value: formatCustomFieldValue(field),
-    }))
-}
+// summarizeCustomFields → imported from customFieldUtils
 
-const extractDefinitionName = (definition = {}) => {
-  if (typeof definition?.name === 'string' && definition.name.trim()) {
-    return definition.name.trim()
-  }
-  if (typeof definition?.key === 'string' && definition.key.trim()) {
-    return definition.key.trim()
-  }
-  if (typeof definition?.label === 'string' && definition.label.trim()) {
-    return definition.label.trim()
-  }
-  return ''
-}
+// extractDefinitionName, extractDefinitionType, extractDefinitionRequired,
+// extractOptionList, extractDefinitionOptions, extractDefinitionDefaultValue,
+// coerceValueForType, normalizeExistingCustomFieldDefinitions,
+// normalizeCustomFieldDefinitionEntry
+// → all imported from customFieldUtils
 
-const extractDefinitionType = (definition = {}, fallback = 'text') => {
-  const allowed = ['text', 'number', 'select', 'boolean', 'date']
-  const rawType =
-    typeof definition?.type === 'string'
-      ? definition.type
-      : typeof definition?.value?.type === 'string'
-        ? definition.value.type
-        : typeof fallback === 'string'
-          ? fallback
-          : 'text'
-  const normalized = rawType.toLowerCase()
-  return allowed.includes(normalized) ? normalized : 'text'
-}
+// extractDefinitionRequired → imported from customFieldUtils
 
-const extractDefinitionRequired = (definition = {}, fallback = false) => {
-  if (typeof definition?.required === 'boolean') {
-    return definition.required
-  }
-  const nested = definition?.value?.required
-  if (typeof nested === 'boolean') {
-    return nested
-  }
-  if (typeof nested === 'string') {
-    const normalized = nested.toLowerCase()
-    if (normalized === 'true' || normalized === '1') {
-      return true
-    }
-    if (normalized === 'false' || normalized === '0') {
-      return false
-    }
-  }
-  return !!fallback
-}
+// extractOptionList → imported from customFieldUtils
 
-const extractOptionList = (input) => {
-  if (!Array.isArray(input)) {
-    return undefined
-  }
-  const mapped = input
-    .map((option) => {
-      if (option === null || option === undefined) {
-        return ''
-      }
-      if (typeof option === 'string') {
-        return option.trim()
-      }
-      if (typeof option === 'object') {
-        const record = option || {}
-        const keys = ['value', 'label', 'name']
-        for (const key of keys) {
-          const candidate = record[key]
-          if (typeof candidate === 'string' && candidate.trim().length > 0) {
-            return candidate.trim()
-          }
-        }
-      }
-      const fallback = String(option).trim()
-      return fallback === '[object Object]' ? '' : fallback
-    })
-    .filter((option) => option.length > 0)
-  return mapped.length ? mapped : undefined
-}
+// extractDefinitionOptions → imported from customFieldUtils
 
-const extractDefinitionOptions = (definition = {}) => {
-  const sources = [definition?.options, definition?.value?.options, definition?.value?.choices]
-  for (const source of sources) {
-    const list = extractOptionList(source)
-    if (list) {
-      return list
-    }
-  }
-  return []
-}
+// extractDefinitionDefaultValue → imported from customFieldUtils
 
-const extractDefinitionDefaultValue = (definition = {}) => {
-  const candidates = [
-    definition?.defaultValue,
-    definition?.value?.defaultValue,
-    definition?.value?.value,
-    definition?.value,
-    definition?.default,
-  ]
-  for (const candidate of candidates) {
-    if (candidate === undefined || candidate === null || candidate === '') {
-      continue
-    }
-    if (typeof candidate === 'object') {
-      if (candidate === null) {
-        continue
-      }
-      if (candidate && typeof candidate === 'object') {
-        const nestedDefault =
-          candidate.defaultValue !== undefined && candidate.defaultValue !== null
-            ? candidate.defaultValue
-            : candidate.value
-        if (nestedDefault !== undefined && nestedDefault !== null && nestedDefault !== '') {
-          return nestedDefault
-        }
-      }
-      continue
-    }
-    return candidate
-  }
-  return undefined
-}
+// coerceValueForType → imported from customFieldUtils
 
-const coerceValueForType = (type, rawValue) => {
-  if (rawValue === undefined || rawValue === null || rawValue === '') {
-    return ''
-  }
-  if (type === 'boolean') {
-    const normalized = String(rawValue).toLowerCase()
-    if (normalized === 'true' || normalized === '1') {
-      return 'true'
-    }
-    if (normalized === 'false' || normalized === '0') {
-      return 'false'
-    }
-    return ''
-  }
-  return String(rawValue)
-}
+// normalizeExistingCustomFieldDefinitions → imported from customFieldUtils
 
-const normalizeExistingCustomFieldDefinitions = (fields) => {
-  if (!Array.isArray(fields)) {
-    return []
-  }
-  return fields
-    .map((field, index) => normalizeCustomFieldDefinitionEntry(field, index))
-    .filter((definition) => definition !== null)
-    .sort((a, b) => (a.orderIndex ?? 0) - (b.orderIndex ?? 0))
-}
-
-const normalizeCustomFieldDefinitionEntry = (definition = {}, fallbackIndex = 0) => {
-  const name = extractDefinitionName(definition)
-  if (!name) {
-    return null
-  }
-  const type = extractDefinitionType(definition)
-  const required = extractDefinitionRequired(definition)
-  const options = extractDefinitionOptions(definition)
-  const defaultValue = extractDefinitionDefaultValue(definition)
-  const id = typeof definition?.id === 'string' ? definition.id : undefined
-  const customFieldId = typeof definition?.customFieldId === 'string' ? definition.customFieldId : id
-  const orderIndex = typeof definition?.orderIndex === 'number' ? definition.orderIndex : fallbackIndex
-  return {
-    id,
-    customFieldId,
-    name,
-    type,
-    required,
-    options,
-    defaultValue,
-    readOnly: !!definition?.readOnly,
-    orderIndex,
-  }
-}
+// normalizeCustomFieldDefinitionEntry → imported from customFieldUtils
 
 const getStructureCustomFields = (structure) => {
   if (!structure || typeof structure !== 'object') {
@@ -2954,236 +2316,11 @@ const getStructureCustomFields = (structure) => {
   return Array.isArray(normalized.customFields) ? normalized.customFields : []
 }
 
-// Transform custom field values to custom fields format
-const normalizeCustomFieldValueEntry = (entry = {}) => {
-  if (!entry || typeof entry !== 'object') {
-    return null
-  }
+// normalizeCustomFieldValueEntry → imported from customFieldUtils
 
-  const normalizedDefinition = normalizeCustomFieldDefinitionEntry(entry)
-  if (!normalizedDefinition) {
-    return null
-  }
+// mergeCustomFieldValuesWithDefinitions → imported from customFieldUtils
 
-  const value = coerceValueForType(
-    normalizedDefinition.type,
-    entry?.value ?? entry?.defaultValue ?? normalizedDefinition.defaultValue ?? '',
-  )
-
-  return {
-    id: entry?.customFieldValueId ?? entry?.id ?? null,
-    customFieldId:
-      entry?.customFieldId
-      ?? normalizedDefinition.customFieldId
-      ?? normalizedDefinition.id
-      ?? null,
-    customField: {
-      id: normalizedDefinition.id ?? normalizedDefinition.customFieldId ?? null,
-      name: normalizedDefinition.name,
-      type: normalizedDefinition.type,
-      required: normalizedDefinition.required,
-      options: normalizedDefinition.options,
-      defaultValue: normalizedDefinition.defaultValue ?? '',
-    },
-    value,
-  }
-}
-
-const mergeCustomFieldValuesWithDefinitions = (valueEntries = [], ...definitionSources) => {
-  const normalizedValues = (Array.isArray(valueEntries) ? valueEntries : [])
-    .map((entry) => {
-      if (!entry || typeof entry !== 'object') {
-        return null
-      }
-
-      const normalizedDefinition = normalizeCustomFieldDefinitionEntry(entry.customField || entry)
-      if (!normalizedDefinition) {
-        return null
-      }
-
-      const value = coerceValueForType(
-        normalizedDefinition.type,
-        entry?.value ?? entry?.defaultValue ?? normalizedDefinition.defaultValue ?? '',
-      )
-
-      return {
-        customFieldValueId: entry?.id ?? entry?.customFieldValueId ?? null,
-        id: normalizedDefinition.id,
-        customFieldId: normalizedDefinition.customFieldId ?? normalizedDefinition.id ?? null,
-        name: normalizedDefinition.name,
-        type: normalizedDefinition.type,
-        required: normalizedDefinition.required,
-        options: normalizedDefinition.options,
-        optionsText: normalizedDefinition.options?.length ? normalizedDefinition.options.join('\n') : '',
-        defaultValue: normalizedDefinition.defaultValue ?? '',
-        value,
-        readOnly: !!entry?.readOnly,
-      }
-    })
-    .filter((entry) => entry !== null)
-
-  const result = [...normalizedValues]
-  const keyFor = (item) => item?.id ?? `${item?.name ?? ''}::${item?.type ?? ''}`
-  const existingMap = new Map()
-  result.forEach((item) => {
-    const key = keyFor(item)
-    if (key) {
-      existingMap.set(key, item)
-    }
-    const fallbackKey = item?.name ? `${item.name}::${item.type ?? ''}` : null
-    if (fallbackKey) {
-      existingMap.set(fallbackKey, item)
-    }
-  })
-
-  const definitions = definitionSources
-    .flatMap((source) => (Array.isArray(source) ? source : []))
-    .map((definition) => normalizeCustomFieldDefinitionEntry(definition))
-    .filter((definition) => definition !== null)
-
-  const allowedKeys = new Set()
-  definitions.forEach((definition) => {
-    if (!definition) {
-      return
-    }
-    if (definition.id) {
-      allowedKeys.add(definition.id)
-    }
-    if (definition.customFieldId) {
-      allowedKeys.add(definition.customFieldId)
-    }
-    if (definition.name) {
-      allowedKeys.add(`${definition.name}::${definition.type}`)
-    }
-  })
-
-  definitions.forEach((normalizedDefinition) => {
-    const key = normalizedDefinition.id ?? `${normalizedDefinition.name}::${normalizedDefinition.type}`
-    if (!key) {
-      return
-    }
-    if (normalizedDefinition.id) {
-      const fallbackKey = `${normalizedDefinition.name}::${normalizedDefinition.type}`
-      if (existingMap.has(fallbackKey)) {
-        const existingFallback = existingMap.get(fallbackKey)
-      if (existingFallback) {
-        existingFallback.id = existingFallback.id || normalizedDefinition.id
-        existingFallback.customFieldId = normalizedDefinition.id
-        existingFallback.readOnly = existingFallback.readOnly && normalizedDefinition.readOnly
-        existingMap.delete(fallbackKey)
-        existingMap.set(normalizedDefinition.id, existingFallback)
-        existingMap.set(fallbackKey, existingFallback)
-        return
-      }
-    }
-    }
-    const existing = existingMap.get(key) || (normalizedDefinition.name
-      ? existingMap.get(`${normalizedDefinition.name}::${normalizedDefinition.type}`)
-      : null)
-    if (existing) {
-      existing.name = existing.name || normalizedDefinition.name
-      existing.type = existing.type || normalizedDefinition.type
-      existing.required = existing.required || normalizedDefinition.required
-      if (!existing.options?.length && normalizedDefinition.options?.length) {
-        existing.options = normalizedDefinition.options
-      }
-      if (!existing.defaultValue && normalizedDefinition.defaultValue) {
-        existing.defaultValue = String(normalizedDefinition.defaultValue)
-        if (!existing.value) {
-          existing.value = coerceValueForType(existing.type, normalizedDefinition.defaultValue)
-        }
-      }
-      existing.customFieldId = existing.customFieldId || normalizedDefinition.id
-      existing.readOnly = existing.readOnly && normalizedDefinition.readOnly
-      if (!existing.optionsText && normalizedDefinition.options?.length) {
-        existing.optionsText = normalizedDefinition.options.join('\n')
-      }
-      if (normalizedDefinition.id) {
-        existingMap.set(normalizedDefinition.id, existing)
-      }
-      if (normalizedDefinition.name) {
-        existingMap.set(`${normalizedDefinition.name}::${normalizedDefinition.type}`, existing)
-      }
-      return
-    }
-
-    const entry = {
-      customFieldValueId: null,
-      id: normalizedDefinition.id,
-      customFieldId: normalizedDefinition.id,
-      name: normalizedDefinition.name,
-      type: normalizedDefinition.type,
-      required: normalizedDefinition.required,
-      options: normalizedDefinition.options,
-      optionsText: normalizedDefinition.options?.length ? normalizedDefinition.options.join('\n') : '',
-      defaultValue: normalizedDefinition.defaultValue ?? '',
-      value: coerceValueForType(normalizedDefinition.type, normalizedDefinition.defaultValue ?? ''),
-      readOnly: false,
-    }
-    result.push(entry)
-    existingMap.set(key, entry)
-    const fallbackKey = entry.name ? `${entry.name}::${entry.type}` : null
-    if (fallbackKey) {
-      existingMap.set(fallbackKey, entry)
-    }
-  })
-
-  return result
-}
-
-const dedupeCustomFieldEntries = (fields) => {
-  if (!Array.isArray(fields) || fields.length <= 1) {
-    return Array.isArray(fields) ? fields : []
-  }
-
-  const seen = new Set()
-  const result = []
-
-  for (const field of fields) {
-    if (!field) {
-      continue
-    }
-
-    field.type = field.type || 'text'
-
-    let normalizedName =
-      typeof field.name === 'string' ? field.name.trim() : ''
-
-    if (!normalizedName && field.customField?.name) {
-      normalizedName = String(field.customField.name).trim()
-      field.name = normalizedName
-    } else if (typeof field.name === 'string') {
-      field.name = normalizedName
-    }
-
-    const key =
-      field.customFieldId ||
-      field.id ||
-      (normalizedName ? `${normalizedName}::${field.type || 'text'}` : null)
-
-    if (!key && !normalizedName) {
-      continue
-    }
-
-    if (key && seen.has(key)) {
-      continue
-    }
-
-    if (!normalizedName) {
-      continue
-    }
-
-    if (key) {
-      seen.add(key)
-    }
-    if (normalizedName) {
-      seen.add(`${normalizedName}::${field.type || 'text'}`)
-    }
-    result.push(field)
-  }
-
-  return result
-}
+// dedupeCustomFieldEntries → imported from customFieldUtils
 
 const transformCustomFields = (pieces) => {
   return (pieces || []).map((piece) => {
@@ -3423,466 +2560,10 @@ const syncMachineCustomFields = () => {
   machineCustomFields.value = merged
 }
 
-function mergePieceLists(existing = [], updates = []) {
-  if (!existing.length) {
-    return updates.map(piece => ({
-      ...piece,
-      constructeurs: piece.constructeurs || [],
-    }))
-  }
-  if (!updates.length) {
-    return existing.map(piece => ({
-      ...piece,
-      constructeurs: piece.constructeurs || [],
-    }))
-  }
+// mergePieceLists, mergeComponentTrees → imported from useMachineHierarchy
+// buildMachineHierarchyFromLinks → imported from useMachineHierarchy
 
-  const updateMap = new Map(
-    updates.map(piece => [
-      piece.id,
-      {
-        ...piece,
-        constructeurs: piece.constructeurs || [],
-      },
-    ]),
-  )
-  const merged = existing.map(piece => {
-    const update = updateMap.get(piece.id)
-    if (!update) {
-      return piece
-    }
-    return {
-      ...piece,
-      ...update,
-      customFields: update.customFields ?? piece.customFields,
-    }
-  })
-
-  updates.forEach(update => {
-    if (!existing.some(piece => piece.id === update.id)) {
-      merged.push(update)
-    }
-  })
-
-  return merged
-}
-
-function mergeComponentTrees(existing = [], updates = []) {
-  if (!existing.length) {
-    return updates.map(component => ({
-      ...component,
-      constructeurs: component.constructeurs || [],
-      pieces: (component.pieces || []).map(piece => ({
-        ...piece,
-        constructeurs: piece.constructeurs || [],
-      })),
-      subComponents: mergeComponentTrees([], component.subComponents || []),
-    }))
-  }
-  if (!updates.length) {
-    return existing
-  }
-
-  const updateMap = new Map(
-    updates.map(component => [
-      component.id,
-      {
-        ...component,
-        constructeurs: component.constructeurs || [],
-        pieces: (component.pieces || []).map(piece => ({
-          ...piece,
-          constructeurs: piece.constructeurs || [],
-        })),
-        subComponents: mergeComponentTrees([], component.subComponents || []),
-      },
-    ]),
-  )
-  const merged = existing.map(component => {
-    const update = updateMap.get(component.id)
-    if (!update) {
-      return {
-        ...component,
-        constructeurs: component.constructeurs || [],
-        pieces: mergePieceLists(component.pieces || [], []),
-        subComponents: mergeComponentTrees(component.subComponents || [], []),
-      }
-    }
-    return {
-      ...component,
-      ...update,
-      customFields: update.customFields ?? component.customFields,
-      pieces: mergePieceLists(component.pieces || [], update.pieces || []),
-      subComponents: mergeComponentTrees(component.subComponents || [], update.subComponents || []),
-    }
-  })
-
-  updates.forEach(update => {
-    if (!existing.some(component => component.id === update.id)) {
-      merged.push(update)
-    }
-  })
-
-  return merged
-}
-
-const buildMachineHierarchyFromLinks = (componentLinks = [], pieceLinks = []) => {
-  const normalizeComponentLinkId = (link) =>
-    resolveIdentifier(link?.id, link?.linkId, link?.machineComponentLinkId)
-
-  const normalizePieceLinkId = (link) =>
-    resolveIdentifier(link?.id, link?.linkId, link?.machinePieceLinkId)
-
-  const createPieceNode = (link, parentComponentName = null) => {
-    if (!link || typeof link !== 'object') {
-      return null
-    }
-
-    const appliedPiece =
-      (link.piece && typeof link.piece === 'object' && link.piece) || {}
-    const originalPiece =
-      (link.originalPiece && typeof link.originalPiece === 'object' && link.originalPiece) || null
-
-    const requirement =
-      link.typeMachinePieceRequirement ||
-      appliedPiece.typeMachinePieceRequirement ||
-      originalPiece?.typeMachinePieceRequirement ||
-      null
-
-    const machinePieceLinkId = normalizePieceLinkId(link)
-    const pieceId = resolveIdentifier(appliedPiece.id, appliedPiece.pieceId, link.pieceId)
-
-    const basePiece = {
-      ...appliedPiece,
-      id: appliedPiece.id || pieceId || machinePieceLinkId || `piece-${machinePieceLinkId}`,
-      pieceId,
-      name:
-        link.overrides?.name ||
-        appliedPiece.name ||
-        appliedPiece.definition?.name ||
-        appliedPiece.definition?.role ||
-        originalPiece?.name ||
-        'Pièce',
-      reference:
-        link.overrides?.reference ||
-        appliedPiece.reference ||
-        appliedPiece.definition?.reference ||
-        originalPiece?.reference ||
-        null,
-      prix:
-        link.overrides?.prix ??
-        appliedPiece.prix ??
-        originalPiece?.prix ??
-        null,
-      constructeur:
-        appliedPiece.constructeur ||
-        originalPiece?.constructeur ||
-        null,
-      constructeurId:
-        appliedPiece.constructeurId ||
-        appliedPiece.constructeur?.id ||
-        originalPiece?.constructeurId ||
-        null,
-      documents:
-        Array.isArray(appliedPiece.documents)
-          ? appliedPiece.documents
-          : Array.isArray(originalPiece?.documents)
-            ? originalPiece.documents
-            : [],
-      typePiece: appliedPiece.typePiece || requirement?.typePiece || null,
-      typePieceId:
-        appliedPiece.typePieceId ||
-        appliedPiece.typePiece?.id ||
-        requirement?.typePieceId ||
-        requirement?.typePiece?.id ||
-        null,
-      typeMachinePieceRequirement: requirement,
-      typeMachinePieceRequirementId: requirement?.id || null,
-      requirementId: requirement?.id || null,
-      overrides: link.overrides || null,
-      originalPiece,
-      machinePieceLink: link,
-      machinePieceLinkId,
-      linkId: machinePieceLinkId,
-      parentComponentLinkId: resolveIdentifier(
-        link.parentComponentLinkId,
-        link.parentLinkId,
-        link.parentMachineComponentLinkId,
-        appliedPiece.parentComponentLinkId,
-      ),
-      parentComponentId: resolveIdentifier(
-        appliedPiece.parentComponentId,
-        link.parentComponentId,
-      ),
-      parentComponentName,
-      parentLinkId: resolveIdentifier(
-        link.parentLinkId,
-        link.parentMachinePieceLinkId,
-        appliedPiece.parentLinkId,
-      ),
-      parentPieceLinkId: resolveIdentifier(
-        link.parentPieceLinkId,
-        appliedPiece.parentPieceLinkId,
-      ),
-      parentPieceId: resolveIdentifier(
-        appliedPiece.parentPieceId,
-        link.parentPieceId,
-      ),
-      parentMachineComponentRequirementId: resolveIdentifier(
-        appliedPiece.parentMachineComponentRequirementId,
-        link.parentMachineComponentRequirementId,
-      ),
-      parentMachinePieceRequirementId: resolveIdentifier(
-        appliedPiece.parentMachinePieceRequirementId,
-        link.parentMachinePieceRequirementId,
-      ),
-      definition: appliedPiece.definition || originalPiece?.definition || {},
-      customFields: appliedPiece.customFields || [],
-      skeletonOnly: !pieceId,
-    }
-
-    const resolvedProductId = resolveIdentifier(
-      appliedPiece.productId,
-      appliedPiece.product?.id,
-      link.productId,
-      link.product?.id,
-      originalPiece?.productId,
-      originalPiece?.product?.id,
-    )
-
-    const resolvedProduct =
-      appliedPiece.product ||
-      link.product ||
-      originalPiece?.product ||
-      (resolvedProductId ? findProductById(resolvedProductId) : null) ||
-      null
-
-    const constructeurs = collectConstructeurs(
-      appliedPiece.constructeurs,
-      appliedPiece.constructeur,
-      appliedPiece.constructeurIds,
-      appliedPiece.constructeurId,
-      originalPiece?.constructeurs,
-      originalPiece?.constructeur,
-      originalPiece?.constructeurIds,
-      originalPiece?.constructeurId,
-    )
-
-    return {
-      ...basePiece,
-      constructeurs,
-      constructeur: constructeurs[0] || basePiece.constructeur || null,
-      constructeurId: constructeurs[0]?.id || basePiece.constructeurId || null,
-      productId: resolvedProductId || appliedPiece.productId || null,
-      product: resolvedProduct || appliedPiece.product || null,
-      __productDisplay: getProductDisplay({
-        product: resolvedProduct || appliedPiece.product || null,
-        productId: resolvedProductId || appliedPiece.productId || null,
-      }),
-    }
-  }
-
-  const createComponentNode = (link) => {
-    if (!link || typeof link !== 'object') {
-      return null
-    }
-
-    const appliedComponent =
-      (link.composant && typeof link.composant === 'object' && link.composant) || {}
-    const originalComponent =
-      (link.originalComposant && typeof link.originalComposant === 'object' && link.originalComposant) || null
-
-    const requirement =
-      link.typeMachineComponentRequirement ||
-      appliedComponent.typeMachineComponentRequirement ||
-      originalComponent?.typeMachineComponentRequirement ||
-      null
-
-    const machineComponentLinkId = normalizeComponentLinkId(link)
-    const composantId = resolveIdentifier(
-      appliedComponent.id,
-      appliedComponent.composantId,
-      link.composantId,
-    )
-
-    const componentName =
-      link.overrides?.name ||
-      appliedComponent.name ||
-      appliedComponent.definition?.alias ||
-      appliedComponent.definition?.name ||
-      originalComponent?.name ||
-      'Composant'
-
-    const pieces = Array.isArray(link.pieceLinks)
-      ? link.pieceLinks.map((pieceLink) => createPieceNode(pieceLink, componentName)).filter(Boolean)
-      : []
-
-    const subComponents = Array.isArray(link.childLinks)
-      ? link.childLinks.map(createComponentNode).filter(Boolean)
-      : []
-
-    const resolvedProductId = resolveIdentifier(
-      appliedComponent.productId,
-      appliedComponent.product?.id,
-      link.productId,
-      link.product?.id,
-      originalComponent?.productId,
-      originalComponent?.product?.id,
-    )
-
-    const resolvedProduct =
-      appliedComponent.product ||
-      link.product ||
-      originalComponent?.product ||
-      (resolvedProductId ? findProductById(resolvedProductId) : null) ||
-      null
-
-    const baseComponent = {
-      ...appliedComponent,
-      id: appliedComponent.id || composantId || machineComponentLinkId || `component-${machineComponentLinkId}`,
-      composantId,
-      name: componentName,
-      reference:
-        link.overrides?.reference ||
-        appliedComponent.reference ||
-        appliedComponent.definition?.reference ||
-        originalComponent?.reference ||
-        null,
-      prix:
-        link.overrides?.prix ??
-        appliedComponent.prix ??
-        originalComponent?.prix ??
-        null,
-      constructeur:
-        appliedComponent.constructeur ||
-        originalComponent?.constructeur ||
-        null,
-      constructeurId:
-        appliedComponent.constructeurId ||
-        appliedComponent.constructeur?.id ||
-        originalComponent?.constructeurId ||
-        null,
-      documents:
-        Array.isArray(appliedComponent.documents)
-          ? appliedComponent.documents
-          : Array.isArray(originalComponent?.documents)
-            ? originalComponent.documents
-            : [],
-      typeComposant:
-        appliedComponent.typeComposant ||
-        requirement?.typeComposant ||
-        null,
-      typeComposantId:
-        appliedComponent.typeComposantId ||
-        appliedComponent.typeComposant?.id ||
-        requirement?.typeComposantId ||
-        requirement?.typeComposant?.id ||
-        null,
-      typeMachineComponentRequirement: requirement,
-      typeMachineComponentRequirementId: requirement?.id || null,
-      requirementId: requirement?.id || null,
-      overrides: link.overrides || null,
-      machineComponentLinkOverrides: link.overrides || null,
-      definitionOverrides: link.overrides || null,
-      originalComposant: originalComponent,
-      machineComponentLink: link,
-      machineComponentLinkId,
-      componentLinkId: machineComponentLinkId,
-      parentComponentLinkId: resolveIdentifier(
-        link.parentComponentLinkId,
-        link.parentLinkId,
-        link.parentMachineComponentLinkId,
-        appliedComponent.parentComponentLinkId,
-      ),
-      parentComposantId: resolveIdentifier(
-        appliedComponent.parentComposantId,
-        link.parentComponentId,
-      ),
-      parentRequirementId: resolveIdentifier(
-        appliedComponent.parentRequirementId,
-        link.parentRequirementId,
-      ),
-      parentMachineComponentRequirementId: resolveIdentifier(
-        appliedComponent.parentMachineComponentRequirementId,
-        link.parentMachineComponentRequirementId,
-      ),
-      parentMachinePieceRequirementId: resolveIdentifier(
-        appliedComponent.parentMachinePieceRequirementId,
-        link.parentMachinePieceRequirementId,
-      ),
-      definition: appliedComponent.definition || originalComponent?.definition || {},
-      customFields: appliedComponent.customFields || [],
-      pieces,
-      subComponents,
-      subcomponents: subComponents,
-      sousComposants: subComponents,
-      skeletonOnly: !composantId,
-    }
-
-    const constructeurs = collectConstructeurs(
-      appliedComponent.constructeurs,
-      appliedComponent.constructeur,
-      appliedComponent.constructeurIds,
-      appliedComponent.constructeurId,
-      originalComponent?.constructeurs,
-      originalComponent?.constructeur,
-      originalComponent?.constructeurIds,
-      originalComponent?.constructeurId,
-    )
-
-    return {
-      ...baseComponent,
-      constructeurs,
-      constructeur: constructeurs[0] || baseComponent.constructeur || null,
-      constructeurId: constructeurs[0]?.id || baseComponent.constructeurId || null,
-      productId: resolvedProductId || appliedComponent.productId || null,
-      product: resolvedProduct || appliedComponent.product || null,
-      __productDisplay: getProductDisplay({
-        product: resolvedProduct || appliedComponent.product || null,
-        productId: resolvedProductId || appliedComponent.productId || null,
-      }),
-    }
-  }
-
-  const rootComponents = (Array.isArray(componentLinks) ? componentLinks : [])
-    .filter((link) =>
-      !resolveIdentifier(
-        link?.parentComponentLinkId,
-        link?.parentLinkId,
-        link?.parentMachineComponentLinkId,
-      ),
-    )
-    .map(createComponentNode)
-    .filter(Boolean)
-
-  const machinePieces = (Array.isArray(pieceLinks) ? pieceLinks : [])
-    .filter((link) =>
-      !resolveIdentifier(
-        link?.parentComponentLinkId,
-        link?.parentLinkId,
-        link?.parentMachineComponentLinkId,
-      ),
-    )
-    .map((link) => createPieceNode(link, null))
-    .filter(Boolean)
-
-  return {
-    components: rootComponents,
-    machinePieces,
-  }
-}
-
-const resolveLinkArray = (source, keys) => {
-  if (!source || typeof source !== 'object') {
-    return null
-  }
-  for (const key of keys) {
-    const value = source[key]
-    if (Array.isArray(value)) {
-      return value
-    }
-  }
-  return null
-}
+// resolveLinkArray → imported from useMachineHierarchy
 
 const applyMachineLinks = (source) => {
   const container = source?.machine ?? null
@@ -3909,7 +2590,7 @@ const applyMachineLinks = (source) => {
   machineProductLinks.value = normalizedProductLinks
 
   const { components: hierarchy, machinePieces: machineLevelPieces } =
-    buildMachineHierarchyFromLinks(normalizedComponentLinks, normalizedPieceLinks)
+    buildMachineHierarchyFromLinks(normalizedComponentLinks, normalizedPieceLinks, findProductById, constructeurs.value)
 
   components.value = transformComponentCustomFields(hierarchy)
   pieces.value = transformCustomFields(machineLevelPieces)