@deerdesign/deertools 1.2.35 → 1.3.0

package/src/estimate/domain.js

@@ -0,0 +1,1016 @@
+'use strict';
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const WHOLE_UNIT_OCR_ROOM_ID = '__caly_lokal__';
+const ANY_ROOM = '*';
+
+const PACKAGE_CONFIGS = {
+  SMART: {
+    key: 'SMART',
+    packageKey: 'smart',
+    selectedPackageId: 'smart_life',
+    selectedPackageName: 'Smart',
+    packageUuid: '21f4865a-3694-47a4-8f95-6ea67d9f4e40',
+    unitPriceM2: 1290,
+    markupPct: 57,
+    defaultVatRate: 8
+  },
+  MODERN: {
+    key: 'MODERN',
+    packageKey: 'modern',
+    selectedPackageId: 'modern_life',
+    selectedPackageName: 'Modern',
+    packageUuid: '919e7e6f-f840-4198-ad7d-fb666ac91764',
+    unitPriceM2: 1640,
+    markupPct: 43,
+    defaultVatRate: 8
+  },
+  HIGH: {
+    key: 'HIGH',
+    packageKey: 'high',
+    selectedPackageId: 'high_life',
+    selectedPackageName: 'High',
+    packageUuid: '8de495c0-e52b-414b-8f41-89d28c026ffa',
+    unitPriceM2: 1990,
+    markupPct: 35,
+    defaultVatRate: 8
+  }
+};
+
+let _cachedDefaultTemplates = null;
+function getDefaultTemplatesSnapshot() {
+  if (!_cachedDefaultTemplates) {
+    const p = path.join(__dirname, 'default-templates-snapshot.json');
+    _cachedDefaultTemplates = JSON.parse(fs.readFileSync(p, 'utf8'));
+  }
+  return JSON.parse(JSON.stringify(_cachedDefaultTemplates));
+}
+
+function resolvePackageConfig(pkgInput) {
+  const s = String(pkgInput || 'SMART').trim().toLowerCase();
+  if (s.includes('high') || s === '8de495c0-e52b-414b-8f41-89d28c026ffa') return PACKAGE_CONFIGS.HIGH;
+  if (s.includes('modern') || s === '919e7e6f-f840-4198-ad7d-fb666ac91764') return PACKAGE_CONFIGS.MODERN;
+  return PACKAGE_CONFIGS.SMART;
+}
+
+function round2(n) {
+  const v = Number(n) || 0;
+  return Math.round(v * 100) / 100;
+}
+
+function newUuid() {
+  return crypto.randomUUID();
+}
+
+function norm(s) {
+  return String(s ?? '').trim().toLowerCase();
+}
+
+function normalizePricingUnit(unit) {
+  const value = String(unit ?? '').trim().toLowerCase();
+  if (['m2', 'm²'].includes(value)) return 'm2';
+  if (['mb', 'm.b.', 'm'].includes(value)) return 'mb';
+  if (['szt', 'szt.', 'pcs', 'piece'].includes(value)) return 'szt';
+  return null;
+}
+
+/**
+ * Wylicza cenę sprzedaży netto/brutto z pozycji katalogowej (zgodnie z computeSalePrice.ts).
+ */
+function computeSalePrice(catalogItem, markupPct = 57) {
+  const vatBps = Number(catalogItem?.vatRateBps);
+  const vatRate = Number.isFinite(vatBps) && vatBps > 0 ? vatBps / 100 : 8;
+  const vatMultiplier = 1 + vatRate / 100;
+
+  const salePrice = Number(catalogItem?.salePrice);
+  if (Number.isFinite(salePrice) && salePrice > 0) {
+    const unitPriceNet = round2(salePrice / vatMultiplier);
+    return {
+      unitPriceNet,
+      unitPriceGross: round2(salePrice),
+      vatRate,
+      source: 'salePrice'
+    };
+  }
+
+  const purchasePrice = Number(catalogItem?.purchasePricePerPricingUnit ?? catalogItem?.purchasePrice);
+  if (Number.isFinite(purchasePrice) && purchasePrice > 0) {
+    const m = Number.isFinite(markupPct) ? markupPct : 57;
+    const unitPriceNet = round2(purchasePrice * (1 + m / 100));
+    return {
+      unitPriceNet,
+      unitPriceGross: round2(unitPriceNet * vatMultiplier),
+      vatRate,
+      source: 'purchasePriceMarkup'
+    };
+  }
+
+  return {
+    unitPriceNet: 0,
+    unitPriceGross: 0,
+    vatRate,
+    source: 'none'
+  };
+}
+
+/**
+ * Odczytuje dane opakowania z pozycji katalogowej (zgodnie z packaging.ts).
+ */
+function readPackaging(catalogItem) {
+  if (!catalogItem) return null;
+  if (catalogItem.pricingUnitsPerPackage !== undefined && catalogItem.pricingUnitsPerPackage !== null) {
+    const size = Number(catalogItem.pricingUnitsPerPackage);
+    const unit = normalizePricingUnit(catalogItem.pricingUnit);
+    if (!Number.isFinite(size) || size <= 0 || !unit) return null;
+    const waste = Number(catalogItem.wastePercent ?? 0);
+    return {
+      areaPerPackage: size,
+      pricingUnitsPerPackage: size,
+      pricingUnit: unit,
+      wastePercent: Number.isFinite(waste) && waste >= 0 && waste <= 100 ? waste : 0,
+      includesReserve: true
+    };
+  }
+  const attrs = catalogItem.attributes || {};
+  const areaPerPkg = Number(attrs.areaPerPackage);
+  if (Number.isFinite(areaPerPkg) && areaPerPkg > 0) {
+    const unitsPerPkg = Number(attrs.unitsPerPackage);
+    return {
+      areaPerPackage: areaPerPkg,
+      ...(Number.isFinite(unitsPerPkg) && unitsPerPkg > 0 ? { unitsPerPackage: unitsPerPkg } : {})
+    };
+  }
+  return null;
+}
+
+/**
+ * Przelicza powierzchnię na pełne opakowania (zawsze zaokrąglane w górę).
+ */
+function computePackaging(areaM2, packaging, wastePercentOverride) {
+  if (!packaging) return null;
+  const raw = Number(areaM2);
+  const { areaPerPackage, unitsPerPackage } = packaging;
+  const wastePercent = wastePercentOverride !== undefined && wastePercentOverride !== null
+    ? Number(wastePercentOverride)
+    : Number(packaging.wastePercent ?? 0);
+
+  if (!Number.isFinite(raw) || raw < 0 || (!packaging.includesReserve && raw === 0) || !Number.isFinite(areaPerPackage) || areaPerPackage <= 0) {
+    return null;
+  }
+
+  const ratio = (raw * (1 + wastePercent / 100)) / areaPerPackage;
+  const nearest = Math.round(ratio);
+  const packages = Math.ceil(Math.abs(ratio - nearest) <= 1e-10 * Math.max(1, ratio) ? nearest : ratio);
+  const billedAreaM2 = Number((packages * areaPerPackage).toFixed(6));
+
+  return {
+    ...packaging,
+    rawAreaM2: raw,
+    wastePercent,
+    packages,
+    billedAreaM2,
+    ...(unitsPerPackage ? { pieces: packages * unitsPerPackage } : {}),
+    surplusM2: round2(billedAreaM2 - raw)
+  };
+}
+
+function toItemPackaging(result) {
+  if (!result) return undefined;
+  return {
+    areaPerPackage: result.areaPerPackage,
+    ...(result.unitsPerPackage ? { unitsPerPackage: result.unitsPerPackage } : {}),
+    packages: result.packages,
+    rawAreaM2: result.rawAreaM2,
+    ...(result.pricingUnitsPerPackage != null
+      ? {
+          pricingUnitsPerPackage: result.pricingUnitsPerPackage,
+          pricingUnit: result.pricingUnit,
+          wastePercent: result.wastePercent,
+          includesReserve: result.includesReserve
+        }
+      : {})
+  };
+}
+
+function calculateRowPrices(quantity, unitPrice, vatRate = 8) {
+  const qty = Number(quantity) || 0;
+  const netUnit = Number(unitPrice) || 0;
+  const vat = vatRate === 'zw' ? 0 : (Number.isFinite(Number(vatRate)) ? Number(vatRate) : 8);
+  const totalNetPrice = round2(qty * netUnit);
+  const totalVatPrice = round2(totalNetPrice * (vat / 100));
+  const totalGrossPrice = round2(totalNetPrice + totalVatPrice);
+  return { totalNetPrice, totalVatPrice, totalGrossPrice };
+}
+
+/**
+ * Buduje pełny wiersz kosztorysu z pozycji katalogowej (zgodnie z createRowData w gridHelpers.ts).
+ */
+function buildEstimateRowFromCatalogItem(catalogItem, {
+  quantity = 1,
+  group = 'Inne',
+  rowId = undefined,
+  expectedUnit = undefined,
+  reservePct = undefined,
+  markupPct = 57,
+  packageLabel = undefined
+} = {}) {
+  const { unitPriceNet, vatRate } = computeSalePrice(catalogItem, markupPct);
+  const attrs = catalogItem.attributes || {};
+  const imageUrl = Array.isArray(attrs.images) && attrs.images.length > 0 ? attrs.images[0] : undefined;
+
+  const packagingInfo = readPackaging(catalogItem);
+  const compatible = !packagingInfo?.pricingUnit ||
+    (!expectedUnit || normalizePricingUnit(expectedUnit) === packagingInfo.pricingUnit);
+  const waste = reservePct != null ? Number(reservePct) : (packagingInfo?.wastePercent ?? 0);
+  const packagingResult = packagingInfo && compatible ? computePackaging(quantity, packagingInfo, waste) : null;
+
+  let unitPrice = packagingResult?.includesReserve
+    ? (catalogItem.purchasePricePerPricingUnit != null && Number.isFinite(Number(catalogItem.purchasePricePerPricingUnit))
+        ? round2(Number(catalogItem.purchasePricePerPricingUnit) * (1 + markupPct / 100))
+        : unitPriceNet)
+    : unitPriceNet;
+
+  const billedQuantity = packagingResult ? packagingResult.billedAreaM2 : Number(quantity) || 0;
+  const rawType = String(catalogItem.type || 'product').toLowerCase();
+  const isService = rawType === 'service';
+  const itemKind = isService ? 'labour' : 'material';
+  const rowType = isService ? 'SERVICE' : 'PRODUCT';
+
+  const prices = calculateRowPrices(billedQuantity, unitPrice, vatRate);
+
+  return {
+    id: rowId || newUuid(),
+    productId: String(catalogItem.id),
+    sourceProductId: String(attrs.sourceProductId || catalogItem.id),
+    name: catalogItem.name,
+    SKU: catalogItem.sku || '',
+    unit: packagingResult?.pricingUnit || (packagingResult ? 'm2' : (catalogItem.unit || expectedUnit || 'szt')),
+    ...(packagingResult ? { packaging: toItemPackaging(packagingResult) } : {}),
+    package: packageLabel || catalogItem.package || '',
+    type: rowType,
+    itemKind,
+    unitPrice,
+    vatRate,
+    quantity: billedQuantity,
+    group,
+    imageUrl,
+    description: catalogItem.description || '',
+    purchasePrice: packagingResult?.includesReserve
+      ? (catalogItem.purchasePricePerPricingUnit ?? catalogItem.purchasePrice ?? 0)
+      : (catalogItem.purchasePricePerPricingUnit ?? catalogItem.purchasePrice ?? 0),
+    manufacturerName: attrs.manufacturerName || '',
+    manufacturerId: attrs.manufacturerId ?? null,
+    categoryName: attrs.categoryName || '',
+    categoryPath: attrs.categoryPath || '',
+    categoryId: attrs.categoryId ?? null,
+    ean: attrs.ean || '',
+    link: attrs.link ?? null,
+    width: attrs.width,
+    height: attrs.height,
+    length: attrs.length,
+    weight: attrs.weight,
+    material: attrs.material,
+    catalogId: String(catalogItem.catalogId || '5'),
+    images: attrs.images || [],
+    ...(reservePct != null && !packagingResult?.includesReserve ? { reservePct: Number(reservePct) } : {}),
+    ...(attrs.reserve != null ? { extraReserve: String(attrs.reserve) } : {}),
+    isBundle: Boolean(attrs.isBundle),
+    averageLandedCost: Number(attrs.averageLandedCost) || 0,
+    ...prices
+  };
+}
+
+/**
+ * Klucze powiązań (signedTotals.ts).
+ */
+function strictBindingKey(b) {
+  if (!b) return '';
+  return [b.ocrRoomId, b.templateRoomId, b.slotId, b.kind].join('§');
+}
+
+function looseBindingKey(b) {
+  if (!b) return '';
+  return [b.ocrRoomId, b.roomKey ?? b.templateRoomId, b.slotKey ?? b.slotId, b.kind].join('§');
+}
+
+function removedBindingKey(b) {
+  if (!b) return '';
+  return [
+    looseBindingKey(b),
+    (b.variantPath || []).join('/'),
+    String(b.catalogRef ?? '').trim().toLowerCase()
+  ].join('§v§');
+}
+
+function hashVariantAnswers(answers) {
+  if (!answers || typeof answers !== 'object') return '';
+  return Object.keys(answers)
+    .sort()
+    .map(k => `${k}=${String(answers[k] ?? '').trim().toLowerCase()}`)
+    .join('|');
+}
+
+/**
+ * Wylicza podpis (signature) powiązań kosztorysu.
+ */
+function computeEstimateSignature(docId, packageUuid, variantAnswers, ocrRooms, roomMappings) {
+  const vaHash = hashVariantAnswers(variantAnswers);
+  const roomsParts = (ocrRooms || []).map(r => {
+    const rid = r.id || '';
+    const area = Number(r.area || 0).toFixed(2);
+    const perim = Number(r.perimeter || 0).toFixed(2);
+    const height = Number(r.height || 2.7).toFixed(2);
+    const ops = [...(r.openings || [])].sort((a, b) => String(a.id || '').localeCompare(String(b.id || '')));
+    const opsStr = ops.map(o => `${o.kind}:${Number(o.width || 0).toFixed(2)}x${Number(o.count || 1)}`).join(',');
+    return `${rid}:${area}/${perim}/${height}[${opsStr}]`;
+  });
+  const roomsStr = roomsParts.join('|');
+
+  const mapParts = (roomMappings || []).map(m => {
+    const tParts = (m.templateRoomIds || []).map(t => {
+      if (t.role === 'addon' && t.areaShare !== undefined) {
+        return `${t.role}:${t.templateRoomId}@${t.areaShare}`;
+      }
+      return `${t.role}:${t.templateRoomId}@`;
+    });
+    return `${m.ocrRoomId}->${tParts.join('+')}`;
+  });
+  const mapsStr = mapParts.join('|');
+  const signature = `${docId}::${packageUuid}::${vaHash}::${roomsStr}::${mapsStr}`;
+  return { signature, variantAnswersHash: vaHash };
+}
+
+/**
+ * Przelicza totalPrices w dataJson.estimatePanelData (pomijając pozycje zredukowane cancelled: true).
+ */
+function recalculateDocumentTotals(dataJson) {
+  if (!dataJson.estimatePanelData) {
+    dataJson.estimatePanelData = { estimateItems: [], totalPrices: { totalNetPrice: 0, totalVatPrice: 0, totalGrossPrice: 0 } };
+  }
+  const items = dataJson.estimatePanelData.estimateItems || [];
+  let totalNet = 0;
+  let totalVat = 0;
+  let totalGross = 0;
+
+  for (const it of items) {
+    const qty = Number(it.quantity) || 0;
+    const unitNet = Number(it.unitPrice ?? it.unitPriceNet) || 0;
+    const vat = it.vatRate === 'zw' ? 0 : (Number.isFinite(Number(it.vatRate)) ? Number(it.vatRate) : 8);
+    const rowPrices = calculateRowPrices(qty, unitNet, vat);
+
+    if (it.unitPrice !== undefined && it.unitPrice !== null) {
+      it.totalNetPrice = rowPrices.totalNetPrice;
+      it.totalVatPrice = rowPrices.totalVatPrice;
+      it.totalGrossPrice = rowPrices.totalGrossPrice;
+    }
+
+    if (it.cancelled) {
+      continue;
+    }
+    const sign = it.settlementMode === 'reduction' ? -1 : 1;
+    totalNet += sign * (Number(it.totalNetPrice) || 0);
+    totalVat += sign * (Number(it.totalVatPrice) || 0);
+    totalGross += sign * (Number(it.totalGrossPrice) || 0);
+  }
+
+  dataJson.estimatePanelData.totalPrices = {
+    totalNetPrice: round2(totalNet),
+    totalVatPrice: round2(totalVat),
+    totalGrossPrice: round2(totalGross)
+  };
+  dataJson.estimatePanelData.totalNet = round2(totalNet);
+  dataJson.estimatePanelData.totalGross = round2(totalGross);
+
+  return dataJson.estimatePanelData.totalPrices;
+}
+
+/**
+ * Heurystyczne mapowanie nazwy pomieszczenia na klucz pokoju wzorca.
+ */
+function guessTemplateRoomKeysForRoomName(roomName) {
+  const n = norm(roomName);
+  if (n.includes('salon') && (n.includes('kuchni') || n.includes('aneks'))) {
+    return [{ role: 'primary', key: 'salon' }, { role: 'addon', key: 'kuchnia_otwarta' }];
+  }
+  if (n.includes('aneks') || n.includes('kuchnia otwarta')) {
+    return [{ role: 'primary', key: 'kuchnia_otwarta' }];
+  }
+  if (n.includes('kuchni')) return [{ role: 'primary', key: 'kuchnia' }];
+  if (n.includes('salon') || n.includes('pokój dzienny') || n.includes('pokoj dzienny')) return [{ role: 'primary', key: 'salon' }];
+  if (n.includes('sypialni') || n.includes('pokój') || n.includes('pokoj') || n.includes('gabinet')) return [{ role: 'primary', key: 'sypialnia' }];
+  if (n.includes('łazienk') || n.includes('lazienk')) return [{ role: 'primary', key: 'lazienka' }];
+  if (n === 'wc' || n.includes('toalet')) return [{ role: 'primary', key: 'wc' }];
+  if (n.includes('garderob')) return [{ role: 'primary', key: 'garderoba' }];
+  if (n.includes('pralni') || n.includes(' kotłown') || n.includes('technicz')) return [{ role: 'primary', key: 'pralnia' }];
+  if (n.includes('spiżarn') || n.includes('spizarn') || n.includes('schowek')) return [{ role: 'primary', key: 'spizarnia' }];
+  return [{ role: 'primary', key: 'przedpokoj' }];
+}
+
+/**
+ * Buduje lub aktualizuje roomMappings dla listy pomieszczeń OCR i wybranego pakietu wzorca.
+ */
+function buildRoomMappingsForPackage(ocrRooms, pkg, existingMappings = []) {
+  const roomByKey = new Map();
+  const roomById = new Map();
+  for (const r of (pkg.rooms || [])) {
+    if (r.key) roomByKey.set(r.key, r);
+    roomById.set(r.id, r);
+  }
+
+  // Indeks starych mapowań, aby zachować role primary/addon i areaShare przy zmianie pakietu
+  const prevByOcrId = new Map();
+  for (const m of (existingMappings || [])) {
+    if (m.ocrRoomId) prevByOcrId.set(m.ocrRoomId, m);
+  }
+
+  return (ocrRooms || []).map(ocr => {
+    const prev = prevByOcrId.get(ocr.id);
+    if (ocr.templateTargets && Array.isArray(ocr.templateTargets) && ocr.templateTargets.length > 0) {
+      const templateRoomIds = ocr.templateTargets.map((t, idx) => {
+        const matchedRoom = roomById.get(t.templateRoomId) || roomByKey.get(t.templateRoomKey || t.key);
+        return {
+          role: t.role || (idx === 0 ? 'primary' : 'addon'),
+          templateRoomId: matchedRoom ? matchedRoom.id : t.templateRoomId,
+          ...(t.areaShare !== undefined ? { areaShare: Number(t.areaShare) } : {})
+        };
+      }).filter(x => x.templateRoomId);
+      if (templateRoomIds.length > 0) {
+        return {
+          ocrRoomId: ocr.id,
+          confidence: 1,
+          ocrRoomName: ocr.name,
+          templateRoomId: templateRoomIds[0].templateRoomId,
+          templateRoomIds
+        };
+      }
+    }
+
+    const guessed = guessTemplateRoomKeysForRoomName(ocr.name);
+    const templateRoomIds = guessed.map(g => {
+      const tr = roomByKey.get(g.key);
+      // Sprawdź czy w poprzednim mapowaniu był addon z areaShare
+      const prevAddon = prev?.templateRoomIds?.find(x => x.role === 'addon' && x.areaShare !== undefined);
+      const areaShare = g.role === 'addon'
+        ? (ocr.kitchenAreaShare !== undefined ? Number(ocr.kitchenAreaShare) : (prevAddon?.areaShare ?? round2(Math.min(4.0, (Number(ocr.area) || 18) * 0.2))))
+        : undefined;
+      return {
+        role: g.role,
+        templateRoomId: tr ? tr.id : '',
+        ...(areaShare !== undefined ? { areaShare } : {})
+      };
+    }).filter(x => x.templateRoomId);
+
+    return {
+      ocrRoomId: ocr.id,
+      confidence: 1,
+      ocrRoomName: ocr.name,
+      templateRoomId: templateRoomIds[0]?.templateRoomId || '',
+      templateRoomIds
+    };
+  });
+}
+
+/**
+ * Zbiera wszystkie osiągalne pytania wariantowe w pakiecie wraz z domyślnymi odpowiedziami.
+ */
+function collectQuestionsAndDefaultAnswers(pkg, roomMappings, totalArea = 55, existingAnswers = {}) {
+  const answers = { ...existingAnswers };
+  const questions = [];
+
+  const areaBracket = totalArea < 35
+    ? 'lokal do 35m2'
+    : totalArea <= 55
+      ? 'lokal od 35m2 do 55m2'
+      : totalArea <= 80
+        ? 'lokal od 55m2 do 80m2'
+        : 'lokal powyżej 80m2';
+
+  const scopes = [];
+  for (const m of (roomMappings || [])) {
+    for (const t of (m.templateRoomIds || [])) {
+      scopes.push({ ocrRoomId: m.ocrRoomId, ocrRoomName: m.ocrRoomName, templateRoomId: t.templateRoomId });
+    }
+  }
+  const wholeRoom = (pkg.rooms || []).find(r => r.key === 'caly_lokal');
+  if (wholeRoom) {
+    scopes.push({ ocrRoomId: WHOLE_UNIT_OCR_ROOM_ID, ocrRoomName: 'Cały lokal', templateRoomId: wholeRoom.id });
+  }
+
+  for (const sc of scopes) {
+    const tr = (pkg.rooms || []).find(r => r.id === sc.templateRoomId);
+    if (!tr) continue;
+
+    for (const slot of (tr.items || [])) {
+      const walk = (node, pathIds = []) => {
+        const variants = node.variants || [];
+        if (!variants.length) return;
+        const qText = (node.question || '').trim();
+        const owner = pathIds.length ? pathIds[pathIds.length - 1] : undefined;
+        const qId = owner ? `${slot.id}>${owner}` : slot.id;
+        const instanceKey = `${sc.ocrRoomId}|${tr.id}|${qId}`;
+        const wildcardKey = `${ANY_ROOM}|${tr.id}|${qId}`;
+
+        const availableOptions = variants.map(v => (v.answer || '').trim()).filter(Boolean);
+        let chosenAnswer = answers[instanceKey] || answers[wildcardKey] || (qText ? answers[qText] : undefined);
+
+        if (!chosenAnswer && availableOptions.length > 0) {
+          // Inteligentny wybór domyślny
+          if (tr.key === 'caly_lokal') {
+            chosenAnswer = availableOptions.find(a => norm(a) === norm(areaBracket)) || availableOptions[0];
+          } else if (qText.toLowerCase().includes('nad blatem')) {
+            chosenAnswer = availableOptions.find(a => norm(a).includes('mini')) || availableOptions[0];
+          } else if (qText.toLowerCase().includes('format płytek')) {
+            chosenAnswer = availableOptions.find(a => norm(a).includes('duży') || norm(a).includes('duzy')) || availableOptions[0];
+          } else if (qText.toLowerCase().includes('brodzik') || qText.toLowerCase().includes('wanna')) {
+            chosenAnswer = availableOptions[0];
+          } else {
+            chosenAnswer = availableOptions[0];
+          }
+        }
+
+        if (chosenAnswer) {
+          answers[instanceKey] = chosenAnswer;
+          answers[wildcardKey] = chosenAnswer;
+        }
+
+        if (variants.length > 1 && qText) {
+          questions.push({
+            ocrRoomId: sc.ocrRoomId,
+            ocrRoomName: sc.ocrRoomName,
+            templateRoomId: tr.id,
+            templateRoomName: tr.name,
+            slotId: slot.id,
+            slotName: slot.name,
+            questionId: qId,
+            question: qText,
+            options: availableOptions,
+            currentAnswer: chosenAnswer,
+            answerKey: instanceKey
+          });
+        }
+
+        const matchedVariant = variants.find(v => norm(v.answer) === norm(chosenAnswer)) || variants[0];
+        if (matchedVariant) {
+          walk(matchedVariant, [...pathIds, matchedVariant.id]);
+        }
+      };
+
+      walk(slot, []);
+    }
+  }
+
+  return { questions, variantAnswers: answers };
+}
+
+/**
+ * Oblicza ilość pozycji ze wzorca na podstawie reguły ilościowej i wymiarów pokoju.
+ */
+function computeSlotQuantity(rule, defaultQty, dim, opts = {}) {
+  const dQty = Number(defaultQty) || 1;
+  const floorArea = Number(dim.floorArea ?? dim.area ?? 0);
+  const perimeter = Number(dim.perimeter ?? 0);
+  const height = Number(dim.height ?? 2.7);
+  const limit = Number.isFinite(Number(opts.wallHeightLimit)) ? Number(opts.wallHeightLimit) : 2.2;
+  const openingsWidth = Number(dim.openingsWidth ?? 0);
+  const doorsCount = Number.isFinite(Number(dim.doors)) ? Number(dim.doors) : 1;
+  const openingsArea = Number(dim.openingsArea ?? (doorsCount * 1.8));
+
+  const applyWallDed = (base) => {
+    let val = base;
+    if (opts.deductDoors) val -= openingsArea;
+    if (Number(opts.mirrorDeduction) > 0) val -= Number(opts.mirrorDeduction);
+    return Math.max(0, round2(val));
+  };
+
+  switch (rule) {
+    case 'powierzchnia_podlogi':
+      return round2(floorArea * dQty);
+    case 'powierzchnia_scian':
+      return round2(applyWallDed(perimeter * height) * dQty);
+    case 'powierzchnia_scian_do_wysokosci':
+      return round2(applyWallDed(perimeter * Math.min(height, limit)) * dQty);
+    case 'powierzchnia_scian_powyzej_wysokosci':
+      return round2(applyWallDed(perimeter * Math.max(height - limit, 0)) * dQty);
+    case 'powierzchnia_scian_pasmo': {
+      const from = Number.isFinite(Number(opts.bandFrom)) ? Math.max(0, Number(opts.bandFrom)) : 0;
+      const to = Number.isFinite(Number(opts.bandTo)) ? Number(opts.bandTo) : height;
+      const bandH = Math.max(0, Math.min(height, to) - from);
+      return round2(applyWallDed(perimeter * bandH) * dQty);
+    }
+    case 'obwod': {
+      const netPerim = opts.deductOpenings ? Math.max(0, round2(perimeter - openingsWidth)) : perimeter;
+      return round2(netPerim * dQty);
+    }
+    case 'sztuka':
+      return (Number(dim.pieces) || 1) * dQty;
+    case 'metry_biezace':
+      return (Number(dim.linearMeters) || 1) * dQty;
+    case 'stala':
+    default:
+      return Number(defaultQty) || 1;
+  }
+}
+
+/**
+ * Rozwiązuje liść drzewa wariantów dla slotu.
+ */
+function resolveSlotVariant(slot, variantAnswers, ocrRoomId, templateRoomId) {
+  let currentVariants = slot.variants || [];
+  let currentQuestion = slot.question;
+  const chain = [slot];
+  const pathIds = [];
+
+  while (currentVariants && currentVariants.length) {
+    const owner = pathIds.length ? pathIds[pathIds.length - 1] : undefined;
+    const qId = owner ? `${slot.id}>${owner}` : slot.id;
+    const k1 = `${ocrRoomId}|${templateRoomId}|${qId}`;
+    const k2 = `${ANY_ROOM}|${templateRoomId}|${qId}`;
+    const wanted = variantAnswers[k1] || variantAnswers[k2] || (currentQuestion ? variantAnswers[currentQuestion.trim()] : undefined);
+
+    const matched = wanted
+      ? currentVariants.find(v => norm(v.answer) === norm(wanted))
+      : currentVariants[0];
+    const chosen = matched || currentVariants[0];
+    if (!chosen) break;
+    pathIds.push(chosen.id);
+    chain.push(chosen);
+    currentVariants = chosen.variants || [];
+    currentQuestion = chosen.question;
+  }
+
+  const deepest = (key) => {
+    for (let i = chain.length - 1; i >= 0; i--) {
+      const val = chain[i][key];
+      if (val !== undefined && val !== null && val !== '') return val;
+    }
+    return undefined;
+  };
+
+  const services = [];
+  const products = [];
+  for (const node of chain) {
+    for (const s of (node.services || [])) services.push(s);
+    for (const p of (node.products || [])) products.push(p);
+  }
+
+  return {
+    services,
+    products,
+    name: deepest('name') || slot.name,
+    unitOverride: deepest('unitOverride'),
+    quantityRule: deepest('quantityRule') || slot.quantityRule,
+    defaultQuantity: deepest('defaultQuantity') ?? slot.defaultQuantity,
+    maxQuantity: deepest('maxQuantity') ?? slot.maxQuantity,
+    wallHeightLimit: deepest('wallHeightLimit'),
+    bandFrom: deepest('bandFrom'),
+    bandTo: deepest('bandTo'),
+    deductDoors: deepest('deductDoors'),
+    mirrorDeduction: deepest('mirrorDeduction'),
+    deductOpenings: deepest('deductOpenings'),
+    settlementMode: deepest('settlementMode'),
+    variantPath: pathIds
+  };
+}
+
+/**
+ * Generuje wiersze wzorca dla pakietu, pokoi OCR, mapowań i odpowiedzi wariantowych,
+ * oraz uzgadnia (reconcile) je z istniejącymi pozycjami (zachowując wybrane produkty i ręczne redukcje).
+ */
+function generateAndReconcilePackageItems({
+  pkg,
+  pkgConfig,
+  ocrRooms,
+  roomMappings,
+  variantAnswers,
+  currentItems = [],
+  removedBindingKeys = [],
+  preserveChosenProducts = true
+}) {
+  const removedSet = new Set(removedBindingKeys || []);
+  const ocrById = new Map((ocrRooms || []).map(r => [r.id, r]));
+  const desired = [];
+  const dimensionsSnapshot = {};
+  const seenSingletonSlots = new Set();
+
+  const buildRowsForTarget = (ocrRoomId, ocrRoomName, tr, dim, skipAreaRules = false) => {
+    const groupLabel = ocrRoomId === WHOLE_UNIT_OCR_ROOM_ID
+      ? 'Cały lokal (pozycje wspólne)'
+      : (tr.name && ocrRoomName && norm(tr.name) !== norm(ocrRoomName)
+          ? `${tr.name} (${ocrRoomName})`
+          : (ocrRoomName || tr.name));
+
+    for (const slot of (tr.items || [])) {
+      if (slot.optional) {
+        const optKey1 = `${ocrRoomId}|${tr.id}|optional>${slot.id}`;
+        const optKey2 = `${ANY_ROOM}|${tr.id}|optional>${slot.id}`;
+        if (norm(variantAnswers[optKey1] || variantAnswers[optKey2]) !== 'tak') continue;
+      }
+
+      if (slot.singleton) {
+        const sKey = slot.slot || slot.name || slot.id;
+        if (seenSingletonSlots.has(sKey)) continue;
+        seenSingletonSlots.add(sKey);
+      }
+
+      const resolved = resolveSlotVariant(slot, variantAnswers, ocrRoomId, tr.id);
+      const wallOpts = {
+        wallHeightLimit: resolved.wallHeightLimit,
+        bandFrom: resolved.bandFrom,
+        bandTo: resolved.bandTo,
+        deductDoors: resolved.deductDoors,
+        mirrorDeduction: resolved.mirrorDeduction,
+        deductOpenings: resolved.deductOpenings
+      };
+
+      // 1. Produkty slotu
+      const seenAltGroups = new Set();
+      for (const prod of resolved.products) {
+        if (prod.altGroupId) {
+          if (seenAltGroups.has(prod.altGroupId)) continue;
+          seenAltGroups.add(prod.altGroupId);
+        }
+        const rule = prod.quantityRule || resolved.quantityRule || 'sztuka';
+        const isArea = ['powierzchnia_podlogi', 'powierzchnia_scian', 'powierzchnia_scian_do_wysokosci', 'powierzchnia_scian_powyzej_wysokosci', 'powierzchnia_scian_pasmo'].includes(rule);
+        const qty = (skipAreaRules && isArea) ? 0 : computeSlotQuantity(rule, resolved.defaultQuantity, dim, wallOpts);
+        const unit = resolved.unitOverride || (isArea ? 'm2' : (rule === 'obwod' || rule === 'metry_biezace' ? 'mb' : 'szt'));
+        const priceMax = prod.filter?.priceMax != null ? Number(prod.filter.priceMax) : null;
+        const priceMin = prod.filter?.priceMin != null ? Number(prod.filter.priceMin) : null;
+        const priceAvg = prod.filter?.priceAvg != null ? Number(prod.filter.priceAvg) : null;
+        const reservePct = prod.filter?.reservePct != null ? Number(prod.filter.reservePct) : undefined;
+        const unitPrice = priceMax != null ? round2(priceMax * (1 + pkgConfig.markupPct / 100)) : 0;
+        const prices = calculateRowPrices(qty, unitPrice, pkgConfig.defaultVatRate);
+        const leafCat = (prod.category?.categoryPath || '').split('|').pop() || resolved.name;
+
+        const binding = {
+          ocrRoomId,
+          templateRoomId: tr.id,
+          slotId: slot.id,
+          roomKey: tr.key || tr.name,
+          slotKey: slot.slot || slot.name,
+          catalogRef: prod.altGroupId || prod.id,
+          variantPath: resolved.variantPath,
+          packageId: pkg.id,
+          kind: 'product'
+        };
+
+        if (removedSet.has(looseBindingKey(binding)) || removedSet.has(removedBindingKey(binding))) continue;
+
+        desired.push({
+          id: newUuid(),
+          group: groupLabel,
+          name: (prod.preferredProductNameSnapshot || '').trim() || leafCat || resolved.name,
+          unit,
+          quantity: qty,
+          type: 'PRODUCT',
+          itemKind: 'material',
+          package: pkg.name,
+          isTemplate: true,
+          purchasePrice: priceMax ?? 0,
+          unitPrice,
+          vatRate: pkgConfig.defaultVatRate,
+          ...(reservePct != null ? { reservePct } : {}),
+          ...prices,
+          templateMeta: {
+            categoryId: prod.category?.categoryId,
+            categoryPath: prod.category?.categoryPath,
+            priceMin,
+            priceMax,
+            priceAvg,
+            packageId: pkg.id,
+            packageName: pkg.name,
+            quantityRule: rule,
+            catalogMissing: true,
+            slotName: resolved.name,
+            ...(typeof resolved.maxQuantity === 'number' ? { maxQuantity: resolved.maxQuantity } : {})
+          },
+          binding
+        });
+      }
+
+      // 2. Usługi slotu
+      for (const srv of resolved.services) {
+        const rule = srv.quantityRule || resolved.quantityRule || 'sztuka';
+        const isArea = ['powierzchnia_podlogi', 'powierzchnia_scian', 'powierzchnia_scian_do_wysokosci', 'powierzchnia_scian_powyzej_wysokosci', 'powierzchnia_scian_pasmo'].includes(rule);
+        const qty = (skipAreaRules && isArea) ? 0 : computeSlotQuantity(rule, resolved.defaultQuantity, dim, wallOpts);
+        const unit = resolved.unitOverride || srv.unitSnapshot || (isArea ? 'm2' : (rule === 'obwod' || rule === 'metry_biezace' ? 'mb' : 'szt'));
+        const purchasePrice = Number(srv.purchasePriceSnapshot) || 0;
+        const salePriceGross = Number(srv.salePriceSnapshot) || 0;
+        const vatRate = srv.vatRateBpsSnapshot ? Number(srv.vatRateBpsSnapshot) / 100 : pkgConfig.defaultVatRate;
+        const unitPrice = salePriceGross > 0
+          ? round2(salePriceGross / (1 + vatRate / 100))
+          : round2(purchasePrice * (1 + pkgConfig.markupPct / 100));
+        const prices = calculateRowPrices(qty, unitPrice, vatRate);
+
+        const binding = {
+          ocrRoomId,
+          templateRoomId: tr.id,
+          slotId: slot.id,
+          roomKey: tr.key || tr.name,
+          slotKey: slot.slot || slot.name,
+          catalogRef: srv.skuSnapshot || srv.id || srv.catalogItemId,
+          variantPath: resolved.variantPath,
+          packageId: pkg.id,
+          kind: 'service'
+        };
+
+        if (removedSet.has(looseBindingKey(binding)) || removedSet.has(removedBindingKey(binding))) continue;
+
+        desired.push({
+          id: newUuid(),
+          group: groupLabel,
+          name: srv.nameSnapshot || resolved.name,
+          productId: srv.catalogItemId ? String(srv.catalogItemId) : undefined,
+          SKU: srv.skuSnapshot || '',
+          catalogId: '5',
+          unit,
+          quantity: qty,
+          type: 'SERVICE',
+          itemKind: 'labour',
+          package: pkg.name,
+          purchasePrice,
+          unitPrice,
+          vatRate,
+          averageLandedCost: Number(srv.averageLandedCostSnapshot) || 0,
+          ...(srv.extraReserveSnapshot != null ? { extraReserve: String(srv.extraReserveSnapshot) } : {}),
+          ...prices,
+          templateMeta: {
+            packageId: pkg.id,
+            packageName: pkg.name,
+            quantityRule: rule,
+            slotName: resolved.name,
+            ...(typeof resolved.maxQuantity === 'number' ? { maxQuantity: resolved.maxQuantity } : {})
+          },
+          binding
+        });
+      }
+    }
+  };
+
+  for (const m of (roomMappings || [])) {
+    const ocr = ocrById.get(m.ocrRoomId);
+    if (!ocr) continue;
+    const roomArea = Number(ocr.area) || 0;
+    const roomPerim = Number(ocr.perimeter) || round2(4 * Math.sqrt(Math.max(1, roomArea)));
+    const roomHeight = Number(ocr.height) || 2.7;
+    const doors = (ocr.openings || []).filter(o => o.kind === 'door' || o.kind === 'internal_door').length || 1;
+    const openingsWidth = (ocr.openings || []).reduce((acc, o) => acc + (Number(o.width) || 0) * (Number(o.count) || 1), 0);
+
+    dimensionsSnapshot[m.ocrRoomId] = {
+      area: roomArea,
+      perimeter: roomPerim,
+      height: roomHeight
+    };
+
+    const targets = m.templateRoomIds || (m.templateRoomId ? [{ role: 'primary', templateRoomId: m.templateRoomId }] : []);
+    const addonShare = targets.reduce((acc, t) => acc + (t.role === 'addon' && t.areaShare ? Number(t.areaShare) : 0), 0);
+
+    for (const t of targets) {
+      const tr = (pkg.rooms || []).find(r => r.id === t.templateRoomId);
+      if (!tr || tr.key === 'caly_lokal') continue;
+
+      let targetArea = roomArea;
+      let targetPerim = roomPerim;
+      let skipAreaRules = false;
+      if (t.role === 'primary' && addonShare > 0) {
+        targetArea = Math.max(0, round2(roomArea - addonShare));
+      } else if (t.role === 'addon') {
+        if (t.areaShare && Number(t.areaShare) > 0) {
+          targetArea = Number(t.areaShare);
+          targetPerim = round2(4 * Math.sqrt(targetArea));
+        } else {
+          targetArea = 0;
+          skipAreaRules = true;
+        }
+      }
+
+      buildRowsForTarget(m.ocrRoomId, ocr.name, tr, {
+        floorArea: targetArea,
+        perimeter: targetPerim,
+        height: roomHeight,
+        doors,
+        openingsWidth
+      }, skipAreaRules);
+    }
+  }
+
+  // Wirtualne pomieszczenie „Cały lokal”
+  const wholeUnitRoom = (pkg.rooms || []).find(r => r.key === 'caly_lokal');
+  if (wholeUnitRoom) {
+    const totalArea = (ocrRooms || []).reduce((s, r) => s + (Number(r.area) || 0), 0);
+    const totalPerim = (ocrRooms || []).reduce((s, r) => s + (Number(r.perimeter) || 0), 0);
+    dimensionsSnapshot[WHOLE_UNIT_OCR_ROOM_ID] = {
+      area: round2(totalArea),
+      perimeter: round2(totalPerim),
+      height: 2.7
+    };
+    buildRowsForTarget(WHOLE_UNIT_OCR_ROOM_ID, 'Cały lokal (pozycje wspólne)', wholeUnitRoom, {
+      floorArea: round2(totalArea),
+      perimeter: round2(totalPerim),
+      height: 2.7,
+      totalApartmentArea: round2(totalArea)
+    }, false);
+  }
+
+  // Uzgadnianie (Reconcile) z currentItems
+  const existingStrict = new Map();
+  const existingLoose = new Map();
+  const consumed = new Set();
+
+  for (const it of (currentItems || [])) {
+    if (!it.binding) continue;
+    const sk = strictBindingKey(it.binding);
+    if (!existingStrict.has(sk)) existingStrict.set(sk, it);
+    const lk = looseBindingKey(it.binding);
+    const arr = existingLoose.get(lk) || [];
+    arr.push(it);
+    existingLoose.set(lk, arr);
+  }
+
+  const merged = [];
+  for (const d of desired) {
+    const sk = strictBindingKey(d.binding);
+    let ex = existingStrict.get(sk);
+    if (!ex || consumed.has(ex.id)) {
+      const lk = looseBindingKey(d.binding);
+      const candidates = existingLoose.get(lk) || [];
+      ex = candidates.find(c => !consumed.has(c.id));
+    }
+
+    if (ex && preserveChosenProducts) {
+      consumed.add(ex.id);
+      const hasChosenProduct = Boolean(ex.productId && !ex.isTemplate && d.type === 'PRODUCT');
+      if (hasChosenProduct) {
+        let qty = ex.quantityConfirmed ? ex.quantity : d.quantity;
+        let packaging = ex.packaging;
+        if (packaging && packaging.areaPerPackage > 0 && !ex.quantityConfirmed) {
+          const pkgRes = computePackaging(d.quantity, packaging, packaging.wastePercent ?? ex.reservePct ?? 0);
+          if (pkgRes) {
+            packaging = toItemPackaging(pkgRes);
+            qty = pkgRes.billedAreaM2;
+          }
+        }
+        const prices = calculateRowPrices(qty, ex.unitPrice, ex.vatRate);
+        merged.push({
+          ...ex,
+          binding: d.binding,
+          package: d.package,
+          group: ex.groupManual ? ex.group : d.group,
+          templateMeta: d.templateMeta,
+          quantity: qty,
+          ...(packaging ? { packaging } : {}),
+          ...prices
+        });
+        continue;
+      }
+
+      // Zachowaj ręczną redukcję (cancelledManual) lub zaktualizuj ilość i ceny wzorca
+      merged.push({
+        ...d,
+        id: ex.id,
+        cancelled: ex.cancelledManual ? true : false,
+        cancelledManual: ex.cancelledManual || undefined,
+        replacedByItemId: ex.replacedByItemId || undefined
+      });
+    } else {
+      merged.push(d);
+    }
+  }
+
+  // Zachowaj pozycje dodatkowe spoza wzorca (bez bindingu lub zamienniki replacesItemId)
+  const customItems = (currentItems || []).filter(it => !it.binding);
+  return {
+    items: [...merged, ...customItems],
+    dimensionsSnapshot
+  };
+}
+
+module.exports = {
+  WHOLE_UNIT_OCR_ROOM_ID,
+  ANY_ROOM,
+  PACKAGE_CONFIGS,
+  getDefaultTemplatesSnapshot,
+  resolvePackageConfig,
+  round2,
+  newUuid,
+  norm,
+  normalizePricingUnit,
+  computeSalePrice,
+  readPackaging,
+  computePackaging,
+  toItemPackaging,
+  calculateRowPrices,
+  buildEstimateRowFromCatalogItem,
+  strictBindingKey,
+  looseBindingKey,
+  removedBindingKey,
+  hashVariantAnswers,
+  computeEstimateSignature,
+  recalculateDocumentTotals,
+  guessTemplateRoomKeysForRoomName,
+  buildRoomMappingsForPackage,
+  collectQuestionsAndDefaultAnswers,
+  computeSlotQuantity,
+  generateAndReconcilePackageItems
+};