@grupolapa/validate-delivery 0.0.0-stage → 0.1.0

package/bin/validate-delivery.mjs

@@ -0,0 +1,2586 @@
+#!/usr/bin/env node
+
+// src/cli/validate-delivery.ts
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+// src/contract/report.ts
+var levelOrder = { error: 0, observacion: 1 };
+var compareText = (a, b) => (a ?? "").localeCompare(b ?? "", "es", { numeric: true });
+function sortFindings(findings) {
+  return [...findings].sort(
+    (a, b) => levelOrder[a.nivel] - levelOrder[b.nivel] || compareText(a.regla, b.regla) || compareText(a.archivo, b.archivo) || compareText(a.hoja, b.hoja) || (a.fila ?? 0) - (b.fila ?? 0) || compareText(a.guid, b.guid) || compareText(a.mensaje, b.mensaje)
+  );
+}
+function location(finding) {
+  const parts = [
+    finding.archivo,
+    finding.hoja && finding.fila ? `${finding.hoja}!${finding.fila}` : finding.hoja,
+    finding.guid ? `GUID ${finding.guid}` : void 0,
+    finding.elementId ? `Element ${finding.elementId}` : void 0
+  ].filter(Boolean);
+  return parts.length ? `${parts.join(" \xB7 ")}: ` : "";
+}
+function groupByRule(findings) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const list3 = groups.get(finding.regla) ?? [];
+    list3.push(finding);
+    groups.set(finding.regla, list3);
+  }
+  return groups;
+}
+function formatReport(report, options = {}) {
+  const examples = options.examples ?? 5;
+  const { entrega } = report;
+  const lines = [];
+  const title = [entrega.proyecto, entrega.revision].filter(Boolean).join(" \xB7 ") || "Entrega";
+  lines.push(`${title}${entrega.fecha ? ` (${entrega.fecha})` : ""}`);
+  lines.push(`Validador ${report.validatorVersion} \xB7 pol\xEDtica ${report.policyVersion}`);
+  if (entrega.huella) lines.push(`Huella de la entrega: ${entrega.huella.slice(0, 16)}\u2026`);
+  if (entrega.archivos.length) {
+    lines.push("");
+    for (const file of entrega.archivos)
+      lines.push(`  ${file.rol.padEnd(10)} ${file.archivo}  (${formatBytes(file.bytes)})`);
+  }
+  lines.push("", `Errores (${report.errores.length})`);
+  for (const finding of report.errores)
+    lines.push(`  \u2716 [${finding.regla}] ${location(finding)}${finding.mensaje}`);
+  lines.push("", `Observaciones (${report.observaciones.length})`);
+  for (const [rule, list3] of groupByRule(report.observaciones)) {
+    lines.push(`  \u26A0 [${rule}] ${list3.length}`);
+    for (const finding of list3.slice(0, examples))
+      lines.push(`      ${location(finding)}${finding.mensaje}`);
+    if (list3.length > examples) lines.push(`      \u2026 y ${list3.length - examples} m\xE1s`);
+  }
+  const metrics = Object.entries(report.metricas);
+  if (metrics.length) {
+    lines.push("", "M\xE9tricas");
+    for (const [key, value2] of metrics) lines.push(`  ${key}: ${value2}`);
+  }
+  lines.push("", `Veredicto: ${report.veredicto.toUpperCase()}`);
+  return lines.join("\n");
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(0)} KiB`;
+  return `${bytes} B`;
+}
+
+// src/contract/validate.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/processing/houses/catalog.mjs
+import { unzipSync, strFromU8 } from "fflate";
+import { XMLParser } from "fast-xml-parser";
+
+// src/processing/model/manifest.mjs
+import { createHash } from "node:crypto";
+import { PDFDocument, PDFName, decodePDFRawStream } from "pdf-lib";
+
+// src/processing/model/approvals.mjs
+var commonFields = ["kind", "decision", "globalId", "elementId", "modelSha256", "reviewer", "date", "reason"];
+var relationFields = [...commonFields, "conceptId", "catalogSha256"];
+var graphicFields = [...commonFields, "viewId", "page", "pdfSha256", "representationSha256"];
+
+// src/processing/model/manifest.mjs
+var hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function verifyMetadata(text, revision, format) {
+  const input = format === "ifc" ? text.slice(0, text.indexOf("ENDSEC;")) : text;
+  for (const [key, pdf, ifc] of [["contentId", "content_id", "ContentGUID"], ["versionId", "version_id", "VersionGUID"]]) {
+    const pattern = format === "pdf" ? new RegExp(`<pdfx:${pdf}>([^<]+)</pdfx:${pdf}>`, "g") : new RegExp(`${ifc}: ([a-fA-F0-9-]+)`, "g");
+    const values = [...input.matchAll(pattern)].map((match) => match[1]);
+    if (values.length !== 1 || values[0] !== revision[key]) throw new Error(`Uncoordinated ${format} ${key}`);
+  }
+}
+async function verifyPdfMetadata(bytes, revision) {
+  const pdf = await PDFDocument.load(bytes);
+  const metadata = pdf.catalog.lookup(PDFName.of("Metadata"));
+  if (!metadata) throw new Error("PDF has no verifiable Revit metadata");
+  verifyMetadata(new TextDecoder().decode(decodePDFRawStream(metadata).decode()), revision, "pdf");
+}
+
+// src/processing/houses/catalog.mjs
+var list = (value2) => value2 == null ? [] : Array.isArray(value2) ? value2 : [value2];
+var xml = new XMLParser({ ignoreAttributes: false, parseTagValue: false, trimValues: false });
+var plain = (value2) => typeof value2 === "string" ? value2 : value2?.["#text"] ?? "";
+var rich = (value2) => value2?.t != null ? plain(value2.t) : list(value2?.r).map((run) => plain(run.t)).join("");
+var normalized = (value2) => String(value2 ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().toUpperCase().replace(/[.\s_]+/g, "");
+var aliases = { code: ["CODIGO", "CODE"], description: ["CONCEPTO", "DESCRIPCION", "DESCRIPTION"], unit: ["UNIDAD", "UNIT"], quantity: ["CANTIDAD", "QUANTITY"], unitPrice: ["PUNITARIO", "PRECIOUNITARIO", "UNITPRICE"], amount: ["IMPORTE", "AMOUNT"] };
+var groupCode = /^\d+(?:\.\d+)*$/;
+function sheetsOf(bytes) {
+  let total = 0;
+  const zip = unzipSync(bytes, { filter(entry) {
+    total += entry.originalSize;
+    if (entry.originalSize > 32 * 1024 * 1024 || total > 64 * 1024 * 1024) throw new Error("El cat\xE1logo XLSX excede el tama\xF1o admitido (64 MB descomprimido).");
+    return entry.name.startsWith("xl/");
+  } });
+  const parse = (path) => {
+    if (!zip[path]) throw new Error(`Falta parte XLSX: ${path}`);
+    const content = strFromU8(zip[path]);
+    if (/<!DOCTYPE|<!ENTITY/i.test(content)) throw new Error("Declaraciones XML externas o entidades personalizadas no admitidas en XLSX.");
+    return xml.parse(content);
+  };
+  const strings = zip["xl/sharedStrings.xml"] ? list(parse("xl/sharedStrings.xml").sst.si).map(rich) : [];
+  const relationships = list(parse("xl/_rels/workbook.xml.rels").Relationships.Relationship);
+  return list(parse("xl/workbook.xml").workbook.sheets.sheet).map((sheet) => {
+    const rel = relationships.find((item) => item["@_Id"] === sheet["@_r:id"]);
+    const target = rel?.["@_Target"]?.replace(/^\/xl\//, "");
+    if (!/^worksheets\/[^/]+\.xml$/.test(target ?? "") || rel?.["@_TargetMode"] === "External") throw new Error("Referencia de hoja XLSX no admitida.");
+    return { sheet: sheet["@_name"], rows: list(parse(`xl/${target}`).worksheet.sheetData?.row).map((row) => ({
+      row: Number(row["@_r"]),
+      cells: Object.fromEntries(list(row.c).map((cell) => {
+        let value2 = cell.v ?? null;
+        if (cell["@_t"] === "s") {
+          value2 = strings[Number(value2)];
+          if (value2 === void 0) throw new Error(`\xCDndice de texto XLSX inv\xE1lido en ${cell["@_r"]}.`);
+        } else if (cell["@_t"] === "inlineStr") value2 = rich(cell.is);
+        else if (value2 != null && !["str", "e"].includes(cell["@_t"])) value2 = Number(value2);
+        return [cell["@_r"].replace(/\d+$/, ""), { value: value2, formula: cell.f == null ? null : plain(cell.f), error: ["e", "b"].includes(cell["@_t"]) }];
+      }))
+    })) };
+  });
+}
+function columnsOf(row) {
+  const columns = {};
+  for (const [field, labels3] of Object.entries(aliases)) {
+    const found = Object.entries(row.cells).filter(([, cell]) => labels3.includes(normalized(cell.value)));
+    if (found.length > 1) throw new Error(`Encabezado duplicado: ${field}, fila ${row.row}`);
+    if (found[0]) columns[field] = found[0][0];
+  }
+  return ["code", "description", "unit", "quantity"].every((field) => columns[field]) ? columns : null;
+}
+function numberField(cell, field, row, optional = false) {
+  if (optional && (cell?.value == null || cell.value === "")) return null;
+  if (typeof cell?.value !== "number" || !Number.isFinite(cell.value) || cell.value < 0) throw new Error(`${field} inv\xE1lido en fila ${row}. Se requiere un n\xFAmero no negativo exportado.`);
+  return cell.value;
+}
+function parseCatalogRows({ rows, sheet, sourceHash, columns, headerRow }) {
+  const nodes = [], concepts = [], ignoredRows = [], warnings = [];
+  const byCode = /* @__PURE__ */ new Map(), qualified = /* @__PURE__ */ new Set();
+  if (rows.some((row, index) => !Number.isInteger(row.row) || row.row < 1 || index > 0 && row.row <= rows[index - 1].row)) throw new Error("Filas XLSX duplicadas o fuera de orden.");
+  let current = null;
+  for (const row of rows.filter((item) => item.row > headerRow)) {
+    const get = (field) => row.cells[columns[field]];
+    const codeValue = get("code")?.value, descriptionValue = get("description")?.value;
+    const code = String(codeValue ?? "").trim(), description = String(descriptionValue ?? "").trim();
+    if (Object.values(row.cells).every((cell) => (cell.value == null || cell.value === "") && cell.formula == null && !cell.error)) continue;
+    for (const field of Object.keys(columns)) if (get(field)?.formula !== null && get(field)?.formula !== void 0 || get(field)?.error)
+      throw new Error(`F\xF3rmula o error en ${sheet}!${columns[field]}${row.row}: exportar valores verificados.`);
+    if (columnsOf(row)) {
+      ignoredRows.push({ row: row.row, reason: "repeated-header" });
+      continue;
+    }
+    if ((/^TOTAL\b/i.test(code) || code.startsWith("(*") || groupCode.test(code) && /^TOTAL\b/i.test(description)) && !get("unit")?.value && get("quantity")?.value == null) {
+      ignoredRows.push({ row: row.row, reason: "total-or-footer" });
+      continue;
+    }
+    if (!code || !description || typeof descriptionValue !== "string") throw new Error(`Fila ${row.row} incompleta: falta c\xF3digo o descripci\xF3n.`);
+    if (groupCode.test(code) && !get("unit")?.value && get("quantity")?.value == null) {
+      if (byCode.has(code)) throw new Error(`Nodo WBS duplicado: ${code}`);
+      const parentCode = code.includes(".") ? code.slice(0, code.lastIndexOf(".")) : null;
+      if (parentCode && !byCode.has(parentCode)) throw new Error(`Falta padre WBS ${parentCode} antes de ${code}`);
+      current = { id: `${sourceHash}:${sheet}:wbs:${row.row}`, code, label: description, parentId: parentCode ? byCode.get(parentCode).id : null, parentCode, row: row.row };
+      nodes.push(current);
+      byCode.set(code, current);
+      continue;
+    }
+    if (!current) throw new Error(`Concepto sin cap\xEDtulo expl\xEDcito en fila ${row.row}`);
+    if (typeof codeValue !== "string" || /\s/.test(code) || code !== codeValue || groupCode.test(code)) throw new Error(`C\xF3digo de concepto inv\xE1lido en fila ${row.row}`);
+    if (typeof get("unit")?.value !== "string" || !get("unit").value.trim()) throw new Error(`Unidad faltante en fila ${row.row}`);
+    const qualifiedCode = `${current.code}-${code}`;
+    if (qualified.has(qualifiedCode)) throw new Error(`Identidad de concepto ambigua/duplicada: ${qualifiedCode}`);
+    qualified.add(qualifiedCode);
+    concepts.push({
+      id: `${sourceHash}:${sheet}:${row.row}`,
+      code,
+      qualifiedCode,
+      description,
+      unit: get("unit").value.trim(),
+      quantity: numberField(get("quantity"), "Cantidad", row.row),
+      unitPrice: numberField(get("unitPrice"), "Precio unitario", row.row, true),
+      amount: numberField(get("amount"), "Importe", row.row, true),
+      chapterCode: current.code,
+      chapter: current.label,
+      chapterRow: current.row,
+      parentId: current.id,
+      sheet,
+      row: row.row,
+      provenance: { sourceHash, sheet, row: row.row, chapterRow: current.row, columns }
+    });
+  }
+  if (!nodes.length || !concepts.length) throw new Error("El cat\xE1logo requiere cap\xEDtulos WBS y conceptos expl\xEDcitos.");
+  if (ignoredRows.length) warnings.push(`${ignoredRows.length} filas de encabezados repetidos, totales o pies se conservaron en auditor\xEDa; no son conceptos.`);
+  return { sheet, sourceHash, headerRow, columns, conceptCount: concepts.length, roots: nodes.filter((node) => node.parentId === null), nodes, concepts, ignoredRows, warnings };
+}
+function readHouseCatalog(bytes) {
+  if (!(bytes instanceof Uint8Array) || bytes.length > 10 * 1024 * 1024) throw new Error("El cat\xE1logo debe ser un XLSX de hasta 10 MB.");
+  const candidates = sheetsOf(bytes).flatMap((sheet) => sheet.rows.flatMap((row) => {
+    const columns = columnsOf(row);
+    return columns ? [{ ...sheet, columns, headerRow: row.row }] : [];
+  }));
+  const sheets = [...new Set(candidates.map((candidate2) => candidate2.sheet))];
+  if (sheets.length !== 1) throw new Error(sheets.length ? "Varias hojas tienen cat\xE1logo; entregar una sola hoja de conceptos inequ\xEDvoca." : "No se encontraron encabezados C\xF3digo, Concepto/Descripci\xF3n, Unidad y Cantidad.");
+  const candidate = candidates[0];
+  return parseCatalogRows({ ...candidate, sourceHash: hash(bytes) });
+}
+
+// src/processing/houses/pipeline.mjs
+import { PDFDocument as PDFDocument3 } from "pdf-lib";
+
+// src/processing/model/ifc-metadata.mjs
+import { createRequire } from "node:module";
+
+// src/processing/model/measurements.mjs
+var dimensions = {
+  length: { unitType: "LENGTHUNIT", name: "METRE", unit: "m", exponent: 1 },
+  area: { unitType: "AREAUNIT", name: "SQUARE_METRE", unit: "m\xB2", exponent: 2 },
+  volume: {
+    unitType: "VOLUMEUNIT",
+    name: "CUBIC_METRE",
+    unit: "m\xB3",
+    exponent: 3
+  }
+};
+var prefixes = {
+  EXA: 1e18,
+  PETA: 1e15,
+  TERA: 1e12,
+  GIGA: 1e9,
+  MEGA: 1e6,
+  KILO: 1e3,
+  HECTO: 100,
+  DECA: 10,
+  DECI: 0.1,
+  CENTI: 0.01,
+  MILLI: 1e-3,
+  MICRO: 1e-6,
+  NANO: 1e-9,
+  PICO: 1e-12,
+  FEMTO: 1e-15,
+  ATTO: 1e-18
+};
+var measureTypes = {
+  IFCLENGTHMEASURE: "length",
+  IFCPOSITIVELENGTHMEASURE: "length",
+  IFCNONNEGATIVELENGTHMEASURE: "length",
+  IFCAREAMEASURE: "area",
+  IFCVOLUMEMEASURE: "volume"
+};
+var quantityFields = {
+  LengthValue: "length",
+  AreaValue: "area",
+  VolumeValue: "volume"
+};
+var labels = {
+  Length: "Longitud",
+  Height: "Altura",
+  Width: "Ancho",
+  Thickness: "Espesor",
+  Area: "\xC1rea exportada",
+  Volume: "Volumen exportado",
+  Perimeter: "Per\xEDmetro",
+  GrossArea: "\xC1rea bruta exportada",
+  NetArea: "\xC1rea neta exportada",
+  GrossSideArea: "\xC1rea lateral bruta exportada",
+  NetSideArea: "\xC1rea lateral neta exportada",
+  GrossFootprintArea: "\xC1rea de huella bruta exportada",
+  NetFootprintArea: "\xC1rea de huella neta exportada",
+  GrossVolume: "Volumen bruto exportado",
+  NetVolume: "Volumen neto exportado",
+  "Unconnected Height": "Altura no conectada",
+  "Rough Height": "Altura de hueco",
+  "Rough Width": "Ancho de hueco",
+  "Default Thickness": "Espesor predeterminado",
+  OverallHeight: "Altura total",
+  OverallWidth: "Ancho total",
+  NominalHeight: "Altura nominal",
+  NominalLength: "Longitud nominal",
+  NominalWidth: "Ancho nominal",
+  CrossSectionArea: "\xC1rea de secci\xF3n transversal",
+  OuterSurfaceArea: "\xC1rea exterior exportada",
+  "System Length": "Longitud del sistema"
+};
+var value = (wrapped) => wrapped?.value;
+function measurementUnit(unit, dimension, seen = /* @__PURE__ */ new Set()) {
+  const definition = dimensions[dimension];
+  if (!unit || !definition || seen.size > 32 || seen.has(unit) || value(unit.UnitType) !== definition.unitType)
+    return null;
+  const visited = new Set(seen).add(unit);
+  if (unit.ConversionFactor) {
+    if (unit.ConversionOffset != null && value(unit.ConversionOffset) !== 0)
+      return null;
+    const factor = value(unit.ConversionFactor.ValueComponent);
+    const base = measurementUnit(
+      unit.ConversionFactor.UnitComponent,
+      dimension,
+      visited
+    );
+    if (!base || typeof factor !== "number" || !Number.isFinite(factor) || factor <= 0 || !Number.isFinite(factor * base.scale) || factor * base.scale <= 0)
+      return null;
+    return { unit: definition.unit, scale: factor * base.scale };
+  }
+  if (value(unit.Name) !== definition.name || !Object.hasOwn(unit, "Prefix"))
+    return null;
+  const prefix = unit.Prefix == null ? 1 : prefixes[value(unit.Prefix)];
+  const scale = prefix ** definition.exponent;
+  return Number.isFinite(scale) && scale > 0 ? { unit: definition.unit, scale } : null;
+}
+function extractMeasurements({
+  instanceSets = [],
+  typeSets = [],
+  projectUnits = [],
+  element = {},
+  category = "",
+  widthParameter = "Width"
+}) {
+  const measurements = [], measurementIssues = [], widths = [];
+  const unitFor = (explicit, dimension) => {
+    if (explicit != null)
+      return {
+        node: explicit,
+        resolved: measurementUnit(explicit, dimension),
+        source: "expl\xEDcita"
+      };
+    const candidates = projectUnits.filter(
+      (unit) => value(unit.UnitType) === dimensions[dimension].unitType
+    );
+    return {
+      node: candidates[0],
+      resolved: candidates.length === 1 ? measurementUnit(candidates[0], dimension) : null,
+      source: "de proyecto"
+    };
+  };
+  const add3 = ({
+    raw,
+    dimension,
+    unit,
+    name,
+    setName,
+    setId,
+    propertyId,
+    scope
+  }) => {
+    if (!dimension) return;
+    const source = `${scope} \xB7 ${setName}.${name} \xB7 IFC #${propertyId ?? setId ?? element.expressID ?? "sin identificador"}`;
+    const selected = unitFor(unit, dimension);
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+      measurementIssues.push(
+        `${source}: valor no num\xE9rico o no finito; pendiente.`
+      );
+      return;
+    }
+    if (!selected.resolved) {
+      measurementIssues.push(
+        `${source}: unidad ${selected.source} ausente, ambigua o no soportada; pendiente.`
+      );
+      return;
+    }
+    const normalized2 = raw * selected.resolved.scale;
+    if (!Number.isFinite(normalized2)) {
+      measurementIssues.push(`${source}: conversi\xF3n fuera de rango; pendiente.`);
+      return;
+    }
+    const wallWidth = /^IfcWall(?:StandardCase|ElementedCase)?$/i.test(category) && name === widthParameter && dimension === "length";
+    const key = `${scope}:${setId ?? setName}:${propertyId ?? name}`;
+    measurements.push({
+      key,
+      label: wallWidth ? "Espesor" : labels[name] ?? name,
+      value: normalized2,
+      unit: selected.resolved.unit,
+      source: `${source} \xB7 unidad ${selected.source} IFC #${selected.node?.expressID ?? "sin identificador"}`
+    });
+    if (wallWidth) widths.push(normalized2);
+  };
+  const visit = (sets, scope) => {
+    for (const set of sets) {
+      const setName = value(set.Name) ?? "Conjunto sin nombre";
+      for (const property of set.HasProperties ?? []) {
+        add3({
+          raw: value(property.NominalValue),
+          dimension: measureTypes[property.NominalValue?.name],
+          unit: property.Unit,
+          name: value(property.Name) ?? "Propiedad sin nombre",
+          setName,
+          setId: set.expressID,
+          propertyId: property.expressID,
+          scope
+        });
+      }
+      for (const quantity of set.Quantities ?? []) {
+        const supported = Object.entries(quantityFields).filter(
+          ([field2]) => quantity[field2] != null
+        );
+        if (supported.length !== 1) continue;
+        const [field, dimension] = supported[0];
+        add3({
+          raw: value(quantity[field]),
+          dimension,
+          unit: quantity.Unit,
+          name: value(quantity.Name) ?? field,
+          setName,
+          setId: set.expressID,
+          propertyId: quantity.expressID,
+          scope
+        });
+      }
+    }
+  };
+  visit(instanceSets, "Instancia");
+  visit(typeSets, "Tipo");
+  for (const name of ["OverallHeight", "OverallWidth"]) {
+    if (element[name] != null)
+      add3({
+        raw: value(element[name]),
+        dimension: "length",
+        name,
+        setName: category,
+        setId: element.expressID,
+        propertyId: `${element.expressID}.${name}`,
+        scope: "Instancia"
+      });
+  }
+  const uniqueWidths = [...new Set(widths)];
+  if (uniqueWidths.length > 1)
+    measurementIssues.push(
+      "Espesor Width del muro ambiguo: se conservan los valores y sus fuentes, sin elegir uno."
+    );
+  return {
+    measurements,
+    measurementIssues,
+    thickness: uniqueWidths.length === 1 ? uniqueWidths[0] : null
+  };
+}
+
+// src/processing/model/identity.mjs
+function indexModelIdentity(elements) {
+  const byTag = /* @__PURE__ */ new Map(), byGlobalId = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    if (typeof element.id !== "string" || !/^[0-3][0-9A-Za-z_$]{21}$/.test(element.id)) throw new Error("Missing or invalid IFC GlobalId");
+    if (byGlobalId.has(element.id)) throw new Error(`Duplicate IFC GlobalId: ${element.id}`);
+    byGlobalId.set(element.id, element);
+    if (!element.elementId) continue;
+    if (byTag.has(element.elementId)) throw new Error(`Ambiguous explicit IFC Tag: ${element.elementId}`);
+    byTag.set(element.elementId, element);
+  }
+  return { byTag, byGlobalId };
+}
+function spatialLevel(id, parents, levels) {
+  const found = /* @__PURE__ */ new Map(), visited = /* @__PURE__ */ new Set(), pending2 = [id];
+  while (pending2.length) {
+    const current = pending2.pop();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    if (levels.has(current)) found.set(current, levels.get(current));
+    pending2.push(...parents.get(current) ?? []);
+  }
+  return { level: found.size === 1 ? [...found.values()][0] : "", ambiguousLevel: found.size > 1 };
+}
+
+// src/processing/model/display-names.mjs
+var clean = (value2) => typeof value2 === "string" ? value2.replace(/_x000D_/gi, " ").replace(/\s+/g, " ").trim() : "";
+var compareText2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var prefixes2 = /^(?:(?:SUMINISTRO Y (?:COLOCACI[OÓ]N|MONTAJE|APLICACI[OÓ]N)|SUMINISTRO E INSTALACI[OÓ]N|CONSTRUCCI[OÓ]N|FABRICACI[OÓ]N|COLOCACI[OÓ]N|INSTALACI[OÓ]N) DE\s+)/i;
+function shortName(value2) {
+  const maxLength = 48;
+  const text = clean(value2);
+  if (text.length <= maxLength) return text;
+  const head = text.slice(0, maxLength - 1);
+  const boundary = head.lastIndexOf(" ");
+  return `${(boundary > maxLength / 2 ? head.slice(0, boundary) : head).trimEnd()}\u2026`;
+}
+function conceptName(description) {
+  const original = clean(description);
+  const body = original.replace(prefixes2, "");
+  const main2 = body.split(/\s+(?:INCLUYE|INCLUYENDO|INC\.?)(?:\s|:)|;|,(?=\s)|\.(?=\s)|\s+(?:CONSISTENTE EN|POR MEDIOS|HECH[OA] (?:CON|A BASE)|ASENTAD[OA] CON|REFORZAD[OA] CON|CON ACABADO|EN APARIENCIA)\b|\s+(?:(?:DE|DEL|CON|EN)\s+)?\d+(?:[.,]\d+)?\s*(?:[x×]|\b(?:CM|CMS|MM|MTS|M|METROS?)\b)/i)[0].trim();
+  const selected = main2 || original;
+  let result = selected.toLocaleLowerCase("es-MX").replace(/\b(?:pvc|cpvc|wpc|mdf|led|hvac|pb|pa|az)\b/gi, (token) => token.toUpperCase());
+  for (const token of selected.match(/\b[A-Z]{1,6}-?\d+(?:-\d+)*\b/g) ?? []) {
+    result = result.replaceAll(token.toLowerCase(), token);
+  }
+  return shortName(result.charAt(0).toLocaleUpperCase("es-MX") + result.slice(1));
+}
+function propertyCandidates(sets, names2, scope) {
+  return sets.flatMap((set) => (set.HasProperties ?? []).flatMap((property) => {
+    const name = property.Name?.value;
+    const value2 = clean(property.NominalValue?.value);
+    return names2.includes(name) && value2 ? [{
+      value: value2,
+      source: `${scope} \xB7 ${set.Name?.value ?? "Conjunto sin nombre"}.${name} \xB7 IFC #${property.expressID ?? set.expressID ?? "sin identificador"}`
+    }] : [];
+  }));
+}
+function uniqueDescriptor(candidates) {
+  const values = [...new Set(candidates.map((candidate) => candidate.value))].toSorted(compareText2);
+  return {
+    value: values.length === 1 ? values[0] : "",
+    candidates: candidates.toSorted((a, b) => compareText2(a.value, b.value) || compareText2(a.source, b.source)),
+    ambiguous: values.length > 1
+  };
+}
+function modelDescriptors(instanceSets = [], types = []) {
+  const typeSets = types.flatMap((type2) => type2.HasPropertySets ?? []);
+  const family = uniqueDescriptor([
+    ...propertyCandidates(instanceSets, ["Family", "Family Name"], "Instancia"),
+    ...propertyCandidates(typeSets, ["Family", "Family Name"], "Tipo")
+  ]);
+  const namedTypes = [
+    ...propertyCandidates(instanceSets, ["Type", "Type Name"], "Instancia"),
+    ...propertyCandidates(typeSets, ["Type", "Type Name"], "Tipo")
+  ];
+  const type = uniqueDescriptor(namedTypes.length ? namedTypes : types.flatMap((item) => {
+    const value2 = clean(item.Name?.value);
+    return value2 ? [{ value: value2, source: `IfcTypeObject.Name \xB7 IFC #${item.expressID ?? "sin identificador"}` }] : [];
+  }));
+  return { family: family.value, typeName: type.value, descriptorEvidence: { family, type } };
+}
+function fallbackName(element) {
+  const category = clean(element.categoryLabel) || "Elemento";
+  const descriptor = clean(element.typeName) || clean(element.family);
+  if (!descriptor) return shortName(category);
+  const categoryStart = descriptor.toLocaleLowerCase("es-MX").startsWith(`${category.toLocaleLowerCase("es-MX")} `);
+  return shortName(categoryStart || descriptor.toLocaleLowerCase("es-MX") === category.toLocaleLowerCase("es-MX") ? descriptor : `${category} \xB7 ${descriptor}`);
+}
+function withDisplayNames(elements, concepts = []) {
+  const byConcept = new Map(concepts.map((concept) => [concept.id, concept]));
+  return elements.map((element) => {
+    const namesByConcept = {}, byConceptEvidence = {};
+    const confirmed = (element.relations ?? []).filter((relation) => relation.status === "confirmed" && !relation.ambiguous).toSorted((a, b) => compareText2(a.conceptId, b.conceptId));
+    for (const relation of confirmed) {
+      const concept = byConcept.get(relation.conceptId);
+      if (!concept || !clean(concept.description)) continue;
+      namesByConcept[concept.id] = conceptName(concept.description);
+      byConceptEvidence[concept.id] = {
+        rule: "catalog-literal-nominal-phrase-before-dimensions-or-execution-clause-v2; sentence-case-preserve-codes; word-boundary-ellipsis-48",
+        catalogSourceHash: concept.provenance?.sourceHash ?? null,
+        sheet: concept.sheet ?? null,
+        row: concept.row ?? null
+      };
+    }
+    return {
+      ...element,
+      displayName: fallbackName(element),
+      namesByConcept,
+      nameEvidence: {
+        fallback: { rule: "ifc-category-with-explicit-type-or-family; word-boundary-ellipsis-48", descriptors: element.descriptorEvidence ?? null },
+        byConcept: byConceptEvidence
+      }
+    };
+  });
+}
+
+// src/processing/model/element-dimensions.mjs
+var fields = ["length", "width", "height"];
+var priorities = ["instance", "type", "bounding-box"];
+var labels2 = { length: "Largo", width: "Ancho", height: "Alto" };
+var names = { Length: "length", Width: "width", Height: "height", OverallWidth: "width", OverallHeight: "height" };
+var lengthTypes = /* @__PURE__ */ new Set(["IFCLENGTHMEASURE", "IFCPOSITIVELENGTHMEASURE", "IFCNONNEGATIVELENGTHMEASURE"]);
+var unwrap = (value2) => value2?.value;
+var equivalent = (a, b) => Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+var bySource = (a, b) => JSON.stringify(a.source).localeCompare(JSON.stringify(b.source), "en");
+function targetField(name, category) {
+  if (Object.hasOwn(names, name)) return names[name];
+  if (name !== "Thickness") return null;
+  if (/^IFCWALL(?:STANDARDCASE|ELEMENTEDCASE)?$/i.test(category)) return "width";
+  return null;
+}
+function propertyLabel(name, field, category) {
+  return name === "Thickness" || name === "Width" && /^IFCWALL(?:STANDARDCASE|ELEMENTEDCASE)?$/i.test(category) ? "Espesor" : labels2[field];
+}
+function propertyRule(name, category) {
+  if (name === "Thickness" || name === "Width" && /^IFCWALL(?:STANDARDCASE|ELEMENTEDCASE)?$/i.test(category))
+    return "Espesor declarado del muro, presentado en width; no se obtiene del dibujo ni de otras dimensiones.";
+  return `Atributo o propiedad dimensional ${name} exportado literalmente; no se infiere su orientaci\xF3n a partir del nombre del elemento.`;
+}
+function resolveUnit(explicit, projectUnits) {
+  const candidates = explicit != null ? [explicit] : projectUnits.filter((unit) => unwrap(unit.UnitType) === "LENGTHUNIT");
+  const node = candidates.length === 1 ? candidates[0] : null;
+  return { node, resolved: measurementUnit(node, "length"), assignment: explicit != null ? "explicit" : "project" };
+}
+function extractElementDimensions({ element, category = "", instanceSets = [], types = [], projectUnits = [], boundingBoxes = [] }) {
+  const candidates = [], issues = [];
+  const identity2 = { globalId: unwrap(element.GlobalId), elementExpressId: element.expressID };
+  const add3 = ({ field, rawValue, kind, label: label2, unit, source, supported = true }) => {
+    const units3 = resolveUnit(unit, projectUnits);
+    const provenance = { ...identity2, ...source, unitAssignment: units3.assignment, unitExpressId: units3.node?.expressID ?? null, unitScale: units3.resolved?.scale ?? null };
+    let reason = null;
+    if (!supported) reason = "El valor no est\xE1 declarado como una medida de longitud IFC.";
+    else if (typeof rawValue !== "number" || !Number.isFinite(rawValue) || rawValue <= 0) reason = "La dimensi\xF3n debe ser num\xE9rica, finita y mayor que cero.";
+    else if (!units3.resolved) reason = "La unidad IFC est\xE1 ausente, es ambigua o no est\xE1 soportada.";
+    const normalized2 = reason ? null : rawValue * units3.resolved.scale;
+    if (normalized2 !== null && (!Number.isFinite(normalized2) || normalized2 <= 0)) reason = "La conversi\xF3n de unidad est\xE1 fuera de rango.";
+    const candidate = { field, value: reason ? null : normalized2, rawValue: Number.isFinite(rawValue) ? rawValue : null, unit: "m", kind, label: label2, source: provenance, ...reason ? { reason } : {} };
+    candidates.push(candidate);
+    if (reason) issues.push({ field, kind, reason, source: provenance });
+  };
+  const visit = (sets, kind, typeId) => {
+    for (const set of sets) {
+      const common = { propertySetExpressId: set.expressID, propertySetName: unwrap(set.Name) ?? "", ...typeId == null ? {} : { ifcTypeExpressId: typeId } };
+      for (const property of [...set.HasProperties ?? [], ...set.Quantities ?? []]) {
+        const name = unwrap(property.Name), field = targetField(name, category);
+        if (!field) continue;
+        const quantity = property.LengthValue != null;
+        add3({
+          field,
+          rawValue: unwrap(quantity ? property.LengthValue : property.NominalValue),
+          kind,
+          label: propertyLabel(name, field, category),
+          unit: property.Unit,
+          supported: quantity || lengthTypes.has(property.NominalValue?.name),
+          source: { ...common, propertyExpressId: property.expressID, propertyName: name, rule: propertyRule(name, category) }
+        });
+      }
+    }
+  };
+  visit(instanceSets, "instance");
+  for (const name of Object.keys(names)) {
+    if (element[name] == null) continue;
+    const field = names[name];
+    add3({
+      field,
+      rawValue: unwrap(element[name]),
+      kind: "instance",
+      label: propertyLabel(name, field, category),
+      source: { propertyName: name, rule: propertyRule(name, category) }
+    });
+  }
+  for (const type of types) visit(type.HasPropertySets ?? [], "type", type.expressID);
+  for (const { box, representationExpressId, productRepresentationExpressId } of boundingBoxes) {
+    const x = unwrap(box.XDim), y = unwrap(box.YDim);
+    const horizontalValid = [x, y].every((value2) => typeof value2 === "number" && Number.isFinite(value2) && value2 > 0);
+    const mapping = { length: horizontalValid && y > x ? "YDim" : "XDim", width: horizontalValid && y > x ? "XDim" : "YDim", height: "ZDim" };
+    for (const field of fields) {
+      const axis = mapping[field];
+      add3({
+        field,
+        rawValue: field !== "height" && !horizontalValid ? null : unwrap(box[axis]),
+        kind: "bounding-box",
+        label: `${labels2[field]} de envolvente`,
+        source: {
+          boundingBoxExpressId: box.expressID,
+          representationExpressId,
+          productRepresentationExpressId,
+          axis,
+          rule: field === "height" ? "ZDim de la caja IFC, en su eje local Z; no implica altura vertical global ni medida exacta de la pieza." : `${field === "length" ? "M\xE1ximo" : "M\xEDnimo"} de XDim e YDim de la caja IFC en ejes locales; dimensi\xF3n de envolvente, no longitud f\xEDsica exacta ni distancia sobre el plano.`
+        }
+      });
+    }
+  }
+  const sorted = candidates.toSorted((a, b) => fields.indexOf(a.field) - fields.indexOf(b.field) || priorities.indexOf(a.kind) - priorities.indexOf(b.kind) || bySource(a, b));
+  const discrepancies = [];
+  const dimensions2 = Object.fromEntries(fields.map((field) => {
+    const options = sorted.filter((candidate) => candidate.field === field);
+    const none = { value: null, unit: "m", kind: null, label: labels2[field], source: null, discrepancy: false };
+    if (!options.length) return [field, { ...none, reason: "El IFC no contiene una dimensi\xF3n compatible ni una caja envolvente directamente asociada." }];
+    const priority = options[0].kind;
+    const preferred = options.filter((candidate) => candidate.kind === priority);
+    const valid = preferred.filter((candidate) => candidate.value !== null);
+    const conflict = valid.some((candidate) => !equivalent(candidate.value, valid[0].value));
+    if (preferred.length !== valid.length || conflict) {
+      const reason2 = conflict ? "Existen dimensiones distintas con la misma prioridad; no se seleccion\xF3 una ni se sustituy\xF3 por una fuente secundaria." : "Una dimensi\xF3n de la fuente prioritaria no es v\xE1lida; requiere revisi\xF3n antes de usar una alternativa.";
+      discrepancies.push({ field, kind: priority, reason: reason2, candidates: preferred });
+      return [field, { ...none, discrepancy: true, reason: reason2 }];
+    }
+    const selected = valid[0];
+    const alternatives = options.filter((candidate) => candidate.value === null || !equivalent(candidate.value, selected.value));
+    const reason = alternatives.length ? `Existen valores distintos o no v\xE1lidos entre fuentes; se prioriza ${priority === "instance" ? "la instancia" : priority === "type" ? "el tipo" : "la caja envolvente"}. Una envolvente puede diferir de la dimensi\xF3n declarada.` : void 0;
+    if (reason) discrepancies.push({ field, kind: priority, reason, selected, alternatives });
+    return [field, { value: selected.value, unit: "m", kind: selected.kind, label: selected.label, source: selected.source, discrepancy: Boolean(reason), ...reason ? { reason } : {} }];
+  }));
+  return { dimensions: dimensions2, dimensionAudit: {
+    candidates: sorted,
+    discrepancies,
+    issues,
+    rules: "Instancia > tipo > caja IFC directamente asociada; igualdad num\xE9rica con tolerancia relativa 1e-9 y absoluta 1e-9 m. No se usan dimensiones nominales, nombres de familia, PDF ni presupuesto. No se transforman cajas de representaciones mapeadas."
+  } };
+}
+
+// src/processing/model/ifc-metadata.mjs
+var require2 = createRequire(import.meta.url);
+var W = require2("web-ifc");
+var categoryLabels = {
+  IFCWALL: "Muro",
+  IFCWALLSTANDARDCASE: "Muro",
+  IFCWALLELEMENTEDCASE: "Muro",
+  IFCDOOR: "Puerta",
+  IFCWINDOW: "Ventana",
+  IFCSLAB: "Losa",
+  IFCBEAM: "Viga",
+  IFCCOLUMN: "Columna",
+  IFCFOOTING: "Cimentaci\xF3n",
+  IFCSTAIR: "Escalera",
+  IFCSTAIRFLIGHT: "Tramo de escalera",
+  IFCMEMBER: "Miembro estructural",
+  IFCPLATE: "Placa",
+  IFCCOVERING: "Revestimiento",
+  IFCRAILING: "Barandal",
+  IFCBUILDINGELEMENTPROXY: "Elemento constructivo",
+  IFCFURNISHINGELEMENT: "Mobiliario",
+  IFCELEMENTASSEMBLY: "Conjunto",
+  IFCFLOWTERMINAL: "Terminal de instalaci\xF3n"
+};
+function directBoundingBoxes(api, model, element) {
+  if (!element.Representation) return [];
+  const product2 = api.GetLine(model, element.Representation.value);
+  return (product2.Representations ?? []).flatMap((reference) => {
+    const representation = api.GetLine(model, reference.value);
+    return (representation.Items ?? []).flatMap((item) => {
+      const box = api.GetLine(model, item.value);
+      return box.type === W.IFCBOUNDINGBOX ? [{ box, representationExpressId: representation.expressID, productRepresentationExpressId: product2.expressID }] : [];
+    });
+  });
+}
+async function readModel(bytes, parameters = {}) {
+  const api = new W.IfcAPI();
+  await api.Init();
+  const model = api.OpenModel(bytes);
+  if (model < 0) throw new Error("IFC could not be opened");
+  const lines = (type) => {
+    const ids = api.GetLineIDsWithType(model, type, true);
+    return Array.from({ length: ids.size() }, (_, i) => api.GetLine(model, ids.get(i)));
+  };
+  try {
+    const parents = /* @__PURE__ */ new Map(), levels = /* @__PURE__ */ new Map();
+    const addParents = (children, parent) => {
+      for (const child of children ?? []) parents.set(child.value, [...parents.get(child.value) ?? [], parent.value]);
+    };
+    for (const rel of lines(W.IFCRELCONTAINEDINSPATIALSTRUCTURE)) addParents(rel.RelatedElements, rel.RelatingStructure);
+    for (const rel of lines(W.IFCRELAGGREGATES)) addParents(rel.RelatedObjects, rel.RelatingObject);
+    for (const level of lines(W.IFCBUILDINGSTOREY)) levels.set(level.expressID, level.Name?.value ?? "");
+    const projects = lines(W.IFCPROJECT);
+    if (projects.length !== 1) throw new Error("IFC must contain one unambiguous project");
+    const projectUnits = api.GetLine(model, projects[0].expressID, true).UnitsInContext?.Units ?? [];
+    const elements = [];
+    for (const e of lines(W.IFCELEMENT).filter((item) => item.type !== W.IFCOPENINGELEMENT)) {
+      const sets = await api.properties.getPropertySets(model, e.expressID, true);
+      const types = await api.properties.getTypeProperties(model, e.expressID, true);
+      const props = sets.flatMap((set) => set.HasProperties ?? []);
+      const category = api.GetNameFromTypeCode(e.type);
+      const categoryLabel = categoryLabels[category.toUpperCase()] ?? "Elemento";
+      const elementId = typeof e.Tag?.value === "string" ? e.Tag.value : "";
+      const measurements = extractMeasurements({
+        instanceSets: sets,
+        typeSets: types.flatMap((type) => type.HasPropertySets ?? []),
+        projectUnits,
+        element: e,
+        category,
+        widthParameter: parameters.width ?? "Width"
+      });
+      const dimensions2 = extractElementDimensions({
+        element: e,
+        category,
+        instanceSets: sets,
+        types,
+        projectUnits,
+        boundingBoxes: directBoundingBoxes(api, model, e)
+      });
+      elements.push({
+        id: e.GlobalId?.value,
+        elementId,
+        name: `${categoryLabel}${elementId ? ` ${elementId}` : ""}`,
+        modelName: e.Name?.value ?? "",
+        category,
+        categoryLabel,
+        ...modelDescriptors(sets, types),
+        ...spatialLevel(e.expressID, parents, levels),
+        wbs: [...new Set(props.filter((p) => p.Name?.value === (parameters.wbs ?? "WBS")).map((p) => p.NominalValue?.value).filter((v) => typeof v === "string" && v.trim()))],
+        relations: [],
+        ...measurements,
+        ...dimensions2,
+        expressId: e.expressID
+      });
+    }
+    indexModelIdentity(elements);
+    return elements.toSorted((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  } finally {
+    api.CloseModel(model);
+  }
+}
+
+// src/processing/documents/pdf-geometry.mjs
+import { PDFDocument as PDFDocument2, PDFArray, PDFName as PDFName2, decodePDFRawStream as decodePDFRawStream2 } from "pdf-lib";
+
+// src/processing/documents/pdf-tokens.mjs
+function* pdfTokens(content) {
+  let position = 0;
+  const whitespace = () => {
+    while (position < content.length) {
+      if (/[\s\0]/.test(content[position])) position++;
+      else if (content[position] === "%") {
+        while (position < content.length && !/[\r\n]/.test(content[position]))
+          position++;
+      } else break;
+    }
+  };
+  const value2 = (depth = 0) => {
+    if (depth > 64) throw new Error("PDF operand nesting exceeds limit");
+    whitespace();
+    const start = position;
+    const char = content[position++];
+    if (char === "(") {
+      let nested = 1;
+      while (position < content.length && nested) {
+        const next = content[position++];
+        if (next === "\\") position++;
+        else if (next === "(") nested++;
+        else if (next === ")") nested--;
+      }
+      if (nested) throw new Error("Unclosed PDF string");
+      return { type: "string", value: content.slice(start, position) };
+    }
+    if (char === "<") {
+      if (content[position] === "<") {
+        position++;
+        const entries = [];
+        while (true) {
+          whitespace();
+          if (content.slice(position, position + 2) === ">>") {
+            position += 2;
+            break;
+          }
+          if (position >= content.length)
+            throw new Error("Unclosed PDF dictionary");
+          entries.push(value2(depth + 1));
+        }
+        if (entries.length % 2 || entries.some(
+          (entry, index) => index % 2 === 0 && entry?.type !== "name"
+        ))
+          throw new Error("Malformed PDF dictionary");
+        return { type: "dictionary", value: entries };
+      }
+      const end = content.indexOf(">", position);
+      if (end < 0 || !/^[\da-f\s]*$/i.test(content.slice(position, end)))
+        throw new Error("Malformed PDF hex string");
+      position = end + 1;
+      return { type: "string", value: content.slice(start, position) };
+    }
+    if (char === "[") {
+      const items = [];
+      while (true) {
+        whitespace();
+        if (content[position] === "]") {
+          position++;
+          break;
+        }
+        if (position >= content.length) throw new Error("Unclosed PDF array");
+        items.push(value2(depth + 1));
+      }
+      return items;
+    }
+    if (char === "/") {
+      while (position < content.length && !/[\s\0()[\]<>/%]/.test(content[position]))
+        position++;
+      return {
+        type: "name",
+        value: content.slice(start + 1, position).replace(
+          /#([\da-f]{2})/gi,
+          (_, hex) => String.fromCharCode(parseInt(hex, 16))
+        )
+      };
+    }
+    if (/[\]<>)]/.test(char)) throw new Error("Unexpected PDF delimiter");
+    while (position < content.length && !/[\s\0()[\]<>/%]/.test(content[position]))
+      position++;
+    const token = content.slice(start, position);
+    if (/^[+-]?(?:\d+\.?\d*|\.\d+)$/.test(token)) {
+      const number = Number(token);
+      if (!Number.isFinite(number)) throw new Error("Nonfinite PDF coordinate");
+      return number;
+    }
+    if (["true", "false", "null"].includes(token))
+      return { type: "literal", value: token };
+    if (!token) throw new Error("Empty PDF token");
+    return { type: "operator", value: token };
+  };
+  while (true) {
+    whitespace();
+    if (position >= content.length) return;
+    yield value2();
+  }
+}
+
+// src/processing/documents/pdf-geometry.mjs
+var finite = (values) => {
+  if (!values.every(Number.isFinite))
+    throw new Error("Nonfinite transformed PDF geometry");
+  return values;
+};
+var identity = [1, 0, 0, 1, 0, 0];
+var product = (a, b) => finite([
+  a[0] * b[0] + a[2] * b[1],
+  a[1] * b[0] + a[3] * b[1],
+  a[0] * b[2] + a[2] * b[3],
+  a[1] * b[2] + a[3] * b[3],
+  a[0] * b[4] + a[2] * b[5] + a[4],
+  a[1] * b[4] + a[3] * b[5] + a[5]
+]);
+var transform = (m, x, y) => finite([m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]]);
+var defaultState = () => ({
+  matrix: identity,
+  clips: [],
+  width: 1,
+  cap: 0,
+  join: 0,
+  miter: 10,
+  dash: [],
+  offset: 0
+});
+var textOperators = /* @__PURE__ */ new Set([
+  "Tf",
+  "Tm",
+  "Td",
+  "TD",
+  "Tj",
+  "TJ",
+  "T*",
+  "Ts",
+  "Tc",
+  "Tw",
+  "Tz",
+  "TL",
+  "'",
+  '"'
+]);
+var numericStyles = { rg: 3, RG: 3, g: 1, G: 1, k: 4, K: 4, i: 1 };
+function extractDocumentPaths(content, box, options = {}) {
+  if (![box.x, box.y, box.width, box.height].every(Number.isFinite) || box.width <= 0 || box.height <= 0)
+    throw new Error("Invalid PDF CropBox");
+  const pageMatrix = [1, 0, 0, -1, -box.x, box.y + box.height];
+  const paths = [], scopes = [], saved = [];
+  let state = defaultState(), args = [], commands = [], pendingClip = null, inText = false;
+  let current = null, start = null, pathIdentity = null, images = 0, unownedPaths = 0;
+  const owner = () => scopes.findLast((name) => /^Element\d+$/.test(name))?.slice(7) ?? null;
+  const region = () => scopes.findLast((name) => /^ViewRegion[\w-]+$/.test(name)) ?? null;
+  const numbers = (count) => {
+    if (args.length !== count || args.some((item) => typeof item !== "number" || !Number.isFinite(item)))
+      throw new Error("Invalid numeric operands");
+    return args;
+  };
+  const emptyPath = () => {
+    if (commands.length || pendingClip)
+      throw new Error("Path crosses a scope or transform boundary");
+  };
+  const point = (x, y) => transform(product(pageMatrix, state.matrix), x, y);
+  const begin = () => {
+    if (inText) throw new Error("Path inside text object");
+    pathIdentity ??= { owner: owner(), region: region() };
+  };
+  const move = (x, y) => {
+    begin();
+    current = point(x, y);
+    start = current;
+    commands.push(`M${current.join(" ")}`);
+  };
+  const line = (x, y) => {
+    if (!current) throw new Error("Line has no current point");
+    current = point(x, y);
+    commands.push(`L${current.join(" ")}`);
+  };
+  const close = () => {
+    if (!current) throw new Error("Close has no current point");
+    commands.push("Z");
+    current = start;
+  };
+  const paint = (kind, fillRule) => {
+    if (!commands.length) return;
+    if (!pathIdentity.owner) {
+      unownedPaths++;
+      return;
+    }
+    const result = {
+      ...pathIdentity,
+      d: commands.join(" "),
+      kind,
+      fillRule,
+      strokeWidth: 0,
+      clips: state.clips
+    };
+    if (kind === "stroke") {
+      const [a, b, c, d] = state.matrix;
+      const sx = Math.hypot(a, b), sy = Math.hypot(c, d);
+      if (!sx || Math.abs(sx - sy) > 1e-9 * Math.max(sx, sy) || Math.abs(a * c + b * d) > 1e-9 * sx * sy)
+        throw new Error("Nonuniform or skewed stroke transform is unsupported");
+      if (state.width <= 0)
+        throw new Error("Device-dependent hairline stroke is unsupported");
+      finite([
+        state.width * sx,
+        state.offset * sx,
+        ...state.dash.map((n) => n * sx)
+      ]);
+      Object.assign(result, {
+        strokeWidth: state.width * sx,
+        strokeLinecap: ["butt", "round", "square"][state.cap],
+        strokeLinejoin: ["miter", "round", "bevel"][state.join],
+        strokeMiterlimit: state.miter,
+        strokeDasharray: state.dash.map((n) => n * sx),
+        strokeDashoffset: state.offset * sx
+      });
+    }
+    paths.push(result);
+  };
+  const finish = () => {
+    if (pendingClip)
+      state = {
+        ...state,
+        clips: [
+          ...state.clips,
+          { d: commands.join(" "), fillRule: pendingClip }
+        ]
+      };
+    commands = [];
+    current = null;
+    start = null;
+    pathIdentity = null;
+    pendingClip = null;
+  };
+  for (const token of pdfTokens(content)) {
+    if (token?.type !== "operator") {
+      args.push(token);
+      continue;
+    }
+    const op = token.value;
+    if (Object.hasOwn(numericStyles, op)) numbers(numericStyles[op]);
+    else if (textOperators.has(op)) {
+      if (!inText) throw new Error("Text operation outside text object");
+    } else
+      switch (op) {
+        case "BMC":
+        case "BDC": {
+          emptyPath();
+          if (args.length !== (op === "BMC" ? 1 : 2) || args[0]?.type !== "name")
+            throw new Error("Malformed marked content");
+          if (/^Element\d+$/.test(args[0].value) && owner())
+            throw new Error("Nested element ownership");
+          if (op === "BDC" && !["name", "dictionary"].includes(args[1]?.type))
+            throw new Error("Malformed marked content properties");
+          if (args[0].value === "OC")
+            throw new Error("Optional-content visibility is unsupported");
+          scopes.push(args[0].value);
+          break;
+        }
+        case "EMC":
+          emptyPath();
+          numbers(0);
+          if (!scopes.pop()) throw new Error("Unbalanced marked content");
+          break;
+        case "q":
+          emptyPath();
+          numbers(0);
+          saved.push({ ...state });
+          break;
+        case "Q":
+          emptyPath();
+          numbers(0);
+          if (!saved.length) throw new Error("Unbalanced graphics state");
+          state = saved.pop();
+          break;
+        case "cm":
+          emptyPath();
+          state = { ...state, matrix: product(state.matrix, numbers(6)) };
+          break;
+        case "w":
+          ;
+          [state.width] = numbers(1);
+          if (state.width < 0) throw new Error("Negative stroke width");
+          break;
+        case "J":
+        case "j": {
+          const [n] = numbers(1);
+          if (![0, 1, 2].includes(n)) throw new Error("Invalid stroke style");
+          state[op === "J" ? "cap" : "join"] = n;
+          break;
+        }
+        case "M":
+          ;
+          [state.miter] = numbers(1);
+          if (state.miter < 1) throw new Error("Invalid miter limit");
+          break;
+        case "d":
+          if (args.length !== 2 || !Array.isArray(args[0]) || args[0].some(
+            (n) => typeof n !== "number" || !Number.isFinite(n) || n < 0
+          ) || typeof args[1] !== "number" || !Number.isFinite(args[1]) || args[0].length && args[0].every((n) => n === 0))
+            throw new Error("Invalid stroke dash");
+          state.dash = args[0];
+          state.offset = args[1];
+          break;
+        case "m":
+          move(...numbers(2));
+          break;
+        case "l":
+          line(...numbers(2));
+          break;
+        case "h":
+          numbers(0);
+          close();
+          break;
+        case "re": {
+          const [x, y, w, h] = numbers(4);
+          move(x, y);
+          line(x + w, y);
+          line(x + w, y + h);
+          line(x, y + h);
+          close();
+          break;
+        }
+        case "c":
+        case "v":
+        case "y": {
+          if (!current) throw new Error("Curve has no current point");
+          const values = numbers(op === "c" ? 6 : 4);
+          const points = [];
+          for (let i = 0; i < values.length; i += 2)
+            points.push(point(values[i], values[i + 1]));
+          if (op === "v") points.unshift(current);
+          if (op === "y") points.push(points[1]);
+          commands.push(`C${points.flat().join(" ")}`);
+          current = points[2];
+          break;
+        }
+        case "W":
+        case "W*":
+          numbers(0);
+          if (!commands.length || pendingClip)
+            throw new Error("Invalid clipping path");
+          pendingClip = op === "W*" ? "evenodd" : "nonzero";
+          break;
+        case "f":
+        case "F":
+        case "f*":
+        case "S":
+        case "s":
+        case "B":
+        case "B*":
+        case "b":
+        case "b*":
+        case "n":
+          numbers(0);
+          if (["s", "b", "b*"].includes(op)) close();
+          if (!["S", "s", "n"].includes(op))
+            paint("fill", op.endsWith("*") ? "evenodd" : "nonzero");
+          if (["S", "s", "B", "B*", "b", "b*"].includes(op))
+            paint("stroke", "nonzero");
+          finish();
+          break;
+        case "BT":
+          numbers(0);
+          emptyPath();
+          if (inText) throw new Error("Nested text object");
+          inText = true;
+          break;
+        case "ET":
+          numbers(0);
+          if (!inText) throw new Error("Unbalanced text object");
+          inText = false;
+          break;
+        case "Tr": {
+          const [n] = numbers(1);
+          if (!inText || ![0, 1, 2, 3].includes(n))
+            throw new Error("Text clipping is unsupported");
+          break;
+        }
+        case "Do":
+          emptyPath();
+          if (args.length !== 1 || args[0]?.type !== "name")
+            throw new Error("Invalid XObject reference");
+          if (owner() || options.xObjects?.[args[0].value] !== "Image")
+            throw new Error(
+              `Uninterpreted identified or non-image XObject: ${args[0].value}`
+            );
+          images++;
+          break;
+        case "ri":
+          if (args.length !== 1 || args[0]?.type !== "name")
+            throw new Error("Invalid rendering intent");
+          break;
+        default:
+          throw new Error(`Unsupported PDF operator: ${op}`);
+      }
+    args = [];
+  }
+  if (saved.length || scopes.length || inText || commands.length || args.length)
+    throw new Error("Unclosed PDF content");
+  return {
+    paths,
+    diagnostics: [
+      `${images} raster image paints retained only in the original document.`,
+      `${unownedPaths} unowned vector paths excluded.`,
+      "Document element tags identify exported drawings; they do not establish IFC identity or WBS relationships."
+    ]
+  };
+}
+async function readDocumentGeometry(bytes, { pageNumber = 1 } = {}) {
+  let viewBox = null;
+  try {
+    const pdf = await PDFDocument2.load(bytes);
+    const page = pdf.getPages()[pageNumber - 1];
+    if (!page) throw new Error(`Missing PDF page ${pageNumber}`);
+    if (page.getRotation().angle !== 0)
+      throw new Error("Rotated PDF page is unsupported");
+    const unit = page.node.lookup(PDFName2.of("UserUnit"));
+    if (unit && unit.asNumber() !== 1)
+      throw new Error("Non-default PDF UserUnit is unsupported");
+    const crop = page.getCropBox(), media = page.getMediaBox();
+    const x = Math.max(crop.x, media.x), y = Math.max(crop.y, media.y);
+    const box = {
+      x,
+      y,
+      width: Math.min(crop.x + crop.width, media.x + media.width) - x,
+      height: Math.min(crop.y + crop.height, media.y + media.height) - y
+    };
+    if (box.width <= 0 || box.height <= 0)
+      throw new Error("CropBox has no intersection with MediaBox");
+    viewBox = [0, 0, box.width, box.height];
+    const raw = page.node.Contents();
+    const streams = raw instanceof PDFArray ? Array.from({ length: raw.size() }, (_, i) => raw.lookup(i)) : [raw];
+    const content = streams.map(
+      (stream) => new TextDecoder("latin1").decode(decodePDFRawStream2(stream).decode())
+    ).join("\n");
+    const objects = page.node.Resources()?.lookup(PDFName2.of("XObject"));
+    const xObjects = Object.fromEntries(
+      (objects?.keys() ?? []).map((key) => [
+        key.decodeText(),
+        objects.lookup(key)?.dict?.lookup(PDFName2.of("Subtype"))?.toString().slice(1)
+      ])
+    );
+    return { supported: true, viewBox, ...extractDocumentPaths(content, box, { xObjects }) };
+  } catch (error) {
+    return {
+      supported: false,
+      viewBox,
+      paths: [],
+      diagnostics: [`Document-only: ${error.message}`]
+    };
+  }
+}
+function requireSupportedDrawing(drawing, viewId) {
+  if (drawing.supported !== true || !drawing.viewBox)
+    throw new Error(`Unsupported or invalid PDF view ${viewId}: ${drawing.diagnostics.join("; ")}. Existing prepared artifacts were not replaced.`);
+  return drawing;
+}
+
+// src/processing/documents/representations.mjs
+function linkRepresentations({ drawing, elements, viewId, source, modelSource, page }) {
+  const { byTag } = indexModelIdentity(elements);
+  const clips = [], clipIds = /* @__PURE__ */ new Map(), pieces = /* @__PURE__ */ new Map(), unknownOwners = /* @__PURE__ */ new Set();
+  for (const path of drawing.paths) {
+    const element = byTag.get(path.owner);
+    if (!element) {
+      unknownOwners.add(path.owner);
+      continue;
+    }
+    const { owner: _owner, region: _region, ...geometry } = path;
+    const clipIndexes = path.clips.map((clip) => {
+      const key = JSON.stringify(clip);
+      if (!clipIds.has(key)) {
+        clipIds.set(key, clips.length);
+        clips.push(clip);
+      }
+      return clipIds.get(key);
+    });
+    if (!pieces.has(element.id)) pieces.set(element.id, { id: element.id, elementId: element.elementId, paths: [] });
+    pieces.get(element.id).paths.push({ ...geometry, clips: clipIndexes });
+  }
+  return {
+    geometry: {
+      schemaVersion: 1,
+      viewId,
+      viewBox: drawing.viewBox,
+      source: { sha256: source.sha256, page },
+      modelSource: { sha256: modelSource.sha256 },
+      clips,
+      pieces: [...pieces.values()]
+    },
+    audit: {
+      unknownOwners: [...unknownOwners].toSorted(),
+      diagnostics: drawing.diagnostics,
+      rawPaths: drawing.paths.length,
+      representations: [...pieces.values()].map((p) => ({
+        globalId: p.id,
+        elementId: p.elementId,
+        paths: p.paths.length,
+        fills: p.paths.filter((path) => path.kind === "fill").length,
+        strokes: p.paths.filter((path) => path.kind === "stroke").length,
+        graphicDecision: null
+      }))
+    }
+  };
+}
+
+// src/processing/documents/admission.mjs
+function requireInteractiveView({ drawing, geometry, viewId }) {
+  const reason = drawing.paths.length === 0 ? "No identified vector paths were extracted; a raster or untagged PDF cannot supply interactive geometry" : geometry.pieces.length === 0 ? "No identified PDF paths match an explicit IFC element identity" : null;
+  if (reason) {
+    throw new Error(`Interactive view ${viewId} rejected: ${reason}. ${drawing.diagnostics.join("; ")}. Existing prepared artifacts were not replaced.`);
+  }
+}
+
+// src/processing/model/comparable-quantity.mjs
+var units = { ML: "m", M: "m", M2: "m\xB2", "M\xB2": "m\xB2", M3: "m\xB3", "M\xB3": "m\xB3", PZA: "pza", PCS: "pza" };
+var unitOf = (value2) => units[String(value2 ?? "").trim().toUpperCase()] ?? null;
+var labelsByUnit = {
+  m: ["Longitud"],
+  "m\xB3": ["Volumen neto exportado", "Volumen exportado", "Volumen bruto exportado"]
+};
+function areaLabels(category) {
+  if (category.toUpperCase().startsWith("IFCWALL")) return [
+    "\xC1rea lateral neta exportada",
+    "\xC1rea neta exportada",
+    "\xC1rea lateral bruta exportada",
+    "\xC1rea bruta exportada"
+  ];
+  if (/^IFC(?:SLAB|ROOF|COVERING)$/.test(category.toUpperCase())) return [
+    "\xC1rea neta exportada",
+    "\xC1rea de huella neta exportada",
+    "\xC1rea bruta exportada",
+    "\xC1rea de huella bruta exportada"
+  ];
+  return ["\xC1rea neta exportada", "\xC1rea bruta exportada"];
+}
+function pending(unit, reason) {
+  return { value: null, unit: unit ?? "", label: "Cantidad comparable pendiente", reason };
+}
+function comparableQuantity(element, concept) {
+  const unit = unitOf(concept.unit);
+  if (!unit) return pending(String(concept.unit ?? ""), "La unidad de la partida no tiene una regla de comparaci\xF3n con una pieza IFC.");
+  if (unit === "pza") {
+    if (!/^[0-3][0-9A-Za-z_$]{21}$/.test(element.id ?? "")) return pending(unit, "La pieza no tiene una identidad IFC verificable.");
+    return { value: 1, unit, label: "Elemento identificado", source: `IFC GlobalId ${element.id}`, reason: "Conteo de una entidad IFC seleccionada; no concilia piezas presupuestadas ni componentes de un conjunto." };
+  }
+  const labels3 = unit === "m\xB2" ? areaLabels(element.category ?? "") : labelsByUnit[unit];
+  for (const label2 of labels3) {
+    const candidates = (element.measurements ?? []).filter((measure) => measure.label === label2);
+    if (!candidates.length) continue;
+    if (candidates.some((measure) => measure.unit !== unit || !Number.isFinite(measure.value) || measure.value < 0 || !measure.source)) {
+      return pending(unit, `${label2}: la unidad, el valor o su procedencia no permiten una comparaci\xF3n verificable.`);
+    }
+    if (new Set(candidates.map((measure) => measure.value)).size > 1) {
+      return pending(unit, `${label2}: existen valores exportados distintos; hace falta confirmar cu\xE1l corresponde a esta pieza.`);
+    }
+    const instance = candidates.filter((measure) => measure.source.startsWith("Instancia"));
+    if (!instance.length) return pending(unit, `${label2}: solo existen propiedades de tipo; no se asumen como cantidad de esta pieza.`);
+    return {
+      value: instance[0].value,
+      unit,
+      label: label2,
+      source: [...new Set(instance.map((measure) => measure.source))].toSorted().join(" | "),
+      reason: "Medida exportada de la pieza para comparar como referencia; no es una cantidad conciliada con el presupuesto."
+    };
+  }
+  if (unit === "m\xB2" && (element.measurements ?? []).some((measure) => measure.label === "\xC1rea exportada")) {
+    return pending(unit, "El IFC aporta un \xE1rea sin identificar si es neta o bruta. No se asume su naturaleza ni se descuentan huecos.");
+  }
+  return pending(unit, unit === "m" ? "No hay longitud de instancia exportada. No se sustituyen longitudes nominales ni se calculan dimensiones." : "No hay una medida exportada compatible. No se multiplican dimensiones ni se descuentan huecos para inventarla.");
+}
+
+// src/processing/houses/materials-relations.mjs
+var add = (map, key, value2) => map.set(key, [...map.get(key) ?? [], value2]);
+var units2 = { ML: "m", M2: "m\xB2", M3: "m\xB3", PZA: "pza" };
+var normalizeUnit = (unit) => String(unit ?? "").toUpperCase().replace("\xB2", "2").replace("\xB3", "3");
+var conflictingQuantities = (entries) => ["ML", "M2", "M3", "PZA"].some((key) => new Set(entries.flatMap((entry) => entry.quantities.filter((quantity) => quantity.unit === key).map((quantity) => quantity.value))).size > 1);
+var pendingQuantity = (unit, reason) => ({ value: null, unit, label: "Cantidad exportada no disponible", reason });
+function workbookQuantity(entries, concept) {
+  const unit = normalizeUnit(concept.unit), displayUnit = units2[unit] ?? concept.unit;
+  if (!entries.length || entries.some((entry) => entry.quantityRole !== "exported")) return pendingQuantity(displayUnit, "Registro documental o cantidad sin alcance definido; no se convierte ni se cuenta como una pieza o lote.");
+  const values = entries.flatMap((entry) => entry.quantities.filter((quantity) => quantity.unit === unit).map((quantity) => ({ ...quantity, source: entry.source })));
+  if (!values.length) return pendingQuantity(displayUnit, "El Excel no contiene una cantidad exportada compatible con la unidad de esta partida.");
+  const conflicts = conflictingQuantities(entries);
+  if (conflicts || entries.some((entry) => entry.issues.includes("conflicting-host-material"))) return pendingQuantity(displayUnit, "Hay cantidades exportadas contradictorias; se conservan las filas y no se suman ni se elige una silenciosamente.");
+  return {
+    value: values[0].value,
+    unit: displayUnit,
+    label: entries[0].recordKind === "material" ? "Cantidad del material \xB7 Excel" : "Cantidad de la pieza \xB7 Excel",
+    source: values.map((value2) => `${value2.source.name} \xB7 ${value2.source.sheet} \xB7 fila ${value2.source.row} \xB7 SHA-256 ${value2.source.sha256}`).join(" | "),
+    reason: "Cantidad documental exportada para esta relaci\xF3n. No se obtiene del \xE1rea del anfitri\xF3n ni se reparte entre capas."
+  };
+}
+function linkDeliveryRelations(elements, concepts, review, modelHash) {
+  const byId = new Map(concepts.map((concept) => [concept.id, concept]));
+  return elements.map((element) => {
+    const rows = review?.elementBindings.get(element.id) ?? [], apps = review?.applications.get(element.id) ?? [];
+    const declarations = [...rows, ...apps], linked = declarations.filter((entry) => entry.matchStatus === "unique");
+    const ifcEvidence = { kind: "ifc", sha256: modelHash, rule: "exact-exported-WBS" };
+    const relations = /* @__PURE__ */ new Map();
+    const put = (relation) => {
+      const old = relations.get(relation.conceptId);
+      if (!old) {
+        relations.set(relation.conceptId, relation);
+        return;
+      }
+      relations.set(relation.conceptId, {
+        ...old,
+        kind: old.kind === "element" || relation.kind === "element" ? "element" : "material",
+        status: old.status === "pending" || relation.status === "pending" ? "pending" : "linked",
+        ambiguous: old.ambiguous || relation.ambiguous,
+        evidence: [...old.evidence, ...relation.evidence],
+        issues: [.../* @__PURE__ */ new Set([...old.issues, ...relation.issues])]
+      });
+    };
+    const ifcUnique = [];
+    for (const code of element.wbs ?? []) {
+      const candidates = concepts.filter((concept) => concept.code === code || concept.qualifiedCode === code);
+      if (candidates.length === 1) ifcUnique.push(candidates[0]);
+      const explicit = linked.filter((entry) => candidates.some((concept) => concept.id === entry.candidates[0].id));
+      if (candidates.length > 1 && explicit.length) continue;
+      for (const concept of candidates) put({ conceptId: concept.id, kind: "element", status: candidates.length === 1 ? "linked" : "pending", ambiguous: candidates.length > 1, evidence: [ifcEvidence], issues: candidates.length > 1 ? ["wbs-ambiguous"] : [] });
+    }
+    const elementGroups = /* @__PURE__ */ new Map();
+    for (const row of rows.filter((entry) => entry.matchStatus === "unique")) add(elementGroups, byId.get(row.candidates[0].id).code, row);
+    const conflictingRows = /* @__PURE__ */ new Set();
+    for (const group of elementGroups.values()) if (new Set(group.map((row) => row.candidates[0].id)).size > 1) for (const row of group) conflictingRows.add(row.id);
+    for (const entry of declarations) {
+      const uniqueConcept = entry.matchStatus === "unique" ? byId.get(entry.candidates[0].id) : null;
+      const conflictingIfc = uniqueConcept && entry.recordKind === "element" ? ifcUnique.filter((concept) => concept.id !== uniqueConcept.id) : [];
+      const conflict = conflictingRows.has(entry.id) || conflictingIfc.length > 0;
+      if (conflict) {
+        entry.relationStatus = "pending";
+        entry.issues.push("conflicting-element-relation");
+        for (const concept of conflictingIfc) {
+          const relation = relations.get(concept.id);
+          relation.status = "pending";
+          relation.issues.push("conflicting-element-relation");
+        }
+      }
+      for (const candidate of entry.candidates) put({
+        conceptId: candidate.id,
+        kind: entry.recordKind,
+        status: entry.matchStatus === "unique" && !conflict ? "linked" : "pending",
+        ambiguous: entry.matchStatus !== "unique" || conflict,
+        evidence: [entry.evidence],
+        issues: conflict ? ["conflicting-element-relation"] : entry.matchStatus !== "unique" ? ["wbs-ambiguous"] : []
+      });
+    }
+    const related = { ...element, relations: [...relations.values()], ...apps.length ? { materialApplications: apps } : {} };
+    const named = withDisplayNames([related], concepts)[0];
+    const quantitiesByConcept = {}, namesByConcept = { ...named.namesByConcept };
+    for (const relation of related.relations) {
+      const concept = byId.get(relation.conceptId);
+      if (relation.status === "linked") namesByConcept[concept.id] = conceptName(concept.description);
+      const relevantRows = rows.filter((row) => row.matchStatus === "unique" && row.candidates[0].id === concept.id);
+      const relevantApps = apps.filter((app) => app.matchStatus === "unique" && app.candidates[0].id === concept.id);
+      if (relation.kind === "material") {
+        quantitiesByConcept[concept.id] = relevantApps.length > 1 ? pendingQuantity(units2[normalizeUnit(concept.unit)] ?? concept.unit, "Varias aplicaciones comparten la partida; consulta sus cantidades individuales en Materiales y acabados. No se suman autom\xE1ticamente.") : workbookQuantity(relevantApps, concept);
+      } else {
+        const fromIfc = comparableQuantity(element, concept);
+        const fromWorkbook = relevantRows.length ? workbookQuantity(relevantRows, concept) : null;
+        if (conflictingQuantities(relevantRows)) {
+          for (const row of relevantRows) row.issues.push("conflicting-element-quantity");
+          relation.issues.push("conflicting-element-quantity");
+          quantitiesByConcept[concept.id] = fromWorkbook;
+        } else if (relevantRows.some((row) => row.quantityRole !== "exported")) quantitiesByConcept[concept.id] = fromWorkbook;
+        else if (fromWorkbook && fromIfc.value !== null && fromWorkbook.value !== null && fromIfc.unit === fromWorkbook.unit && Math.abs(fromIfc.value - fromWorkbook.value) > Math.max(1, Math.abs(fromIfc.value), Math.abs(fromWorkbook.value)) * 1e-9) {
+          for (const row of relevantRows) row.issues.push("ifc-workbook-quantity-discrepancy");
+          relation.issues.push("ifc-workbook-quantity-discrepancy");
+          quantitiesByConcept[concept.id] = pendingQuantity(fromIfc.unit, "IFC y Excel exportan cantidades distintas; pueden tener alcances diferentes. Se conservan ambas fuentes sin conciliarlas ni elegir una silenciosamente.");
+        } else quantitiesByConcept[concept.id] = fromIfc.value !== null || !relevantRows.length ? fromIfc : fromWorkbook;
+      }
+    }
+    return { ...named, namesByConcept, quantitiesByConcept };
+  });
+}
+
+// src/processing/model/compact-measures.mjs
+var choices = {
+  wall: [["Espesor"], ["Longitud"], ["Altura", "Altura no conectada"]],
+  opening: [["Ancho total", "Ancho"], ["Altura total", "Altura"]],
+  slab: [["\xC1rea neta exportada", "\xC1rea exportada"], ["Espesor", "Espesor predeterminado"]],
+  structural: [["Longitud"], ["Ancho"], ["Altura"]]
+};
+function compactMeasurements(element) {
+  const category = element.category.toUpperCase();
+  const groups = category.includes("WALL") ? choices.wall : /IFC(DOOR|WINDOW)$/.test(category) ? choices.opening : /IFC(SLAB|COVERING|ROOF)$/.test(category) ? choices.slab : /IFC(BEAM|COLUMN|MEMBER|FOOTING)$/.test(category) ? choices.structural : [];
+  const result = [];
+  for (const labels3 of groups) {
+    for (const label2 of labels3) {
+      const matches = element.measurements.filter((m) => m.label === label2 && m.value > 0 && Number.isFinite(m.value));
+      if (!matches.length) continue;
+      if (new Set(matches.map((m) => `${m.unit}:${m.value}`)).size !== 1) break;
+      result.push(matches.find((m) => m.source.startsWith("Instancia")) ?? matches[0]);
+      break;
+    }
+  }
+  return result;
+}
+
+// src/processing/houses/materials-workbook.mjs
+import { unzipSync as unzipSync2, strFromU8 as strFromU82 } from "fflate";
+import { XMLParser as XMLParser2, XMLValidator } from "fast-xml-parser";
+var list2 = (value2) => value2 == null ? [] : Array.isArray(value2) ? value2 : [value2];
+var xml2 = new XMLParser2({ ignoreAttributes: false, parseTagValue: false, trimValues: false });
+var plain2 = (value2) => typeof value2 === "string" ? value2 : value2?.["#text"] ?? "";
+var rich2 = (value2) => value2?.t != null ? plain2(value2.t) : list2(value2?.r).map((run) => plain2(run.t)).join("");
+var headerKey = (value2) => String(value2 ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().toUpperCase().replace(/[\s_:]+/g, "");
+function readMaterialsSheets(bytes) {
+  let total = 0, count = 0;
+  const archive = unzipSync2(bytes, { filter(entry) {
+    total += entry.originalSize;
+    if (++count > 1e4 || entry.originalSize > 32 * 1024 * 1024 || total > 64 * 1024 * 1024) throw new Error("El Excel de materiales y acabados excede el tama\xF1o admitido (64 MB descomprimido).");
+    return entry.name.startsWith("xl/") && entry.name.endsWith(".xml") || entry.name === "xl/_rels/workbook.xml.rels";
+  } });
+  const parse = (path) => {
+    if (!archive[path]) throw new Error(`Excel de materiales y acabados inv\xE1lido: falta ${path}.`);
+    const content = strFromU82(archive[path]);
+    if (/<!DOCTYPE|<!ENTITY/i.test(content) || XMLValidator.validate(content) !== true) throw new Error("XML inv\xE1lido o entidades personalizadas en el Excel de materiales y acabados.");
+    return xml2.parse(content);
+  };
+  const sheets = list2(parse("xl/workbook.xml").workbook?.sheets?.sheet);
+  const relationships = list2(parse("xl/_rels/workbook.xml.rels").Relationships?.Relationship);
+  const strings = archive["xl/sharedStrings.xml"] ? list2(parse("xl/sharedStrings.xml").sst?.si).map(rich2) : [];
+  if (!sheets.length) throw new Error("El Excel de materiales y acabados no contiene hojas.");
+  if (sheets.some((sheet) => typeof sheet["@_name"] !== "string" || !sheet["@_name"].trim()) || new Set(sheets.map((sheet) => sheet["@_name"])).size !== sheets.length) throw new Error("El Excel requiere nombres de hoja \xFAnicos y no vac\xEDos.");
+  return sheets.map((sheet) => {
+    const relation = relationships.find((item) => item["@_Id"] === sheet["@_r:id"]);
+    const target = relation?.["@_Target"]?.replace(/^\/xl\//, "");
+    if (!/^worksheets\/[^/]+\.xml$/.test(target ?? "") || relation?.["@_TargetMode"] === "External") throw new Error("Referencia de hoja no admitida en el Excel de materiales y acabados.");
+    const parsed = parse(`xl/${target}`);
+    if (!Object.hasOwn(parsed, "worksheet")) throw new Error("Hoja inv\xE1lida en el Excel de materiales y acabados.");
+    return { sheet: sheet["@_name"], rows: list2(parsed.worksheet.sheetData?.row).map((row) => ({
+      row: Number(row["@_r"]),
+      cells: Object.fromEntries(list2(row.c).map((cell) => {
+        let value2 = cell.v ?? null, error = ["e", "b"].includes(cell["@_t"]);
+        if (cell["@_t"] === "s") {
+          value2 = strings[Number(value2)] ?? null;
+          error ||= value2 === null;
+        } else if (cell["@_t"] === "inlineStr") value2 = rich2(cell.is);
+        else if (value2 != null && !["str", "e"].includes(cell["@_t"])) value2 = Number(value2);
+        return [String(cell["@_r"]).replace(/\d+$/, ""), { value: value2, formula: cell.f == null ? null : plain2(cell.f), error }];
+      }))
+    })) };
+  });
+}
+function materialsColumns(row) {
+  const aliases2 = { guid: ["IFCGUID", "GLOBALID"], material: ["MATERIAL", "MATERIALNAME", "NOMBREDEMATERIAL"], wbs: ["WBS", "MATERIALWBS", "WBSCOMPLETO"], elementId: ["ELEMENTID", "REVITELEMENTID"], table: ["TABLA", "TABLE"], declaredStatus: ["ESTADO", "STATUS"], rule: ["REGLA/MOTIVO", "REGLA", "RULE"], recordKind: ["TIPODEREGISTRO", "RECORDKIND"], quantityRole: ["USOCANTIDAD", "QUANTITYROLE"], ML: ["ML"], M2: ["M2", "M\xB2"], M3: ["M3", "M\xB3"], PZA: ["PZA"] };
+  const columns = {}, duplicates = [];
+  for (const [field, names2] of Object.entries(aliases2)) {
+    const found = Object.entries(row.cells).filter(([, cell]) => names2.includes(headerKey(cell.value)));
+    if (found.length > 1) duplicates.push(field);
+    if (found.length) columns[field] = found[0][0];
+  }
+  return columns.guid && (columns.material || columns.wbs) ? { columns, duplicates } : null;
+}
+function exportedQuantity(value2, unit) {
+  if (typeof value2 === "number") return Number.isFinite(value2) && value2 >= 0 ? value2 : null;
+  if (typeof value2 !== "string") return null;
+  const match = value2.trim().match(/^(\d+(?:\.\d+)?)(?:\s*(m²|m³|m2|m3|ml|m|pza))?$/i);
+  if (!match) return null;
+  const suffix = match[2]?.toUpperCase().replace("\xB2", "2").replace("\xB3", "3");
+  if (suffix && (suffix === "M" ? "ML" : suffix) !== unit) return null;
+  const number = Number(match[1]);
+  return Number.isFinite(number) ? number : null;
+}
+
+// src/processing/houses/materials-supplement.mjs
+var empty = (cell) => cell.value == null || cell.value === "";
+var normalizedUnit = (unit) => String(unit).trim().toUpperCase().replace("\xB2", "2").replace("\xB3", "3");
+var textValue = (cell) => typeof cell?.value === "string" ? cell.value.trim() : "";
+var add2 = (map, key, value2) => map.set(key, [...map.get(key) ?? [], value2]);
+function inventory(sheets, requested) {
+  const recognized = sheets.flatMap((sheet) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of sheet.rows) counts.set(row.row, (counts.get(row.row) ?? 0) + 1);
+    const header = sheet.rows.find((row) => counts.get(row.row) === 1 && materialsColumns(row));
+    return header ? [{ name: sheet.sheet, rows: sheet.rows.filter((row) => row.row > header.row && !materialsColumns(row) && Object.values(row.cells).some((cell) => !empty(cell))).length }] : [];
+  });
+  if (requested && !recognized.some((sheet) => sheet.name === requested)) throw new Error("La hoja de materiales seleccionada no contiene encabezados reconocidos.");
+  const main2 = recognized.filter((sheet) => headerKey(sheet.name) === "MATERIALES");
+  const selectedSheet = requested || (main2.length === 1 ? main2[0].name : recognized.length === 1 ? recognized[0].name : void 0);
+  return { sheets: recognized, ...selectedSheet ? { selectedSheet } : {}, selectionRequired: recognized.length > 1 && !selectedSheet };
+}
+function linkMaterialsWorkbook({ materials, elements = [], concepts = [], associations = /* @__PURE__ */ new Map(), modelAvailable = true, materialsSheet }) {
+  const sheets = readMaterialsSheets(materials.bytes), selection = inventory(sheets, materialsSheet);
+  const source = { name: materials.name, sha256: hash(materials.bytes) };
+  const hosts = new Map(elements.map((element) => [element.id, element])), applications = /* @__PURE__ */ new Map(), elementBindings = /* @__PURE__ */ new Map(), records = [];
+  for (const sheet of sheets) {
+    const rowCounts = /* @__PURE__ */ new Map();
+    for (const row of sheet.rows) rowCounts.set(row.row, (rowCounts.get(row.row) ?? 0) + 1);
+    const header = sheet.rows.filter((row) => rowCounts.get(row.row) === 1).map((row) => ({ row, match: materialsColumns(row) })).find((item) => item.match);
+    for (const row of sheet.rows) {
+      if (Object.values(row.cells).every((cell) => empty(cell) && cell.formula === null && !cell.error)) continue;
+      const record = { sheet: sheet.sheet, row: row.row, values: row.cells, status: "ignored", issues: [] };
+      records.push(record);
+      if (!header) {
+        record.reason = "non-material-table";
+        continue;
+      }
+      if (sheet.sheet !== selection.selectedSheet) {
+        record.reason = selection.selectionRequired ? "sheet-selection-required" : "auxiliary-sheet";
+        continue;
+      }
+      if (rowCounts.get(row.row) > 1) {
+        record.status = "exception";
+        record.issues.push("duplicate-row");
+        continue;
+      }
+      if (row.row <= header.row.row || materialsColumns(row)) {
+        record.reason = "header-or-preamble";
+        continue;
+      }
+      const { columns, duplicates } = header.match, get = (field) => row.cells[columns[field]];
+      const material = textValue(get("material")), guid = textValue(get("guid"));
+      if (!material && !guid) {
+        record.reason = "total-or-empty-material";
+        continue;
+      }
+      record.status = "exception";
+      if (duplicates.length) {
+        record.issues.push("duplicate-columns");
+        continue;
+      }
+      if (!Number.isInteger(row.row) || row.row < 1) {
+        record.issues.push("invalid-row");
+        continue;
+      }
+      if (Object.values(row.cells).some((cell) => cell.formula !== null)) {
+        record.issues.push("formula");
+        continue;
+      }
+      if (Object.values(row.cells).some((cell) => cell.error)) {
+        record.issues.push("cell-error");
+        continue;
+      }
+      if (!guid) {
+        record.issues.push("missing-guid");
+        continue;
+      }
+      record.hostId = guid;
+      if (!hosts.has(guid)) {
+        record.issues.push(modelAvailable ? "unknown-host" : "model-required");
+        continue;
+      }
+      const elementId = get("elementId")?.value;
+      if (elementId != null && elementId !== "" && String(elementId).trim() !== String(hosts.get(guid).elementId)) {
+        record.issues.push("element-id-mismatch");
+        continue;
+      }
+      const declaredKind = headerKey(get("recordKind")?.value), recordKind = declaredKind ? { MATERIAL: "material", ELEMENTO: "element", ELEMENT: "element" }[declaredKind] : material ? "material" : "element";
+      if (!recordKind || recordKind === "material" && !material || recordKind === "element" && material) {
+        record.issues.push("invalid-record-kind");
+        continue;
+      }
+      record.recordKind = recordKind;
+      const wbs = textValue(get("wbs")) || null;
+      if (get("wbs")?.value != null && get("wbs").value !== "" && !wbs) record.issues.push("invalid-wbs");
+      const matches = wbs ? concepts.filter((concept) => concept.code === wbs || concept.qualifiedCode === wbs) : [];
+      const matchStatus = !wbs ? "no-code" : matches.length === 1 ? "unique" : matches.length ? "ambiguous" : "unmatched";
+      if (matchStatus !== "unique") record.issues.push(`wbs-${matchStatus}`);
+      const quantities = [];
+      for (const unit of ["ML", "M2", "M3", "PZA"]) {
+        const cell = get(unit);
+        if (!cell || empty(cell)) continue;
+        const value2 = exportedQuantity(cell.value, unit);
+        if (value2 === null) record.issues.push(`invalid-quantity-${unit}`);
+        else quantities.push({ column: columns[unit], value: value2, unit });
+      }
+      const declaredRole = headerKey(get("quantityRole")?.value);
+      const quantityRole = declaredRole ? { EXPORTED: "exported", EXPORTADA: "exported", CUANTIFICABLE: "exported", DOCUMENTARY: "documentary", DOCUMENTAL: "documentary", UNRESOLVED: "unresolved", PENDIENTE: "unresolved" }[declaredRole] : matches.length === 1 && normalizedUnit(matches[0].unit) === "LOTE" ? "unresolved" : "exported";
+      if (!quantityRole) record.issues.push("invalid-quantity-role");
+      const quantity = quantityRole === "exported" && matches.length === 1 ? quantities.find((item) => item.unit === normalizedUnit(matches[0].unit)) ?? null : null;
+      if (matches.length === 1 && !quantity) record.issues.push("quantity-unavailable");
+      const evidence = {
+        kind: "workbook",
+        ...source,
+        sheet: sheet.sheet,
+        row: row.row,
+        ...textValue(get("rule")) ? { rule: textValue(get("rule")) } : {},
+        ...textValue(get("declaredStatus")) ? { declaredStatus: textValue(get("declaredStatus")) } : {},
+        ...textValue(get("table")) ? { table: textValue(get("table")) } : {}
+      };
+      const entry = {
+        id: hash(`${source.sha256}:${sheet.sheet}:${row.row}`),
+        name: material,
+        wbs,
+        candidates: matches.map(({ id, qualifiedCode, unit }) => ({ id, qualifiedCode, unit })),
+        matchStatus,
+        relationStatus: matchStatus === "unique" ? "linked" : "pending",
+        recordKind,
+        quantityRole: quantityRole ?? "unresolved",
+        quantity,
+        quantities,
+        source: { ...source, sheet: sheet.sheet, row: row.row },
+        evidence,
+        issues: record.issues
+      };
+      if (recordKind === "material") {
+        const layers = (associations.get(guid) ?? []).filter((item) => item.name === material).map(({ name: _name, ...reference }) => reference);
+        if (!layers.length) record.issues.push("excel-only-material");
+        entry.materialEvidence = { status: layers.length ? "ifc-layer-name-match" : "excel-only", layers };
+        add2(applications, guid, entry);
+      } else add2(elementBindings, guid, entry);
+      record.status = "linked";
+      record.applicationId = entry.id;
+    }
+  }
+  for (const apps of applications.values()) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const app of apps) add2(groups, `${app.name}\0${app.wbs}`, app);
+    for (const group of groups.values()) if (group.length > 1) {
+      const signatures = new Set(group.map((app) => JSON.stringify(app.quantities.map(({ value: value2, unit }) => [unit, value2]))));
+      for (const app of group) {
+        app.issues.push("duplicate-host-material");
+        if (signatures.size > 1) {
+          app.quantity = null;
+          app.quantityRole = "unresolved";
+          app.issues.push("conflicting-host-material");
+        }
+      }
+    }
+  }
+  const linked = records.filter((record) => record.status === "linked"), exceptions = records.filter((record) => record.issues.length);
+  const summary = {
+    ...selection,
+    status: !selection.sheets.length || selection.selectionRequired ? "stored-not-linked" : exceptions.length ? "processed-with-exceptions" : "processed",
+    rows: records.filter((record) => record.status !== "ignored").length,
+    linkedRows: linked.length,
+    applications: [...applications.values()].reduce((count, apps) => count + apps.length, 0),
+    elementRows: [...elementBindings.values()].reduce((count, rows) => count + rows.length, 0),
+    exceptions: exceptions.length,
+    ignoredRows: records.filter((record) => record.status === "ignored").length
+  };
+  return { applications, elementBindings, audit: { source, summary, records }, summary };
+}
+function materialsWarnings(summary) {
+  if (summary.selectionRequired) return ["Selecciona la hoja de datos del Excel; las hojas auxiliares no deben duplicar registros."];
+  if (summary.status === "stored-not-linked") return ["Excel guardado: no se identificaron tablas de materiales o elementos con encabezados compatibles."];
+  return [`Excel complementario: ${summary.linkedRows} filas vinculadas por GlobalId; ${summary.exceptions} filas con excepciones. Las cantidades exportadas no se reparten entre capas ni se suman autom\xE1ticamente.`];
+}
+
+// src/processing/houses/material-associations.mjs
+import { createRequire as createRequire2 } from "node:module";
+var require3 = createRequire2(import.meta.url);
+var W2 = require3("web-ifc");
+async function readMaterialAssociations(bytes) {
+  const api = new W2.IfcAPI();
+  await api.Init();
+  const model = api.OpenModel(bytes);
+  if (model < 0) throw new Error("IFC could not be opened");
+  const lines = (type) => {
+    const ids = api.GetLineIDsWithType(model, type, true);
+    return Array.from({ length: ids.size() }, (_, index) => api.GetLine(model, ids.get(index)));
+  };
+  try {
+    const byHost = /* @__PURE__ */ new Map(), types = /* @__PURE__ */ new Map();
+    for (const rel of lines(W2.IFCRELASSOCIATESMATERIAL)) for (const host of rel.RelatedObjects ?? []) byHost.set(host.value, [...byHost.get(host.value) ?? [], rel]);
+    for (const rel of lines(W2.IFCRELDEFINESBYTYPE)) for (const host of rel.RelatedObjects ?? []) types.set(host.value, [...types.get(host.value) ?? [], rel.RelatingType.value]);
+    const resolve2 = (id, seen = /* @__PURE__ */ new Set()) => {
+      if (seen.has(id)) return [];
+      const next = /* @__PURE__ */ new Set([...seen, id]), item = api.GetLine(model, id);
+      if (item.type === W2.IFCMATERIAL) return [{ name: item.Name?.value ?? "", materialExpressId: id }];
+      if (item.ForLayerSet) return resolve2(item.ForLayerSet.value, next);
+      if (item.MaterialLayers) return item.MaterialLayers.flatMap((layer) => resolve2(layer.value, next));
+      if (item.Material) return resolve2(item.Material.value, next).map((material) => ({ ...material, ...item.type === W2.IFCMATERIALLAYER ? { layerExpressId: id } : {} }));
+      if (item.Materials) return item.Materials.flatMap((material) => resolve2(material.value, next));
+      return [];
+    };
+    return new Map(lines(W2.IFCELEMENT).map((element) => {
+      const direct = byHost.get(element.expressID) ?? [];
+      const inherited = (types.get(element.expressID) ?? []).flatMap((type) => byHost.get(type) ?? []);
+      const associations = direct.length ? direct : inherited;
+      return [element.GlobalId?.value, associations.flatMap((rel) => resolve2(rel.RelatingMaterial.value).map((material) => ({ ...material, associationExpressId: rel.expressID, origin: direct.length ? "instance" : "type" })))];
+    }));
+  } finally {
+    api.CloseModel(model);
+  }
+}
+
+// src/processing/houses/pipeline.mjs
+var jsonBytes = (value2) => new TextEncoder().encode(JSON.stringify(value2, null, 2) + "\n");
+var safeId = (value2) => typeof value2 === "string" && /^[a-z0-9][a-z0-9_-]{0,79}$/.test(value2);
+var publicCatalog = (catalog) => ({ ...catalog, roots: catalog.roots.length });
+function modelRevision(bytes) {
+  const text = new TextDecoder().decode(bytes), header = text.slice(0, text.indexOf("ENDSEC;"));
+  const revision = Object.fromEntries([["contentId", "ContentGUID"], ["versionId", "VersionGUID"]].map(([key, marker]) => {
+    const matches = [...header.matchAll(new RegExp(`${marker}: ([a-fA-F0-9-]+)`, "g"))];
+    if (matches.length !== 1 || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(matches[0][1])) throw new Error(`El IFC no declara ${marker} \xFAnico de Revit; entregar una exportaci\xF3n coordinada.`);
+    return [key, matches[0][1]];
+  }));
+  verifyMetadata(text, revision, "ifc");
+  return revision;
+}
+function validatePdfs(pdfs) {
+  if (!Array.isArray(pdfs) || new Set(pdfs.map((pdf) => pdf.id)).size !== pdfs.length || pdfs.some((pdf) => !safeId(pdf.id) || ["model", "catalog"].includes(pdf.id) || typeof pdf.name !== "string" || !pdf.name.trim() || !(pdf.bytes instanceof Uint8Array))) throw new Error("Cada PDF requiere ID \xFAnico seguro, nombre y contenido (model/catalog son reservados).");
+}
+async function inspectDelivery({ catalogBytes, modelBytes, pdfs = [], materials }) {
+  validatePdfs(pdfs);
+  const catalog = readHouseCatalog(catalogBytes), warnings = [...catalog.warnings];
+  const pdfInventory = await Promise.all(pdfs.map(async (pdf) => ({ id: pdf.id, name: pdf.name, pages: (await PDFDocument3.load(pdf.bytes)).getPageCount() })));
+  let model = null, rawElements = [];
+  if (modelBytes) {
+    const revision = modelRevision(modelBytes), elements = await readModel(modelBytes);
+    rawElements = elements;
+    model = { revision, levels: [...new Set(elements.map((element) => element.level).filter(Boolean))].toSorted(), elementCount: elements.length };
+    for (const pdf of pdfs) {
+      try {
+        await verifyPdfMetadata(pdf.bytes, revision);
+      } catch {
+        warnings.push(`${pdf.name}: no coincide con la revisi\xF3n IFC o no tiene metadatos coordinados; no podr\xE1 procesarse como vista interactiva.`);
+      }
+    }
+  } else warnings.push("Falta IFC coordinado: el cat\xE1logo puede revisarse, pero a\xFAn no genera un visor interactivo.");
+  if (!pdfs.length) warnings.push("Faltan PDF vectoriales identificados para crear vistas interactivas.");
+  const materialsReview = materials ? linkMaterialsWorkbook({ materials, elements: rawElements, concepts: catalog.concepts, modelAvailable: Boolean(modelBytes), associations: modelBytes ? await readMaterialAssociations(modelBytes) : /* @__PURE__ */ new Map() }) : null;
+  if (materialsReview) {
+    warnings.push(...materialsWarnings(materialsReview.summary));
+    if (!modelBytes) warnings.push("Adjunta el IFC para comprobar los GlobalId de las filas de materiales; a\xFAn no hay piezas con las cuales enlazarlas.");
+  }
+  return { ...materialsReview ? { materials: materialsReview.summary } : {}, catalog: publicCatalog(catalog), ...model ? { model } : {}, pdfs: pdfInventory, warnings };
+}
+function validateHouseConfig(config, catalog, pdfs) {
+  if (!config || !Array.isArray(config.floors) || !config.floors.length || config.floors.some((floor) => !safeId(floor.id) || typeof floor.label !== "string" || !floor.label.trim()) || new Set(config.floors.map((floor) => floor.id)).size !== config.floors.length) throw new Error("Define plantas con ID \xFAnico y nombre.");
+  const floors = new Set(config.floors.map((floor) => floor.id)), sources = new Set(pdfs.map((pdf) => pdf.id)), seenViews = /* @__PURE__ */ new Set();
+  if (!Array.isArray(config.views) || !config.views.length) throw new Error("Configura al menos una vista PDF.");
+  for (const view of config.views) {
+    if (!sources.has(view.pdfId) || !Number.isInteger(view.page) || view.page < 1 || !floors.has(view.floorId) || typeof view.title !== "string" || !view.title.trim()) throw new Error("Cada vista requiere PDF, p\xE1gina positiva, planta y t\xEDtulo.");
+    const key = `${view.pdfId}:${view.page}`;
+    if (seenViews.has(key)) throw new Error("La misma p\xE1gina PDF no puede configurarse dos veces.");
+    seenViews.add(key);
+  }
+  if (!Array.isArray(config.scopeCodes) || config.scopeCodes.some((code) => !catalog.concepts.some((concept) => concept.qualifiedCode === code)) || new Set(config.scopeCodes).size !== config.scopeCodes.length) throw new Error("El alcance debe usar c\xF3digos WBS completos y \xFAnicos del cat\xE1logo.");
+  if (!["MXN", "unconfirmed"].includes(config.currency)) throw new Error("Indica MXN confirmado o moneda sin confirmar.");
+  if (!config.floorBindings || typeof config.floorBindings !== "object" || Array.isArray(config.floorBindings)) throw new Error("Falta la asociaci\xF3n expl\xEDcita WBS\u2013plantas.");
+  for (const [code, ids] of Object.entries(config.floorBindings)) {
+    if (!catalog.nodes.some((node) => node.code === code) || !Array.isArray(ids) || !ids.length || ids.some((id) => !floors.has(id)) || new Set(ids).size !== ids.length) throw new Error(`Asociaci\xF3n WBS\u2013plantas inv\xE1lida: ${code}`);
+  }
+  const included = catalog.concepts.filter((concept) => !config.scopeCodes.length || config.scopeCodes.includes(concept.qualifiedCode));
+  const requiredRoots = catalog.roots.filter((root) => included.some((concept) => concept.chapterCode === root.code || concept.chapterCode.startsWith(`${root.code}.`)));
+  for (const root of requiredRoots) if (!Object.hasOwn(config.floorBindings, root.code)) throw new Error(`Asigna expl\xEDcitamente plantas a la partida ${root.code} (${root.label}).`);
+  return config;
+}
+function hierarchyFor(catalog, config) {
+  const byCode = new Map(catalog.nodes.map((node) => [node.code, node]));
+  const bindingFor = (code) => {
+    let current = code;
+    while (current) {
+      if (Object.hasOwn(config.floorBindings, current)) return config.floorBindings[current];
+      current = byCode.get(current)?.parentCode;
+    }
+    return [];
+  };
+  const rootFor = (code) => {
+    let node = byCode.get(code);
+    while (node.parentCode) node = byCode.get(node.parentCode);
+    return node.id;
+  };
+  const concepts = catalog.concepts.map((concept) => ({ ...concept, floorIds: [...bindingFor(concept.chapterCode)], wbsNodeId: rootFor(concept.chapterCode) }));
+  const nodes = catalog.nodes.map((node) => {
+    const assigned = new Set(catalog.nodes.filter((item) => item.code === node.code || item.code.startsWith(`${node.code}.`)).flatMap((item) => bindingFor(item.code)));
+    return { id: node.id, code: node.code, label: node.label, parentId: node.parentId, floorIds: config.floors.filter((floor) => assigned.has(floor.id)).map((floor) => floor.id) };
+  });
+  return { concepts, nodes };
+}
+function publishConcept(concept, currency) {
+  const { id, code, qualifiedCode, description, chapter, unit, quantity, parentId, wbsNodeId, floorIds } = concept;
+  const budget = currency === "MXN" ? { unitPrice: concept.unitPrice, currency: "MXN", status: "pending", note: "Precio exportado del cat\xE1logo en MXN. Tratamiento de impuestos pendiente de confirmar." } : null;
+  return { id, code, qualifiedCode, description, shortName: conceptName(description), chapter, unit, quantity, parentId, wbsNodeId, floorIds, budget };
+}
+function publishElements(elements, enabled) {
+  return elements.map((element) => ({
+    id: element.id,
+    elementId: element.elementId,
+    name: element.name,
+    category: element.category,
+    categoryLabel: element.categoryLabel,
+    level: element.level,
+    family: element.family,
+    typeName: element.typeName,
+    displayName: element.displayName,
+    wbs: element.wbs,
+    namesByConcept: Object.fromEntries(Object.entries(element.namesByConcept ?? {}).filter(([id]) => enabled.has(id))),
+    quantitiesByConcept: Object.fromEntries(Object.entries(element.quantitiesByConcept ?? {}).filter(([id]) => enabled.has(id))),
+    ...element.materialApplications ? { materialApplications: element.materialApplications } : {},
+    relations: element.relations.filter((relation) => enabled.has(relation.conceptId)),
+    measurements: compactMeasurements(element),
+    dimensions: element.dimensions
+  }));
+}
+async function processDelivery({ houseId, revisionId, name, catalogBytes, modelBytes, pdfs = [], config, materials, assetUrl }) {
+  if (!safeId(houseId) || !safeId(revisionId) || typeof name !== "string" || !name.trim()) throw new Error("Casa y revisi\xF3n requieren ID seguro y un nombre.");
+  if (!(modelBytes instanceof Uint8Array)) throw new Error("Falta el IFC coordinado para procesar.");
+  validatePdfs(pdfs);
+  const catalog = readHouseCatalog(catalogBytes);
+  validateHouseConfig(config, catalog, pdfs);
+  const revision = modelRevision(modelBytes), modelSource = { id: "model", sha256: hash(modelBytes) }, catalogSource = { id: "catalog", sha256: hash(catalogBytes) };
+  const hierarchy = hierarchyFor(catalog, config);
+  const selected = hierarchy.concepts.filter((concept) => !config.scopeCodes.length || config.scopeCodes.includes(concept.qualifiedCode)), enabled = new Set(selected.map((concept) => concept.id));
+  const rawElements = await readModel(modelBytes);
+  const materialsReview = materials ? linkMaterialsWorkbook({ materials, elements: rawElements, concepts: hierarchy.concepts, associations: await readMaterialAssociations(modelBytes), materialsSheet: config.materialsSheet }) : null;
+  if (materialsReview?.summary.selectionRequired) throw new Error("Selecciona una hoja de datos del Excel complementario antes de generar el visor.");
+  const enriched = linkDeliveryRelations(rawElements, hierarchy.concepts, materialsReview, modelSource.sha256);
+  if (materialsReview) {
+    materialsReview.summary.exceptions = materialsReview.audit.records.filter((record) => record.issues.length).length;
+    if (materialsReview.summary.exceptions) materialsReview.summary.status = "processed-with-exceptions";
+  }
+  const assets = /* @__PURE__ */ new Map(), views = [], geometryAudit = [], rejectedViews = [], warnings = [...catalog.warnings], sourceEntries = [catalogSource, modelSource];
+  if (materialsReview) {
+    const { bytes: _bytes, ...materialSource } = materials;
+    sourceEntries.push({ ...materialSource, sha256: materialsReview.audit.source.sha256, status: materialsReview.summary.status });
+    warnings.push(...materialsWarnings(materialsReview.summary));
+  }
+  const url = `/data/houses/${houseId}/${revisionId}`;
+  const resolveAssetUrl = typeof assetUrl === "function" ? assetUrl : (file) => `${url}/${file}`;
+  const sources = new Map(pdfs.map((pdf) => [pdf.id, pdf]));
+  sourceEntries.push(...pdfs.map((pdf) => ({ id: pdf.id, name: pdf.name, sha256: hash(pdf.bytes) })));
+  const rejectView = (view, reason) => {
+    rejectedViews.push({ ...view, reason });
+    warnings.push(reason);
+  };
+  for (const view of config.views) {
+    const pdf = sources.get(view.pdfId), source = { id: pdf.id, name: pdf.name, sha256: hash(pdf.bytes) };
+    try {
+      await verifyPdfMetadata(pdf.bytes, revision);
+    } catch {
+      rejectView(view, `${pdf.name}: PDF e IFC no comparten ContentGUID/VersionGUID. Reexportar ambos desde la misma revisi\xF3n.`);
+      continue;
+    }
+    const viewId = `${pdf.id}-p${view.page}`;
+    const parsedDrawing = await readDocumentGeometry(pdf.bytes, { pageNumber: view.page });
+    if (!parsedDrawing.supported || !parsedDrawing.viewBox) {
+      rejectView(view, `${pdf.name}, p\xE1gina ${view.page}: vista vectorial no admitida. ${parsedDrawing.diagnostics.join("; ")}`);
+      continue;
+    }
+    const drawing = requireSupportedDrawing(parsedDrawing, viewId);
+    const linked = linkRepresentations({ drawing, elements: enriched, viewId, source, modelSource, page: view.page });
+    try {
+      requireInteractiveView({ drawing, geometry: linked.geometry, viewId });
+    } catch {
+      rejectView(view, `${pdf.name}, p\xE1gina ${view.page}: faltan contornos vectoriales identificados que coincidan con el IFC. Exportar la vista de Revit en modo vectorial coordinado.`);
+      continue;
+    }
+    const geometryBytes = jsonBytes(linked.geometry), geometryFile = `${viewId}.json`, pdfFile = `${pdf.id}.pdf`;
+    assets.set(geometryFile, geometryBytes);
+    assets.set(pdfFile, pdf.bytes);
+    views.push({
+      id: viewId,
+      floorId: view.floorId,
+      title: view.title,
+      page: view.page,
+      pdfUrl: resolveAssetUrl(pdfFile),
+      geometryUrl: resolveAssetUrl(geometryFile),
+      pdfSha256: source.sha256,
+      modelSha256: modelSource.sha256,
+      geometrySha256: hash(geometryBytes),
+      width: linked.geometry.viewBox[2],
+      height: linked.geometry.viewBox[3],
+      elementIds: linked.geometry.pieces.map((piece) => piece.id)
+    });
+    geometryAudit.push({ viewId, source, page: view.page, ...linked.audit });
+    if (linked.audit.unknownOwners.length) warnings.push(`${view.title}: ${linked.audit.unknownOwners.length} identificadores del PDF no existen en el IFC; no se invent\xF3 geometr\xEDa interactiva para ellos.`);
+    if (!sourceEntries.some((entry) => entry.id === source.id)) sourceEntries.push(source);
+  }
+  if (!views.length) throw new Error(`No se pudo generar ninguna vista interactiva. ${rejectedViews.map((view) => view.reason).join(" ")}`);
+  const project = {
+    schemaVersion: 1,
+    id: houseId,
+    name: name.trim(),
+    revision: revision.versionId,
+    defaultViewId: views[0].id,
+    floors: config.floors,
+    views,
+    concepts: selected.map((concept) => publishConcept(concept, config.currency)),
+    elements: publishElements(enriched, enabled),
+    wbsNodes: hierarchy.nodes
+  };
+  const reviewCandidates = enriched.flatMap((element) => element.relations.filter((relation) => enabled.has(relation.conceptId)).map((relation) => ({
+    id: hash(`${modelSource.sha256}:${catalogSource.sha256}:${element.id}:${relation.conceptId}`),
+    globalId: element.id,
+    elementId: element.elementId,
+    conceptId: relation.conceptId,
+    qualifiedCode: catalog.concepts.find((concept) => concept.id === relation.conceptId).qualifiedCode,
+    ambiguous: relation.ambiguous,
+    status: relation.status,
+    kind: relation.kind,
+    evidence: relation.evidence,
+    issues: relation.issues,
+    modelSha256: modelSource.sha256,
+    catalogSha256: catalogSource.sha256,
+    viewIds: views.filter((view) => view.elementIds.includes(element.id)).map((view) => view.id)
+  })));
+  const ambiguous = reviewCandidates.filter((candidate) => candidate.ambiguous).length;
+  if (ambiguous) warnings.push(`${ambiguous} relaciones tienen varios candidatos exactos en el cat\xE1logo; requieren resolver la partida, no aprobaci\xF3n autom\xE1tica.`);
+  if (!reviewCandidates.length) warnings.push("No se encontraron relaciones WBS exactas dentro del alcance; el plano no acredita por s\xED solo una asociaci\xF3n con partidas.");
+  const withoutWbs = rawElements.filter((element) => !element.wbs.length).length;
+  if (withoutWbs) warnings.push(`${withoutWbs} elementos IFC no declaran WBS propio; solo se a\xF1aden las relaciones expl\xEDcitas que aporte el Excel complementario.`);
+  if (config.currency === "unconfirmed") warnings.push("Moneda sin confirmar: precios e importes permanecen en auditor\xEDa y no se publican como valores financieros.");
+  const unmatchedCodes = [...new Set(enriched.flatMap((element) => element.wbs.filter((code) => !catalog.concepts.some((concept) => concept.code === code || concept.qualifiedCode === code))))].toSorted();
+  if (unmatchedCodes.length) warnings.push(`${unmatchedCodes.length} c\xF3digos IFC no tienen coincidencia exacta con el cat\xE1logo.`);
+  const audit = {
+    schemaVersion: 1,
+    houseId,
+    revisionId,
+    revision,
+    sources: sourceEntries,
+    config,
+    catalog: publicCatalog(catalog),
+    ...materialsReview ? { materials: materialsReview.audit } : {},
+    elements: enriched,
+    views: geometryAudit,
+    rejectedViews,
+    reviewCandidates,
+    unmatchedCodes,
+    warnings,
+    counts: { catalogConcepts: catalog.conceptCount, publishedConcepts: selected.length, rootNodes: catalog.roots.length, modelElements: rawElements.length, views: views.length, representedElements: new Set(views.flatMap((view) => view.elementIds)).size, pendingRelations: reviewCandidates.filter((candidate) => candidate.status === "pending").length, linkedRelations: reviewCandidates.filter((candidate) => candidate.status === "linked").length, ambiguousRelations: ambiguous },
+    semantics: "Relaciones exactas vinculadas autom\xE1ticamente con evidencia de fuente; conflictos pendientes sin aprobaci\xF3n humana atribuida. El alcance no resuelve ambig\xFCedades. Geometr\xEDa vectorial PDF vinculada por ElementId IFC; sin c\xE1lculo de \xE1reas/vol\xFAmenes ni geometr\xEDa inventada. Todas las cantidades IFC permanecen en esta auditor\xEDa."
+  };
+  return { project, assets, audit };
+}
+
+// src/version.ts
+import { readFileSync } from "node:fs";
+var manifest = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+var pipelineVersion = manifest.version;
+var validatorVersion = manifest.version;
+
+// src/contract/derive-config.ts
+function planoSources(manifest2) {
+  const pdfIds = /* @__PURE__ */ new Map();
+  manifest2.archivos.filter((file) => file.rol === "plano").forEach((plano2, index) => pdfIds.set(plano2, `pdf-${index + 1}`));
+  return { pdfIds };
+}
+function floorId(label2) {
+  const slug = label2.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 79);
+  return slug || "planta";
+}
+function deriveImportConfig(manifest2, catalog) {
+  const { pdfIds } = planoSources(manifest2);
+  const floors = [];
+  const idsByLabel = /* @__PURE__ */ new Map();
+  for (const plano2 of pdfIds.keys()) {
+    if (idsByLabel.has(plano2.planta)) continue;
+    let id = floorId(plano2.planta);
+    for (let n = 2; floors.some((floor) => floor.id === id); n++) id = `${floorId(plano2.planta)}-${n}`;
+    idsByLabel.set(plano2.planta, id);
+    floors.push({ id, label: plano2.planta });
+  }
+  const views = [...pdfIds.entries()].map(([plano2, pdfId]) => ({
+    pdfId,
+    page: plano2.pagina,
+    title: plano2.titulo ?? plano2.planta,
+    floorId: idsByLabel.get(plano2.planta)
+  }));
+  const allFloorIds = floors.map((floor) => floor.id);
+  const floorBindings = Object.fromEntries(
+    catalog.nodes.filter((node) => node.parentId === null).map((node) => [node.code, allFloorIds])
+  );
+  const materials = manifest2.archivos.find((file) => file.rol === "materiales");
+  return {
+    floors,
+    views,
+    scopeCodes: [],
+    floorBindings,
+    currency: "unconfirmed",
+    ...materials?.hoja ? { materialsSheet: materials.hoja } : {}
+  };
+}
+
+// src/contract/manifest.ts
+import { Schema } from "effect";
+var sha256 = Schema.String.check(Schema.isPattern(/^[a-fA-F0-9]{64}$/));
+var fileName = Schema.String.check(
+  Schema.isPattern(/^[^/\\\u0000-\u001f]+\.[A-Za-z0-9]{1,16}$/),
+  Schema.isMaxLength(255)
+);
+var label = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(120));
+var sheetName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(31));
+var fileBase = { archivo: fileName, sha256 };
+var catalogo = Schema.Struct({ rol: Schema.Literal("catalogo"), ...fileBase });
+var modelo = Schema.Struct({ rol: Schema.Literal("modelo"), ...fileBase });
+var plano = Schema.Struct({
+  rol: Schema.Literal("plano"),
+  ...fileBase,
+  planta: label,
+  pagina: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e4 })),
+  titulo: Schema.optional(label)
+});
+var materiales = Schema.Struct({
+  rol: Schema.Literal("materiales"),
+  ...fileBase,
+  hoja: Schema.optional(sheetName)
+});
+var manifestFileSchema = Schema.Union([catalogo, modelo, plano, materiales]);
+var deliveryManifestSchema = Schema.Struct({
+  schemaVersion: Schema.Literal(1),
+  proyecto: label,
+  revision: label,
+  fecha: Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/)),
+  notas: Schema.optional(Schema.String.check(Schema.isMaxLength(2e3))),
+  archivos: Schema.Array(manifestFileSchema).check(
+    Schema.isMinLength(2),
+    Schema.isMaxLength(40)
+  )
+});
+var decode = Schema.decodeUnknownSync(deliveryManifestSchema);
+function parseManifest(input) {
+  let manifest2;
+  try {
+    const decoded = decode(input, { onExcessProperty: "error" });
+    manifest2 = {
+      ...decoded,
+      archivos: decoded.archivos.map((file) => ({ ...file, sha256: file.sha256.toLowerCase() }))
+    };
+  } catch (error) {
+    const mensaje = Schema.isSchemaError(error) ? error.message : "El manifiesto no es un objeto JSON v\xE1lido.";
+    return {
+      ok: false,
+      findings: [{ regla: "manifest.invalid", nivel: "error", mensaje }]
+    };
+  }
+  const findings = structuralFindings(manifest2);
+  return findings.length ? { ok: false, findings } : { ok: true, manifest: manifest2 };
+}
+function structuralFindings(manifest2) {
+  const findings = [];
+  const count = (rol) => manifest2.archivos.filter((file) => file.rol === rol).length;
+  const expectExactly = (rol, expected) => {
+    const actual = count(rol);
+    if (actual !== expected)
+      findings.push({
+        regla: "manifest.role-count",
+        nivel: "error",
+        mensaje: `La entrega requiere exactamente ${expected} archivo con rol "${rol}"; se declararon ${actual}.`
+      });
+  };
+  expectExactly("catalogo", 1);
+  expectExactly("modelo", 1);
+  if (count("plano") === 0)
+    findings.push({
+      regla: "manifest.role-count",
+      nivel: "error",
+      mensaje: 'La entrega requiere al menos un archivo con rol "plano".'
+    });
+  if (count("materiales") > 1)
+    findings.push({
+      regla: "manifest.role-count",
+      nivel: "error",
+      mensaje: `La entrega admite un solo archivo con rol "materiales"; se declararon ${count("materiales")}.`
+    });
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const file of manifest2.archivos) {
+    if (seenNames.has(file.archivo))
+      findings.push({
+        regla: "manifest.duplicate-file",
+        nivel: "error",
+        archivo: file.archivo,
+        mensaje: `El archivo "${file.archivo}" se declara m\xE1s de una vez.`
+      });
+    seenNames.add(file.archivo);
+  }
+  const seenViews = /* @__PURE__ */ new Set();
+  for (const file of manifest2.archivos) {
+    if (file.rol !== "plano") continue;
+    const key = `${file.archivo}#${file.pagina}`;
+    if (seenViews.has(key))
+      findings.push({
+        regla: "manifest.duplicate-view",
+        nivel: "error",
+        archivo: file.archivo,
+        mensaje: `La p\xE1gina ${file.pagina} de "${file.archivo}" se declara como vista m\xE1s de una vez.`
+      });
+    seenViews.add(key);
+  }
+  return findings;
+}
+
+// src/contract/policy.ts
+var policyVersion = "2026-10-20.1";
+var rules = {
+  // Manifest and integrity
+  "manifest.invalid": { nivel: "error", descripcion: "entrega.json no cumple el schema." },
+  "manifest.role-count": { nivel: "error", descripcion: "N\xFAmero de archivos por rol fuera del contrato." },
+  "manifest.duplicate-file": { nivel: "error", descripcion: "Archivo declarado dos veces." },
+  "manifest.duplicate-view": { nivel: "error", descripcion: "Misma p\xE1gina PDF declarada dos veces." },
+  "delivery.file-missing": { nivel: "error", descripcion: "Archivo declarado que no est\xE1 en la entrega." },
+  "delivery.hash-mismatch": { nivel: "error", descripcion: "El contenido no coincide con la huella declarada." },
+  "delivery.file-undeclared": { nivel: "observacion", descripcion: "Archivo presente pero no declarado; se ignora." },
+  // Catalog
+  "catalog.invalid": { nivel: "error", descripcion: "El cat\xE1logo no cumple la plantilla (hoja, columnas, jerarqu\xEDa, valores)." },
+  // IFC
+  "model.invalid": { nivel: "error", descripcion: "El IFC no es legible o no declara la revisi\xF3n de Revit." },
+  "model.wbs-unmatched": { nivel: "error", descripcion: "Pieza IFC con c\xF3digo WBS que no existe en el cat\xE1logo." },
+  "model.without-wbs": { nivel: "observacion", descripcion: "Piezas IFC sin WBS propio." },
+  // PDF views
+  "view.page-out-of-range": { nivel: "error", descripcion: "P\xE1gina declarada inexistente en el PDF." },
+  "view.rejected": { nivel: "error", descripcion: "Vista no admitida: revisi\xF3n distinta al IFC, no vectorial o sin piezas identificadas." },
+  "view.none": { nivel: "error", descripcion: "Ninguna vista v\xE1lida; no se puede generar el visor." },
+  "view.unknown-pdf-owners": { nivel: "observacion", descripcion: "Identificadores del PDF sin pieza en el IFC." },
+  // Materials workbook
+  "materials.invalid": { nivel: "error", descripcion: "El Excel de materiales no es legible." },
+  "materials.sheet-missing": { nivel: "error", descripcion: "La hoja declarada no existe en el Excel." },
+  "materials.sheet-selection": { nivel: "error", descripcion: "Varias hojas reconocibles y ninguna declarada." },
+  // Incoherence inside a row: the file contradicts itself or the other files.
+  "materials.formula": { nivel: "error", descripcion: "Celda con f\xF3rmula; exportar valores." },
+  "materials.cell-error": { nivel: "error", descripcion: "Celda con error de Excel." },
+  "materials.duplicate-columns": { nivel: "error", descripcion: "Encabezado duplicado en la hoja." },
+  "materials.element-id-mismatch": { nivel: "error", descripcion: "El ElementId declarado no corresponde al GUID." },
+  "materials.invalid-record-kind": { nivel: "error", descripcion: "Tipo de registro incoherente con la fila." },
+  "materials.invalid-wbs": { nivel: "error", descripcion: "C\xF3digo WBS con formato inv\xE1lido." },
+  "materials.wbs-unmatched": { nivel: "error", descripcion: "C\xF3digo WBS que no existe en el cat\xE1logo." },
+  // Absence or ambiguity: reported, the row is skipped or left pending.
+  "materials.missing-guid": { nivel: "observacion", descripcion: "Fila sin GUID anfitri\xF3n." },
+  "materials.unknown-host": { nivel: "observacion", descripcion: "GUID anfitri\xF3n no encontrado en el IFC." },
+  "materials.duplicate-row": { nivel: "observacion", descripcion: "Fila repetida en la hoja." },
+  "materials.invalid-row": { nivel: "observacion", descripcion: "N\xFAmero de fila inv\xE1lido." },
+  "materials.wbs-no-code": { nivel: "observacion", descripcion: "Fila sin c\xF3digo WBS." },
+  "materials.wbs-ambiguous": { nivel: "observacion", descripcion: "C\xF3digo corto con varios candidatos en el cat\xE1logo." },
+  "materials.quantity-unavailable": { nivel: "observacion", descripcion: "Sin cantidad compatible con la unidad del concepto." },
+  "materials.ifc-workbook-quantity-discrepancy": { nivel: "observacion", descripcion: "Cantidad IFC y Excel difieren; queda pendiente." },
+  "materials.conflicting-element-quantity": { nivel: "observacion", descripcion: "Filas de pieza con cantidades contradictorias." },
+  "materials.conflicting-element-relation": { nivel: "observacion", descripcion: "Filas de pieza con partidas contradictorias." },
+  "materials.excel-only-material": { nivel: "observacion", descripcion: "Material documentado solo en Excel." },
+  "materials.issue": { nivel: "observacion", descripcion: "Otra observaci\xF3n del Excel de materiales." },
+  // Relations and pipeline
+  "relations.pending": { nivel: "observacion", descripcion: "Relaciones ambiguas o pendientes de resolver." },
+  "pipeline.warning": { nivel: "observacion", descripcion: "Aviso del procesamiento." },
+  "pipeline.failed": { nivel: "error", descripcion: "El procesamiento fall\xF3." }
+};
+var defaultPolicy = Object.freeze(
+  Object.fromEntries(
+    Object.entries(rules).map(([id, rule]) => [id, rule.nivel])
+  )
+);
+function isRuleId(value2) {
+  return Object.hasOwn(rules, value2);
+}
+function levelFor(rule, policy = defaultPolicy) {
+  if (isRuleId(rule)) return policy[rule] ?? rules[rule].nivel;
+  return "observacion";
+}
+
+// src/contract/validate.ts
+var reservedFileNames = /* @__PURE__ */ new Set([
+  "entrega.json",
+  "validacion.json",
+  "ficha-entrega.md",
+  "log-exportacion.txt"
+]);
+var sha2562 = (bytes) => createHash2("sha256").update(bytes).digest("hex");
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+async function validateDelivery(input) {
+  return (await validateDeliveryDetailed(input)).report;
+}
+async function validateDeliveryDetailed(input) {
+  const policy = input.policy ?? defaultPolicy;
+  const findings = [];
+  const metricas = {};
+  let config = null;
+  let processed = null;
+  const add3 = (finding) => findings.push({ ...finding, nivel: levelFor(finding.regla, policy) });
+  const finish = (manifest3, archivos2) => {
+    const report = buildReport({ manifest: manifest3, archivos: archivos2, findings, metricas });
+    return { report, config, processed: report.veredicto === "aceptada" ? processed : null };
+  };
+  const parsed = parseManifest(input.manifest);
+  if (!parsed.ok) {
+    for (const finding of parsed.findings) add3(finding);
+    return finish(null, []);
+  }
+  const manifest2 = parsed.manifest;
+  const byName = new Map(input.files.map((file) => [file.name, file]));
+  const archivos = [];
+  let integrityFailed = false;
+  for (const declared of manifest2.archivos) {
+    const file = byName.get(declared.archivo);
+    if (!file) {
+      integrityFailed = true;
+      add3({
+        regla: "delivery.file-missing",
+        archivo: declared.archivo,
+        mensaje: "Archivo declarado en entrega.json pero ausente en la entrega."
+      });
+      archivos.push({ rol: declared.rol, archivo: declared.archivo, sha256: declared.sha256, bytes: 0 });
+      continue;
+    }
+    const actual = sha2562(file.bytes);
+    archivos.push({ rol: declared.rol, archivo: declared.archivo, sha256: actual, bytes: file.bytes.length });
+    if (actual !== declared.sha256) {
+      integrityFailed = true;
+      add3({
+        regla: "delivery.hash-mismatch",
+        archivo: declared.archivo,
+        mensaje: `La huella SHA-256 del contenido (${actual.slice(0, 12)}\u2026) no coincide con la declarada (${declared.sha256.slice(0, 12)}\u2026).`
+      });
+    }
+  }
+  for (const file of input.files) {
+    if (reservedFileNames.has(file.name) || manifest2.archivos.some((d) => d.archivo === file.name)) continue;
+    add3({
+      regla: "delivery.file-undeclared",
+      archivo: file.name,
+      mensaje: "Archivo presente en la entrega pero no declarado en entrega.json; se ignora."
+    });
+  }
+  if (integrityFailed) return finish(manifest2, archivos);
+  const bytesOf = (file) => byName.get(file.archivo).bytes;
+  const catalogFile = manifest2.archivos.find((f) => f.rol === "catalogo");
+  const modelFile = manifest2.archivos.find((f) => f.rol === "modelo");
+  const materialsFile = manifest2.archivos.find((f) => f.rol === "materiales");
+  const { pdfIds } = planoSources(manifest2);
+  const pdfs = [...pdfIds.entries()].map(([plano2, id]) => ({ id, name: plano2.archivo, bytes: bytesOf(plano2) }));
+  const materials = materialsFile ? {
+    id: "materials",
+    name: materialsFile.archivo,
+    role: "materials",
+    sha256: materialsFile.sha256,
+    bytes: bytesOf(materialsFile)
+  } : void 0;
+  let catalog;
+  try {
+    catalog = readHouseCatalog(bytesOf(catalogFile));
+  } catch (error) {
+    add3({ regla: "catalog.invalid", archivo: catalogFile.archivo, mensaje: messageOf(error) });
+    return finish(manifest2, archivos);
+  }
+  try {
+    modelRevision(bytesOf(modelFile));
+  } catch (error) {
+    add3({ regla: "model.invalid", archivo: modelFile.archivo, mensaje: messageOf(error) });
+    return finish(manifest2, archivos);
+  }
+  let inspection;
+  try {
+    inspection = await inspectDelivery({ catalogBytes: bytesOf(catalogFile), modelBytes: bytesOf(modelFile), pdfs, materials });
+  } catch (error) {
+    add3({ regla: "pipeline.failed", mensaje: `La inspecci\xF3n de la entrega fall\xF3: ${messageOf(error)}` });
+    return finish(manifest2, archivos);
+  }
+  metricas.catalogConcepts = inspection.catalog.conceptCount;
+  metricas.catalogRoots = inspection.catalog.roots;
+  if (inspection.model) metricas.modelElements = inspection.model.elementCount;
+  let declaredViewsValid = true;
+  for (const [plano2, id] of pdfIds) {
+    const pages = inspection.pdfs.find((pdf) => pdf.id === id)?.pages ?? 0;
+    if (plano2.pagina > pages) {
+      declaredViewsValid = false;
+      add3({
+        regla: "view.page-out-of-range",
+        archivo: plano2.archivo,
+        mensaje: `Se declar\xF3 la p\xE1gina ${plano2.pagina} pero el PDF tiene ${pages} p\xE1gina(s).`
+      });
+    }
+  }
+  if (materialsFile?.hoja && inspection.materials?.sheets) {
+    if (!inspection.materials.sheets.some((sheet) => sheet.name === materialsFile.hoja))
+      add3({
+        regla: "materials.sheet-missing",
+        archivo: materialsFile.archivo,
+        hoja: materialsFile.hoja,
+        mensaje: `La hoja declarada "${materialsFile.hoja}" no existe en el Excel de materiales.`
+      });
+  }
+  if (!declaredViewsValid) return finish(manifest2, archivos);
+  const derived = deriveImportConfig(manifest2, inspection.catalog);
+  config = derived;
+  try {
+    validateHouseConfig(derived, catalog, pdfs);
+  } catch (error) {
+    add3({ regla: "pipeline.failed", mensaje: `La configuraci\xF3n derivada no es v\xE1lida: ${messageOf(error)}` });
+    return finish(manifest2, archivos);
+  }
+  let audit;
+  try {
+    const result = await processDelivery({
+      houseId: "validacion",
+      revisionId: "validacion",
+      name: manifest2.proyecto,
+      catalogBytes: bytesOf(catalogFile),
+      modelBytes: bytesOf(modelFile),
+      pdfs,
+      config: derived,
+      materials,
+      // Hosts publish assets by name; the viewer resolves them to URLs at load time.
+      assetUrl: (fileName2) => fileName2
+    });
+    audit = result.audit;
+    processed = result;
+  } catch (error) {
+    const message = messageOf(error);
+    if (message.startsWith("No se pudo generar ninguna vista interactiva"))
+      add3({ regla: "view.none", mensaje: message });
+    else if (message.startsWith("Selecciona una hoja"))
+      add3({ regla: "materials.sheet-selection", archivo: materialsFile?.archivo, mensaje: message });
+    else add3({ regla: "pipeline.failed", mensaje: message });
+    return finish(manifest2, archivos);
+  }
+  const rejectedReasons = /* @__PURE__ */ new Set();
+  for (const rejected of audit.rejectedViews ?? []) {
+    rejectedReasons.add(rejected.reason);
+    const plano2 = [...pdfIds.entries()].find(([, id]) => id === rejected.pdfId)?.[0];
+    add3({
+      regla: "view.rejected",
+      archivo: plano2?.archivo ?? rejected.pdfId,
+      mensaje: rejected.reason,
+      datos: { pagina: rejected.page }
+    });
+  }
+  for (const view of audit.views ?? []) {
+    const unknown = view.unknownOwners?.length ?? 0;
+    if (!unknown) continue;
+    add3({
+      regla: "view.unknown-pdf-owners",
+      archivo: view.source?.name,
+      mensaje: `${unknown} identificador(es) del PDF no existen en el IFC; permanecen como fondo sin interacci\xF3n.`,
+      datos: { pagina: view.page, cantidad: unknown }
+    });
+  }
+  for (const code of audit.unmatchedCodes ?? []) {
+    const owners = (audit.elements ?? []).filter((element) => element.wbs?.includes(code));
+    add3({
+      regla: "model.wbs-unmatched",
+      archivo: modelFile.archivo,
+      mensaje: `El c\xF3digo WBS "${code}" declarado en ${owners.length} pieza(s) del IFC no existe en el cat\xE1logo.`,
+      datos: { codigo: code, piezas: owners.length, ejemplos: owners.slice(0, 5).map((e) => e.elementId) }
+    });
+  }
+  const withoutWbs = (audit.elements ?? []).filter((element) => !element.wbs?.length).length;
+  if (withoutWbs)
+    add3({
+      regla: "model.without-wbs",
+      archivo: modelFile.archivo,
+      mensaje: `${withoutWbs} pieza(s) del IFC no declaran WBS propio; solo reciben las relaciones expl\xEDcitas del Excel.`,
+      datos: { piezas: withoutWbs }
+    });
+  for (const record of audit.materials?.records ?? []) {
+    for (const issue of record.issues ?? []) {
+      const regla = `materials.${issue}`;
+      add3({
+        regla: isRuleId(regla) ? regla : "materials.issue",
+        archivo: materialsFile?.archivo,
+        hoja: record.sheet,
+        fila: record.row,
+        guid: record.hostId,
+        mensaje: materialsIssueMessage(issue, record),
+        datos: { incidencia: issue }
+      });
+    }
+  }
+  const counts = audit.counts ?? {};
+  Object.assign(metricas, counts);
+  metricas.elementsWithoutWbs = withoutWbs;
+  metricas.rejectedViews = audit.rejectedViews?.length ?? 0;
+  metricas.materialsRecords = audit.materials?.records?.length ?? 0;
+  metricas.materialsRecordsWithIssues = (audit.materials?.records ?? []).filter((r) => r.issues?.length).length;
+  if ((counts.pendingRelations ?? 0) + (counts.ambiguousRelations ?? 0) > 0)
+    add3({
+      regla: "relations.pending",
+      mensaje: `${counts.pendingRelations ?? 0} relaci\xF3n(es) pendientes y ${counts.ambiguousRelations ?? 0} ambiguas requieren resolver la partida en origen.`
+    });
+  for (const warning of audit.warnings ?? []) {
+    if (rejectedReasons.has(warning)) continue;
+    if (/^\d+ códigos IFC no tienen coincidencia exacta/.test(warning)) continue;
+    if (/^\d+ elementos IFC no declaran WBS propio/.test(warning)) continue;
+    if (/^Moneda sin confirmar/.test(warning)) continue;
+    if (/identificadores del PDF no existen en el IFC/.test(warning)) continue;
+    add3({ regla: "pipeline.warning", mensaje: warning });
+  }
+  return finish(manifest2, archivos);
+}
+function materialsIssueMessage(issue, record) {
+  const subject = record.recordKind === "material" ? "Aplicaci\xF3n de material" : "Fila de pieza";
+  switch (issue) {
+    case "unknown-host":
+      return `${subject}: el GUID anfitri\xF3n no existe en el IFC de la entrega.`;
+    case "wbs-no-code":
+      return `${subject}: la fila no declara c\xF3digo WBS.`;
+    case "quantity-unavailable":
+      return `${subject}: no hay cantidad exportada compatible con la unidad del concepto.`;
+    case "ifc-workbook-quantity-discrepancy":
+      return `${subject}: la cantidad del IFC y la del Excel difieren; queda pendiente sin conciliar.`;
+    case "excel-only-material":
+      return `${subject}: documentado solo en el Excel, sin asociaci\xF3n de material en el IFC.`;
+    default:
+      return `${subject}: ${issue}.`;
+  }
+}
+function buildReport(input) {
+  const sorted = sortFindings(input.findings);
+  const errores = sorted.filter((f) => f.nivel === "error");
+  const observaciones = sorted.filter((f) => f.nivel === "observacion");
+  const huella = input.archivos.length ? sha2562(
+    Buffer.from(
+      input.archivos.map((file) => `${file.rol}	${file.archivo}	${file.sha256}`).sort().join("\n")
+    )
+  ) : null;
+  return {
+    schemaVersion: 1,
+    validatorVersion,
+    policyVersion,
+    entrega: {
+      proyecto: input.manifest?.proyecto ?? null,
+      revision: input.manifest?.revision ?? null,
+      fecha: input.manifest?.fecha ?? null,
+      huella,
+      archivos: input.archivos
+    },
+    veredicto: errores.length ? "rechazada" : "aceptada",
+    errores,
+    observaciones,
+    metricas: Object.fromEntries(Object.entries(input.metricas).sort(([a], [b]) => a.localeCompare(b)))
+  };
+}
+
+// src/cli/validate-delivery.ts
+function parseArgs(argv) {
+  let dir;
+  let output = "validacion.json";
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") json = true;
+    else if (arg === "--salida" || arg === "--output") output = argv[++i] ?? output;
+    else if (arg.startsWith("-")) return null;
+    else if (dir === void 0) dir = arg;
+    else return null;
+  }
+  return dir === void 0 ? null : { dir: resolve(dir), output, json };
+}
+async function readDeliveryFolder(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isFile() || entry.name.startsWith(".")) continue;
+    files.push({ name: entry.name, bytes: new Uint8Array(await readFile(join(dir, entry.name))) });
+  }
+  const manifestFile = files.find((file) => file.name === "entrega.json");
+  if (!manifestFile) throw new Error(`No se encontr\xF3 entrega.json en ${dir}`);
+  let manifest2;
+  try {
+    manifest2 = JSON.parse(Buffer.from(manifestFile.bytes).toString("utf8"));
+  } catch (error) {
+    throw new Error(`entrega.json no es JSON v\xE1lido: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { manifest: manifest2, files: files.filter((file) => !reservedFileNames.has(file.name)) };
+}
+async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  if (!options) {
+    process.stderr.write("Uso: validate-delivery <carpeta> [--salida validacion.json] [--json]\n");
+    return 2;
+  }
+  if (!(await stat(options.dir).catch(() => null))?.isDirectory()) {
+    process.stderr.write(`La carpeta no existe: ${options.dir}
+`);
+    return 2;
+  }
+  const { manifest: manifest2, files } = await readDeliveryFolder(options.dir);
+  const report = await validateDelivery({
+    manifest: manifest2,
+    files: files.filter((file) => file.name !== options.output)
+  });
+  const serialized = `${JSON.stringify(report, null, 2)}
+`;
+  await writeFile(resolve(options.dir, options.output), serialized, "utf8");
+  process.stdout.write(options.json ? serialized : `${formatReport(report)}
+
+Reporte escrito en ${options.output}
+`);
+  return report.veredicto === "aceptada" ? 0 : 1;
+}
+
+// src/cli/entry.ts
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(2);
+  }
+);