diff --git a/app/[locale]/products/[...slug]/page.tsx b/app/[locale]/products/[...slug]/page.tsx
index 94f7964f..d58e4892 100644
--- a/app/[locale]/products/[...slug]/page.tsx
+++ b/app/[locale]/products/[...slug]/page.tsx
@@ -499,9 +499,14 @@ export default async function ProductPage({ params }: ProductPageProps) {
                   </h2>
                   <div className="h-1.5 w-24 bg-accent rounded-full" />
                 </div>
-                <div className="flex flex-col gap-4 max-w-2xl">
-                  <DatasheetDownload datasheetPath={datasheetPath} className="mt-0" />
-                  {excelPath && <ExcelDownload excelPath={excelPath} className="mt-0" />}
+                <div className="flex flex-row flex-wrap items-center gap-4 max-w-2xl">
+                  <DatasheetDownload
+                    datasheetPath={datasheetPath}
+                    className="mt-0 w-full sm:w-auto"
+                  />
+                  {excelPath && (
+                    <ExcelDownload excelPath={excelPath} className="mt-0 w-full sm:w-auto" />
+                  )}
                 </div>
               </div>
             )}
diff --git a/app/actions/brochure.ts b/app/actions/brochure.ts
index c5397624..a8a25a8a 100644
--- a/app/actions/brochure.ts
+++ b/app/actions/brochure.ts
@@ -23,6 +23,14 @@ export async function requestBrochureAction(formData: FormData) {
   const email = formData.get('email') as string;
   const locale = (formData.get('locale') as string) || 'en';
 
+  // Anti-spam Honeypot Check
+  const honeypot = formData.get('company_website') as string;
+  if (honeypot) {
+    logger.warn('Spam detected via honeypot in brochure request', { email });
+    // Silently succeed to fool the bot without doing actual work
+    return { success: true };
+  }
+
   if (!email) {
     logger.warn('Missing email in brochure request');
     return { success: false, error: 'Missing email address' };
@@ -77,7 +85,7 @@ export async function requestBrochureAction(formData: FormData) {
 
     const html = await render(
       React.createElement(BrochureDeliveryEmail, {
-        email,
+        _email: email,
         brochureUrl,
         locale: locale as 'en' | 'de',
       }),
diff --git a/app/actions/contact.ts b/app/actions/contact.ts
index f1ee3c57..2e692761 100644
--- a/app/actions/contact.ts
+++ b/app/actions/contact.ts
@@ -25,6 +25,14 @@ export async function sendContactFormAction(formData: FormData) {
   // Track attempt
   services.analytics.track('contact-form-attempt');
 
+  // Anti-spam Honeypot Check
+  const honeypot = formData.get('company_website') as string;
+  if (honeypot) {
+    logger.warn('Spam detected via honeypot in contact request', { email: formData.get('email') });
+    // Silently succeed to fool the bot without doing actual work
+    return { success: true };
+  }
+
   const name = formData.get('name') as string;
   const email = formData.get('email') as string;
   const message = formData.get('message') as string;
diff --git a/components/ContactForm.tsx b/components/ContactForm.tsx
index 47116404..87c44bdf 100644
--- a/components/ContactForm.tsx
+++ b/components/ContactForm.tsx
@@ -139,6 +139,15 @@ export default function ContactForm() {
         {t('form.title')}
       </Heading>
       <form onSubmit={handleSubmit} className="grid grid-cols-1 md:grid-cols-2 gap-4 md:gap-8">
+        {/* Anti-spam Honeypot */}
+        <input
+          type="text"
+          name="company_website"
+          tabIndex={-1}
+          autoComplete="off"
+          style={{ display: 'none' }}
+          aria-hidden="true"
+        />
         <div className="space-y-1 md:space-y-2">
           <Label htmlFor="contact-name">{t('form.name')}</Label>
           <Input
diff --git a/components/FooterBrochureForm.tsx b/components/FooterBrochureForm.tsx
index 85b1ddbe..6a3eadef 100644
--- a/components/FooterBrochureForm.tsx
+++ b/components/FooterBrochureForm.tsx
@@ -93,6 +93,16 @@ export default function FooterBrochureForm({ className }: Props) {
         onSubmit={handleSubmit}
         className="w-full md:w-auto flex flex-col sm:flex-row gap-3"
       >
+        {/* Anti-spam Honeypot */}
+        <input
+          type="text"
+          name="company_website"
+          tabIndex={-1}
+          autoComplete="off"
+          style={{ display: 'none' }}
+          aria-hidden="true"
+        />
+
         <div className="relative w-full sm:w-64">
           <input
             name="email"
diff --git a/components/RequestQuoteForm.tsx b/components/RequestQuoteForm.tsx
index 57ebee05..976f9639 100644
--- a/components/RequestQuoteForm.tsx
+++ b/components/RequestQuoteForm.tsx
@@ -165,6 +165,16 @@ export default function RequestQuoteForm({ productName }: RequestQuoteFormProps)
 
   return (
     <form onSubmit={handleSubmit} className="space-y-3 !mt-0">
+      {/* Anti-spam Honeypot */}
+      <input
+        type="text"
+        name="company_website"
+        tabIndex={-1}
+        autoComplete="off"
+        style={{ display: 'none' }}
+        aria-hidden="true"
+      />
+
       <div className="space-y-2 !mt-0">
         <div className="space-y-1 !mt-0">
           <label htmlFor={emailId} className="sr-only">
diff --git a/middleware.ts b/middleware.ts
index 2261faad..5e90d8e5 100644
--- a/middleware.ts
+++ b/middleware.ts
@@ -102,7 +102,7 @@ export default async function middleware(request: NextRequest) {
 
 export const config = {
   matcher: [
-    '/((?!api|_next/static|_next/image|favicon.ico|admin|manifest.webmanifest|.*\\.(?:svg|png|jpg|jpeg|gif|webp|pdf|txt|vcf|xml|webm|mp4|map)$).*)',
+    '/((?!api|_next/static|_next/image|favicon.ico|admin|manifest.webmanifest|.*\\.(?:svg|png|jpg|jpeg|gif|webp|pdf|xlsx|txt|vcf|xml|webm|mp4|map)$).*)',
     '/(de|en)/:path*',
   ],
 };
diff --git a/next.config.mjs b/next.config.mjs
index 68fb5117..0fda2008 100644
--- a/next.config.mjs
+++ b/next.config.mjs
@@ -25,6 +25,18 @@ const nextConfig = {
     },
   },
   ...(isProd ? { output: 'standalone' } : {}),
+  async rewrites() {
+    return [
+      {
+        source: '/:locale/datasheets/:path*',
+        destination: '/datasheets/:path*',
+      },
+      {
+        source: '/:locale/brochure/:path*',
+        destination: '/brochure/:path*',
+      },
+    ];
+  },
   async headers() {
     const isProd = process.env.NODE_ENV === 'production';
     const umamiDomain = new URL(process.env.UMAMI_API_ENDPOINT || 'https://analytics.infra.mintel.me').origin;
diff --git a/public/brochure/klz-product-catalog-de.pdf b/public/brochure/klz-product-catalog-de.pdf
index 9d782cd6..e1de2ebd 100644
Binary files a/public/brochure/klz-product-catalog-de.pdf and b/public/brochure/klz-product-catalog-de.pdf differ
diff --git a/public/brochure/klz-product-catalog-en.pdf b/public/brochure/klz-product-catalog-en.pdf
index dad62160..2fcafdb5 100644
Binary files a/public/brochure/klz-product-catalog-en.pdf and b/public/brochure/klz-product-catalog-en.pdf differ
diff --git a/public/datasheets/h1z2z2-k-de.pdf b/public/datasheets/h1z2z2-k-de.pdf
index fa2937db..15def87e 100644
Binary files a/public/datasheets/h1z2z2-k-de.pdf and b/public/datasheets/h1z2z2-k-de.pdf differ
diff --git a/public/datasheets/h1z2z2-k-en.pdf b/public/datasheets/h1z2z2-k-en.pdf
index 4039130f..e1192d45 100644
Binary files a/public/datasheets/h1z2z2-k-en.pdf and b/public/datasheets/h1z2z2-k-en.pdf differ
diff --git a/public/datasheets/n2x2y-de.pdf b/public/datasheets/n2x2y-de.pdf
index b938e412..b0a8eaea 100644
Binary files a/public/datasheets/n2x2y-de.pdf and b/public/datasheets/n2x2y-de.pdf differ
diff --git a/public/datasheets/n2x2y-en.pdf b/public/datasheets/n2x2y-en.pdf
index ad68e598..5fb78340 100644
Binary files a/public/datasheets/n2x2y-en.pdf and b/public/datasheets/n2x2y-en.pdf differ
diff --git a/public/datasheets/n2xfk2y-de.pdf b/public/datasheets/n2xfk2y-de.pdf
index 1c870d3c..a1abad1f 100644
Binary files a/public/datasheets/n2xfk2y-de.pdf and b/public/datasheets/n2xfk2y-de.pdf differ
diff --git a/public/datasheets/n2xfk2y-en.pdf b/public/datasheets/n2xfk2y-en.pdf
index b2fdadf1..d34892bf 100644
Binary files a/public/datasheets/n2xfk2y-en.pdf and b/public/datasheets/n2xfk2y-en.pdf differ
diff --git a/public/datasheets/n2xfkld2y-de.pdf b/public/datasheets/n2xfkld2y-de.pdf
index e274e46a..8f0eb3ae 100644
Binary files a/public/datasheets/n2xfkld2y-de.pdf and b/public/datasheets/n2xfkld2y-de.pdf differ
diff --git a/public/datasheets/n2xfkld2y-en.pdf b/public/datasheets/n2xfkld2y-en.pdf
index 5c201395..5afbff91 100644
Binary files a/public/datasheets/n2xfkld2y-en.pdf and b/public/datasheets/n2xfkld2y-en.pdf differ
diff --git a/public/datasheets/n2xs2y-de.pdf b/public/datasheets/n2xs2y-de.pdf
index 1fcbea1a..7ce7a112 100644
Binary files a/public/datasheets/n2xs2y-de.pdf and b/public/datasheets/n2xs2y-de.pdf differ
diff --git a/public/datasheets/n2xs2y-en.pdf b/public/datasheets/n2xs2y-en.pdf
index af7819ae..20ed9f0e 100644
Binary files a/public/datasheets/n2xs2y-en.pdf and b/public/datasheets/n2xs2y-en.pdf differ
diff --git a/public/datasheets/n2xsf2y-de.pdf b/public/datasheets/n2xsf2y-de.pdf
index 4ef99c55..70a4bf27 100644
Binary files a/public/datasheets/n2xsf2y-de.pdf and b/public/datasheets/n2xsf2y-de.pdf differ
diff --git a/public/datasheets/n2xsf2y-en.pdf b/public/datasheets/n2xsf2y-en.pdf
index 579b8b11..5b7afb4d 100644
Binary files a/public/datasheets/n2xsf2y-en.pdf and b/public/datasheets/n2xsf2y-en.pdf differ
diff --git a/public/datasheets/n2xsfl2y-hv-de.pdf b/public/datasheets/n2xsfl2y-hv-de.pdf
index 4e82996d..fd4fdad7 100644
Binary files a/public/datasheets/n2xsfl2y-hv-de.pdf and b/public/datasheets/n2xsfl2y-hv-de.pdf differ
diff --git a/public/datasheets/n2xsfl2y-hv-en.pdf b/public/datasheets/n2xsfl2y-hv-en.pdf
index bec00fc7..5e8eb877 100644
Binary files a/public/datasheets/n2xsfl2y-hv-en.pdf and b/public/datasheets/n2xsfl2y-hv-en.pdf differ
diff --git a/public/datasheets/n2xsfl2y-mv-de.pdf b/public/datasheets/n2xsfl2y-mv-de.pdf
index b193c2cb..86dad6ca 100644
Binary files a/public/datasheets/n2xsfl2y-mv-de.pdf and b/public/datasheets/n2xsfl2y-mv-de.pdf differ
diff --git a/public/datasheets/n2xsfl2y-mv-en.pdf b/public/datasheets/n2xsfl2y-mv-en.pdf
index 537cb8a9..2f77f1e5 100644
Binary files a/public/datasheets/n2xsfl2y-mv-en.pdf and b/public/datasheets/n2xsfl2y-mv-en.pdf differ
diff --git a/public/datasheets/n2xsy-de.pdf b/public/datasheets/n2xsy-de.pdf
index e12432b4..6fb55231 100644
Binary files a/public/datasheets/n2xsy-de.pdf and b/public/datasheets/n2xsy-de.pdf differ
diff --git a/public/datasheets/n2xsy-en.pdf b/public/datasheets/n2xsy-en.pdf
index 5635c47c..208f0e28 100644
Binary files a/public/datasheets/n2xsy-en.pdf and b/public/datasheets/n2xsy-en.pdf differ
diff --git a/public/datasheets/n2xy-de.pdf b/public/datasheets/n2xy-de.pdf
index 9a805ff2..cbf0a9f4 100644
Binary files a/public/datasheets/n2xy-de.pdf and b/public/datasheets/n2xy-de.pdf differ
diff --git a/public/datasheets/n2xy-en.pdf b/public/datasheets/n2xy-en.pdf
index 77decce6..1eff0be3 100644
Binary files a/public/datasheets/n2xy-en.pdf and b/public/datasheets/n2xy-en.pdf differ
diff --git a/public/datasheets/na2x2y-de.pdf b/public/datasheets/na2x2y-de.pdf
index a84a281a..3e5b04aa 100644
Binary files a/public/datasheets/na2x2y-de.pdf and b/public/datasheets/na2x2y-de.pdf differ
diff --git a/public/datasheets/na2x2y-en.pdf b/public/datasheets/na2x2y-en.pdf
index 9bb108ee..b3de96ec 100644
Binary files a/public/datasheets/na2x2y-en.pdf and b/public/datasheets/na2x2y-en.pdf differ
diff --git a/public/datasheets/na2xfk2y-de.pdf b/public/datasheets/na2xfk2y-de.pdf
index f8557687..aaf0cbcf 100644
Binary files a/public/datasheets/na2xfk2y-de.pdf and b/public/datasheets/na2xfk2y-de.pdf differ
diff --git a/public/datasheets/na2xfk2y-en.pdf b/public/datasheets/na2xfk2y-en.pdf
index 3548ab1b..b090a53e 100644
Binary files a/public/datasheets/na2xfk2y-en.pdf and b/public/datasheets/na2xfk2y-en.pdf differ
diff --git a/public/datasheets/na2xfkld2y-de.pdf b/public/datasheets/na2xfkld2y-de.pdf
index 9ab1bc50..b2008576 100644
Binary files a/public/datasheets/na2xfkld2y-de.pdf and b/public/datasheets/na2xfkld2y-de.pdf differ
diff --git a/public/datasheets/na2xfkld2y-en.pdf b/public/datasheets/na2xfkld2y-en.pdf
index b6e8fa9e..57d2468b 100644
Binary files a/public/datasheets/na2xfkld2y-en.pdf and b/public/datasheets/na2xfkld2y-en.pdf differ
diff --git a/public/datasheets/na2xs2y-de.pdf b/public/datasheets/na2xs2y-de.pdf
index 79e80c02..5266ce26 100644
Binary files a/public/datasheets/na2xs2y-de.pdf and b/public/datasheets/na2xs2y-de.pdf differ
diff --git a/public/datasheets/na2xs2y-en.pdf b/public/datasheets/na2xs2y-en.pdf
index adfa03a6..32db5b53 100644
Binary files a/public/datasheets/na2xs2y-en.pdf and b/public/datasheets/na2xs2y-en.pdf differ
diff --git a/public/datasheets/na2xsf2y-de.pdf b/public/datasheets/na2xsf2y-de.pdf
index 20a2a764..49a78739 100644
Binary files a/public/datasheets/na2xsf2y-de.pdf and b/public/datasheets/na2xsf2y-de.pdf differ
diff --git a/public/datasheets/na2xsf2y-en.pdf b/public/datasheets/na2xsf2y-en.pdf
index 36ecc08d..f0c152a2 100644
Binary files a/public/datasheets/na2xsf2y-en.pdf and b/public/datasheets/na2xsf2y-en.pdf differ
diff --git a/public/datasheets/na2xsfl2y-hv-de.pdf b/public/datasheets/na2xsfl2y-hv-de.pdf
index 162bcdd5..e707b9f3 100644
Binary files a/public/datasheets/na2xsfl2y-hv-de.pdf and b/public/datasheets/na2xsfl2y-hv-de.pdf differ
diff --git a/public/datasheets/na2xsfl2y-hv-en.pdf b/public/datasheets/na2xsfl2y-hv-en.pdf
index 7257ba3f..1970a5b4 100644
Binary files a/public/datasheets/na2xsfl2y-hv-en.pdf and b/public/datasheets/na2xsfl2y-hv-en.pdf differ
diff --git a/public/datasheets/na2xsfl2y-mv-de.pdf b/public/datasheets/na2xsfl2y-mv-de.pdf
index fa5c7e88..25ab7d63 100644
Binary files a/public/datasheets/na2xsfl2y-mv-de.pdf and b/public/datasheets/na2xsfl2y-mv-de.pdf differ
diff --git a/public/datasheets/na2xsfl2y-mv-en.pdf b/public/datasheets/na2xsfl2y-mv-en.pdf
index e33d5c8d..73d43f82 100644
Binary files a/public/datasheets/na2xsfl2y-mv-en.pdf and b/public/datasheets/na2xsfl2y-mv-en.pdf differ
diff --git a/public/datasheets/na2xsy-de.pdf b/public/datasheets/na2xsy-de.pdf
index ec8ff3ea..17d8851d 100644
Binary files a/public/datasheets/na2xsy-de.pdf and b/public/datasheets/na2xsy-de.pdf differ
diff --git a/public/datasheets/na2xsy-en.pdf b/public/datasheets/na2xsy-en.pdf
index a7428d22..e0c03b1a 100644
Binary files a/public/datasheets/na2xsy-en.pdf and b/public/datasheets/na2xsy-en.pdf differ
diff --git a/public/datasheets/na2xy-de.pdf b/public/datasheets/na2xy-de.pdf
index b40ba87e..48fe528c 100644
Binary files a/public/datasheets/na2xy-de.pdf and b/public/datasheets/na2xy-de.pdf differ
diff --git a/public/datasheets/na2xy-en.pdf b/public/datasheets/na2xy-en.pdf
index a074e8e1..75d9b1d5 100644
Binary files a/public/datasheets/na2xy-en.pdf and b/public/datasheets/na2xy-en.pdf differ
diff --git a/public/datasheets/nay2y-de.pdf b/public/datasheets/nay2y-de.pdf
index b899dc28..38c8725d 100644
Binary files a/public/datasheets/nay2y-de.pdf and b/public/datasheets/nay2y-de.pdf differ
diff --git a/public/datasheets/nay2y-en.pdf b/public/datasheets/nay2y-en.pdf
index cdde3a48..620073fc 100644
Binary files a/public/datasheets/nay2y-en.pdf and b/public/datasheets/nay2y-en.pdf differ
diff --git a/public/datasheets/naycwy-de.pdf b/public/datasheets/naycwy-de.pdf
index 08373f43..e19342b9 100644
Binary files a/public/datasheets/naycwy-de.pdf and b/public/datasheets/naycwy-de.pdf differ
diff --git a/public/datasheets/naycwy-en.pdf b/public/datasheets/naycwy-en.pdf
index 085421ee..5277b452 100644
Binary files a/public/datasheets/naycwy-en.pdf and b/public/datasheets/naycwy-en.pdf differ
diff --git a/public/datasheets/nayy-de.pdf b/public/datasheets/nayy-de.pdf
index 92713ff4..adbe5beb 100644
Binary files a/public/datasheets/nayy-de.pdf and b/public/datasheets/nayy-de.pdf differ
diff --git a/public/datasheets/nayy-en.pdf b/public/datasheets/nayy-en.pdf
index d9366e6c..b3034995 100644
Binary files a/public/datasheets/nayy-en.pdf and b/public/datasheets/nayy-en.pdf differ
diff --git a/public/datasheets/ny2y-de.pdf b/public/datasheets/ny2y-de.pdf
index edd476c3..eb29ae1f 100644
Binary files a/public/datasheets/ny2y-de.pdf and b/public/datasheets/ny2y-de.pdf differ
diff --git a/public/datasheets/ny2y-en.pdf b/public/datasheets/ny2y-en.pdf
index 1169253a..bb007950 100644
Binary files a/public/datasheets/ny2y-en.pdf and b/public/datasheets/ny2y-en.pdf differ
diff --git a/public/datasheets/nycwy-de.pdf b/public/datasheets/nycwy-de.pdf
index d65b2752..cf09fd0e 100644
Binary files a/public/datasheets/nycwy-de.pdf and b/public/datasheets/nycwy-de.pdf differ
diff --git a/public/datasheets/nycwy-en.pdf b/public/datasheets/nycwy-en.pdf
index 7060d89f..6e9414ad 100644
Binary files a/public/datasheets/nycwy-en.pdf and b/public/datasheets/nycwy-en.pdf differ
diff --git a/public/datasheets/nyy-de.pdf b/public/datasheets/nyy-de.pdf
index f7624376..0872766c 100644
Binary files a/public/datasheets/nyy-de.pdf and b/public/datasheets/nyy-de.pdf differ
diff --git a/public/datasheets/nyy-en.pdf b/public/datasheets/nyy-en.pdf
index 7c6b7cdf..a2026059 100644
Binary files a/public/datasheets/nyy-en.pdf and b/public/datasheets/nyy-en.pdf differ
diff --git a/public/datasheets/products/h1z2z2-k-de.xlsx b/public/datasheets/products/h1z2z2-k-de.xlsx
index b4b798b0..a1228858 100644
Binary files a/public/datasheets/products/h1z2z2-k-de.xlsx and b/public/datasheets/products/h1z2z2-k-de.xlsx differ
diff --git a/public/datasheets/products/h1z2z2-k-en.xlsx b/public/datasheets/products/h1z2z2-k-en.xlsx
index 8c7219ab..1d1ddd7c 100644
Binary files a/public/datasheets/products/h1z2z2-k-en.xlsx and b/public/datasheets/products/h1z2z2-k-en.xlsx differ
diff --git a/public/datasheets/products/n2x2y-de.xlsx b/public/datasheets/products/n2x2y-de.xlsx
index 614d032a..4d0b7ec7 100644
Binary files a/public/datasheets/products/n2x2y-de.xlsx and b/public/datasheets/products/n2x2y-de.xlsx differ
diff --git a/public/datasheets/products/n2x2y-en.xlsx b/public/datasheets/products/n2x2y-en.xlsx
index b3778477..438bf925 100644
Binary files a/public/datasheets/products/n2x2y-en.xlsx and b/public/datasheets/products/n2x2y-en.xlsx differ
diff --git a/public/datasheets/products/n2xs2y-de.xlsx b/public/datasheets/products/n2xs2y-de.xlsx
index d07a6986..6d8ff636 100644
Binary files a/public/datasheets/products/n2xs2y-de.xlsx and b/public/datasheets/products/n2xs2y-de.xlsx differ
diff --git a/public/datasheets/products/n2xs2y-en.xlsx b/public/datasheets/products/n2xs2y-en.xlsx
index 40fe4b68..476e525b 100644
Binary files a/public/datasheets/products/n2xs2y-en.xlsx and b/public/datasheets/products/n2xs2y-en.xlsx differ
diff --git a/public/datasheets/products/n2xsf2y-de.xlsx b/public/datasheets/products/n2xsf2y-de.xlsx
index 438cd126..800f290d 100644
Binary files a/public/datasheets/products/n2xsf2y-de.xlsx and b/public/datasheets/products/n2xsf2y-de.xlsx differ
diff --git a/public/datasheets/products/n2xsf2y-en.xlsx b/public/datasheets/products/n2xsf2y-en.xlsx
index 6e725738..3603ad33 100644
Binary files a/public/datasheets/products/n2xsf2y-en.xlsx and b/public/datasheets/products/n2xsf2y-en.xlsx differ
diff --git a/public/datasheets/products/n2xsfl2y-hv-de.xlsx b/public/datasheets/products/n2xsfl2y-hv-de.xlsx
index 43b4e39f..ce872a63 100644
Binary files a/public/datasheets/products/n2xsfl2y-hv-de.xlsx and b/public/datasheets/products/n2xsfl2y-hv-de.xlsx differ
diff --git a/public/datasheets/products/n2xsfl2y-hv-en.xlsx b/public/datasheets/products/n2xsfl2y-hv-en.xlsx
index 733a0ea3..680e00e1 100644
Binary files a/public/datasheets/products/n2xsfl2y-hv-en.xlsx and b/public/datasheets/products/n2xsfl2y-hv-en.xlsx differ
diff --git a/public/datasheets/products/n2xsfl2y-mv-de.xlsx b/public/datasheets/products/n2xsfl2y-mv-de.xlsx
index 43b4e39f..ce872a63 100644
Binary files a/public/datasheets/products/n2xsfl2y-mv-de.xlsx and b/public/datasheets/products/n2xsfl2y-mv-de.xlsx differ
diff --git a/public/datasheets/products/n2xsfl2y-mv-en.xlsx b/public/datasheets/products/n2xsfl2y-mv-en.xlsx
index 733a0ea3..680e00e1 100644
Binary files a/public/datasheets/products/n2xsfl2y-mv-en.xlsx and b/public/datasheets/products/n2xsfl2y-mv-en.xlsx differ
diff --git a/public/datasheets/products/n2xsy-de.xlsx b/public/datasheets/products/n2xsy-de.xlsx
index a8e35b63..91ae2e5f 100644
Binary files a/public/datasheets/products/n2xsy-de.xlsx and b/public/datasheets/products/n2xsy-de.xlsx differ
diff --git a/public/datasheets/products/n2xsy-en.xlsx b/public/datasheets/products/n2xsy-en.xlsx
index 322b89fe..61823413 100644
Binary files a/public/datasheets/products/n2xsy-en.xlsx and b/public/datasheets/products/n2xsy-en.xlsx differ
diff --git a/public/datasheets/products/n2xy-de.xlsx b/public/datasheets/products/n2xy-de.xlsx
index 9ee311d7..c02a622f 100644
Binary files a/public/datasheets/products/n2xy-de.xlsx and b/public/datasheets/products/n2xy-de.xlsx differ
diff --git a/public/datasheets/products/n2xy-en.xlsx b/public/datasheets/products/n2xy-en.xlsx
index ce0e1585..4298dae9 100644
Binary files a/public/datasheets/products/n2xy-en.xlsx and b/public/datasheets/products/n2xy-en.xlsx differ
diff --git a/public/datasheets/products/na2x2y-de.xlsx b/public/datasheets/products/na2x2y-de.xlsx
index b671bbfe..d7be09a4 100644
Binary files a/public/datasheets/products/na2x2y-de.xlsx and b/public/datasheets/products/na2x2y-de.xlsx differ
diff --git a/public/datasheets/products/na2x2y-en.xlsx b/public/datasheets/products/na2x2y-en.xlsx
index 22f61b11..20d53de7 100644
Binary files a/public/datasheets/products/na2x2y-en.xlsx and b/public/datasheets/products/na2x2y-en.xlsx differ
diff --git a/public/datasheets/products/na2xs2y-de.xlsx b/public/datasheets/products/na2xs2y-de.xlsx
index 7f620057..02a4536f 100644
Binary files a/public/datasheets/products/na2xs2y-de.xlsx and b/public/datasheets/products/na2xs2y-de.xlsx differ
diff --git a/public/datasheets/products/na2xs2y-en.xlsx b/public/datasheets/products/na2xs2y-en.xlsx
index 05e6b428..ac729689 100644
Binary files a/public/datasheets/products/na2xs2y-en.xlsx and b/public/datasheets/products/na2xs2y-en.xlsx differ
diff --git a/public/datasheets/products/na2xsf2y-de.xlsx b/public/datasheets/products/na2xsf2y-de.xlsx
index 5dce5c74..c2dab6a7 100644
Binary files a/public/datasheets/products/na2xsf2y-de.xlsx and b/public/datasheets/products/na2xsf2y-de.xlsx differ
diff --git a/public/datasheets/products/na2xsf2y-en.xlsx b/public/datasheets/products/na2xsf2y-en.xlsx
index 83d7e7df..5a99d648 100644
Binary files a/public/datasheets/products/na2xsf2y-en.xlsx and b/public/datasheets/products/na2xsf2y-en.xlsx differ
diff --git a/public/datasheets/products/na2xsfl2y-hv-de.xlsx b/public/datasheets/products/na2xsfl2y-hv-de.xlsx
index f865acff..df7c500b 100644
Binary files a/public/datasheets/products/na2xsfl2y-hv-de.xlsx and b/public/datasheets/products/na2xsfl2y-hv-de.xlsx differ
diff --git a/public/datasheets/products/na2xsfl2y-hv-en.xlsx b/public/datasheets/products/na2xsfl2y-hv-en.xlsx
index 222cfc20..e378add0 100644
Binary files a/public/datasheets/products/na2xsfl2y-hv-en.xlsx and b/public/datasheets/products/na2xsfl2y-hv-en.xlsx differ
diff --git a/public/datasheets/products/na2xsfl2y-mv-de.xlsx b/public/datasheets/products/na2xsfl2y-mv-de.xlsx
index f865acff..df7c500b 100644
Binary files a/public/datasheets/products/na2xsfl2y-mv-de.xlsx and b/public/datasheets/products/na2xsfl2y-mv-de.xlsx differ
diff --git a/public/datasheets/products/na2xsfl2y-mv-en.xlsx b/public/datasheets/products/na2xsfl2y-mv-en.xlsx
index 222cfc20..e378add0 100644
Binary files a/public/datasheets/products/na2xsfl2y-mv-en.xlsx and b/public/datasheets/products/na2xsfl2y-mv-en.xlsx differ
diff --git a/public/datasheets/products/na2xsy-de.xlsx b/public/datasheets/products/na2xsy-de.xlsx
index 537b5493..a73c6042 100644
Binary files a/public/datasheets/products/na2xsy-de.xlsx and b/public/datasheets/products/na2xsy-de.xlsx differ
diff --git a/public/datasheets/products/na2xsy-en.xlsx b/public/datasheets/products/na2xsy-en.xlsx
index 50acc4c5..bccde935 100644
Binary files a/public/datasheets/products/na2xsy-en.xlsx and b/public/datasheets/products/na2xsy-en.xlsx differ
diff --git a/public/datasheets/products/na2xy-de.xlsx b/public/datasheets/products/na2xy-de.xlsx
index 42b17fd6..bb28fcb8 100644
Binary files a/public/datasheets/products/na2xy-de.xlsx and b/public/datasheets/products/na2xy-de.xlsx differ
diff --git a/public/datasheets/products/na2xy-en.xlsx b/public/datasheets/products/na2xy-en.xlsx
index e8aa6760..07dad760 100644
Binary files a/public/datasheets/products/na2xy-en.xlsx and b/public/datasheets/products/na2xy-en.xlsx differ
diff --git a/public/datasheets/products/nay2y-de.xlsx b/public/datasheets/products/nay2y-de.xlsx
index 91efd89e..084e742b 100644
Binary files a/public/datasheets/products/nay2y-de.xlsx and b/public/datasheets/products/nay2y-de.xlsx differ
diff --git a/public/datasheets/products/nay2y-en.xlsx b/public/datasheets/products/nay2y-en.xlsx
index a8dd0539..673c8b11 100644
Binary files a/public/datasheets/products/nay2y-en.xlsx and b/public/datasheets/products/nay2y-en.xlsx differ
diff --git a/public/datasheets/products/naycwy-de.xlsx b/public/datasheets/products/naycwy-de.xlsx
index 92fa6f43..5210d4cc 100644
Binary files a/public/datasheets/products/naycwy-de.xlsx and b/public/datasheets/products/naycwy-de.xlsx differ
diff --git a/public/datasheets/products/naycwy-en.xlsx b/public/datasheets/products/naycwy-en.xlsx
index 5849cf67..d9e0a5af 100644
Binary files a/public/datasheets/products/naycwy-en.xlsx and b/public/datasheets/products/naycwy-en.xlsx differ
diff --git a/public/datasheets/products/nayy-de.xlsx b/public/datasheets/products/nayy-de.xlsx
index 47359f88..7d372e7b 100644
Binary files a/public/datasheets/products/nayy-de.xlsx and b/public/datasheets/products/nayy-de.xlsx differ
diff --git a/public/datasheets/products/nayy-en.xlsx b/public/datasheets/products/nayy-en.xlsx
index 646e174d..66a3a90d 100644
Binary files a/public/datasheets/products/nayy-en.xlsx and b/public/datasheets/products/nayy-en.xlsx differ
diff --git a/public/datasheets/products/ny2y-de.xlsx b/public/datasheets/products/ny2y-de.xlsx
index 3487360d..6e3fee2c 100644
Binary files a/public/datasheets/products/ny2y-de.xlsx and b/public/datasheets/products/ny2y-de.xlsx differ
diff --git a/public/datasheets/products/ny2y-en.xlsx b/public/datasheets/products/ny2y-en.xlsx
index 76ed4539..82dd4797 100644
Binary files a/public/datasheets/products/ny2y-en.xlsx and b/public/datasheets/products/ny2y-en.xlsx differ
diff --git a/public/datasheets/products/nycwy-de.xlsx b/public/datasheets/products/nycwy-de.xlsx
index b59d18b6..17d8d992 100644
Binary files a/public/datasheets/products/nycwy-de.xlsx and b/public/datasheets/products/nycwy-de.xlsx differ
diff --git a/public/datasheets/products/nycwy-en.xlsx b/public/datasheets/products/nycwy-en.xlsx
index 96c17570..df38f67b 100644
Binary files a/public/datasheets/products/nycwy-en.xlsx and b/public/datasheets/products/nycwy-en.xlsx differ
diff --git a/public/datasheets/products/nyy-de.xlsx b/public/datasheets/products/nyy-de.xlsx
index 78acff21..019f57f0 100644
Binary files a/public/datasheets/products/nyy-de.xlsx and b/public/datasheets/products/nyy-de.xlsx differ
diff --git a/public/datasheets/products/nyy-en.xlsx b/public/datasheets/products/nyy-en.xlsx
index 883f9d52..373c4a42 100644
Binary files a/public/datasheets/products/nyy-en.xlsx and b/public/datasheets/products/nyy-en.xlsx differ
diff --git a/scripts/generate-brochure.ts b/scripts/generate-brochure.ts
index c1d73236..bb748ef3 100644
--- a/scripts/generate-brochure.ts
+++ b/scripts/generate-brochure.ts
@@ -21,447 +21,490 @@ import { getDatasheetPath } from '../lib/datasheets';
 import { mapFileSlugToTranslated } from '../lib/slugs';
 
 const CONFIG = {
-    outputDir: path.join(process.cwd(), 'public/brochure'),
-    host: process.env.NEXT_PUBLIC_SITE_URL || 'https://klz-cables.com',
+  outputDir: path.join(process.cwd(), 'public/brochure'),
+  host: process.env.NEXT_PUBLIC_SITE_URL || 'https://klz-cables.com',
 } as const;
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 async function resolveImage(url: string): Promise<string | Buffer> {
-    if (!url) return '';
-    let localPath = '';
-    // If it's a Payload media URL like /api/media/file/filename.ext
-    if (url.startsWith('/api/media/file/')) {
-        const filename = url.replace('/api/media/file/', '');
-        localPath = path.join(process.cwd(), 'public/media', filename);
-    } else if (url.startsWith('/media/')) {
-        localPath = path.join(process.cwd(), 'public', url);
-    }
+  if (!url) return '';
+  let localPath = '';
+  // If it's a Payload media URL like /api/media/file/filename.ext
+  if (url.startsWith('/api/media/file/')) {
+    const filename = url.replace('/api/media/file/', '');
+    localPath = path.join(process.cwd(), 'public/media', filename);
+  } else if (url.startsWith('/media/')) {
+    localPath = path.join(process.cwd(), 'public', url);
+  }
 
-    if (localPath && fs.existsSync(localPath)) {
-        // If it's webp, convert to png buffer for react-pdf
-        if (localPath.toLowerCase().endsWith('.webp')) {
-            try {
-                return await sharp(localPath).png().toBuffer();
-            } catch (err) {
-                return localPath;
-            }
-        }
+  if (localPath && fs.existsSync(localPath)) {
+    // If it's webp, convert to png buffer for react-pdf
+    if (localPath.toLowerCase().endsWith('.webp')) {
+      try {
+        return await sharp(localPath).png().toBuffer();
+      } catch (err) {
         return localPath;
+      }
     }
-    // Fallback to absolute URL if starting with /
-    if (url.startsWith('/')) return `${CONFIG.host}${url}`;
-    return url;
+    return localPath;
+  }
+  // Fallback to absolute URL if starting with /
+  if (url.startsWith('/')) return `${CONFIG.host}${url}`;
+  return url;
 }
 
 function stripHtml(html: string): string {
-    if (!html) return '';
-    return html.replace(/<[^>]*>/g, '').trim();
+  if (!html) return '';
+  return html.replace(/<[^>]*>/g, '').trim();
 }
 
 function ensureOutputDir(): void {
-    if (!fs.existsSync(CONFIG.outputDir)) {
-        fs.mkdirSync(CONFIG.outputDir, { recursive: true });
-    }
+  if (!fs.existsSync(CONFIG.outputDir)) {
+    fs.mkdirSync(CONFIG.outputDir, { recursive: true });
+  }
 }
 
 async function fetchQrCodeBuffer(url: string): Promise<Buffer | undefined> {
-    if (!url) return undefined;
-    try {
-        const qrApi = `https://api.qrserver.com/v1/create-qr-code/?size=80x80&data=${encodeURIComponent(url)}&margin=0`;
-        const res = await fetch(qrApi);
-        if (res.ok) {
-            const arrayBuffer = await res.arrayBuffer();
-            return Buffer.from(arrayBuffer);
-        } else {
-            console.error(`  [QR] Failed (HTTP ${res.status}) for ${url}`);
-        }
-    } catch (err) {
-        console.error(`  [QR] Failed for ${url}:`, err);
+  if (!url) return undefined;
+  try {
+    const qrApi = `https://api.qrserver.com/v1/create-qr-code/?size=80x80&data=${encodeURIComponent(url)}&margin=0`;
+    const res = await fetch(qrApi);
+    if (res.ok) {
+      const arrayBuffer = await res.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } else {
+      console.error(`  [QR] Failed (HTTP ${res.status}) for ${url}`);
     }
-    return undefined;
+  } catch (err) {
+    console.error(`  [QR] Failed for ${url}:`, err);
+  }
+  return undefined;
 }
 
 async function resolveLocalFile(relativePath: string): Promise<string | Buffer | undefined> {
-    const abs = path.join(process.cwd(), 'public', relativePath);
-    if (!fs.existsSync(abs)) return undefined;
-    if (abs.endsWith('.svg')) {
-        try {
-            const svgBuf = fs.readFileSync(abs);
-            return await sharp(svgBuf).resize(600).png().toBuffer();
-        } catch { return abs; }
+  const abs = path.join(process.cwd(), 'public', relativePath);
+  if (!fs.existsSync(abs)) return undefined;
+  if (abs.endsWith('.svg')) {
+    try {
+      const svgBuf = fs.readFileSync(abs);
+      return await sharp(svgBuf).resize(600).png().toBuffer();
+    } catch {
+      return abs;
     }
-    return abs;
+  }
+  return abs;
 }
 
 // ─── CMS Product Loading ────────────────────────────────────────────────────
 
 async function loadProducts(locale: 'en' | 'de'): Promise<BrochureProduct[]> {
-    const products: BrochureProduct[] = [];
-    try {
-        const payload = await getPayload({ config: configPromise });
-        const isDev = process.env.NODE_ENV === 'development';
+  const products: BrochureProduct[] = [];
+  try {
+    const payload = await getPayload({ config: configPromise });
+    const isDev = process.env.NODE_ENV === 'development';
 
-        const result = await payload.find({
-            collection: 'products',
-            where: {
-                ...(!isDev ? { _status: { equals: 'published' } } : {}),
-            },
-            locale: locale as any,
-            pagination: false,
-        });
+    const result = await payload.find({
+      collection: 'products',
+      where: {
+        ...(!isDev ? { _status: { equals: 'published' } } : {}),
+      },
+      locale: locale as any,
+      pagination: false,
+    });
 
-        const productsSlug = await mapFileSlugToTranslated('products', locale);
+    const productsSlug = await mapFileSlugToTranslated('products', locale);
 
-        let id = 1;
-        for (const doc of result.docs) {
-            if (!doc.title || !doc.slug) continue;
+    let id = 1;
+    for (const doc of result.docs) {
+      if (!doc.title || !doc.slug) continue;
 
-            const images: any[] = [];
-            const rawImages: string[] = [];
+      const images: any[] = [];
+      const rawImages: string[] = [];
 
-            if (doc.featuredImage) {
-                const url = typeof doc.featuredImage === 'string' ? doc.featuredImage : (doc.featuredImage as any).url;
-                if (url) rawImages.push(url);
-            }
-            if (Array.isArray(doc.images)) {
-                for (const img of doc.images) {
-                    const url = typeof img === 'string' ? img : (img as any).url;
-                    if (url && !rawImages.includes(url)) rawImages.push(url);
-                }
-            }
-
-            for (const url of rawImages) {
-                const resolved = await resolveImage(url);
-                if (resolved) images.push(resolved);
-            }
-
-            const attributes: any[] = [];
-            // Extract basic technical attributes from Lexical AST
-            if (Array.isArray(doc.content?.root?.children)) {
-                const productTabsBlock = doc.content.root.children.find(
-                    (node: any) => node.type === 'block' && node.fields?.blockType === 'productTabs'
-                );
-
-                if (productTabsBlock && productTabsBlock.fields) {
-                    if (Array.isArray(productTabsBlock.fields.technicalItems)) {
-                        for (const item of productTabsBlock.fields.technicalItems) {
-                            const label = item.unit ? `${item.label} [${item.unit}]` : item.label;
-                            if (label && item.value) {
-                                attributes.push({ name: label, options: [item.value] });
-                            }
-                        }
-                    }
-                    if (Array.isArray(productTabsBlock.fields.voltageTables)) {
-                        for (const vt of productTabsBlock.fields.voltageTables) {
-                            if (vt.voltageLabel) {
-                                attributes.push({ name: 'Voltage', options: [vt.voltageLabel] });
-                            }
-                        }
-                    }
-                }
-            }
-
-            const categories = Array.isArray(doc.categories)
-                ? doc.categories.map((c: any) => ({ name: String(c.category || c), slug: String(c.slug || c) })).filter((c: any) => c.name)
-                : [];
-
-            // Compute QR URLs
-            let qrWebsiteUrl = '';
-            if (categories.length > 0 && categories[0].slug) {
-                const catTranslatedSlug = await mapFileSlugToTranslated(categories[0].slug, locale);
-                qrWebsiteUrl = `${CONFIG.host}/${locale}/${productsSlug}/${catTranslatedSlug}/${doc.slug}`;
-            }
-
-            let qrDatasheetUrl = '';
-            const datasheetRelativePath = getDatasheetPath(String(doc.slug), locale);
-            if (datasheetRelativePath) {
-                qrDatasheetUrl = `${CONFIG.host}${datasheetRelativePath}`;
-            }
-
-            const [qrWebsite, qrDatasheet] = await Promise.all([
-                qrWebsiteUrl ? fetchQrCodeBuffer(qrWebsiteUrl) : Promise.resolve(undefined),
-                qrDatasheetUrl ? fetchQrCodeBuffer(qrDatasheetUrl) : Promise.resolve(undefined),
-            ]);
-
-            products.push({
-                id: id++,
-                name: String(doc.title),
-                slug: String(doc.slug),
-                sku: String(doc.sku || ''),
-                shortDescriptionHtml: '',
-                descriptionHtml: stripHtml(String(doc.description || '')),
-                images: images as any, // mix of paths and buffers
-                featuredImage: images[0] || null,
-                categories,
-                attributes,
-                qrWebsite,
-                qrDatasheet,
-            });
-            console.log(`  - ${doc.title} (QR: ${qrWebsite ? 'Web ' : ''}${qrDatasheet ? 'PDF' : ''})`);
+      if (doc.featuredImage) {
+        const url =
+          typeof doc.featuredImage === 'string'
+            ? doc.featuredImage
+            : (doc.featuredImage as any).url;
+        if (url) rawImages.push(url);
+      }
+      if (Array.isArray(doc.images)) {
+        for (const img of doc.images) {
+          const url = typeof img === 'string' ? img : (img as any).url;
+          if (url && !rawImages.includes(url)) rawImages.push(url);
         }
-    } catch (error) {
-        console.error(`[Payload] Failed to fetch products (${locale}):`, error);
+      }
+
+      for (const url of rawImages) {
+        const resolved = await resolveImage(url);
+        if (resolved) images.push(resolved);
+      }
+
+      const attributes: any[] = [];
+      // Extract basic technical attributes from Lexical AST if present
+      if (Array.isArray(doc.content?.root?.children)) {
+        const productTabsBlock = doc.content.root.children.find(
+          (node: any) => node.type === 'block' && node.fields?.blockType === 'productTabs',
+        );
+
+        if (productTabsBlock && productTabsBlock.fields) {
+          if (Array.isArray(productTabsBlock.fields.technicalItems)) {
+            for (const item of productTabsBlock.fields.technicalItems) {
+              const label = item.unit ? `${item.label} [${item.unit}]` : item.label;
+              if (label && item.value) {
+                attributes.push({
+                  name: label,
+                  options: [String(item.value)],
+                });
+              }
+            }
+          }
+        }
+      }
+
+      const categories = Array.isArray(doc.categories)
+        ? doc.categories
+            .map((c: any) => ({ name: String(c.category || c), slug: String(c.slug || c) }))
+            .filter((c: any) => c.name)
+        : [];
+
+      // Compute QR URLs
+      let qrWebsiteUrl = '';
+      if (categories.length > 0 && categories[0].slug) {
+        const catTranslatedSlug = await mapFileSlugToTranslated(categories[0].slug, locale);
+        qrWebsiteUrl = `${CONFIG.host}/${locale}/${productsSlug}/${catTranslatedSlug}/${doc.slug}`;
+      }
+
+      let qrDatasheetUrl = '';
+      const datasheetRelativePath = getDatasheetPath(String(doc.slug), locale);
+      if (datasheetRelativePath) {
+        qrDatasheetUrl = `${CONFIG.host}${datasheetRelativePath}`;
+      }
+
+      const [qrWebsite, qrDatasheet] = await Promise.all([
+        qrWebsiteUrl ? fetchQrCodeBuffer(qrWebsiteUrl) : Promise.resolve(undefined),
+        qrDatasheetUrl ? fetchQrCodeBuffer(qrDatasheetUrl) : Promise.resolve(undefined),
+      ]);
+
+      products.push({
+        id: id++,
+        name: String(doc.title),
+        slug: String(doc.slug),
+        sku: String(doc.sku || ''),
+        shortDescriptionHtml: '',
+        descriptionHtml: stripHtml(String(doc.description || '')),
+        images: images as any, // mix of paths and buffers
+        featuredImage: images[0] || null,
+        categories,
+        attributes,
+        qrWebsite,
+        qrDatasheet,
+      });
+      console.log(`  - ${doc.title} (QR: ${qrWebsite ? 'Web ' : ''}${qrDatasheet ? 'PDF' : ''})`);
     }
+  } catch (error) {
+    console.error(`[Payload] Failed to fetch products (${locale}):`, error);
+  }
 
-    products.sort((a, b) => a.name.localeCompare(b.name));
+  products.sort((a, b) => a.name.localeCompare(b.name));
 
-    // FILTER: Only include products that have images for the high-fidelity brochure
-    const filteredProducts = products.filter(p => p.images.length > 0 || p.featuredImage);
-    console.log(`  Filtered: ${filteredProducts.length} products with images (out of ${products.length})`);
+  // FILTER: Only include products that have images for the high-fidelity brochure
+  const filteredProducts = products.filter((p) => p.images.length > 0 || p.featuredImage);
+  console.log(
+    `  Filtered: ${filteredProducts.length} products with images (out of ${products.length})`,
+  );
 
-    return filteredProducts;
+  return filteredProducts;
 }
 
 // ─── CMS Start/Intro Page ───────────────────────────────────────────────────
 
-async function loadIntroContent(locale: 'en' | 'de'): Promise<BrochureProps['introContent'] | undefined> {
-    try {
-        const payload = await getPayload({ config: configPromise });
-        const result = await payload.find({
-            collection: 'pages',
-            where: { slug: { equals: 'start' } },
-            locale: locale as any,
-        });
+async function loadIntroContent(
+  locale: 'en' | 'de',
+): Promise<BrochureProps['introContent'] | undefined> {
+  try {
+    const payload = await getPayload({ config: configPromise });
+    const result = await payload.find({
+      collection: 'pages',
+      where: { slug: { equals: 'start' } },
+      locale: locale as any,
+    });
 
-        if (result.docs.length > 0) {
-            const doc = result.docs[0];
-            const heroUrl = typeof doc.featuredImage === 'string'
-                ? doc.featuredImage
-                : (doc.featuredImage as any)?.url;
+    if (result.docs.length > 0) {
+      const doc = result.docs[0];
+      const heroUrl =
+        typeof doc.featuredImage === 'string' ? doc.featuredImage : (doc.featuredImage as any)?.url;
 
-            const heroImage = await resolveImage(heroUrl);
+      const heroImage = await resolveImage(heroUrl);
 
-            return {
-                title: String(doc.title),
-                excerpt: String(doc.excerpt || ''),
-                heroImage: heroImage as any,
-            };
-        }
-    } catch (error) {
-        console.error(`[Payload] Failed to fetch intro content (${locale}):`, error);
+      return {
+        title: String(doc.title),
+        excerpt: String(doc.excerpt || ''),
+        heroImage: heroImage as any,
+      };
     }
-    return undefined;
+  } catch (error) {
+    console.error(`[Payload] Failed to fetch intro content (${locale}):`, error);
+  }
+  return undefined;
 }
 
 // ─── Marketing Sections ───────────────────────────────────────────────────
 
-async function loadMarketingSections(locale: 'en' | 'de'): Promise<BrochureProps['marketingSections'] | undefined> {
-    try {
-        const messagesPath = path.join(process.cwd(), `messages/${locale}.json`);
-        const messagesJson = fs.readFileSync(messagesPath, 'utf-8');
-        const messages = JSON.parse(messagesJson);
+async function loadMarketingSections(
+  locale: 'en' | 'de',
+): Promise<BrochureProps['marketingSections'] | undefined> {
+  try {
+    const messagesPath = path.join(process.cwd(), `messages/${locale}.json`);
+    const messagesJson = fs.readFileSync(messagesPath, 'utf-8');
+    const messages = JSON.parse(messagesJson);
 
-        const sections: NonNullable<BrochureProps['marketingSections']> = [];
+    const sections: NonNullable<BrochureProps['marketingSections']> = [];
 
-        // ── 1. Was wir tun + Warum wir — MERGED into one compact section ──
-        {
-            const allItems: Array<{ title: string; description: string }> = [];
+    // ── 1. Was wir tun + Warum wir — MERGED into one compact section ──
+    {
+      const allItems: Array<{ title: string; description: string }> = [];
 
-            // WhatWeDo items — truncated to 1 sentence each
-            if (messages.Home?.whatWeDo?.items) {
-                for (const item of messages.Home.whatWeDo.items) {
-                    allItems.push({
-                        title: item.title.split('.')[0], // short title
-                        description: item.description.split('.')[0] + '.',
-                    });
-                }
-            }
-            // WhyChooseUs items — truncated to 1 sentence each
-            if (messages.Home?.whyChooseUs?.items) {
-                for (const item of messages.Home.whyChooseUs.items) {
-                    allItems.push({
-                        title: item.title,
-                        description: item.description.split('.')[0] + '.',
-                    });
-                }
-            }
-
-            sections.push({
-                title: messages.Home?.whatWeDo?.title || (locale === 'de' ? 'Was wir tun' : 'What We Do'),
-                subtitle: locale === 'de' ? 'Leistungen & Stärken' : 'Services & Strengths',
-                description: messages.Home?.whatWeDo?.subtitle || '',
-                items: allItems,
-            });
+      // WhatWeDo items — truncated to 1 sentence each
+      if (messages.Home?.whatWeDo?.items) {
+        for (const item of messages.Home.whatWeDo.items) {
+          allItems.push({
+            title: item.title.split('.')[0], // short title
+            description: item.description.split('.')[0] + '.',
+          });
         }
-
-        // ── 2. Experience & Quality — merge Legacy + Experience highlights ──
-        {
-            const legacy = messages.Team?.legacy;
-            const experience = messages.Home?.experience;
-            const highlights: Array<{ value: string; label: string }> = [];
-
-            if (legacy) {
-                highlights.push(
-                    { value: legacy.expertise || 'Expertise', label: legacy.expertiseDesc || '' },
-                    { value: legacy.network || (locale === 'de' ? 'Netzwerk' : 'Network'), label: legacy.networkDesc || '' },
-                );
-            }
-            if (experience) {
-                highlights.push(
-                    { value: experience.certifiedQuality || (locale === 'de' ? 'Zertifiziert' : 'Certified'), label: experience.vdeApproved || '' },
-                    { value: experience.fullSpectrum || (locale === 'de' ? 'Volles Spektrum' : 'Full Spectrum'), label: experience.solutionsRange || '' },
-                );
-            }
-
-            const desc = legacy?.p1 || '';
-
-            sections.push({
-                title: legacy?.title || (locale === 'de' ? 'Erfahrung & Qualität' : 'Experience & Quality'),
-                subtitle: locale === 'de' ? 'Unser Erbe' : 'Our Heritage',
-                description: desc,
-                highlights,
-            });
+      }
+      // WhyChooseUs items — truncated to 1 sentence each
+      if (messages.Home?.whyChooseUs?.items) {
+        for (const item of messages.Home.whyChooseUs.items) {
+          allItems.push({
+            title: item.title,
+            description: item.description.split('.')[0] + '.',
+          });
         }
+      }
 
-        return sections.length > 0 ? sections : undefined;
-    } catch (error) {
-        console.error(`[Messages] Failed to fetch marketing sections (${locale}):`, error);
+      sections.push({
+        title: messages.Home?.whatWeDo?.title || (locale === 'de' ? 'Was wir tun' : 'What We Do'),
+        subtitle: locale === 'de' ? 'Leistungen & Stärken' : 'Services & Strengths',
+        description: messages.Home?.whatWeDo?.subtitle || '',
+        items: allItems,
+      });
     }
-    return undefined;
+
+    // ── 2. Experience & Quality — merge Legacy + Experience highlights ──
+    {
+      const legacy = messages.Team?.legacy;
+      const experience = messages.Home?.experience;
+      const highlights: Array<{ value: string; label: string }> = [];
+
+      if (legacy) {
+        highlights.push(
+          { value: legacy.expertise || 'Expertise', label: legacy.expertiseDesc || '' },
+          {
+            value: legacy.network || (locale === 'de' ? 'Netzwerk' : 'Network'),
+            label: legacy.networkDesc || '',
+          },
+        );
+      }
+      if (experience) {
+        highlights.push(
+          {
+            value: experience.certifiedQuality || (locale === 'de' ? 'Zertifiziert' : 'Certified'),
+            label: experience.vdeApproved || '',
+          },
+          {
+            value:
+              experience.fullSpectrum || (locale === 'de' ? 'Volles Spektrum' : 'Full Spectrum'),
+            label: experience.solutionsRange || '',
+          },
+        );
+      }
+
+      const desc = legacy?.p1 || '';
+
+      sections.push({
+        title: legacy?.title || (locale === 'de' ? 'Erfahrung & Qualität' : 'Experience & Quality'),
+        subtitle: locale === 'de' ? 'Unser Erbe' : 'Our Heritage',
+        description: desc,
+        highlights,
+      });
+    }
+
+    return sections.length > 0 ? sections : undefined;
+  } catch (error) {
+    console.error(`[Messages] Failed to fetch marketing sections (${locale}):`, error);
+  }
+  return undefined;
 }
 
 // ─── Company Info ───────────────────────────────────────────────────────────
 
 function getCompanyInfo(locale: 'en' | 'de'): BrochureProps['companyInfo'] {
-    const values = locale === 'de' ? [
-        { title: 'Kompetenz', description: 'Jahrzehntelange Erfahrung und europaweites Know-how.' },
-        { title: 'Verfügbarkeit', description: 'Immer für Sie da – schnelle Unterstützung.' },
-        { title: 'Lösungen', description: 'Wir finden die beste Kabellösung für Ihr Projekt.' },
-        { title: 'Zuverlässigkeit', description: 'Wir halten, was wir versprechen.' },
-    ] : [
-        { title: 'Competence', description: 'Decades of experience and Europe-wide know-how.' },
-        { title: 'Availability', description: 'Always there for you – fast support.' },
-        { title: 'Solutions', description: 'We find the best cable solution for your project.' },
-        { title: 'Reliability', description: 'We deliver what we promise.' },
-    ];
+  const values =
+    locale === 'de'
+      ? [
+          {
+            title: 'Kompetenz',
+            description: 'Jahrzehntelange Erfahrung und europaweites Know-how.',
+          },
+          { title: 'Verfügbarkeit', description: 'Immer für Sie da – schnelle Unterstützung.' },
+          { title: 'Lösungen', description: 'Wir finden die beste Kabellösung für Ihr Projekt.' },
+          { title: 'Zuverlässigkeit', description: 'Wir halten, was wir versprechen.' },
+        ]
+      : [
+          { title: 'Competence', description: 'Decades of experience and Europe-wide know-how.' },
+          { title: 'Availability', description: 'Always there for you – fast support.' },
+          { title: 'Solutions', description: 'We find the best cable solution for your project.' },
+          { title: 'Reliability', description: 'We deliver what we promise.' },
+        ];
 
-    return {
-        tagline: locale === 'de'
-            ? 'Wegweisend in der Kabelinfrastruktur.'
-            : 'Leading the way in cable infrastructure.',
-        values,
-        address: 'Raiffeisenstraße 22, 73630 Remshalden, Germany',
-        phone: '+49 (0) 7151 959 89-0',
-        email: 'info@klz-cables.com',
-        website: 'www.klz-cables.com',
-    };
+  return {
+    tagline:
+      locale === 'de'
+        ? 'Wegweisend in der Kabelinfrastruktur.'
+        : 'Leading the way in cable infrastructure.',
+    values,
+    address: 'Raiffeisenstraße 22, 73630 Remshalden, Germany',
+    phone: '+49 (0) 7151 959 89-0',
+    email: 'info@klz-cables.com',
+    website: 'www.klz-cables.com',
+  };
 }
 
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 async function main(): Promise<void> {
-    const start = Date.now();
-    console.log('Starting brochure generation (Full Brochure with website content)');
-    ensureOutputDir();
+  const start = Date.now();
+  console.log('Starting brochure generation (Full Brochure with website content)');
+  ensureOutputDir();
 
-    const locales: Array<'en' | 'de'> = ['en', 'de'];
+  const locales: Array<'en' | 'de'> = ['en', 'de'];
 
-    // Load the REAL logos (not the favicon/icon!)
-    const logoWhitePath = path.join(process.cwd(), 'public/logo-white.png');
-    const logoBlackPath = path.join(process.cwd(), 'public/logo-black.png');
-    const logoFallbackPath = path.join(process.cwd(), 'public/logo.png');
+  // Load the REAL logos (not the favicon/icon!)
+  const logoWhitePath = path.join(process.cwd(), 'public/logo-white.png');
+  const logoBlackPath = path.join(process.cwd(), 'public/logo-black.png');
+  const logoFallbackPath = path.join(process.cwd(), 'public/logo.png');
 
-    const logoWhite = fs.existsSync(logoWhitePath) ? logoWhitePath : undefined;
-    const logoBlack = fs.existsSync(logoBlackPath) ? logoBlackPath : (fs.existsSync(logoFallbackPath) ? logoFallbackPath : undefined);
+  const logoWhite = fs.existsSync(logoWhitePath) ? logoWhitePath : undefined;
+  const logoBlack = fs.existsSync(logoBlackPath)
+    ? logoBlackPath
+    : fs.existsSync(logoFallbackPath)
+      ? logoFallbackPath
+      : undefined;
 
-    console.log(`Logos: white=${!!logoWhite} black=${!!logoBlack}`);
+  console.log(`Logos: white=${!!logoWhite} black=${!!logoBlack}`);
 
-    // EXACT image mapping — 2 marketing sections now
-    // Index map: 0=Cover, 1=About, 2=WasWirTun(null), 3=Erfahrung(Legacy image), 4=BackCover
-    const galleryPaths: Array<string | null> = [
-        'uploads/2024/12/large-rolls-of-wires-against-the-blue-sky-at-sunse-2023-11-27-05-20-33-utc-Large.webp', // 0: Cover (cable drums, no people)
-        'uploads/2024/12/DSC07460-Large-600x400.webp',   // 1: About section
-        null,                                            // 2: Was wir tun (NO IMAGE — text-heavy)
-        'uploads/2024/12/1694273920124-copy.webp',       // 3: Erfahrung & Qualität
-        'uploads/2024/12/DSC07433-Large-600x400.webp',   // 4: Back cover
-    ];
+  // EXACT image mapping — 2 marketing sections now
+  // Index map: 0=Cover, 1=About, 2=WasWirTun(null), 3=Erfahrung(Legacy image), 4=BackCover
+  const galleryPaths: Array<string | null> = [
+    'uploads/2024/12/large-rolls-of-wires-against-the-blue-sky-at-sunse-2023-11-27-05-20-33-utc-Large.webp', // 0: Cover (cable drums, no people)
+    'uploads/2024/12/DSC07460-Large-600x400.webp', // 1: About section
+    null, // 2: Was wir tun (NO IMAGE — text-heavy)
+    'uploads/2024/12/1694273920124-copy.webp', // 3: Erfahrung & Qualität
+    'uploads/2024/12/DSC07433-Large-600x400.webp', // 4: Back cover
+  ];
 
-    const galleryImages: (string | Buffer | undefined)[] = [];
-    for (const gp of galleryPaths) {
-        if (!gp) {
-            galleryImages.push(undefined);
-            continue;
-        }
-        const fullPath = path.join(process.cwd(), 'public', gp);
-        if (fs.existsSync(fullPath)) {
-            try {
-                const buf = await sharp(fullPath).png({ quality: 80 }).resize(800).toBuffer();
-                galleryImages.push(buf);
-            } catch {
-                galleryImages.push(undefined);
-            }
-        } else {
-            galleryImages.push(undefined);
-        }
+  const galleryImages: (string | Buffer | undefined)[] = [];
+  for (const gp of galleryPaths) {
+    if (!gp) {
+      galleryImages.push(undefined);
+      continue;
     }
-    console.log(`Gallery images mapping complete. Succeeded bindings: ${galleryImages.filter(b => b !== undefined).length}`);
+    const fullPath = path.join(process.cwd(), 'public', gp);
+    if (fs.existsSync(fullPath)) {
+      try {
+        const buf = await sharp(fullPath).png({ quality: 80 }).resize(800).toBuffer();
+        galleryImages.push(buf);
+      } catch {
+        galleryImages.push(undefined);
+      }
+    } else {
+      galleryImages.push(undefined);
+    }
+  }
+  console.log(
+    `Gallery images mapping complete. Succeeded bindings: ${galleryImages.filter((b) => b !== undefined).length}`,
+  );
 
-    for (const locale of locales) {
-        console.log(`\nGenerating ${locale.toUpperCase()} brochure...`);
-        const [products, introContent, marketingSections] = await Promise.all([
-            loadProducts(locale),
-            loadIntroContent(locale),
-            loadMarketingSections(locale)
-        ]);
+  for (const locale of locales) {
+    console.log(`\nGenerating ${locale.toUpperCase()} brochure...`);
+    const [products, introContent, marketingSections] = await Promise.all([
+      loadProducts(locale),
+      loadIntroContent(locale),
+      loadMarketingSections(locale),
+    ]);
 
-        if (products.length === 0) continue;
-        const companyInfo = getCompanyInfo(locale);
+    if (products.length === 0) continue;
+    const companyInfo = getCompanyInfo(locale);
 
-        // Load messages for About page content (directors, legacy, etc.)
-        let messages: Record<string, any> | undefined;
-        try {
-            const messagesPath = path.join(process.cwd(), `messages/${locale}.json`);
-            messages = JSON.parse(fs.readFileSync(messagesPath, 'utf-8'));
-        } catch { /* messages are optional */ }
-
-        // Load director portrait photos and crop to circles
-        const directorPhotos: { michael?: Buffer; klaus?: Buffer } = {};
-        const portraitPaths = {
-            michael: path.join(process.cwd(), 'public/uploads/2024/12/DSC07768-Large.webp'),
-            klaus: path.join(process.cwd(), 'public/uploads/2024/12/DSC07963-Large.webp'),
-        };
-        const AVATAR_SIZE = 120; // px, will be rendered at 32pt in PDF
-        const circleMask = Buffer.from(
-            `<svg width="${AVATAR_SIZE}" height="${AVATAR_SIZE}"><circle cx="${AVATAR_SIZE / 2}" cy="${AVATAR_SIZE / 2}" r="${AVATAR_SIZE / 2}" fill="white"/></svg>`
-        );
-        for (const [key, photoPath] of Object.entries(portraitPaths)) {
-            if (fs.existsSync(photoPath)) {
-                try {
-                    const cropped = await sharp(photoPath)
-                        .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: 'cover', position: 'top' })
-                        .composite([{ input: circleMask, blend: 'dest-in' }])
-                        .png()
-                        .toBuffer();
-                    directorPhotos[key as 'michael' | 'klaus'] = cropped;
-                } catch { /* skip */ }
-            }
-        }
-
-        try {
-            // Render the React-PDF brochure
-            const buffer = await renderToBuffer(
-                React.createElement(PDFBrochure, {
-                    products, locale, companyInfo, introContent,
-                    marketingSections, logoBlack, logoWhite, galleryImages, messages, directorPhotos,
-                } as any) as any
-            );
-
-            // Write final PDF
-            const outPath = path.join(process.cwd(), `public/brochure/klz-product-catalog-${locale}.pdf`);
-            fs.mkdirSync(path.dirname(outPath), { recursive: true });
-            fs.writeFileSync(outPath, buffer);
-
-            const sizeKB = Math.round(buffer.length / 1024);
-            console.log(`  ✓ Generated: klz-product-catalog-${locale}.pdf (${sizeKB} KB)`);
-        } catch (error) {
-            console.error(`  ✗ Failed to generate ${locale} brochure:`, error);
-        }
+    // Load messages for About page content (directors, legacy, etc.)
+    let messages: Record<string, any> | undefined;
+    try {
+      const messagesPath = path.join(process.cwd(), `messages/${locale}.json`);
+      messages = JSON.parse(fs.readFileSync(messagesPath, 'utf-8'));
+    } catch {
+      /* messages are optional */
     }
 
-    console.log(`\n✅ Done!`);
-    console.log(`Output: ${CONFIG.outputDir}`);
-    console.log(`Time: ${((Date.now() - start) / 1000).toFixed(2)}s`);
+    // Load director portrait photos and crop to circles
+    const directorPhotos: { michael?: Buffer; klaus?: Buffer } = {};
+    const portraitPaths = {
+      michael: path.join(process.cwd(), 'public/uploads/2024/12/DSC07768-Large.webp'),
+      klaus: path.join(process.cwd(), 'public/uploads/2024/12/DSC07963-Large.webp'),
+    };
+    const AVATAR_SIZE = 120; // px, will be rendered at 32pt in PDF
+    const circleMask = Buffer.from(
+      `<svg width="${AVATAR_SIZE}" height="${AVATAR_SIZE}"><circle cx="${AVATAR_SIZE / 2}" cy="${AVATAR_SIZE / 2}" r="${AVATAR_SIZE / 2}" fill="white"/></svg>`,
+    );
+    for (const [key, photoPath] of Object.entries(portraitPaths)) {
+      if (fs.existsSync(photoPath)) {
+        try {
+          const cropped = await sharp(photoPath)
+            .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: 'cover', position: 'top' })
+            .composite([{ input: circleMask, blend: 'dest-in' }])
+            .png()
+            .toBuffer();
+          directorPhotos[key as 'michael' | 'klaus'] = cropped;
+        } catch {
+          /* skip */
+        }
+      }
+    }
+
+    try {
+      // Render the React-PDF brochure
+      const buffer = await renderToBuffer(
+        React.createElement(PDFBrochure, {
+          products,
+          locale,
+          companyInfo,
+          introContent,
+          marketingSections,
+          logoBlack,
+          logoWhite,
+          galleryImages,
+          messages,
+          directorPhotos,
+        } as any) as any,
+      );
+
+      // Write final PDF
+      const outPath = path.join(process.cwd(), `public/brochure/klz-product-catalog-${locale}.pdf`);
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, buffer);
+
+      const sizeKB = Math.round(buffer.length / 1024);
+      console.log(`  ✓ Generated: klz-product-catalog-${locale}.pdf (${sizeKB} KB)`);
+    } catch (error) {
+      console.error(`  ✗ Failed to generate ${locale} brochure:`, error);
+    }
+  }
+
+  console.log(`\n✅ Done!`);
+  console.log(`Output: ${CONFIG.outputDir}`);
+  console.log(`Time: ${((Date.now() - start) / 1000).toFixed(2)}s`);
 }
 
 main().catch(console.error);
diff --git a/scripts/generate-pdf-datasheets-pdf-lib.ts b/scripts/generate-pdf-datasheets-pdf-lib.ts
index 1868d122..77a2aa04 100644
--- a/scripts/generate-pdf-datasheets-pdf-lib.ts
+++ b/scripts/generate-pdf-datasheets-pdf-lib.ts
@@ -30,10 +30,10 @@ const ASSET_MAP_FILE = path.join(process.cwd(), 'data/processed/asset-map.json')
 const PUBLIC_DIR = path.join(process.cwd(), 'public');
 
 const EXCEL_SOURCE_FILES = [
-  path.join(process.cwd(), 'data/source/high-voltage.xlsx'),
-  path.join(process.cwd(), 'data/source/medium-voltage-KM.xlsx'),
-  path.join(process.cwd(), 'data/source/low-voltage-KM.xlsx'),
-  path.join(process.cwd(), 'data/source/solar-cables.xlsx'),
+  path.join(process.cwd(), 'data/excel/high-voltage.xlsx'),
+  path.join(process.cwd(), 'data/excel/medium-voltage-KM.xlsx'),
+  path.join(process.cwd(), 'data/excel/low-voltage-KM.xlsx'),
+  path.join(process.cwd(), 'data/excel/solar-cables.xlsx'),
 ];
 
 type AssetMap = Record<string, string>;
diff --git a/scripts/lib/excel-data-parser.ts b/scripts/lib/excel-data-parser.ts
index 78d3d089..b94d5e76 100644
--- a/scripts/lib/excel-data-parser.ts
+++ b/scripts/lib/excel-data-parser.ts
@@ -3,19 +3,19 @@ import * as path from 'path';
 import { execSync } from 'child_process';
 
 const EXCEL_SOURCE_FILES = [
-    path.join(process.cwd(), 'data/source/high-voltage.xlsx'),
-    path.join(process.cwd(), 'data/source/medium-voltage-KM.xlsx'),
-    path.join(process.cwd(), 'data/source/low-voltage-KM.xlsx'),
-    path.join(process.cwd(), 'data/source/solar-cables.xlsx'),
+  path.join(process.cwd(), 'data/excel/high-voltage.xlsx'),
+  path.join(process.cwd(), 'data/excel/medium-voltage-KM.xlsx'),
+  path.join(process.cwd(), 'data/excel/low-voltage-KM.xlsx'),
+  path.join(process.cwd(), 'data/excel/solar-cables.xlsx'),
 ];
 
 export interface ProductData {
-    id?: number;
-    name: string;
-    slug?: string;
-    sku: string;
-    translationKey?: string;
-    locale?: 'en' | 'de';
+  id?: number;
+  name: string;
+  slug?: string;
+  sku: string;
+  translationKey?: string;
+  locale?: 'en' | 'de';
 }
 
 export type ExcelRow = Record<string, any>;
@@ -24,820 +24,975 @@ let EXCEL_INDEX: Map<string, ExcelMatch> | null = null;
 
 export type KeyValueItem = { label: string; value: string; unit?: string };
 export type VoltageTableModel = {
-    voltageLabel: string;
-    metaItems: KeyValueItem[];
-    crossSections: string[];
-    columns: Array<{ key: string; label: string; get: (rowIndex: number) => string }>;
+  voltageLabel: string;
+  metaItems: KeyValueItem[];
+  crossSections: string[];
+  columns: Array<{ key: string; label: string; get: (rowIndex: number) => string }>;
 };
 
 function stripHtml(html: string): string {
-    if (!html) return '';
-    return html.replace(/<[^>]*>/g, '').trim();
+  if (!html) return '';
+  return html.replace(/<[^>]*>/g, '').trim();
 }
 
 function normalizeValue(value: string): string {
-    return stripHtml(value).replace(/\s+/g, ' ').trim();
+  return stripHtml(value).replace(/\s+/g, ' ').trim();
 }
 
 function formatNumber(n: number): string {
-    const s = Number.isInteger(n) ? String(n) : String(n);
-    return s.replace(/\.0+$/, '');
+  const s = Number.isInteger(n) ? String(n) : String(n);
+  return s.replace(/\.0+$/, '');
 }
 
 function parseNumericOption(value: string): number | null {
-    const v = normalizeValue(value).replace(/,/g, '.');
-    const m = v.match(/-?\d+(?:\.\d+)?/);
-    if (!m) return null;
-    const n = Number(m[0]);
-    return Number.isFinite(n) ? n : null;
+  const v = normalizeValue(value).replace(/,/g, '.');
+  const m = v.match(/-?\d+(?:\.\d+)?/);
+  if (!m) return null;
+  const n = Number(m[0]);
+  return Number.isFinite(n) ? n : null;
 }
 
 function summarizeNumericRange(options: string[] | undefined): { ok: boolean; text: string } {
-    const vals = (options || []).map(parseNumericOption).filter((n): n is number => n !== null);
-    if (vals.length < 3) return { ok: false, text: '' };
-    const uniq = Array.from(new Set(vals));
-    if (uniq.length < 4) return { ok: false, text: '' };
-    uniq.sort((a, b) => a - b);
-    const min = uniq[0];
-    const max = uniq[uniq.length - 1];
-    return { ok: true, text: `${formatNumber(min)}–${formatNumber(max)}` };
+  const vals = (options || []).map(parseNumericOption).filter((n): n is number => n !== null);
+  if (vals.length < 3) return { ok: false, text: '' };
+  const uniq = Array.from(new Set(vals));
+  if (uniq.length < 4) return { ok: false, text: '' };
+  uniq.sort((a, b) => a - b);
+  const min = uniq[0];
+  const max = uniq[uniq.length - 1];
+  return { ok: true, text: `${formatNumber(min)}–${formatNumber(max)}` };
 }
 
 function summarizeOptions(options: string[] | undefined, maxItems: number = 3): string {
-    const vals = (options || []).map(normalizeValue).filter(Boolean);
-    if (vals.length === 0) return '';
-    const uniq = Array.from(new Set(vals));
-    if (uniq.length === 1) return uniq[0];
-    if (uniq.length <= maxItems) return uniq.join(' / ');
-    return `${uniq.slice(0, maxItems).join(' / ')} / ...`;
+  const vals = (options || []).map(normalizeValue).filter(Boolean);
+  if (vals.length === 0) return '';
+  const uniq = Array.from(new Set(vals));
+  if (uniq.length === 1) return uniq[0];
+  if (uniq.length <= maxItems) return uniq.join(' / ');
+  return `${uniq.slice(0, maxItems).join(' / ')} / ...`;
 }
 
 function summarizeSmartOptions(label: string, options: string[] | undefined): string {
-    const range = summarizeNumericRange(options);
-    if (range.ok) return range.text;
-    return summarizeOptions(options, 3);
+  const range = summarizeNumericRange(options);
+  if (range.ok) return range.text;
+  return summarizeOptions(options, 3);
 }
 
 function looksNumeric(value: string): boolean {
-    const v = normalizeValue(value).replace(/,/g, '.');
-    return /^-?\d+(?:\.\d+)?$/.test(v);
+  const v = normalizeValue(value).replace(/,/g, '.');
+  return /^-?\d+(?:\.\d+)?$/.test(v);
 }
 
 function normalizeUnit(unitRaw: string): string {
-    const u = normalizeValue(unitRaw);
-    if (!u) return '';
-    if (/^c$/i.test(u) || /^°c$/i.test(u)) return '°C';
-    return u
-        .replace(/Ω/gi, 'Ohm')
-        .replace(/[\u00B5\u03BC]/g, 'u');
+  const u = normalizeValue(unitRaw);
+  if (!u) return '';
+  if (/^c$/i.test(u) || /^°c$/i.test(u)) return '°C';
+  return u.replace(/Ω/gi, 'Ohm').replace(/[\u00B5\u03BC]/g, 'u');
 }
 
 function denseAbbrevLabel(args: {
-    key: string;
-    locale: 'en' | 'de';
-    unit?: string;
-    withUnit?: boolean;
+  key: string;
+  locale: 'en' | 'de';
+  unit?: string;
+  withUnit?: boolean;
 }): string {
-    const u = normalizeUnit(args.unit || '');
-    const withUnit = args.withUnit ?? true;
-    const unitSafe = u
-        .replace(/Ω/gi, 'Ohm')
-        .replace(/[\u00B5\u03BC]/g, 'u');
-    const suffix = withUnit && unitSafe ? ` [${unitSafe}]` : '';
+  const u = normalizeUnit(args.unit || '');
+  const withUnit = args.withUnit ?? true;
+  const unitSafe = u.replace(/Ω/gi, 'Ohm').replace(/[\u00B5\u03BC]/g, 'u');
+  const suffix = withUnit && unitSafe ? ` [${unitSafe}]` : '';
 
-    switch (args.key) {
-        case 'DI':
-        case 'RI':
-        case 'Wi':
-        case 'Ibl':
-        case 'Ibe':
-        case 'Wm':
-        case 'Rbv':
-        case 'Fzv':
-        case 'G':
-            return `${args.key}${suffix}`;
-        case 'Ik_cond':
-            return `Ik${suffix}`;
-        case 'Ik_screen':
-            return `Ik_s${suffix}`;
-        case 'Ø':
-            return `Ø${suffix}`;
-        case 'Cond':
-            return args.locale === 'de' ? 'Leiter' : 'Cond.';
-        case 'shape':
-            return args.locale === 'de' ? 'Form' : 'Shape';
-        case 'cap':
-            return `C${suffix}`;
-        case 'X':
-            return `X${suffix}`;
-        case 'temp_range':
-            return `T${suffix}`;
-        case 'max_op_temp':
-            return `T_op${suffix}`;
-        case 'max_sc_temp':
-            return `T_sc${suffix}`;
-        case 'min_store_temp':
-            return `T_st${suffix}`;
-        case 'min_lay_temp':
-            return `T_lay${suffix}`;
-        case 'cpr':
-            return `CPR${suffix}`;
-        case 'flame':
-            return `FR${suffix}`;
-        case 'test_volt':
-            return `U_test${suffix}`;
-        case 'rated_volt':
-            return `U0/U${suffix}`;
-        default:
-            return args.key || '';
-    }
+  switch (args.key) {
+    case 'DI':
+    case 'RI':
+    case 'Wi':
+    case 'Ibl':
+    case 'Ibe':
+    case 'Wm':
+    case 'Rbv':
+    case 'Fzv':
+    case 'G':
+      return `${args.key}${suffix}`;
+    case 'Ik_cond':
+      return `Ik${suffix}`;
+    case 'Ik_screen':
+      return `Ik_s${suffix}`;
+    case 'Ø':
+      return `Ø${suffix}`;
+    case 'Cond':
+      return args.locale === 'de' ? 'Leiter' : 'Cond.';
+    case 'shape':
+      return args.locale === 'de' ? 'Form' : 'Shape';
+    case 'cap':
+      return `C${suffix}`;
+    case 'X':
+      return `X${suffix}`;
+    case 'temp_range':
+      return `T${suffix}`;
+    case 'max_op_temp':
+      return `T_op${suffix}`;
+    case 'max_sc_temp':
+      return `T_sc${suffix}`;
+    case 'min_store_temp':
+      return `T_st${suffix}`;
+    case 'min_lay_temp':
+      return `T_lay${suffix}`;
+    case 'cpr':
+      return `CPR${suffix}`;
+    case 'flame':
+      return `FR${suffix}`;
+    case 'test_volt':
+      return `U_test${suffix}`;
+    case 'rated_volt':
+      return `U0/U${suffix}`;
+    default:
+      return args.key || '';
+  }
 }
 
 function formatExcelHeaderLabel(key: string, unit?: string): string {
-    const k = normalizeValue(key);
-    if (!k) return '';
-    const u = normalizeValue(unit || '');
+  const k = normalizeValue(key);
+  if (!k) return '';
+  const u = normalizeValue(unit || '');
 
-    const compact = k
-        .replace(/\s*\(approx\.?\)\s*/gi, ' (approx.) ')
-        .replace(/\s+/g, ' ')
-        .trim();
+  const compact = k
+    .replace(/\s*\(approx\.?\)\s*/gi, ' (approx.) ')
+    .replace(/\s+/g, ' ')
+    .trim();
 
-    if (!u) return compact;
-    if (new RegExp(`\\(${u.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&')}\\)`, 'i').test(compact)) return compact;
-    return `${compact} (${u})`;
+  if (!u) return compact;
+  if (new RegExp(`\\(${u.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&')}\\)`, 'i').test(compact))
+    return compact;
+  return `${compact} (${u})`;
 }
 
 function metaFullLabel(args: { key: string; excelKey: string; locale: 'en' | 'de' }): string {
-    const key = normalizeValue(args.key);
-    if (args.locale === 'de') {
-        switch (key) {
-            case 'test_volt':
-                return 'Prüfspannung';
-            case 'temp_range':
-                return 'Temperaturbereich';
-            case 'max_op_temp':
-                return 'Leitertemperatur (max.)';
-            case 'max_sc_temp':
-                return 'Kurzschlusstemperatur (max.)';
-            case 'min_lay_temp':
-                return 'Minimale Verlegetemperatur';
-            case 'min_store_temp':
-                return 'Minimale Lagertemperatur';
-            case 'cpr':
-                return 'CPR-Klasse';
-            case 'flame':
-                return 'Flammhemmend';
-            default:
-                return formatExcelHeaderLabel(args.excelKey);
-        }
-    }
-
+  const key = normalizeValue(args.key);
+  if (args.locale === 'de') {
     switch (key) {
-        case 'test_volt':
-            return 'Test voltage';
-        case 'temp_range':
-            return 'Operating temperature range';
-        case 'max_op_temp':
-            return 'Conductor temperature (max.)';
-        case 'max_sc_temp':
-            return 'Short-circuit temperature (max.)';
-        case 'min_lay_temp':
-            return 'Minimum laying temperature';
-        case 'min_store_temp':
-            return 'Minimum storage temperature';
-        case 'cpr':
-            return 'CPR class';
-        case 'flame':
-            return 'Flame retardant';
-        default:
-            return formatExcelHeaderLabel(args.excelKey);
+      case 'test_volt':
+        return 'Prüfspannung';
+      case 'temp_range':
+        return 'Temperaturbereich';
+      case 'max_op_temp':
+        return 'Leitertemperatur (max.)';
+      case 'max_sc_temp':
+        return 'Kurzschlusstemperatur (max.)';
+      case 'min_lay_temp':
+        return 'Minimale Verlegetemperatur';
+      case 'min_store_temp':
+        return 'Minimale Lagertemperatur';
+      case 'cpr':
+        return 'CPR-Klasse';
+      case 'flame':
+        return 'Flammhemmend';
+      default:
+        return formatExcelHeaderLabel(args.excelKey);
     }
+  }
+
+  switch (key) {
+    case 'test_volt':
+      return 'Test voltage';
+    case 'temp_range':
+      return 'Operating temperature range';
+    case 'max_op_temp':
+      return 'Conductor temperature (max.)';
+    case 'max_sc_temp':
+      return 'Short-circuit temperature (max.)';
+    case 'min_lay_temp':
+      return 'Minimum laying temperature';
+    case 'min_store_temp':
+      return 'Minimum storage temperature';
+    case 'cpr':
+      return 'CPR class';
+    case 'flame':
+      return 'Flame retardant';
+    default:
+      return formatExcelHeaderLabel(args.excelKey);
+  }
 }
 
 function technicalFullLabel(args: { key: string; excelKey: string; locale: 'en' | 'de' }): string {
-    const k = normalizeValue(args.key);
+  const k = normalizeValue(args.key);
 
-    if (args.locale === 'de') {
-        switch (k) {
-            case 'DI': return 'Durchmesser über Isolierung';
-            case 'RI': return 'DC-Leiterwiderstand (20 °C)';
-            case 'Wi': return 'Isolationsdicke';
-            case 'Ibl': return 'Strombelastbarkeit in Luft (trefoil)';
-            case 'Ibe': return 'Strombelastbarkeit im Erdreich (trefoil)';
-            case 'Ik_cond': return 'Kurzschlussstrom Leiter';
-            case 'Ik_screen': return 'Kurzschlussstrom Schirm';
-            case 'Wm': return 'Manteldicke';
-            case 'Rbv': return 'Biegeradius (min.)';
-            case 'Ø': return 'Außen-Ø';
-            case 'Fzv': return 'Zugkraft (max.)';
-            case 'G': return 'Gewicht';
-            case 'Cond':
-            case 'conductor': return 'Leiter';
-            case 'shape': return 'Leiterform';
-            case 'insulation': return 'Isolierung';
-            case 'sheath': return 'Mantel';
-            case 'cap': return 'Kapazität';
-            case 'ind_trefoil': return 'Induktivität (trefoil)';
-            case 'ind_air_flat': return 'Induktivität (Luft, flach)';
-            case 'ind_ground_flat': return 'Induktivität (Erdreich, flach)';
-            case 'X': return 'Reaktanz';
-            case 'test_volt': return 'Prüfspannung';
-            case 'rated_volt': return 'Nennspannung';
-            case 'temp_range': return 'Temperaturbereich';
-            case 'max_op_temp': return 'Leitertemperatur (max.)';
-            case 'max_sc_temp': return 'Kurzschlusstemperatur (max.)';
-            case 'min_store_temp': return 'Minimale Lagertemperatur';
-            case 'min_lay_temp': return 'Minimale Verlegetemperatur';
-            case 'cpr': return 'CPR-Klasse';
-            case 'flame': return 'Flammhemmend';
-            case 'packaging': return 'Verpackung';
-            case 'ce': return 'CE-Konformität';
-            case 'norm': return 'Norm';
-            case 'standard': return 'Standard';
-            case 'D_screen': return 'Durchmesser über Schirm';
-            case 'S_screen': return 'Metallischer Schirm';
-            default: break;
-        }
-
-        const raw = normalizeValue(args.excelKey);
-        if (!raw) return '';
-        return raw
-            .replace(/\(approx\.?\)/gi, '(ca.)')
-            .replace(/\bcapacitance\b/gi, 'Kapazität')
-            .replace(/\binductance\b/gi, 'Induktivität')
-            .replace(/\breactance\b/gi, 'Reaktanz')
-            .replace(/\btest voltage\b/gi, 'Prüfspannung')
-            .replace(/\brated voltage\b/gi, 'Nennspannung')
-            .replace(/\boperating temperature range\b/gi, 'Temperaturbereich')
-            .replace(/\bminimum sheath thickness\b/gi, 'Manteldicke (min.)')
-            .replace(/\bsheath thickness\b/gi, 'Manteldicke')
-            .replace(/\bnominal insulation thickness\b/gi, 'Isolationsdicke (nom.)')
-            .replace(/\binsulation thickness\b/gi, 'Isolationsdicke')
-            .replace(/\bdc resistance at 20\s*°?c\b/gi, 'DC-Leiterwiderstand (20 °C)')
-            .replace(/\bouter diameter(?: of cable)?\b/gi, 'Außen-Ø')
-            .replace(/\bbending radius\b/gi, 'Biegeradius')
-            .replace(/\bpackaging\b/gi, 'Verpackung')
-            .replace(/\bce\s*-?conformity\b/gi, 'CE-Konformität');
+  if (args.locale === 'de') {
+    switch (k) {
+      case 'DI':
+        return 'Durchmesser über Isolierung';
+      case 'RI':
+        return 'DC-Leiterwiderstand (20 °C)';
+      case 'Wi':
+        return 'Isolationsdicke';
+      case 'Ibl':
+        return 'Strombelastbarkeit in Luft (trefoil)';
+      case 'Ibe':
+        return 'Strombelastbarkeit im Erdreich (trefoil)';
+      case 'Ik_cond':
+        return 'Kurzschlussstrom Leiter';
+      case 'Ik_screen':
+        return 'Kurzschlussstrom Schirm';
+      case 'Wm':
+        return 'Manteldicke';
+      case 'Rbv':
+        return 'Biegeradius (min.)';
+      case 'Ø':
+        return 'Außen-Ø';
+      case 'Fzv':
+        return 'Zugkraft (max.)';
+      case 'G':
+        return 'Gewicht';
+      case 'Cond':
+      case 'conductor':
+        return 'Leiter';
+      case 'shape':
+        return 'Leiterform';
+      case 'insulation':
+        return 'Isolierung';
+      case 'sheath':
+        return 'Mantel';
+      case 'cap':
+        return 'Kapazität';
+      case 'ind_trefoil':
+        return 'Induktivität (trefoil)';
+      case 'ind_air_flat':
+        return 'Induktivität (Luft, flach)';
+      case 'ind_ground_flat':
+        return 'Induktivität (Erdreich, flach)';
+      case 'X':
+        return 'Reaktanz';
+      case 'test_volt':
+        return 'Prüfspannung';
+      case 'rated_volt':
+        return 'Nennspannung';
+      case 'temp_range':
+        return 'Temperaturbereich';
+      case 'max_op_temp':
+        return 'Leitertemperatur (max.)';
+      case 'max_sc_temp':
+        return 'Kurzschlusstemperatur (max.)';
+      case 'min_store_temp':
+        return 'Minimale Lagertemperatur';
+      case 'min_lay_temp':
+        return 'Minimale Verlegetemperatur';
+      case 'cpr':
+        return 'CPR-Klasse';
+      case 'flame':
+        return 'Flammhemmend';
+      case 'packaging':
+        return 'Verpackung';
+      case 'ce':
+        return 'CE-Konformität';
+      case 'norm':
+        return 'Norm';
+      case 'standard':
+        return 'Standard';
+      case 'D_screen':
+        return 'Durchmesser über Schirm';
+      case 'S_screen':
+        return 'Metallischer Schirm';
+      default:
+        break;
     }
 
-    return normalizeValue(args.excelKey);
+    const raw = normalizeValue(args.excelKey);
+    if (!raw) return '';
+    return raw
+      .replace(/\(approx\.?\)/gi, '(ca.)')
+      .replace(/\bcapacitance\b/gi, 'Kapazität')
+      .replace(/\binductance\b/gi, 'Induktivität')
+      .replace(/\breactance\b/gi, 'Reaktanz')
+      .replace(/\btest voltage\b/gi, 'Prüfspannung')
+      .replace(/\brated voltage\b/gi, 'Nennspannung')
+      .replace(/\boperating temperature range\b/gi, 'Temperaturbereich')
+      .replace(/\bminimum sheath thickness\b/gi, 'Manteldicke (min.)')
+      .replace(/\bsheath thickness\b/gi, 'Manteldicke')
+      .replace(/\bnominal insulation thickness\b/gi, 'Isolationsdicke (nom.)')
+      .replace(/\binsulation thickness\b/gi, 'Isolationsdicke')
+      .replace(/\bdc resistance at 20\s*°?c\b/gi, 'DC-Leiterwiderstand (20 °C)')
+      .replace(/\bouter diameter(?: of cable)?\b/gi, 'Außen-Ø')
+      .replace(/\bbending radius\b/gi, 'Biegeradius')
+      .replace(/\bpackaging\b/gi, 'Verpackung')
+      .replace(/\bce\s*-?conformity\b/gi, 'CE-Konformität');
+  }
+
+  return normalizeValue(args.excelKey);
 }
 
 function compactNumericForLocale(value: string, locale: 'en' | 'de'): string {
-    const v = normalizeValue(value);
-    if (!v) return '';
+  const v = normalizeValue(value);
+  if (!v) return '';
 
-    if (/\d+xD/.test(v)) {
-        const numbers = [];
-        const matches = Array.from(v.matchAll(/(\d+)xD/g));
-        for (let i = 0; i < matches.length; i++) numbers.push(matches[i][1]);
-        if (numbers.length > 0) {
-            const unique: string[] = [];
-            for (const num of numbers) {
-                if (!unique.includes(num)) {
-                    unique.push(num);
-                }
-            }
-            return unique.join('/') + 'xD';
+  if (/\d+xD/.test(v)) {
+    const numbers = [];
+    const matches = Array.from(v.matchAll(/(\d+)xD/g));
+    for (let i = 0; i < matches.length; i++) numbers.push(matches[i][1]);
+    if (numbers.length > 0) {
+      const unique: string[] = [];
+      for (const num of numbers) {
+        if (!unique.includes(num)) {
+          unique.push(num);
         }
+      }
+      return unique.join('/') + 'xD';
     }
+  }
 
-    const hasDigit = /\d/.test(v);
-    if (!hasDigit) return v;
-    const trimmed = v.replace(/\s+/g, ' ').trim();
-    const parts = trimmed.split(/(–|-)/);
-    const out = parts.map(p => {
-        if (p === '–' || p === '-') return p;
-        const s = p.trim();
-        if (!/^-?\d+(?:[\.,]\d+)?$/.test(s)) return p;
-        const n = s.replace(/,/g, '.');
+  const hasDigit = /\d/.test(v);
+  if (!hasDigit) return v;
+  const trimmed = v.replace(/\s+/g, ' ').trim();
+  const parts = trimmed.split(/(–|-)/);
+  const out = parts.map((p) => {
+    if (p === '–' || p === '-') return p;
+    const s = p.trim();
+    if (!/^-?\d+(?:[\.,]\d+)?$/.test(s)) return p;
+    const n = s.replace(/,/g, '.');
 
-        const compact = n
-            .replace(/\.0+$/, '')
-            .replace(/(\.\d*?)0+$/, '$1')
-            .replace(/\.$/, '');
+    const compact = n
+      .replace(/\.0+$/, '')
+      .replace(/(\.\d*?)0+$/, '$1')
+      .replace(/\.$/, '');
 
-        const hadPlus = /^\+/.test(s);
-        const withPlus = hadPlus && !/^\+/.test(compact) ? `+${compact}` : compact;
-        return locale === 'de' ? withPlus.replace(/\./g, ',') : withPlus;
-    });
-    return out.join('');
+    const hadPlus = /^\+/.test(s);
+    const withPlus = hadPlus && !/^\+/.test(compact) ? `+${compact}` : compact;
+    return locale === 'de' ? withPlus.replace(/\./g, ',') : withPlus;
+  });
+  return out.join('');
 }
 
-function compactCellForDenseTable(value: string, unit: string | undefined, locale: 'en' | 'de'): string {
-    let v = normalizeValue(value);
-    if (!v) return '';
-    const u = normalizeValue(unit || '');
-    if (u) {
-        const esc = u.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        v = v.replace(new RegExp(`\\s*${esc}\\b`, 'ig'), '').trim();
-        v = v
-            .replace(/\bkg\s*\/\s*km\b/gi, '')
-            .replace(/\bohm\s*\/\s*km\b/gi, '')
-            .replace(/\bΩ\s*\/\s*km\b/gi, '')
-            .replace(/\bu\s*f\s*\/\s*km\b/gi, '')
-            .replace(/\bmh\s*\/\s*km\b/gi, '')
-            .replace(/\bkA\b/gi, '')
-            .replace(/\bmm\b/gi, '')
-            .replace(/\bkv\b/gi, '')
-            .replace(/\b°?c\b/gi, '')
-            .replace(/\s+/g, ' ')
-            .trim();
-    }
-
+function compactCellForDenseTable(
+  value: string,
+  unit: string | undefined,
+  locale: 'en' | 'de',
+): string {
+  let v = normalizeValue(value);
+  if (!v) return '';
+  const u = normalizeValue(unit || '');
+  if (u) {
+    const esc = u.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    v = v.replace(new RegExp(`\\s*${esc}\\b`, 'ig'), '').trim();
     v = v
-        .replace(/\s*–\s*/g, '-')
-        .replace(/\s*-\s*/g, '-')
-        .replace(/\s*\/\s*/g, '/')
-        .replace(/\s+/g, ' ')
-        .trim();
+      .replace(/\bkg\s*\/\s*km\b/gi, '')
+      .replace(/\bohm\s*\/\s*km\b/gi, '')
+      .replace(/\bΩ\s*\/\s*km\b/gi, '')
+      .replace(/\bu\s*f\s*\/\s*km\b/gi, '')
+      .replace(/\bmh\s*\/\s*km\b/gi, '')
+      .replace(/\bkA\b/gi, '')
+      .replace(/\bmm\b/gi, '')
+      .replace(/\bkv\b/gi, '')
+      .replace(/\b°?c\b/gi, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
 
-    return compactNumericForLocale(v, locale);
+  v = v
+    .replace(/\s*–\s*/g, '-')
+    .replace(/\s*-\s*/g, '-')
+    .replace(/\s*\/\s*/g, '/')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return compactNumericForLocale(v, locale);
 }
 
 function normalizeVoltageLabel(raw: string): string {
-    const v = normalizeValue(raw);
-    if (!v) return '';
-    const cleaned = v.replace(/\s+/g, ' ');
-    if (/\bkv\b/i.test(cleaned)) return cleaned.replace(/\bkv\b/i, 'kV');
-    const num = cleaned.match(/\d+(?:[\.,]\d+)?(?:\s*\/\s*\d+(?:[\.,]\d+)?)?/);
-    if (!num) return cleaned;
-    if (/[a-z]/i.test(cleaned)) return cleaned;
-    return `${cleaned} kV`;
+  const v = normalizeValue(raw);
+  if (!v) return '';
+  const cleaned = v.replace(/\s+/g, ' ');
+  if (/\bkv\b/i.test(cleaned)) return cleaned.replace(/\bkv\b/i, 'kV');
+  const num = cleaned.match(/\d+(?:[\.,]\d+)?(?:\s*\/\s*\d+(?:[\.,]\d+)?)?/);
+  if (!num) return cleaned;
+  if (/[a-z]/i.test(cleaned)) return cleaned;
+  return `${cleaned} kV`;
 }
 
 function parseVoltageSortKey(voltageLabel: string): number {
-    const v = normalizeVoltageLabel(voltageLabel);
-    const nums = v
-        .replace(/,/g, '.')
-        .match(/\d+(?:\.\d+)?/g)
-        ?.map(n => Number(n))
-        .filter(n => Number.isFinite(n));
-    if (!nums || nums.length === 0) return Number.POSITIVE_INFINITY;
-    return nums[nums.length - 1];
+  const v = normalizeVoltageLabel(voltageLabel);
+  const nums = v
+    .replace(/,/g, '.')
+    .match(/\d+(?:\.\d+)?/g)
+    ?.map((n) => Number(n))
+    .filter((n) => Number.isFinite(n));
+  if (!nums || nums.length === 0) return Number.POSITIVE_INFINITY;
+  return nums[nums.length - 1];
 }
 
 function normalizeExcelKey(value: string): string {
-    return String(value || '')
-        .toUpperCase()
-        .replace(/-\d+$/g, '')
-        .replace(/[^A-Z0-9]+/g, '');
+  return String(value || '')
+    .toUpperCase()
+    .replace(/-\d+$/g, '')
+    .replace(/[^A-Z0-9]+/g, '');
 }
 
 function loadExcelRows(filePath: string): ExcelRow[] {
-    const out = execSync(`npx -y xlsx-cli -j "${filePath}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    const trimmed = out.trim();
-    const jsonStart = trimmed.indexOf('[');
-    if (jsonStart < 0) return [];
-    const jsonText = trimmed.slice(jsonStart);
-    try {
-        return JSON.parse(jsonText) as ExcelRow[];
-    } catch {
-        return [];
-    }
+  const out = execSync(`npx -y xlsx-cli -j "${filePath}"`, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  const trimmed = out.trim();
+  const jsonStart = trimmed.indexOf('[');
+  if (jsonStart < 0) return [];
+  const jsonText = trimmed.slice(jsonStart);
+  try {
+    return JSON.parse(jsonText) as ExcelRow[];
+  } catch {
+    return [];
+  }
 }
 
 function getExcelIndex(): Map<string, ExcelMatch> {
-    if (EXCEL_INDEX) return EXCEL_INDEX;
-    const idx = new Map<string, ExcelMatch>();
-    for (const file of EXCEL_SOURCE_FILES) {
-        if (!fs.existsSync(file)) continue;
-        const rows = loadExcelRows(file);
+  if (EXCEL_INDEX) return EXCEL_INDEX;
+  const idx = new Map<string, ExcelMatch>();
+  for (const file of EXCEL_SOURCE_FILES) {
+    if (!fs.existsSync(file)) continue;
+    const rows = loadExcelRows(file);
 
-        const unitsRow = rows.find(r => r && r['Part Number'] === 'Units') || null;
-        const units: Record<string, string> = {};
-        if (unitsRow) {
-            for (const [k, v] of Object.entries(unitsRow)) {
-                if (k === 'Part Number') continue;
-                const unit = normalizeValue(String(v ?? ''));
-                if (unit) units[k] = unit;
-            }
-        }
-
-        for (const r of rows) {
-            const pn = r?.['Part Number'];
-            if (!pn || pn === 'Units') continue;
-            const key = normalizeExcelKey(String(pn));
-            if (!key) continue;
-            const cur = idx.get(key);
-            if (!cur) {
-                idx.set(key, { rows: [r], units });
-            } else {
-                cur.rows.push(r);
-                if (Object.keys(cur.units).length < Object.keys(units).length) cur.units = units;
-            }
-        }
+    const unitsRow = rows.find((r) => r && r['Part Number'] === 'Units') || null;
+    const units: Record<string, string> = {};
+    if (unitsRow) {
+      for (const [k, v] of Object.entries(unitsRow)) {
+        if (k === 'Part Number') continue;
+        const unit = normalizeValue(String(v ?? ''));
+        if (unit) units[k] = unit;
+      }
     }
-    EXCEL_INDEX = idx;
-    return idx;
+
+    for (const r of rows) {
+      const pn = r?.['Part Number'];
+      if (!pn || pn === 'Units') continue;
+      const key = normalizeExcelKey(String(pn));
+      if (!key) continue;
+      const cur = idx.get(key);
+      if (!cur) {
+        idx.set(key, { rows: [r], units });
+      } else {
+        cur.rows.push(r);
+        if (Object.keys(cur.units).length < Object.keys(units).length) cur.units = units;
+      }
+    }
+  }
+  EXCEL_INDEX = idx;
+  return idx;
 }
 
 function findExcelForProduct(product: ProductData): ExcelMatch | null {
-    const idx = getExcelIndex();
-    const candidates = [
-        product.name,
-        product.slug ? product.slug.replace(/-\d+$/g, '') : '',
-        product.sku,
-        product.translationKey,
-    ].filter(Boolean) as string[];
+  const idx = getExcelIndex();
+  const candidates = [
+    product.name,
+    product.slug ? product.slug.replace(/-\d+$/g, '') : '',
+    product.sku,
+    product.translationKey,
+  ].filter(Boolean) as string[];
 
-    for (const c of candidates) {
-        const key = normalizeExcelKey(c);
-        const match = idx.get(key);
-        if (match && match.rows.length) return match;
-    }
-    return null;
+  for (const c of candidates) {
+    const key = normalizeExcelKey(c);
+    const match = idx.get(key);
+    if (match && match.rows.length) return match;
+  }
+  return null;
 }
 
 function guessColumnKey(row: ExcelRow, patterns: RegExp[]): string | null {
-    const keys = Object.keys(row || {});
+  const keys = Object.keys(row || {});
 
-    for (const re of patterns) {
-        const k = keys.find(x => {
-            const key = String(x);
-            if (re.test('conductor') && /ross section conductor/i.test(key)) return false;
-            if (re.test('insulation thickness') && /Diameter over insulation/i.test(key)) return false;
-            if (re.test('conductor') && !/^conductor$/i.test(key)) return false;
-            if (re.test('insulation') && !/^insulation$/i.test(key)) return false;
-            if (re.test('sheath') && !/^sheath$/i.test(key)) return false;
-            if (re.test('norm') && !/^norm$/i.test(key)) return false;
-            return re.test(key);
-        });
-        if (k) return k;
-    }
-    return null;
+  for (const re of patterns) {
+    const k = keys.find((x) => {
+      const key = String(x);
+      if (re.test('conductor') && /ross section conductor/i.test(key)) return false;
+      if (re.test('insulation thickness') && /Diameter over insulation/i.test(key)) return false;
+      if (re.test('conductor') && !/^conductor$/i.test(key)) return false;
+      if (re.test('insulation') && !/^insulation$/i.test(key)) return false;
+      if (re.test('sheath') && !/^sheath$/i.test(key)) return false;
+      if (re.test('norm') && !/^norm$/i.test(key)) return false;
+      return re.test(key);
+    });
+    if (k) return k;
+  }
+  return null;
 }
 
-export function buildExcelModel(args: {
-    product: ProductData;
-    locale: 'en' | 'de';
-}): { ok: boolean; technicalItems: KeyValueItem[]; voltageTables: VoltageTableModel[] } {
-    const match = findExcelForProduct(args.product);
-    if (!match || match.rows.length === 0) return { ok: false, technicalItems: [], voltageTables: [] };
+export function buildExcelModel(args: { product: ProductData; locale: 'en' | 'de' }): {
+  ok: boolean;
+  technicalItems: KeyValueItem[];
+  voltageTables: VoltageTableModel[];
+} {
+  const match = findExcelForProduct(args.product);
+  if (!match || match.rows.length === 0)
+    return { ok: false, technicalItems: [], voltageTables: [] };
 
-    const units = match.units || {};
-    const rows = match.rows;
+  const units = match.units || {};
+  const rows = match.rows;
 
-    let sample = rows.find(r => r && Object.keys(r).length > 0) || {};
-    let maxColumns = Object.keys(sample).filter(k => k && k !== 'Part Number' && k !== 'Units').length;
+  let sample = rows.find((r) => r && Object.keys(r).length > 0) || {};
+  let maxColumns = Object.keys(sample).filter(
+    (k) => k && k !== 'Part Number' && k !== 'Units',
+  ).length;
 
-    for (const r of rows) {
-        const cols = Object.keys(r).filter(k => k && k !== 'Part Number' && k !== 'Units').length;
-        if (cols > maxColumns) {
-            sample = r;
-            maxColumns = cols;
-        }
+  for (const r of rows) {
+    const cols = Object.keys(r).filter((k) => k && k !== 'Part Number' && k !== 'Units').length;
+    if (cols > maxColumns) {
+      sample = r;
+      maxColumns = cols;
+    }
+  }
+
+  const columnMapping: Record<string, { header: string; unit: string; key: string }> = {
+    'number of cores and cross-section': {
+      header: 'Cross-section',
+      unit: '',
+      key: 'cross_section',
+    },
+    'ross section conductor': { header: 'Cross-section', unit: '', key: 'cross_section' },
+    'diameter over insulation': { header: 'DI', unit: 'mm', key: 'DI' },
+    'diameter over insulation (approx.)': { header: 'DI', unit: 'mm', key: 'DI' },
+    'dc resistance at 20 °C': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
+    'dc resistance at 20°C': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
+    'resistance conductor': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
+    'maximum resistance of conductor': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
+    'insulation thickness': { header: 'Wi', unit: 'mm', key: 'Wi' },
+    'nominal insulation thickness': { header: 'Wi', unit: 'mm', key: 'Wi' },
+    'current ratings in air, trefoil': { header: 'Ibl', unit: 'A', key: 'Ibl' },
+    'current ratings in air, trefoil*': { header: 'Ibl', unit: 'A', key: 'Ibl' },
+    'current ratings in ground, trefoil': { header: 'Ibe', unit: 'A', key: 'Ibe' },
+    'current ratings in ground, trefoil*': { header: 'Ibe', unit: 'A', key: 'Ibe' },
+    'conductor shortcircuit current': { header: 'Ik', unit: 'kA', key: 'Ik_cond' },
+    'screen shortcircuit current': { header: 'Ik', unit: 'kA', key: 'Ik_screen' },
+    'sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
+    'minimum sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
+    'nominal sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
+    'bending radius': { header: 'Rbv', unit: 'mm', key: 'Rbv' },
+    'bending radius (min.)': { header: 'Rbv', unit: 'mm', key: 'Rbv' },
+    'outer diameter': { header: 'Ø', unit: 'mm', key: 'Ø' },
+    'outer diameter (approx.)': { header: 'Ø', unit: 'mm', key: 'Ø' },
+    'outer diameter of cable': { header: 'Ø', unit: 'mm', key: 'Ø' },
+    'pulling force': { header: 'Fzv', unit: 'N', key: 'Fzv' },
+    'max. pulling force': { header: 'Fzv', unit: 'N', key: 'Fzv' },
+    'conductor aluminum': { header: 'Cond.', unit: '', key: 'Cond' },
+    'conductor copper': { header: 'Cond.', unit: '', key: 'Cond' },
+    weight: { header: 'G', unit: 'kg/km', key: 'G' },
+    'weight (approx.)': { header: 'G', unit: 'kg/km', key: 'G' },
+    'cable weight': { header: 'G', unit: 'kg/km', key: 'G' },
+    'conductor diameter (approx.)': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
+    'conductor diameter': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
+    'diameter conductor': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
+    'diameter over screen': { header: 'Diameter over screen', unit: 'mm', key: 'D_screen' },
+    'metallic screen mm2': { header: 'Metallic screen', unit: 'mm2', key: 'S_screen' },
+    'metallic screen': { header: 'Metallic screen', unit: 'mm2', key: 'S_screen' },
+    reactance: { header: 'Reactance', unit: 'Ohm/km', key: 'X' },
+    'capacitance (approx.)': { header: 'Capacitance', unit: 'uF/km', key: 'cap' },
+    capacitance: { header: 'Capacitance', unit: 'uF/km', key: 'cap' },
+    'inductance, trefoil (approx.)': {
+      header: 'Inductance trefoil',
+      unit: 'mH/km',
+      key: 'ind_trefoil',
+    },
+    'inductance, trefoil': { header: 'Inductance trefoil', unit: 'mH/km', key: 'ind_trefoil' },
+    'inductance in air, flat (approx.)': {
+      header: 'Inductance air flat',
+      unit: 'mH/km',
+      key: 'ind_air_flat',
+    },
+    'inductance in air, flat': {
+      header: 'Inductance air flat',
+      unit: 'mH/km',
+      key: 'ind_air_flat',
+    },
+    'inductance in ground, flat (approx.)': {
+      header: 'Inductance ground flat',
+      unit: 'mH/km',
+      key: 'ind_ground_flat',
+    },
+    'inductance in ground, flat': {
+      header: 'Inductance ground flat',
+      unit: 'mH/km',
+      key: 'ind_ground_flat',
+    },
+    'current ratings in air, flat': { header: 'Current air flat', unit: 'A', key: 'cur_air_flat' },
+    'current ratings in air, flat*': { header: 'Current air flat', unit: 'A', key: 'cur_air_flat' },
+    'current ratings in ground, flat': {
+      header: 'Current ground flat',
+      unit: 'A',
+      key: 'cur_ground_flat',
+    },
+    'current ratings in ground, flat*': {
+      header: 'Current ground flat',
+      unit: 'A',
+      key: 'cur_ground_flat',
+    },
+    'heating time constant, trefoil*': {
+      header: 'Heating time trefoil',
+      unit: 's',
+      key: 'heat_trefoil',
+    },
+    'heating time constant, trefoil': {
+      header: 'Heating time trefoil',
+      unit: 's',
+      key: 'heat_trefoil',
+    },
+    'heating time constant, flat*': { header: 'Heating time flat', unit: 's', key: 'heat_flat' },
+    'heating time constant, flat': { header: 'Heating time flat', unit: 's', key: 'heat_flat' },
+    'maximal operating conductor temperature': {
+      header: 'Max operating temp',
+      unit: '°C',
+      key: 'max_op_temp',
+    },
+    'maximal short-circuit temperature': {
+      header: 'Max short-circuit temp',
+      unit: '°C',
+      key: 'max_sc_temp',
+    },
+    'operating temperature range': {
+      header: 'Operating temp range',
+      unit: '°C',
+      key: 'temp_range',
+    },
+    'minimal storage temperature': {
+      header: 'Min storage temp',
+      unit: '°C',
+      key: 'min_store_temp',
+    },
+    'minimal temperature for laying': {
+      header: 'Min laying temp',
+      unit: '°C',
+      key: 'min_lay_temp',
+    },
+    'test voltage': { header: 'Test voltage', unit: 'kV', key: 'test_volt' },
+    'rated voltage': { header: 'Rated voltage', unit: 'kV', key: 'rated_volt' },
+    conductor: { header: 'Conductor', unit: '', key: 'conductor' },
+    'copper wire screen and tape': { header: 'Copper screen', unit: '', key: 'copper_screen' },
+    CUScreen: { header: 'Copper screen', unit: '', key: 'copper_screen' },
+    'conductive tape below screen': {
+      header: 'Conductive tape below',
+      unit: '',
+      key: 'tape_below',
+    },
+    'non conducting tape above screen': {
+      header: 'Non-conductive tape above',
+      unit: '',
+      key: 'tape_above',
+    },
+    'al foil': { header: 'Al foil', unit: '', key: 'al_foil' },
+    'shape of conductor': { header: 'Conductor shape', unit: '', key: 'shape' },
+    'colour of insulation': { header: 'Insulation color', unit: '', key: 'color_ins' },
+    'colour of sheath': { header: 'Sheath color', unit: '', key: 'color_sheath' },
+    insulation: { header: 'Insulation', unit: '', key: 'insulation' },
+    sheath: { header: 'Sheath', unit: '', key: 'sheath' },
+    norm: { header: 'Norm', unit: '', key: 'norm' },
+    standard: { header: 'Standard', unit: '', key: 'standard' },
+    'cpr class': { header: 'CPR class', unit: '', key: 'cpr' },
+    'flame retardant': { header: 'Flame retardant', unit: '', key: 'flame' },
+    'self-extinguishing of single cable': { header: 'Flame retardant', unit: '', key: 'flame' },
+    packaging: { header: 'Packaging', unit: '', key: 'packaging' },
+    'ce-conformity': { header: 'CE conformity', unit: '', key: 'ce' },
+    'rohs/reach': { header: 'RoHS/REACH', unit: '', key: 'rohs_reach' },
+  };
+
+  const excelKeys = Object.keys(sample).filter((k) => k && k !== 'Part Number' && k !== 'Units');
+
+  const matchedColumns: Array<{
+    excelKey: string;
+    mapping: { header: string; unit: string; key: string };
+  }> = [];
+  for (const excelKey of excelKeys) {
+    const normalized = normalizeValue(excelKey).toLowerCase();
+    for (const [pattern, mapping] of Object.entries(columnMapping)) {
+      if (normalized === pattern.toLowerCase() || new RegExp(pattern, 'i').test(normalized)) {
+        matchedColumns.push({ excelKey, mapping });
+        break;
+      }
+    }
+  }
+
+  const seenKeys = new Set<string>();
+  const deduplicated: typeof matchedColumns = [];
+  for (const item of matchedColumns) {
+    if (!seenKeys.has(item.mapping.key)) {
+      seenKeys.add(item.mapping.key);
+      deduplicated.push(item);
+    }
+  }
+  matchedColumns.length = 0;
+  matchedColumns.push(...deduplicated);
+
+  const sampleKeys = Object.keys(sample)
+    .filter((k) => k && k !== 'Part Number' && k !== 'Units')
+    .sort();
+  const compatibleRows = rows.filter((r) => {
+    const rKeys = Object.keys(r)
+      .filter((k) => k && k !== 'Part Number' && k !== 'Units')
+      .sort();
+    return JSON.stringify(rKeys) === JSON.stringify(sampleKeys);
+  });
+
+  if (compatibleRows.length === 0) return { ok: false, technicalItems: [], voltageTables: [] };
+
+  const csKey =
+    guessColumnKey(sample, [
+      /number of cores and cross-section/i,
+      /cross.?section/i,
+      /ross section conductor/i,
+    ]) || null;
+  const voltageKey =
+    guessColumnKey(sample, [/rated voltage/i, /voltage rating/i, /nennspannung/i, /spannungs/i]) ||
+    null;
+
+  if (!csKey) return { ok: false, technicalItems: [], voltageTables: [] };
+
+  const byVoltage = new Map<string, number[]>();
+  for (let i = 0; i < compatibleRows.length; i++) {
+    const cs = normalizeValue(String(compatibleRows[i]?.[csKey] ?? ''));
+    if (!cs) continue;
+    const rawV = voltageKey ? normalizeValue(String(compatibleRows[i]?.[voltageKey] ?? '')) : '';
+    const voltageLabel = normalizeVoltageLabel(rawV || '');
+    const key = voltageLabel || (args.locale === 'de' ? 'Spannung unbekannt' : 'Voltage unknown');
+    const arr = byVoltage.get(key) ?? [];
+    arr.push(i);
+    byVoltage.set(key, arr);
+  }
+
+  const voltageTables: VoltageTableModel[] = [];
+  const technicalItems: KeyValueItem[] = [];
+
+  const voltageKeysSorted = Array.from(byVoltage.keys()).sort((a, b) => {
+    const na = parseVoltageSortKey(a);
+    const nb = parseVoltageSortKey(b);
+    if (na !== nb) return na - nb;
+    return a.localeCompare(b);
+  });
+
+  const globalConstantColumns = new Set<string>();
+
+  for (const { excelKey, mapping } of matchedColumns) {
+    const values = compatibleRows
+      .map((r) => normalizeValue(String(r?.[excelKey] ?? '')))
+      .filter(Boolean);
+    const unique = Array.from(new Set(values.map((v) => v.toLowerCase())));
+
+    if (unique.length === 1 && values.length > 0) {
+      globalConstantColumns.add(excelKey);
+
+      const unit = normalizeUnit(units[excelKey] || mapping.unit || '');
+      const labelBase = technicalFullLabel({ key: mapping.key, excelKey, locale: args.locale });
+      const label = formatExcelHeaderLabel(labelBase, unit);
+      const value = compactCellForDenseTable(values[0], unit, args.locale);
+      const existing = technicalItems.find((t) => t.label === label);
+      if (!existing) technicalItems.push({ label, value, unit });
+    }
+  }
+
+  const metaKeyPriority = [
+    'test_volt',
+    'temp_range',
+    'max_op_temp',
+    'max_sc_temp',
+    'min_lay_temp',
+    'min_store_temp',
+    'cpr',
+    'flame',
+  ];
+  const metaKeyPrioritySet = new Set(metaKeyPriority);
+
+  for (const vKey of voltageKeysSorted) {
+    const indices = byVoltage.get(vKey) || [];
+    if (!indices.length) continue;
+
+    const crossSections = indices.map((idx) =>
+      normalizeValue(String(compatibleRows[idx]?.[csKey] ?? '')),
+    );
+
+    const metaItems: KeyValueItem[] = [];
+    const metaCandidates = new Map<string, KeyValueItem>();
+    if (voltageKey) {
+      const rawV = normalizeValue(String(compatibleRows[indices[0]]?.[voltageKey] ?? ''));
+      metaItems.push({
+        label: args.locale === 'de' ? 'Spannung' : 'Voltage',
+        value: normalizeVoltageLabel(rawV || ''),
+      });
     }
 
-    const columnMapping: Record<string, { header: string; unit: string; key: string }> = {
-        'number of cores and cross-section': { header: 'Cross-section', unit: '', key: 'cross_section' },
-        'ross section conductor': { header: 'Cross-section', unit: '', key: 'cross_section' },
-        'diameter over insulation': { header: 'DI', unit: 'mm', key: 'DI' },
-        'diameter over insulation (approx.)': { header: 'DI', unit: 'mm', key: 'DI' },
-        'dc resistance at 20 °C': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
-        'dc resistance at 20°C': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
-        'resistance conductor': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
-        'maximum resistance of conductor': { header: 'RI', unit: 'Ohm/km', key: 'RI' },
-        'insulation thickness': { header: 'Wi', unit: 'mm', key: 'Wi' },
-        'nominal insulation thickness': { header: 'Wi', unit: 'mm', key: 'Wi' },
-        'current ratings in air, trefoil': { header: 'Ibl', unit: 'A', key: 'Ibl' },
-        'current ratings in air, trefoil*': { header: 'Ibl', unit: 'A', key: 'Ibl' },
-        'current ratings in ground, trefoil': { header: 'Ibe', unit: 'A', key: 'Ibe' },
-        'current ratings in ground, trefoil*': { header: 'Ibe', unit: 'A', key: 'Ibe' },
-        'conductor shortcircuit current': { header: 'Ik', unit: 'kA', key: 'Ik_cond' },
-        'screen shortcircuit current': { header: 'Ik', unit: 'kA', key: 'Ik_screen' },
-        'sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
-        'minimum sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
-        'nominal sheath thickness': { header: 'Wm', unit: 'mm', key: 'Wm' },
-        'bending radius': { header: 'Rbv', unit: 'mm', key: 'Rbv' },
-        'bending radius (min.)': { header: 'Rbv', unit: 'mm', key: 'Rbv' },
-        'outer diameter': { header: 'Ø', unit: 'mm', key: 'Ø' },
-        'outer diameter (approx.)': { header: 'Ø', unit: 'mm', key: 'Ø' },
-        'outer diameter of cable': { header: 'Ø', unit: 'mm', key: 'Ø' },
-        'pulling force': { header: 'Fzv', unit: 'N', key: 'Fzv' },
-        'max. pulling force': { header: 'Fzv', unit: 'N', key: 'Fzv' },
-        'conductor aluminum': { header: 'Cond.', unit: '', key: 'Cond' },
-        'conductor copper': { header: 'Cond.', unit: '', key: 'Cond' },
-        'weight': { header: 'G', unit: 'kg/km', key: 'G' },
-        'weight (approx.)': { header: 'G', unit: 'kg/km', key: 'G' },
-        'cable weight': { header: 'G', unit: 'kg/km', key: 'G' },
-        'conductor diameter (approx.)': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
-        'conductor diameter': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
-        'diameter conductor': { header: 'Conductor diameter', unit: 'mm', key: 'cond_diam' },
-        'diameter over screen': { header: 'Diameter over screen', unit: 'mm', key: 'D_screen' },
-        'metallic screen mm2': { header: 'Metallic screen', unit: 'mm2', key: 'S_screen' },
-        'metallic screen': { header: 'Metallic screen', unit: 'mm2', key: 'S_screen' },
-        'reactance': { header: 'Reactance', unit: 'Ohm/km', key: 'X' },
-        'capacitance (approx.)': { header: 'Capacitance', unit: 'uF/km', key: 'cap' },
-        'capacitance': { header: 'Capacitance', unit: 'uF/km', key: 'cap' },
-        'inductance, trefoil (approx.)': { header: 'Inductance trefoil', unit: 'mH/km', key: 'ind_trefoil' },
-        'inductance, trefoil': { header: 'Inductance trefoil', unit: 'mH/km', key: 'ind_trefoil' },
-        'inductance in air, flat (approx.)': { header: 'Inductance air flat', unit: 'mH/km', key: 'ind_air_flat' },
-        'inductance in air, flat': { header: 'Inductance air flat', unit: 'mH/km', key: 'ind_air_flat' },
-        'inductance in ground, flat (approx.)': { header: 'Inductance ground flat', unit: 'mH/km', key: 'ind_ground_flat' },
-        'inductance in ground, flat': { header: 'Inductance ground flat', unit: 'mH/km', key: 'ind_ground_flat' },
-        'current ratings in air, flat': { header: 'Current air flat', unit: 'A', key: 'cur_air_flat' },
-        'current ratings in air, flat*': { header: 'Current air flat', unit: 'A', key: 'cur_air_flat' },
-        'current ratings in ground, flat': { header: 'Current ground flat', unit: 'A', key: 'cur_ground_flat' },
-        'current ratings in ground, flat*': { header: 'Current ground flat', unit: 'A', key: 'cur_ground_flat' },
-        'heating time constant, trefoil*': { header: 'Heating time trefoil', unit: 's', key: 'heat_trefoil' },
-        'heating time constant, trefoil': { header: 'Heating time trefoil', unit: 's', key: 'heat_trefoil' },
-        'heating time constant, flat*': { header: 'Heating time flat', unit: 's', key: 'heat_flat' },
-        'heating time constant, flat': { header: 'Heating time flat', unit: 's', key: 'heat_flat' },
-        'maximal operating conductor temperature': { header: 'Max operating temp', unit: '°C', key: 'max_op_temp' },
-        'maximal short-circuit temperature': { header: 'Max short-circuit temp', unit: '°C', key: 'max_sc_temp' },
-        'operating temperature range': { header: 'Operating temp range', unit: '°C', key: 'temp_range' },
-        'minimal storage temperature': { header: 'Min storage temp', unit: '°C', key: 'min_store_temp' },
-        'minimal temperature for laying': { header: 'Min laying temp', unit: '°C', key: 'min_lay_temp' },
-        'test voltage': { header: 'Test voltage', unit: 'kV', key: 'test_volt' },
-        'rated voltage': { header: 'Rated voltage', unit: 'kV', key: 'rated_volt' },
-        'conductor': { header: 'Conductor', unit: '', key: 'conductor' },
-        'copper wire screen and tape': { header: 'Copper screen', unit: '', key: 'copper_screen' },
-        'CUScreen': { header: 'Copper screen', unit: '', key: 'copper_screen' },
-        'conductive tape below screen': { header: 'Conductive tape below', unit: '', key: 'tape_below' },
-        'non conducting tape above screen': { header: 'Non-conductive tape above', unit: '', key: 'tape_above' },
-        'al foil': { header: 'Al foil', unit: '', key: 'al_foil' },
-        'shape of conductor': { header: 'Conductor shape', unit: '', key: 'shape' },
-        'colour of insulation': { header: 'Insulation color', unit: '', key: 'color_ins' },
-        'colour of sheath': { header: 'Sheath color', unit: '', key: 'color_sheath' },
-        'insulation': { header: 'Insulation', unit: '', key: 'insulation' },
-        'sheath': { header: 'Sheath', unit: '', key: 'sheath' },
-        'norm': { header: 'Norm', unit: '', key: 'norm' },
-        'standard': { header: 'Standard', unit: '', key: 'standard' },
-        'cpr class': { header: 'CPR class', unit: '', key: 'cpr' },
-        'flame retardant': { header: 'Flame retardant', unit: '', key: 'flame' },
-        'self-extinguishing of single cable': { header: 'Flame retardant', unit: '', key: 'flame' },
-        'packaging': { header: 'Packaging', unit: '', key: 'packaging' },
-        'ce-conformity': { header: 'CE conformity', unit: '', key: 'ce' },
-        'rohs/reach': { header: 'RoHS/REACH', unit: '', key: 'rohs_reach' },
-    };
+    const tableColumns: Array<{
+      excelKey: string;
+      mapping: { header: string; unit: string; key: string };
+    }> = [];
 
-    const excelKeys = Object.keys(sample).filter(k => k && k !== 'Part Number' && k !== 'Units');
+    const denseTableKeyOrder = [
+      'Cond',
+      'shape',
+      'cap',
+      'X',
+      'DI',
+      'RI',
+      'Wi',
+      'Ibl',
+      'Ibe',
+      'Ik_cond',
+      'Wm',
+      'Rbv',
+      'Ø',
+      'D_screen',
+      'S_screen',
+      'Fzv',
+      'G',
+    ] as const;
+    const denseTableKeys = new Set<string>(denseTableKeyOrder);
 
-    const matchedColumns: Array<{ excelKey: string; mapping: { header: string; unit: string; key: string } }> = [];
-    for (const excelKey of excelKeys) {
-        const normalized = normalizeValue(excelKey).toLowerCase();
-        for (const [pattern, mapping] of Object.entries(columnMapping)) {
-            if (normalized === pattern.toLowerCase() || new RegExp(pattern, 'i').test(normalized)) {
-                matchedColumns.push({ excelKey, mapping });
-                break;
-            }
-        }
+    const bendingRadiusKey = matchedColumns.find((c) => c.mapping.key === 'Rbv')?.excelKey || null;
+    let bendUnitOverride = '';
+    if (bendingRadiusKey) {
+      const bendVals = indices
+        .map((idx) => normalizeValue(String(compatibleRows[idx]?.[bendingRadiusKey] ?? '')))
+        .filter(Boolean);
+      if (bendVals.some((v) => /\bxD\b/i.test(v))) bendUnitOverride = 'xD';
     }
 
-    const seenKeys = new Set<string>();
-    const deduplicated: typeof matchedColumns = [];
-    for (const item of matchedColumns) {
-        if (!seenKeys.has(item.mapping.key)) {
-            seenKeys.add(item.mapping.key);
-            deduplicated.push(item);
-        }
-    }
-    matchedColumns.length = 0;
-    matchedColumns.push(...deduplicated);
-
-    const sampleKeys = Object.keys(sample).filter(k => k && k !== 'Part Number' && k !== 'Units').sort();
-    const compatibleRows = rows.filter(r => {
-        const rKeys = Object.keys(r).filter(k => k && k !== 'Part Number' && k !== 'Units').sort();
-        return JSON.stringify(rKeys) === JSON.stringify(sampleKeys);
-    });
-
-    if (compatibleRows.length === 0) return { ok: false, technicalItems: [], voltageTables: [] };
-
-    const csKey =
-        guessColumnKey(sample, [/number of cores and cross-section/i, /cross.?section/i, /ross section conductor/i]) || null;
-    const voltageKey =
-        guessColumnKey(sample, [/rated voltage/i, /voltage rating/i, /nennspannung/i, /spannungs/i]) || null;
-
-    if (!csKey) return { ok: false, technicalItems: [], voltageTables: [] };
-
-    const byVoltage = new Map<string, number[]>();
-    for (let i = 0; i < compatibleRows.length; i++) {
-        const cs = normalizeValue(String(compatibleRows[i]?.[csKey] ?? ''));
-        if (!cs) continue;
-        const rawV = voltageKey ? normalizeValue(String(compatibleRows[i]?.[voltageKey] ?? '')) : '';
-        const voltageLabel = normalizeVoltageLabel(rawV || '');
-        const key = voltageLabel || (args.locale === 'de' ? 'Spannung unbekannt' : 'Voltage unknown');
-        const arr = byVoltage.get(key) ?? [];
-        arr.push(i);
-        byVoltage.set(key, arr);
-    }
-
-    const voltageTables: VoltageTableModel[] = [];
-    const technicalItems: KeyValueItem[] = [];
-
-    const voltageKeysSorted = Array.from(byVoltage.keys()).sort((a, b) => {
-        const na = parseVoltageSortKey(a);
-        const nb = parseVoltageSortKey(b);
-        if (na !== nb) return na - nb;
-        return a.localeCompare(b);
-    });
-
-    const globalConstantColumns = new Set<string>();
-
     for (const { excelKey, mapping } of matchedColumns) {
-        const values = compatibleRows.map(r => normalizeValue(String(r?.[excelKey] ?? ''))).filter(Boolean);
-        const unique = Array.from(new Set(values.map(v => v.toLowerCase())));
+      if (excelKey === csKey || excelKey === voltageKey) continue;
 
-        if (unique.length === 1 && values.length > 0) {
-            globalConstantColumns.add(excelKey);
+      const values = indices
+        .map((idx) => normalizeValue(String(compatibleRows[idx]?.[excelKey] ?? '')))
+        .filter(Boolean);
 
-            const unit = normalizeUnit(units[excelKey] || mapping.unit || '');
-            const labelBase = technicalFullLabel({ key: mapping.key, excelKey, locale: args.locale });
-            const label = formatExcelHeaderLabel(labelBase, unit);
-            const value = compactCellForDenseTable(values[0], unit, args.locale);
-            const existing = technicalItems.find(t => t.label === label);
-            if (!existing) technicalItems.push({ label, value, unit });
+      if (values.length > 0) {
+        const unique = Array.from(new Set(values.map((v) => v.toLowerCase())));
+        let unit = normalizeUnit(units[excelKey] || mapping.unit || '');
+        if (mapping.key === 'Rbv' && bendUnitOverride) unit = bendUnitOverride;
+
+        if (denseTableKeys.has(mapping.key)) {
+          tableColumns.push({ excelKey, mapping });
+          continue;
         }
+
+        if (globalConstantColumns.has(excelKey) && !metaKeyPrioritySet.has(mapping.key)) {
+          continue;
+        }
+
+        const value =
+          unique.length === 1
+            ? compactCellForDenseTable(values[0], unit, args.locale)
+            : summarizeSmartOptions(mapping.key, values);
+
+        const label = metaFullLabel({ key: mapping.key, excelKey, locale: args.locale });
+
+        metaCandidates.set(mapping.key, { label, value, unit });
+      }
     }
 
-    const metaKeyPriority = [
-        'test_volt',
-        'temp_range',
-        'max_op_temp',
-        'max_sc_temp',
-        'min_lay_temp',
-        'min_store_temp',
-        'cpr',
-        'flame',
-    ];
-    const metaKeyPrioritySet = new Set(metaKeyPriority);
+    for (const k of metaKeyPriority) {
+      const item = metaCandidates.get(k);
+      if (item && item.label && item.value) metaItems.push(item);
+    }
 
-    for (const vKey of voltageKeysSorted) {
-        const indices = byVoltage.get(vKey) || [];
-        if (!indices.length) continue;
+    const mappedByKey = new Map<
+      string,
+      { excelKey: string; mapping: { header: string; unit: string; key: string } }
+    >();
+    for (const c of tableColumns) {
+      if (!mappedByKey.has(c.mapping.key)) mappedByKey.set(c.mapping.key, c);
+    }
 
-        const crossSections = indices.map(idx => normalizeValue(String(compatibleRows[idx]?.[csKey] ?? '')));
+    const outerDiameterKey = mappedByKey.get('Ø')?.excelKey || '' || null;
+    const sheathThicknessKey = mappedByKey.get('Wm')?.excelKey || '' || null;
 
-        const metaItems: KeyValueItem[] = [];
-        const metaCandidates = new Map<string, KeyValueItem>();
-        if (voltageKey) {
-            const rawV = normalizeValue(String(compatibleRows[indices[0]]?.[voltageKey] ?? ''));
-            metaItems.push({
-                label: args.locale === 'de' ? 'Spannung' : 'Voltage',
-                value: normalizeVoltageLabel(rawV || ''),
-            });
-        }
+    const canDeriveDenseKey = (k: (typeof denseTableKeyOrder)[number]): boolean => {
+      if (k === 'DI') return Boolean(outerDiameterKey && sheathThicknessKey);
+      if (k === 'Cond') return true;
+      return false;
+    };
 
-        const tableColumns: Array<{ excelKey: string; mapping: { header: string; unit: string; key: string } }> = [];
-
-        const denseTableKeyOrder = [
-            'Cond',
-            'shape',
-            'cap',
-            'X',
-            'DI',
-            'RI',
-            'Wi',
-            'Ibl',
-            'Ibe',
-            'Ik_cond',
-            'Wm',
-            'Rbv',
-            'Ø',
-            'D_screen',
-            'S_screen',
-            'Fzv',
-            'G',
-        ] as const;
-        const denseTableKeys = new Set<string>(denseTableKeyOrder);
-
-        const bendingRadiusKey = matchedColumns.find(c => c.mapping.key === 'Rbv')?.excelKey || null;
-        let bendUnitOverride = '';
-        if (bendingRadiusKey) {
-            const bendVals = indices
-                .map(idx => normalizeValue(String(compatibleRows[idx]?.[bendingRadiusKey] ?? '')))
-                .filter(Boolean);
-            if (bendVals.some(v => /\bxD\b/i.test(v))) bendUnitOverride = 'xD';
-        }
-
-        for (const { excelKey, mapping } of matchedColumns) {
-            if (excelKey === csKey || excelKey === voltageKey) continue;
-
-            const values = indices.map(idx => normalizeValue(String(compatibleRows[idx]?.[excelKey] ?? ''))).filter(Boolean);
-
-            if (values.length > 0) {
-                const unique = Array.from(new Set(values.map(v => v.toLowerCase())));
-                let unit = normalizeUnit(units[excelKey] || mapping.unit || '');
-                if (mapping.key === 'Rbv' && bendUnitOverride) unit = bendUnitOverride;
-
-                if (denseTableKeys.has(mapping.key)) {
-                    tableColumns.push({ excelKey, mapping });
-                    continue;
-                }
-
-                if (globalConstantColumns.has(excelKey) && !metaKeyPrioritySet.has(mapping.key)) {
-                    continue;
-                }
-
-                const value =
-                    unique.length === 1
-                        ? compactCellForDenseTable(values[0], unit, args.locale)
-                        : summarizeSmartOptions(mapping.key, values);
-
-                const label = metaFullLabel({ key: mapping.key, excelKey, locale: args.locale });
-
-                metaCandidates.set(mapping.key, { label, value, unit });
-            }
-        }
-
-        for (const k of metaKeyPriority) {
-            const item = metaCandidates.get(k);
-            if (item && item.label && item.value) metaItems.push(item);
-        }
-
-        const mappedByKey = new Map<string, { excelKey: string; mapping: { header: string; unit: string; key: string } }>();
-        for (const c of tableColumns) {
-            if (!mappedByKey.has(c.mapping.key)) mappedByKey.set(c.mapping.key, c);
-        }
-
-        const outerDiameterKey = (mappedByKey.get('Ø')?.excelKey || '') || null;
-        const sheathThicknessKey = (mappedByKey.get('Wm')?.excelKey || '') || null;
-
-        const canDeriveDenseKey = (k: (typeof denseTableKeyOrder)[number]): boolean => {
-            if (k === 'DI') return Boolean(outerDiameterKey && sheathThicknessKey);
-            if (k === 'Cond') return true;
-            return false;
+    const orderedTableColumns = denseTableKeyOrder
+      .filter((k) => mappedByKey.has(k) || canDeriveDenseKey(k))
+      .map((k) => {
+        const existing = mappedByKey.get(k);
+        if (existing) return existing;
+        return {
+          excelKey: '',
+          mapping: { header: k, unit: '', key: k },
         };
+      });
 
-        const orderedTableColumns = denseTableKeyOrder
-            .filter(k => mappedByKey.has(k) || canDeriveDenseKey(k))
-            .map(k => {
-                const existing = mappedByKey.get(k);
-                if (existing) return existing;
-                return {
-                    excelKey: '',
-                    mapping: { header: k, unit: '', key: k },
-                };
-            });
+    const columns = orderedTableColumns.map(({ excelKey, mapping }) => {
+      const defaultUnitByKey: Record<string, string> = {
+        DI: 'mm',
+        RI: 'Ohm/km',
+        Wi: 'mm',
+        Ibl: 'A',
+        Ibe: 'A',
+        Ik_cond: 'kA',
+        Wm: 'mm',
+        Rbv: 'mm',
+        Ø: 'mm',
+        Fzv: 'N',
+        G: 'kg/km',
+      };
 
-        const columns = orderedTableColumns.map(({ excelKey, mapping }) => {
-            const defaultUnitByKey: Record<string, string> = {
-                DI: 'mm',
-                RI: 'Ohm/km',
-                Wi: 'mm',
-                Ibl: 'A',
-                Ibe: 'A',
-                Ik_cond: 'kA',
-                Wm: 'mm',
-                Rbv: 'mm',
-                'Ø': 'mm',
-                Fzv: 'N',
-                G: 'kg/km',
-            };
+      let unit = normalizeUnit(
+        (excelKey ? units[excelKey] : '') || mapping.unit || defaultUnitByKey[mapping.key] || '',
+      );
+      if (mapping.key === 'Rbv' && bendUnitOverride) unit = bendUnitOverride;
 
-            let unit = normalizeUnit((excelKey ? units[excelKey] : '') || mapping.unit || defaultUnitByKey[mapping.key] || '');
-            if (mapping.key === 'Rbv' && bendUnitOverride) unit = bendUnitOverride;
+      return {
+        key: mapping.key,
+        label:
+          denseAbbrevLabel({ key: mapping.key, locale: args.locale, unit, withUnit: true }) ||
+          formatExcelHeaderLabel(excelKey, unit),
+        get: (rowIndex: number) => {
+          const srcRowIndex = indices[rowIndex];
+          const raw = excelKey
+            ? normalizeValue(String(compatibleRows[srcRowIndex]?.[excelKey] ?? ''))
+            : '';
+          const unitLocal = unit;
 
-            return {
-                key: mapping.key,
-                label: denseAbbrevLabel({ key: mapping.key, locale: args.locale, unit, withUnit: true }) || formatExcelHeaderLabel(excelKey, unit),
-                get: (rowIndex: number) => {
-                    const srcRowIndex = indices[rowIndex];
-                    const raw = excelKey ? normalizeValue(String(compatibleRows[srcRowIndex]?.[excelKey] ?? '')) : '';
-                    const unitLocal = unit;
+          if (mapping.key === 'DI' && !raw && outerDiameterKey && sheathThicknessKey) {
+            const odRaw = normalizeValue(
+              String(compatibleRows[srcRowIndex]?.[outerDiameterKey] ?? ''),
+            );
+            const wmRaw = normalizeValue(
+              String(compatibleRows[srcRowIndex]?.[sheathThicknessKey] ?? ''),
+            );
+            const od = parseNumericOption(odRaw);
+            const wm = parseNumericOption(wmRaw);
+            if (od !== null && wm !== null) {
+              const di = od - 2 * wm;
+              if (Number.isFinite(di) && di > 0)
+                return `~${compactNumericForLocale(String(di), args.locale)}`;
+            }
+          }
 
-                    if (mapping.key === 'DI' && !raw && outerDiameterKey && sheathThicknessKey) {
-                        const odRaw = normalizeValue(String(compatibleRows[srcRowIndex]?.[outerDiameterKey] ?? ''));
-                        const wmRaw = normalizeValue(String(compatibleRows[srcRowIndex]?.[sheathThicknessKey] ?? ''));
-                        const od = parseNumericOption(odRaw);
-                        const wm = parseNumericOption(wmRaw);
-                        if (od !== null && wm !== null) {
-                            const di = od - 2 * wm;
-                            if (Number.isFinite(di) && di > 0) return `~${compactNumericForLocale(String(di), args.locale)}`;
-                        }
-                    }
+          if (mapping.key === 'Cond' && !raw) {
+            const pn = normalizeExcelKey(
+              args.product.name || args.product.slug || args.product.sku || '',
+            );
+            if (/^NA/.test(pn)) return 'Al';
+            if (/^N/.test(pn)) return 'Cu';
+          }
 
-                    if (mapping.key === 'Cond' && !raw) {
-                        const pn = normalizeExcelKey(args.product.name || args.product.slug || args.product.sku || '');
-                        if (/^NA/.test(pn)) return 'Al';
-                        if (/^N/.test(pn)) return 'Cu';
-                    }
+          if (mapping.key === 'Rbv' && /\bxD\b/i.test(raw))
+            return compactNumericForLocale(raw, args.locale);
 
-                    if (mapping.key === 'Rbv' && /\bxD\b/i.test(raw)) return compactNumericForLocale(raw, args.locale);
+          if (mapping.key === 'Rbv' && unitLocal.toLowerCase() === 'mm') {
+            const n = parseNumericOption(raw);
+            const looksLikeMeters =
+              n !== null && n > 0 && n < 50 && /[\.,]\d{1,3}/.test(raw) && !/\dxD/i.test(raw);
+            if (looksLikeMeters)
+              return compactNumericForLocale(String(Math.round(n * 1000)), args.locale);
+          }
 
-                    if (mapping.key === 'Rbv' && unitLocal.toLowerCase() === 'mm') {
-                        const n = parseNumericOption(raw);
-                        const looksLikeMeters = n !== null && n > 0 && n < 50 && /[\.,]\d{1,3}/.test(raw) && !/\dxD/i.test(raw);
-                        if (looksLikeMeters) return compactNumericForLocale(String(Math.round(n * 1000)), args.locale);
-                    }
+          if (mapping.key === 'Fzv' && unitLocal.toLowerCase() === 'n') {
+            const n = parseNumericOption(raw);
+            const looksLikeKN =
+              n !== null && n > 0 && n < 100 && !/\bN\b/i.test(raw) && !/\bkN\b/i.test(raw);
+            if (looksLikeKN)
+              return compactNumericForLocale(String(Math.round(n * 1000)), args.locale);
+          }
 
-                    if (mapping.key === 'Fzv' && unitLocal.toLowerCase() === 'n') {
-                        const n = parseNumericOption(raw);
-                        const looksLikeKN = n !== null && n > 0 && n < 100 && !/\bN\b/i.test(raw) && !/\bkN\b/i.test(raw);
-                        if (looksLikeKN) return compactNumericForLocale(String(Math.round(n * 1000)), args.locale);
-                    }
+          return compactCellForDenseTable(raw, unitLocal, args.locale);
+        },
+      };
+    });
 
-                    return compactCellForDenseTable(raw, unitLocal, args.locale);
-                },
-            };
-        });
+    voltageTables.push({ voltageLabel: vKey, metaItems, crossSections, columns });
+  }
 
-        voltageTables.push({ voltageLabel: vKey, metaItems, crossSections, columns });
-    }
+  technicalItems.sort((a, b) => a.label.localeCompare(b.label));
 
-    technicalItems.sort((a, b) => a.label.localeCompare(b.label));
-
-    return { ok: true, technicalItems, voltageTables };
+  return { ok: true, technicalItems, voltageTables };
 }