@primocaredentgroup/dental-digital-intake-shared 0.1.1

package/dist/index.js

@@ -0,0 +1,1568 @@
+// src/externalReferences.ts
+function mergeExternalReferences(base, patch) {
+  return { ...base ?? {}, ...patch };
+}
+
+// src/exocadParser.ts
+var KNOWN_MANUFACTURERS = [
+  "Neodent",
+  "Straumann",
+  "Nobel Biocare",
+  "Nobel",
+  "Camlog",
+  "BioHorizons",
+  "Zimmer",
+  "Dentsply",
+  "Ankylos",
+  "Astra",
+  "Megagen",
+  "Bredent",
+  "Rhein",
+  "Sweden & Martina",
+  "Sweden"
+];
+var CONNECTION_MAP = {
+  GM: "Grand Morse",
+  CM: "Cone Morse"
+};
+var DENTAL_CAD_KEYWORDS = [
+  "Neodent",
+  "Straumann",
+  "Nobel",
+  "Sweden",
+  "Camlog",
+  "BioHorizons",
+  "Zimmer",
+  "Dentsply",
+  "Ankylos",
+  "Astra",
+  "Megagen",
+  "Bredent",
+  "Rhein",
+  "analog",
+  "implant",
+  "scanbody",
+  "tibase",
+  "abutment",
+  "local-milling",
+  "local-printing",
+  "sdfa",
+  "library\\implant"
+];
+function baseName(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return normalized.split("/").pop() ?? normalized;
+}
+function extensionOf(name) {
+  const b = baseName(name);
+  const i = b.lastIndexOf(".");
+  return i <= 0 ? "" : b.slice(i + 1).toLowerCase();
+}
+function decodeText(data) {
+  let start = 0;
+  if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
+    start = 3;
+  }
+  return new TextDecoder("utf-8", { fatal: false }).decode(data.subarray(start));
+}
+function stripTags(raw) {
+  return raw.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/gi, "$1").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function decodeEntities(raw) {
+  return raw.replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;|&apos;/gi, "'");
+}
+function classifyExocadFile(path) {
+  const ext = extensionOf(path);
+  switch (ext) {
+    case "dentalproject":
+      return "dentalProject";
+    case "constructioninfo":
+      return "constructionInfo";
+    case "modelinfo":
+      return "modelInfo";
+    case "dentalcad":
+      return "dentalCAD";
+    case "stl":
+      return "stl";
+    default:
+      return "other";
+  }
+}
+function detectExocadFiles(entries) {
+  const classified = [];
+  const files = {
+    dentalProject: [],
+    constructionInfo: [],
+    modelInfo: [],
+    dentalCAD: [],
+    stl: []
+  };
+  for (const e of entries) {
+    const bn = baseName(e.path);
+    const ext = extensionOf(e.path);
+    const kind = classifyExocadFile(e.path);
+    classified.push({ path: e.path, baseName: bn, ext, kind, data: e.data });
+    if (kind === "dentalProject") files.dentalProject.push(bn);
+    else if (kind === "constructionInfo") files.constructionInfo.push(bn);
+    else if (kind === "modelInfo") files.modelInfo.push(bn);
+    else if (kind === "dentalCAD") files.dentalCAD.push(bn);
+    else if (kind === "stl") files.stl.push(bn);
+  }
+  return { classified, files };
+}
+function isExocadPackage(entries) {
+  return entries.some((e) => classifyExocadFile(e.path) !== "other" && classifyExocadFile(e.path) !== "stl") || entries.some((e) => classifyExocadFile(e.path) !== "other");
+}
+function firstTag(xml, tags) {
+  for (const tag of tags) {
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
+    const m = xml.match(re);
+    if (m?.[1]) {
+      const val = stripTags(m[1]);
+      if (val) return val;
+    }
+  }
+  return void 0;
+}
+function valuesForKey(text, key) {
+  const out = [];
+  const tagRe = new RegExp(`<${key}\\b[^>]*>([\\s\\S]*?)<\\/${key}>`, "gi");
+  let m;
+  while ((m = tagRe.exec(text)) !== null) {
+    const val = decodeEntities(m[1]).trim();
+    if (val) out.push(val);
+  }
+  if (out.length === 0) {
+    const lineRe = new RegExp(`${key}\\s*[:=]\\s*([^\\r\\n]+)`, "gi");
+    while ((m = lineRe.exec(text)) !== null) {
+      const val = decodeEntities(m[1]).trim();
+      if (val) out.push(val);
+    }
+  }
+  return out;
+}
+function parseBool(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "true" || v === "1" || v === "yes") return true;
+  if (v === "false" || v === "0" || v === "no") return false;
+  return void 0;
+}
+var TOOTH_BLOCK_RE = /<Tooth\b[^>]*>([\s\S]*?)<\/Tooth>/gi;
+function parseDentalProject(text) {
+  const patientLast = firstTag(text, ["PatientName"]);
+  const patientFirst = firstTag(text, ["PatientFirstName"]);
+  const patientName = [patientFirst, patientLast].filter(Boolean).join(" ").trim() || null;
+  const caseInfo = {
+    patientName,
+    practiceName: firstTag(text, ["PracticeName"]) ?? null,
+    practiceId: firstTag(text, ["PracticeId"]) ?? null,
+    projectDate: firstTag(text, ["DateTime", "Date"]) ?? null,
+    exocadVersion: firstTag(text, ["DentalDBProductName"]) ?? null
+  };
+  const items = [];
+  for (const m of text.matchAll(TOOTH_BLOCK_RE)) {
+    const block = m[1] ?? "";
+    const tooth = firstTag(block, ["Number", "ToothNumber", "FDI"]);
+    if (!tooth) continue;
+    const type = firstTag(block, ["ReconstructionType"]);
+    const material = firstTag(block, ["MaterialName"]);
+    const materialCode = firstTag(block, ["Material"]);
+    const shade = firstTag(block, ["Shade", "Color", "ToothColor"]);
+    const preparationType = firstTag(block, ["PreparationType"]);
+    const implantType = firstTag(block, ["ImplantType"]);
+    const scanAbutmentScan = parseBool(firstTag(block, ["ScanAbutmentScan"]));
+    const mesialConnector = parseBool(firstTag(block, ["MesialConnector"]));
+    items.push({
+      tooth,
+      ...type ? { type } : {},
+      ...material ? { material } : {},
+      ...materialCode ? { materialCode } : {},
+      ...shade && shade !== "---" ? { shade } : {},
+      ...preparationType ? { preparationType } : {},
+      ...implantType ? { implantType } : {},
+      ...scanAbutmentScan !== void 0 ? { scanAbutmentScan } : {},
+      ...mesialConnector !== void 0 ? { mesialConnector } : {}
+    });
+  }
+  return { case: caseInfo, items };
+}
+var BASE_TYPE_MAP = {
+  mini: "Mini Abutment",
+  base: "Ti-Base",
+  tibase: "Ti-Base",
+  uni: "Universal Base",
+  pro: "Pro Abutment"
+};
+function tenths(digits) {
+  const n = Number(digits);
+  if (!Number.isFinite(n)) return digits;
+  return (n / 10).toFixed(1);
+}
+function inferGeometryCode(code) {
+  if (!code) return void 0;
+  const out = {};
+  const noBase = code.replace(/^base[_-]?/i, "");
+  const firstToken = noBase.split(/[_\-\s.]/)[0] ?? "";
+  const word = firstToken.replace(/\d+$/, "");
+  if (word && /[a-z]/i.test(word)) {
+    const mapped = BASE_TYPE_MAP[word.toLowerCase()];
+    out.baseType = {
+      value: mapped ?? word,
+      confidence: "inferred"
+    };
+  }
+  const d = code.match(/D(\d{2,3})\b/i);
+  if (d?.[1]) {
+    out.diameterOrPlatform = { value: tenths(d[1]), confidence: "inferred" };
+  }
+  const ah = code.match(/AH(\d{2,3})\b/i);
+  if (ah?.[1]) {
+    out.abutmentHeight = { value: tenths(ah[1]), confidence: "inferred" };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function detectManufacturer(...sources) {
+  const hay = sources.join(" ").toLowerCase();
+  for (const m of KNOWN_MANUFACTURERS) {
+    if (hay.includes(m.toLowerCase())) return m;
+  }
+  return void 0;
+}
+function detectConnection(...sources) {
+  const text = sources.join(" ");
+  for (const [abbr, full] of Object.entries(CONNECTION_MAP)) {
+    const re = new RegExp(`\\b${abbr}\\b`);
+    if (re.test(text)) return full;
+  }
+  return void 0;
+}
+function parseDisplayInfo(raw) {
+  const segs = raw.split(/[\r\n:]+/).map((s) => s.trim()).filter(Boolean);
+  if (segs.length === 0) return {};
+  const result = {};
+  const seg0 = segs[0];
+  const dashSplit = seg0.split(/\s[-–]\s/);
+  if (dashSplit.length >= 2) {
+    result.manufacturer = dashSplit[0].replace(/[®™©]/g, "").trim();
+    let platformRaw = dashSplit.slice(1).join(" - ").trim();
+    const wf = platformRaw.match(/\(([^)]+)\)/);
+    if (wf?.[1]) result.workflow = wf[1].trim();
+    platformRaw = platformRaw.replace(/\([^)]*\)/g, "").trim();
+    if (platformRaw) result.platform = platformRaw;
+  } else {
+    const mfg = detectManufacturer(seg0);
+    if (mfg) result.manufacturer = mfg;
+  }
+  if (segs[1]) result.component = segs[1];
+  if (segs[2]) result.libraryName = segs[2];
+  return result;
+}
+function parseConstructionInfo(text, sourceFile) {
+  const geometryPaths = valuesForKey(text, "FilenameImplantGeometry");
+  const displayInfos = valuesForKey(text, "ImplantLibraryEntryDisplayInformation");
+  const scanAbutment = valuesForKey(text, "ScanAbutmentScan").some(
+    (v) => parseBool(v) === true
+  );
+  const isImplantCase = geometryPaths.length > 0 || scanAbutment || /FilenameImplantGeometry|ImplantLibrary\b/i.test(text);
+  const count = Math.max(geometryPaths.length, displayInfos.length);
+  const components = [];
+  for (let i = 0; i < count; i++) {
+    const geomPath = geometryPaths[i];
+    const display = displayInfos[i];
+    const component = {
+      sourceFiles: [sourceFile],
+      confidence: "high"
+    };
+    if (geomPath) {
+      component.libraryPath = geomPath;
+      const file = baseName(geomPath);
+      component.geometryFile = file;
+      const code = file.replace(/\.[^.]+$/, "");
+      component.geometryCode = code;
+      const parsed = inferGeometryCode(code);
+      if (parsed) component.parsedGeometry = parsed;
+    }
+    if (display) {
+      const info = parseDisplayInfo(display);
+      if (info.manufacturer) component.manufacturer = info.manufacturer;
+      if (info.platform) component.platform = info.platform;
+      if (info.component) component.component = info.component;
+      if (info.libraryName) component.libraryName = info.libraryName;
+    }
+    if (!component.manufacturer) {
+      const mfg = detectManufacturer(geomPath ?? "", display ?? "");
+      if (mfg) component.manufacturer = mfg;
+    }
+    const connection = detectConnection(
+      component.component ?? "",
+      display ?? "",
+      geomPath ?? ""
+    );
+    if (connection) component.connection = connection;
+    if (component.geometryFile || component.component || component.libraryName) {
+      components.push(component);
+    }
+  }
+  return { components, isImplantCase };
+}
+function parseModelInfo(text) {
+  const out = {};
+  const analogLib = valuesForKey(text, "AnalogLibrary")[0] ?? text.match(/([A-Za-z][\w&]*_Analogs?[\w-]*)/)?.[1] ?? text.match(/([A-Za-z][\w ]*Analog[\w. ]*)/)?.[1]?.trim();
+  if (analogLib) out.analogLibrary = analogLib;
+  const analogMfg = detectManufacturer(text);
+  if (analogMfg) out.analogManufacturer = analogMfg;
+  if (/local-printing/i.test(text)) out.modelWorkflow = "local-printing";
+  else if (/local-milling/i.test(text)) out.modelWorkflow = "local-milling";
+  else if (/printed/i.test(text)) out.modelWorkflow = "printed model";
+  return out;
+}
+function extractStringsFromDentalCAD(data, minLength = 4) {
+  const out = [];
+  let current = "";
+  for (let i = 0; i < data.length; i++) {
+    const c = data[i];
+    if (c >= 32 && c <= 126) {
+      current += String.fromCharCode(c);
+    } else {
+      if (current.length >= minLength) out.push(current);
+      current = "";
+    }
+  }
+  if (current.length >= minLength) out.push(current);
+  return out;
+}
+function findDentalCadKeywords(strings) {
+  const found = /* @__PURE__ */ new Set();
+  const joined = strings.join("\n");
+  for (const kw of DENTAL_CAD_KEYWORDS) {
+    const re = new RegExp(kw.replace(/[\\]/g, "\\\\"), "i");
+    if (re.test(joined)) found.add(kw);
+  }
+  return [...found];
+}
+function inferStlRole(fileName) {
+  const n = fileName.toLowerCase();
+  if (/modelbase|model_base|baseplate/.test(n)) return "modelbase";
+  if (/gingiva/.test(n)) return "gingiva";
+  if (/waxup|wax_up|wax-up/.test(n)) return "waxup";
+  if (/antagonist|opposing/.test(n)) return "antagonist";
+  if (/scanbody|scan_body|scan-body/.test(n)) return "scanbody";
+  if (/abutment/.test(n)) return "abutment";
+  if (/upper|maxilla|oberkiefer/.test(n)) return "upper";
+  if (/lower|mandible|unterkiefer/.test(n)) return "lower";
+  if (/scan|matrix/.test(n)) return "scan";
+  return "unknown";
+}
+function componentKey(c) {
+  return [c.geometryCode ?? "", c.component ?? "", c.libraryName ?? ""].join("|").toLowerCase();
+}
+function normalizeImplantComponents(components) {
+  const byKey = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const c of components) {
+    const key = componentKey(c);
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, { ...c, sourceFiles: [...new Set(c.sourceFiles)] });
+      order.push(key);
+      continue;
+    }
+    existing.sourceFiles = [
+      .../* @__PURE__ */ new Set([...existing.sourceFiles, ...c.sourceFiles])
+    ];
+    existing.manufacturer ??= c.manufacturer;
+    existing.platform ??= c.platform;
+    existing.connection ??= c.connection;
+    existing.component ??= c.component;
+    existing.libraryName ??= c.libraryName;
+    existing.libraryPath ??= c.libraryPath;
+    existing.geometryFile ??= c.geometryFile;
+    existing.geometryCode ??= c.geometryCode;
+    existing.parsedGeometry ??= c.parsedGeometry;
+    existing.tooth ??= c.tooth;
+  }
+  return order.map((k) => byKey.get(k));
+}
+function computeSpan(teeth) {
+  if (teeth.length < 2) return { span: null, isBridge: false };
+  const nums = teeth.map(Number).sort((a, b) => a - b);
+  const span = `${nums[0]}-${nums[nums.length - 1]}`;
+  return { span, isBridge: true };
+}
+var EMPTY_CASE = {
+  patientName: null,
+  practiceName: null,
+  practiceId: null,
+  projectDate: null,
+  exocadVersion: null
+};
+function buildExocadSummary(entries) {
+  const { classified, files } = detectExocadFiles(entries);
+  const hasExocadSidecar = classified.some(
+    (f) => f.kind === "dentalProject" || f.kind === "constructionInfo" || f.kind === "modelInfo" || f.kind === "dentalCAD"
+  );
+  if (!hasExocadSidecar) return void 0;
+  const warnings = [];
+  let caseInfo = { ...EMPTY_CASE };
+  let restorationItems = [];
+  const rawComponents = [];
+  let isImplantCase = false;
+  const model = {
+    hasModelBase: false,
+    hasGingiva: false,
+    hasWaxup: false,
+    analogLibrary: null,
+    analogManufacturer: null,
+    modelWorkflow: null
+  };
+  for (const f of classified) {
+    if (f.kind === "dentalProject") {
+      const parsed = parseDentalProject(decodeText(f.data));
+      caseInfo = { ...caseInfo, ...nonNull(parsed.case) };
+      if (parsed.items.length > 0) restorationItems = parsed.items;
+    } else if (f.kind === "constructionInfo") {
+      const parsed = parseConstructionInfo(decodeText(f.data), f.baseName);
+      rawComponents.push(...parsed.components);
+      if (parsed.isImplantCase) isImplantCase = true;
+    } else if (f.kind === "modelInfo") {
+      const m = parseModelInfo(decodeText(f.data));
+      if (m.analogLibrary) model.analogLibrary = m.analogLibrary;
+      if (m.analogManufacturer) model.analogManufacturer = m.analogManufacturer;
+      if (m.modelWorkflow) model.modelWorkflow = m.modelWorkflow;
+    } else if (f.kind === "dentalCAD") {
+      const strings = extractStringsFromDentalCAD(f.data);
+      const kws = findDentalCadKeywords(strings);
+      if (kws.length > 0) {
+        warnings.push(
+          `dentalCAD: keyword rilevate (medium confidence): ${kws.join(", ")}.`
+        );
+      }
+      if (rawComponents.length === 0) {
+        const mfg = detectManufacturer(strings.join(" "));
+        if (mfg) {
+          rawComponents.push({
+            manufacturer: mfg,
+            sourceFiles: [f.baseName],
+            confidence: "medium"
+          });
+        }
+      }
+    }
+  }
+  const stlEntries = files.stl.map((fileName) => ({
+    fileName,
+    role: inferStlRole(fileName)
+  }));
+  model.hasModelBase = stlEntries.some((s) => s.role === "modelbase");
+  model.hasGingiva = stlEntries.some((s) => s.role === "gingiva");
+  model.hasWaxup = stlEntries.some((s) => s.role === "waxup");
+  const teeth = [
+    ...new Set(restorationItems.map((i) => i.tooth))
+  ].sort((a, b) => Number(a) - Number(b));
+  const { span, isBridge } = computeSpan(teeth);
+  const implantComponents = normalizeImplantComponents(rawComponents);
+  if (implantComponents.length > 0) {
+    warnings.push("Commercial SKU not found in Exocad files");
+    if (implantComponents.some((c) => c.parsedGeometry)) {
+      warnings.push(
+        "Geometry code interpretation is inferred and requires manufacturer mapping"
+      );
+    }
+  }
+  if (!isImplantCase && restorationItems.some((i) => i.implantType && i.implantType !== "WithoutAbutment")) {
+    isImplantCase = true;
+  }
+  return {
+    case: caseInfo,
+    restoration: {
+      teeth,
+      items: restorationItems,
+      span,
+      isBridge
+    },
+    implantComponents,
+    model,
+    files,
+    isImplantCase,
+    warnings: [...new Set(warnings)]
+  };
+}
+function nonNull(obj) {
+  const out = {};
+  Object.keys(obj).forEach((k) => {
+    if (obj[k] !== null) out[k] = obj[k];
+  });
+  return out;
+}
+
+// src/threeShapeParser.ts
+var MANUFACTURERS = [
+  { keys: ["NEODENT", "NEOGM", "NEO"], name: "Neodent" },
+  { keys: ["STRAUMANN"], name: "Straumann" },
+  { keys: ["NOBEL"], name: "Nobel Biocare" },
+  { keys: ["CAMLOG"], name: "Camlog" },
+  { keys: ["DENTSPLY"], name: "Dentsply" },
+  { keys: ["ASTRA"], name: "Astra" },
+  { keys: ["ZIMMER"], name: "Zimmer" },
+  { keys: ["MEGAGEN"], name: "Megagen" },
+  { keys: ["BREDENT"], name: "Bredent" }
+];
+function baseName2(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return normalized.split("/").pop() ?? normalized;
+}
+function extensionOf2(name) {
+  const b = baseName2(name);
+  const i = b.lastIndexOf(".");
+  return i <= 0 ? "" : b.slice(i + 1).toLowerCase();
+}
+function decodeText2(data) {
+  let start = 0;
+  if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
+    start = 3;
+  }
+  return new TextDecoder("utf-8", { fatal: false }).decode(data.subarray(start));
+}
+function decodeEntities2(raw) {
+  return raw.replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;|&apos;/gi, "'").trim();
+}
+function stripTags2(raw) {
+  return decodeEntities2(
+    raw.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/gi, "$1").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ")
+  );
+}
+function extractReadableStringsFromBinary(data, minLength = 4) {
+  const out = [];
+  let current = "";
+  for (let i = 0; i < data.length; i++) {
+    const c = data[i];
+    if (c >= 32 && c <= 126) {
+      current += String.fromCharCode(c);
+    } else {
+      if (current.length >= minLength) out.push(current);
+      current = "";
+    }
+  }
+  if (current.length >= minLength) out.push(current);
+  return out;
+}
+function valuesForKey2(text, base) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (v) => {
+    const val = decodeEntities2(v).replace(/^["']|["']$/g, "").trim();
+    if (val && !seen.has(val)) {
+      seen.add(val);
+      out.push(val);
+    }
+  };
+  const tagRe = new RegExp(`<(${base}\\w*)\\b[^>]*>([\\s\\S]*?)</\\1>`, "gi");
+  let m;
+  while ((m = tagRe.exec(text)) !== null) push(stripTags2(m[2]));
+  const attrRe = new RegExp(`\\b${base}\\w*\\s*=\\s*"([^"]*)"`, "gi");
+  while ((m = attrRe.exec(text)) !== null) push(m[1]);
+  const kvRe = new RegExp(`\\b${base}\\w*\\s*[:=]\\s*([^\\r\\n<"]+)`, "gi");
+  while ((m = kvRe.exec(text)) !== null) push(m[1]);
+  return out;
+}
+function firstValue(text, bases) {
+  for (const b of bases) {
+    const v = valuesForKey2(text, b)[0];
+    if (v) return v;
+  }
+  return null;
+}
+var FDI_RE = /\b([1-4][1-8])\b/g;
+function parseFdi(text) {
+  const set = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(FDI_RE)) {
+    const n = Number(m[1]);
+    if (n >= 11 && n <= 48) set.add(n);
+  }
+  return [...set].sort((a, b) => a - b);
+}
+function hasNonEmptyList(text, listName) {
+  const re = new RegExp(`<${listName}\\b[^>]*>([\\s\\S]*?)</${listName}>`, "i");
+  const m = text.match(re);
+  if (!m) return false;
+  const inner = m[1] ?? "";
+  return /<\w/.test(inner) || stripTags2(inner).length > 0;
+}
+function classifyThreeShapeFile(path) {
+  const lower = path.replace(/\\/g, "/").toLowerCase();
+  const bn = baseName2(lower);
+  const ext = extensionOf2(lower);
+  if (lower.includes("external models/")) return "externalModel";
+  if (ext === "3ml") return "threeMl";
+  if (bn === "materials.xml") return "materialsXml";
+  if (bn.includes("printableorderform")) return "printableOrderForm";
+  if (lower.includes("scans/")) return "scan";
+  if (ext === "dcm") return "cadDcm";
+  if (ext === "xml") return "mainXml";
+  if (ext === "html" || ext === "htm") return "printableOrderForm";
+  return "other";
+}
+function detectThreeShapeFiles(entries) {
+  const classified = [];
+  const files = {
+    mainXml: [],
+    materialsXml: [],
+    printableOrderForms: [],
+    cadDcm: [],
+    externalModels: [],
+    scans: [],
+    encrypted3ml: []
+  };
+  for (const e of entries) {
+    const kind = classifyThreeShapeFile(e.path);
+    const bn = baseName2(e.path);
+    classified.push({
+      path: e.path,
+      baseName: bn,
+      ext: extensionOf2(e.path),
+      kind,
+      data: e.data
+    });
+    switch (kind) {
+      case "mainXml":
+        files.mainXml.push(bn);
+        break;
+      case "materialsXml":
+        files.materialsXml.push(bn);
+        break;
+      case "printableOrderForm":
+        files.printableOrderForms.push(bn);
+        break;
+      case "cadDcm":
+        files.cadDcm.push(bn);
+        break;
+      case "externalModel":
+        files.externalModels.push(e.path);
+        break;
+      case "scan":
+        files.scans.push(bn);
+        break;
+      default:
+        break;
+    }
+  }
+  return { classified, files };
+}
+function isThreeShapePackage(entries) {
+  const { classified } = detectThreeShapeFiles(entries);
+  if (classified.some(
+    (f) => f.kind === "materialsXml" || f.kind === "printableOrderForm" || f.kind === "threeMl" || f.kind === "externalModel"
+  )) {
+    return true;
+  }
+  return classified.some(
+    (f) => f.kind === "mainXml" && /3shape|dentaldesigner|abutmentkit|toothelementtype|globalimplantid/i.test(
+      decodeText2(f.data)
+    )
+  );
+}
+function normalizeRestorationType(text) {
+  if (/AbutmentScrewRetainedCrown/i.test(text)) {
+    return {
+      type: "Screw Retained Crown",
+      isImplantCase: true,
+      isScrewRetained: true
+    };
+  }
+  if (/te?TemporaryVPrepCrown/i.test(text) || /TemporaryVPrepCrown/i.test(text)) {
+    return {
+      type: "Temporary Virtual Preparation Crown",
+      isImplantCase: false,
+      isScrewRetained: false
+    };
+  }
+  const raw = firstValue(text, [
+    "RestorationType",
+    "ToothElementType",
+    "ElementType"
+  ]);
+  return {
+    type: raw,
+    isImplantCase: /abutment|screwretained|screw retained/i.test(text),
+    isScrewRetained: /screwretained|screw retained/i.test(text)
+  };
+}
+function inferManufacturerFromIdsAndNames(value) {
+  const hay = value.toUpperCase();
+  let manufacturer = null;
+  for (const m of MANUFACTURERS) {
+    if (m.keys.some((k) => hay.includes(k))) {
+      manufacturer = m.name;
+      break;
+    }
+  }
+  let connection = null;
+  if (/\bGM\b|_GM_|_GM\b|NEOGM/.test(hay)) connection = "GM / Grand Morse";
+  else if (/\bCM\b|_CM_/.test(hay)) connection = "CM / Cone Morse";
+  return { manufacturer, connection };
+}
+function normalizeImplantComponent(fileName, sourcePath, confidence = "high") {
+  const n = fileName.toUpperCase();
+  let type = "unknown";
+  if (/SCAN ?BODY/.test(n)) type = "scanbody";
+  else if (/SOCKET/.test(n)) type = "analog_socket";
+  else if (/ANALOG/.test(n)) type = "analog";
+  else if (/\bLINK/.test(n)) type = "link/tibase_candidate";
+  else if (/\bTX\b|^TX|[-_]TX[-_]/.test(n))
+    type = "screw_or_transmucosal_component_candidate";
+  else if (/\bVM\b|^VM|NEO/.test(n)) type = "manufacturer_component_candidate";
+  return {
+    name: fileName.replace(/\.[^.]+$/, ""),
+    fileName,
+    type,
+    sourcePath,
+    confidence
+  };
+}
+function parseExternalModels(classified) {
+  const externalDcm = classified.filter(
+    (f) => f.kind === "externalModel" && f.ext === "dcm"
+  );
+  const components = [];
+  let abutmentKitId = null;
+  for (const f of externalDcm) {
+    const norm = f.path.replace(/\\/g, "/");
+    const idx = norm.toLowerCase().indexOf("external models/");
+    if (idx >= 0 && !abutmentKitId) {
+      const rest = norm.slice(idx + "external models/".length);
+      const folder = rest.split("/")[0];
+      if (folder && /abutmentkit|kit|\d{3,}/i.test(folder)) {
+        abutmentKitId = folder;
+      }
+    }
+    components.push(normalizeImplantComponent(f.baseName, f.path, "high"));
+  }
+  return { components, abutmentKitId };
+}
+function parseMaterialsXml(xml) {
+  const map = {};
+  const blockRe = /<Material\b[^>]*>([\s\S]*?)<\/Material>/gi;
+  let m;
+  let matched = false;
+  while ((m = blockRe.exec(xml)) !== null) {
+    const scope = m[0];
+    const id = valuesForKey2(scope, "MaterialID")[0];
+    if (!id) continue;
+    matched = true;
+    map[id] = {
+      ...valuesForKey2(scope, "Name")[0] ? { name: valuesForKey2(scope, "Name")[0] } : {},
+      ...valuesForKey2(scope, "MaterialFamily")[0] ? { family: valuesForKey2(scope, "MaterialFamily")[0] } : {},
+      ...valuesForKey2(scope, "ShaderMaterial")[0] ? { shader: valuesForKey2(scope, "ShaderMaterial")[0] } : {}
+    };
+  }
+  if (!matched) {
+    const id = valuesForKey2(xml, "MaterialID")[0];
+    if (id) {
+      map[id] = {
+        ...valuesForKey2(xml, "Name")[0] ? { name: valuesForKey2(xml, "Name")[0] } : {},
+        ...valuesForKey2(xml, "MaterialFamily")[0] ? { family: valuesForKey2(xml, "MaterialFamily")[0] } : {},
+        ...valuesForKey2(xml, "ShaderMaterial")[0] ? { shader: valuesForKey2(xml, "ShaderMaterial")[0] } : {}
+      };
+    }
+  }
+  return map;
+}
+function parseMainOrderXml(xml) {
+  const restType = normalizeRestorationType(xml);
+  const internalToothNumbers = valuesForKey2(xml, "ToothNumber").map((v) => Number(v.replace(/[^\d]/g, ""))).filter((n) => Number.isFinite(n) && n > 0);
+  const abutmentKitId = firstValue(xml, ["AbutmentKitID"]);
+  const connectionId = firstValue(xml, ["GlobalConnectionID"]);
+  const implantSystemId = firstValue(xml, ["GlobalImplantID"]);
+  const hasImplantLists = hasNonEmptyList(xml, "ImplantSystemList") || hasNonEmptyList(xml, "ImplantSystemPartList") || hasNonEmptyList(xml, "AbutmentKitList");
+  const isImplantCase = restType.isImplantCase || Boolean(abutmentKitId || connectionId || implantSystemId) || hasImplantLists;
+  return {
+    case: {
+      ...firstValue(xml, ["PatientName", "Patient"]) ? { patientName: firstValue(xml, ["PatientName", "Patient"]) } : {},
+      ...firstValue(xml, ["OrderId", "OrderNumber", "OrderID"]) ? { orderId: firstValue(xml, ["OrderId", "OrderNumber", "OrderID"]) } : {},
+      ...firstValue(xml, ["Customer", "Clinic"]) ? { customer: firstValue(xml, ["Customer", "Clinic"]) } : {},
+      ...firstValue(xml, ["Operator", "Technician", "User"]) ? { operator: firstValue(xml, ["Operator", "Technician", "User"]) } : {},
+      ...firstValue(xml, ["CreatedAt", "CreateDate", "OrderDate", "Created"]) ? {
+        createdAt: firstValue(xml, [
+          "CreatedAt",
+          "CreateDate",
+          "OrderDate",
+          "Created"
+        ])
+      } : {},
+      ...firstValue(xml, ["GroupFolder", "Folder"]) ? { groupFolder: firstValue(xml, ["GroupFolder", "Folder"]) } : {},
+      ...firstValue(xml, ["Software", "Application"]) ? { software: firstValue(xml, ["Software", "Application"]) } : {},
+      ...firstValue(xml, ["SoftwareVersion", "Version"]) ? { softwareVersion: firstValue(xml, ["SoftwareVersion", "Version"]) } : {},
+      ...firstValue(xml, ["ProcessStatus", "Status"]) ? { processStatus: firstValue(xml, ["ProcessStatus", "Status"]) } : {},
+      ...firstValue(xml, ["ScanSource", "Source"]) ? { scanSource: firstValue(xml, ["ScanSource", "Source"]) } : {}
+    },
+    restoration: {
+      internalToothNumbers,
+      ...restType.type ? { type: restType.type } : {},
+      ...firstValue(xml, ["RestorationName"]) ? { name: firstValue(xml, ["RestorationName"]) } : {},
+      ...firstValue(xml, ["ToothElementTypeID"]) ? { toothElementTypeID: firstValue(xml, ["ToothElementTypeID"]) } : {},
+      ...firstValue(xml, ["CacheToothTypeClass"]) ? { cacheToothTypeClass: firstValue(xml, ["CacheToothTypeClass"]) } : {},
+      ...firstValue(xml, ["MaterialID"]) ? { materialId: firstValue(xml, ["MaterialID"]) } : {},
+      ...firstValue(xml, ["Shade", "Color"]) ? { shade: firstValue(xml, ["Shade", "Color"]) } : {},
+      isImplantCase,
+      isScrewRetained: restType.isScrewRetained
+    },
+    implantIds: { abutmentKitId, connectionId, implantSystemId },
+    hasImplantLists
+  };
+}
+function htmlToLines(html) {
+  const norm = html.replace(/<\s*br\s*\/?>/gi, "\n").replace(/<\/(tr|p|div|li|h[1-6]|td|th)>/gi, "\n");
+  return norm.split(/\n+/).map((l) => stripTags2(l)).filter((l) => l.length > 0);
+}
+function parsePrintableOrderForm(html) {
+  const lines = htmlToLines(html);
+  const teeth = parseFdi(lines.join("\n"));
+  const kv = (label) => {
+    const re = new RegExp(`\\b${label}\\b\\s*[:#]\\s*(.+)$`, "i");
+    for (const line of lines) {
+      const m = line.match(re);
+      if (m?.[1]) return m[1].trim();
+    }
+    return null;
+  };
+  return {
+    teeth,
+    patientName: kv("Patient") ?? firstValue(html, ["PatientName"]),
+    orderId: kv("Order") ?? firstValue(html, ["OrderId", "OrderNumber"]),
+    customer: kv("Customer") ?? kv("Clinic"),
+    operator: kv("Operator") ?? kv("Technician"),
+    shade: kv("Shade") ?? kv("Color")
+  };
+}
+function parseCadDcm(data) {
+  const strings = extractReadableStringsFromBinary(data);
+  const joined = strings.join("\n");
+  const restType = normalizeRestorationType(joined);
+  const keywords = [];
+  for (const kw of [
+    "AbutmentScrewRetainedCrown",
+    "TemporaryVPrepCrown",
+    "ScanBody",
+    "Analog",
+    "TiBase",
+    "Socket",
+    "NEODENT",
+    "STRAUMANN",
+    "NOBEL"
+  ]) {
+    if (new RegExp(kw, "i").test(joined)) keywords.push(kw);
+  }
+  return { restorationType: restType.type, keywords };
+}
+function parseScans(classified) {
+  return classified.filter((f) => f.kind === "scan").map((f) => f.baseName);
+}
+var EMPTY_CASE2 = {
+  patientName: null,
+  orderId: null,
+  customer: null,
+  operator: null,
+  createdAt: null,
+  groupFolder: null,
+  software: "3Shape Dental Designer",
+  softwareVersion: null,
+  processStatus: null,
+  scanSource: null
+};
+function looksEncrypted(data) {
+  if (data.length >= 2 && data[0] === 80 && data[1] === 75) return true;
+  const sample = decodeText2(data.subarray(0, Math.min(512, data.length)));
+  return !/[<\w]/.test(sample);
+}
+function buildThreeShapeSummary(entries) {
+  if (!isThreeShapePackage(entries)) return void 0;
+  const { classified, files } = detectThreeShapeFiles(entries);
+  const warnings = [];
+  let caseInfo = { ...EMPTY_CASE2 };
+  let restoration = {
+    teeth: [],
+    internalToothNumbers: [],
+    name: null,
+    type: null,
+    toothElementTypeID: null,
+    cacheToothTypeClass: null,
+    materialId: null,
+    materialName: null,
+    materialFamily: null,
+    shaderMaterial: null,
+    shade: null,
+    isImplantCase: false,
+    isScrewRetained: false
+  };
+  const implant = {
+    isImplantCase: false,
+    manufacturer: null,
+    connection: null,
+    connectionId: null,
+    implantSystemId: null,
+    abutmentKitId: null,
+    components: []
+  };
+  for (const f of classified.filter((c) => c.kind === "mainXml")) {
+    const parsed = parseMainOrderXml(decodeText2(f.data));
+    caseInfo = { ...caseInfo, ...stripNull(parsed.case) };
+    restoration = mergeRestoration(restoration, parsed.restoration);
+    if (parsed.restoration.isImplantCase) restoration.isImplantCase = true;
+    if (parsed.restoration.isScrewRetained) restoration.isScrewRetained = true;
+    if (parsed.implantIds.abutmentKitId)
+      implant.abutmentKitId = parsed.implantIds.abutmentKitId;
+    if (parsed.implantIds.connectionId)
+      implant.connectionId = parsed.implantIds.connectionId;
+    if (parsed.implantIds.implantSystemId)
+      implant.implantSystemId = parsed.implantIds.implantSystemId;
+  }
+  let printableTeeth = [];
+  for (const f of classified.filter((c) => c.kind === "printableOrderForm")) {
+    const p = parsePrintableOrderForm(decodeText2(f.data));
+    if (p.teeth.length > 0) printableTeeth = p.teeth;
+    if (p.patientName && !caseInfo.patientName) caseInfo.patientName = p.patientName;
+    if (p.orderId && !caseInfo.orderId) caseInfo.orderId = p.orderId;
+    if (p.customer && !caseInfo.customer) caseInfo.customer = p.customer;
+    if (p.operator && !caseInfo.operator) caseInfo.operator = p.operator;
+    if (p.shade && !restoration.shade) restoration.shade = p.shade;
+  }
+  const materialMap = {};
+  for (const f of classified.filter((c) => c.kind === "materialsXml")) {
+    Object.assign(materialMap, parseMaterialsXml(decodeText2(f.data)));
+  }
+  if (restoration.materialId && materialMap[restoration.materialId]) {
+    const mat = materialMap[restoration.materialId];
+    restoration.materialName = mat.name ?? null;
+    restoration.materialFamily = mat.family ?? null;
+    restoration.shaderMaterial = mat.shader ?? null;
+  } else if (restoration.materialId) {
+    warnings.push(
+      `MaterialID ${restoration.materialId} non trovato in Materials.xml.`
+    );
+  }
+  const ext = parseExternalModels(classified);
+  if (ext.components.length > 0) implant.components = ext.components;
+  if (ext.abutmentKitId && !implant.abutmentKitId)
+    implant.abutmentKitId = ext.abutmentKitId;
+  if (!restoration.type) {
+    for (const f of classified.filter((c) => c.kind === "cadDcm")) {
+      const dcm = parseCadDcm(f.data);
+      if (dcm.restorationType) {
+        restoration.type = dcm.restorationType;
+        warnings.push(
+          `Tipo restauro dedotto da CAD/*.dcm (medium): ${dcm.restorationType}.`
+        );
+        break;
+      }
+    }
+  }
+  for (const f of classified.filter((c) => c.kind === "threeMl")) {
+    if (looksEncrypted(f.data)) {
+      files.encrypted3ml.push(f.baseName);
+    }
+  }
+  if (files.encrypted3ml.length > 0) {
+    warnings.push(
+      `File .3ml cifrati/non leggibili saltati: ${files.encrypted3ml.join(", ")}.`
+    );
+  }
+  if (printableTeeth.length > 0) {
+    restoration.teeth = printableTeeth;
+  } else {
+    restoration.teeth = restoration.internalToothNumbers.filter(
+      (n) => n >= 11 && n <= 48
+    );
+  }
+  if (printableTeeth.length > 0 && restoration.internalToothNumbers.length > 0 && restoration.internalToothNumbers.some((n) => !printableTeeth.includes(n))) {
+    warnings.push(
+      `ToothNumber interno (${restoration.internalToothNumbers.join(", ")}) diverso dal dente FDI dell'ordine (${printableTeeth.join(", ")}).`
+    );
+  }
+  const idText = [
+    implant.connectionId,
+    implant.implantSystemId,
+    implant.abutmentKitId,
+    ...implant.components.map((c) => c.fileName)
+  ].filter(Boolean).join(" ");
+  if (idText) {
+    const inf = inferManufacturerFromIdsAndNames(idText);
+    if (inf.manufacturer) implant.manufacturer = inf.manufacturer;
+    if (inf.connection) implant.connection = inf.connection;
+  }
+  const isImplantCase = restoration.isImplantCase || Boolean(
+    implant.abutmentKitId || implant.connectionId || implant.implantSystemId
+  ) || implant.components.length > 0;
+  implant.isImplantCase = isImplantCase;
+  restoration.isImplantCase = isImplantCase;
+  if (isImplantCase) {
+    if (!implant.manufacturer) {
+      warnings.push("Caso implantare ma produttore non identificato.");
+    }
+    warnings.push("Commercial SKU not found in 3Shape files");
+    if (implant.components.length > 0) {
+      warnings.push(
+        "Componenti classificati solo dal nome file (verifica manuale consigliata)."
+      );
+    }
+  }
+  return {
+    source: "3Shape",
+    case: caseInfo,
+    restoration,
+    implant,
+    files,
+    warnings: [...new Set(warnings)]
+  };
+}
+function stripNull(obj) {
+  const out = {};
+  Object.keys(obj).forEach((k) => {
+    const val = obj[k];
+    if (val !== null && val !== void 0) out[k] = val;
+  });
+  return out;
+}
+function mergeRestoration(base, patch) {
+  const merged = { ...base };
+  Object.keys(patch).forEach((k) => {
+    const val = patch[k];
+    if (val === null || val === void 0) return;
+    if (k === "internalToothNumbers" && Array.isArray(val)) {
+      merged.internalToothNumbers = [
+        .../* @__PURE__ */ new Set([...merged.internalToothNumbers, ...val])
+      ];
+      return;
+    }
+    if (k === "isImplantCase" || k === "isScrewRetained") return;
+    merged[k] = val;
+  });
+  return merged;
+}
+
+// src/cadProjectParser.ts
+var CAD_SIDECAR_RE = /\.(constructioninfo|modelinfo|dentalproject|dentalcad)(?:\.html)?$/i;
+var TOOTH_BLOCK_RE2 = /<(?:Tooth|Restoration|ConstructionElement|Element|RestorationElement)\b[^>]*>([\s\S]*?)<\/(?:Tooth|Restoration|ConstructionElement|Element|RestorationElement)>/gi;
+var FDI_TOOTH_RE = /\b([1-4][1-8])\b/g;
+function decodeCadText(data) {
+  let start = 0;
+  if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
+    start = 3;
+  }
+  return new TextDecoder("utf-8", { fatal: false }).decode(data.subarray(start));
+}
+function stripXmlText(raw) {
+  return raw.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/gi, "$1").replace(/<[^>]+>/g, "").trim();
+}
+function firstTagValue(xml, tags) {
+  for (const tag of tags) {
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
+    const m = xml.match(re);
+    if (m?.[1]) {
+      const val = stripXmlText(m[1]);
+      if (val) return val;
+    }
+  }
+  return void 0;
+}
+function allTagValues(xml, tags) {
+  const out = [];
+  for (const tag of tags) {
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "gi");
+    let m;
+    while ((m = re.exec(xml)) !== null) {
+      const val = stripXmlText(m[1]);
+      if (val) out.push(val);
+    }
+  }
+  return out;
+}
+function parseBool2(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "true" || v === "1" || v === "yes") return true;
+  if (v === "false" || v === "0" || v === "no") return false;
+  return void 0;
+}
+function parseFdiNumbers(text) {
+  const nums = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(FDI_TOOTH_RE)) {
+    const n = Number(m[1]);
+    if (n >= 11 && n <= 48) nums.add(n);
+  }
+  return [...nums].sort((a, b) => a - b);
+}
+function detectCadSource(fileName, text) {
+  const lower = fileName.toLowerCase();
+  if (lower.includes("constructioninfo") || lower.includes("dentalproject") || lower.includes("dentalcad") || /construction\s*info/i.test(text) || /<ConstructionInfo\b/i.test(text) || /<DentalProject\b/i.test(text)) {
+    return "exocad";
+  }
+  return "unknown";
+}
+function parseRestorationBlocks(xml) {
+  const entries = [];
+  for (const m of xml.matchAll(TOOTH_BLOCK_RE2)) {
+    const block = m[1] ?? "";
+    const toothNumbers = parseFdiNumbers(
+      firstTagValue(block, [
+        "Number",
+        "ToothNumber",
+        "Tooth",
+        "FDI",
+        "ToothID"
+      ]) ?? block
+    );
+    const material = firstTagValue(block, [
+      "Material",
+      "MaterialName",
+      "MaterialDisplayName",
+      "BlankMaterial"
+    ]);
+    const shade = firstTagValue(block, [
+      "Shade",
+      "ToothColor",
+      "Color",
+      "VitaShade"
+    ]);
+    const reconstructionType = firstTagValue(block, [
+      "ReconstructionType",
+      "Type",
+      "WorkType",
+      "RestorationType"
+    ]);
+    const meshFileName = firstTagValue(block, [
+      "MeshFileName",
+      "MeshFile",
+      "FileName",
+      "STLFileName",
+      "ScanFileName"
+    ]);
+    const preparationType = firstTagValue(block, ["PreparationType"]);
+    const implantType = firstTagValue(block, ["ImplantType"]);
+    const scanAbutmentScan = parseBool2(firstTagValue(block, ["ScanAbutmentScan"]));
+    const mesialConnector = parseBool2(firstTagValue(block, ["MesialConnector"]));
+    if (toothNumbers.length === 0 && !material && !shade && !reconstructionType && !meshFileName && !preparationType && !implantType) {
+      continue;
+    }
+    entries.push({
+      toothNumbers,
+      ...material ? { material } : {},
+      ...shade ? { shade } : {},
+      ...reconstructionType ? { reconstructionType } : {},
+      ...meshFileName ? { meshFileName } : {},
+      ...preparationType ? { preparationType } : {},
+      ...implantType ? { implantType } : {},
+      ...scanAbutmentScan !== void 0 ? { scanAbutmentScan } : {},
+      ...mesialConnector !== void 0 ? { mesialConnector } : {}
+    });
+  }
+  return entries;
+}
+function isCadSidecarFileName(fileName) {
+  const base = fileName.replace(/\\/g, "/").split("/").pop() ?? fileName;
+  return CAD_SIDECAR_RE.test(base) || /\.xml$/i.test(base);
+}
+function parseCadSidecarBytes(fileName, data) {
+  if (!isCadSidecarFileName(fileName) && data.byteLength > 0) {
+    const head = decodeCadText(data.subarray(0, Math.min(256, data.byteLength)));
+    if (!head.includes("<") && !head.includes("<?xml")) {
+      return null;
+    }
+  } else if (!isCadSidecarFileName(fileName)) {
+    return null;
+  }
+  const text = decodeCadText(data).trim();
+  if (!text || text.length < 8) {
+    return null;
+  }
+  const parseWarnings = [];
+  if (!text.includes("<")) {
+    parseWarnings.push("Contenuto non XML: metadati CAD limitati.");
+  }
+  const source = detectCadSource(fileName, text);
+  const projectName = firstTagValue(text, [
+    "ProjectName",
+    "Name",
+    "CaseName",
+    "OrderName"
+  ]);
+  const projectDirectory = firstTagValue(text, [
+    "ProjectDirectory",
+    "ProjectDir",
+    "Directory"
+  ]);
+  const reconstructions = parseRestorationBlocks(text);
+  const materialsFromTags = allTagValues(text, [
+    "Material",
+    "MaterialName",
+    "MaterialDisplayName",
+    "BlankMaterial"
+  ]);
+  const shadesFromTags = allTagValues(text, [
+    "Shade",
+    "ToothColor",
+    "Color",
+    "VitaShade"
+  ]);
+  if (reconstructions.length === 0 && (materialsFromTags.length || shadesFromTags.length)) {
+    reconstructions.push({
+      toothNumbers: parseFdiNumbers(text),
+      ...materialsFromTags[0] ? { material: materialsFromTags[0] } : {},
+      ...shadesFromTags[0] ? { shade: shadesFromTags[0] } : {}
+    });
+  }
+  const toothNumbers = [
+    ...new Set(reconstructions.flatMap((r) => r.toothNumbers))
+  ].sort((a, b) => a - b);
+  const materials = [
+    .../* @__PURE__ */ new Set([
+      ...materialsFromTags,
+      ...reconstructions.map((r) => r.material).filter(Boolean)
+    ])
+  ];
+  const shades = [
+    .../* @__PURE__ */ new Set([
+      ...shadesFromTags,
+      ...reconstructions.map((r) => r.shade).filter(Boolean)
+    ])
+  ];
+  if (!projectName && toothNumbers.length === 0 && materials.length === 0 && reconstructions.length === 0) {
+    return null;
+  }
+  return {
+    source,
+    sourceFile: fileName,
+    sourceFiles: [fileName],
+    ...projectName ? { projectName } : {},
+    ...projectDirectory ? { projectDirectory } : {},
+    materials,
+    shades,
+    toothNumbers,
+    reconstructions,
+    parseWarnings
+  };
+}
+function toSourceFileMetadata(part) {
+  return {
+    sourceFile: part.sourceFile,
+    source: part.source,
+    ...part.projectName ? { projectName: part.projectName } : {},
+    ...part.projectDirectory ? { projectDirectory: part.projectDirectory } : {},
+    materials: part.materials,
+    shades: part.shades,
+    toothNumbers: part.toothNumbers,
+    reconstructions: part.reconstructions,
+    parseWarnings: part.parseWarnings
+  };
+}
+function mergeCadProjectParseResults(parts) {
+  if (parts.length === 0) return void 0;
+  const sourceFiles = [...new Set(parts.flatMap((p) => p.sourceFiles))];
+  const bySourceFile = parts.map(toSourceFileMetadata);
+  const source = parts.some((p) => p.source === "exocad") ? "exocad" : "unknown";
+  const projectName = parts.find((p) => p.projectName)?.projectName;
+  const projectDirectory = parts.find((p) => p.projectDirectory)?.projectDirectory;
+  const reconstructions = [];
+  for (const p of parts) {
+    reconstructions.push(...p.reconstructions);
+  }
+  const toothNumbers = [
+    ...new Set(reconstructions.flatMap((r) => r.toothNumbers))
+  ].sort((a, b) => a - b);
+  const materials = [
+    .../* @__PURE__ */ new Set([
+      ...parts.flatMap((p) => p.materials),
+      ...reconstructions.map((r) => r.material).filter(Boolean)
+    ])
+  ];
+  const shades = [
+    .../* @__PURE__ */ new Set([
+      ...parts.flatMap((p) => p.shades),
+      ...reconstructions.map((r) => r.shade).filter(Boolean)
+    ])
+  ];
+  const parseWarnings = [...new Set(parts.flatMap((p) => p.parseWarnings))];
+  return {
+    source,
+    sourceFiles,
+    bySourceFile,
+    ...projectName ? { projectName } : {},
+    ...projectDirectory ? { projectDirectory } : {},
+    materials,
+    shades,
+    toothNumbers,
+    reconstructions,
+    parseWarnings
+  };
+}
+function collectCadMetadataFromZipEntries(entries) {
+  const parts = [];
+  for (const e of entries) {
+    const baseName3 = e.safePath.split("/").pop() ?? e.safePath;
+    const parsed = parseCadSidecarBytes(baseName3, e.data);
+    if (parsed) parts.push(parsed);
+  }
+  const merged = mergeCadProjectParseResults(parts);
+  const fileEntries = entries.map((e) => ({ path: e.safePath, data: e.data }));
+  const exocad = buildExocadSummary(fileEntries);
+  const threeShape = buildThreeShapeSummary(fileEntries);
+  if (!merged) {
+    if (!exocad && !threeShape) return void 0;
+    const base = {
+      source: exocad ? "exocad" : "unknown",
+      sourceFiles: exocad ? [
+        ...exocad.files.dentalProject,
+        ...exocad.files.constructionInfo,
+        ...exocad.files.modelInfo,
+        ...exocad.files.dentalCAD
+      ] : [
+        ...threeShape?.files.mainXml ?? [],
+        ...threeShape?.files.materialsXml ?? [],
+        ...threeShape?.files.printableOrderForms ?? []
+      ],
+      materials: [],
+      shades: [],
+      toothNumbers: exocad ? exocad.restoration.teeth.map(Number) : threeShape?.restoration.teeth ?? [],
+      reconstructions: [],
+      parseWarnings: [],
+      ...exocad ? { exocad } : {},
+      ...threeShape ? { threeShape } : {}
+    };
+    return base;
+  }
+  if (exocad) {
+    merged.exocad = exocad;
+    if (exocad.implantComponents.length > 0 || exocad.isImplantCase) {
+      merged.source = "exocad";
+    }
+  }
+  if (threeShape) {
+    merged.threeShape = threeShape;
+  }
+  return merged;
+}
+
+// src/zipExtractor.ts
+import { unzipSync } from "fflate";
+var MAX_ZIP_ENTRIES = 200;
+var MAX_FILE_BYTES = 250 * 1024 * 1024;
+var MAX_TOTAL_EXTRACTED_BYTES = 1024 * 1024 * 1024;
+var MAX_ZIP_PACKAGE_BYTES = 40 * 1024 * 1024;
+function zipPackageTooLargeMessage(sizeBytes) {
+  const mb = (sizeBytes / (1024 * 1024)).toFixed(1);
+  const limit = (MAX_ZIP_PACKAGE_BYTES / (1024 * 1024)).toFixed(0);
+  return `ZIP troppo grande (${mb} MB). Limite estrazione su Convex: ${limit} MB (runtime action ~64 MB). Usa l\u2019estrazione nel browser nell\u2019app o carica i file singolarmente.`;
+}
+var WHITELIST = /* @__PURE__ */ new Set([
+  "stl",
+  "ply",
+  "obj",
+  "dcm",
+  "xml",
+  "json",
+  "png",
+  "jpg",
+  "jpeg",
+  "pdf",
+  "txt",
+  /** Metadati progetto CAD (es. Exocad / pacchetti dental CAD export) */
+  "constructioninfo",
+  "modelinfo",
+  "dentalproject",
+  "dentalcad",
+  "html",
+  /** 3Shape Dental System / Dental Designer (spesso ZIP cifrati, lettura best-effort) */
+  "3ml"
+]);
+var BLOCKED = /* @__PURE__ */ new Set([
+  "exe",
+  "dmg",
+  "app",
+  "sh",
+  "bat",
+  "cmd",
+  "js",
+  "msi",
+  "jar",
+  "ps1"
+]);
+function sanitizeZipEntryPath(entryPath) {
+  const normalized = entryPath.replace(/\\/g, "/").replace(/^\uFEFF/, "");
+  if (/^[a-zA-Z]:/.test(normalized)) return null;
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) return null;
+  const parts = normalized.split("/").filter((p) => p.length > 0);
+  const built = [];
+  for (const p of parts) {
+    if (p === "..") return null;
+    if (p === ".") continue;
+    built.push(p);
+  }
+  if (built.length === 0) return null;
+  return built.join("/");
+}
+function extensionFromSafePath(safePath) {
+  const base = safePath.split("/").pop() ?? safePath;
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.slice(i + 1).toLowerCase();
+}
+function expandThreeShape3mlEntries(entries) {
+  const out = [];
+  const warnings = [];
+  for (const entry of entries) {
+    out.push(entry);
+    if (entry.extension !== "3ml") continue;
+    let inner;
+    try {
+      inner = unzipSync(entry.data);
+    } catch {
+      warnings.push(
+        `.3ml non leggibile (probabilmente cifrato/proprietario): ${entry.safePath}`
+      );
+      continue;
+    }
+    let found = 0;
+    let skippedFormat = 0;
+    for (const rawPath of Object.keys(inner)) {
+      if (out.length >= MAX_ZIP_ENTRIES) {
+        warnings.push(
+          `Limite di ${MAX_ZIP_ENTRIES} file raggiunto: contenuto residuo di ${entry.safePath} ignorato.`
+        );
+        break;
+      }
+      const data = inner[rawPath];
+      if (!data || data.byteLength === 0) continue;
+      const safe = sanitizeZipEntryPath(rawPath);
+      if (safe === null) continue;
+      const ext = extensionFromSafePath(safe);
+      if (!ext || BLOCKED.has(ext) || ext === "3ml") {
+        skippedFormat++;
+        continue;
+      }
+      if (!WHITELIST.has(ext)) {
+        skippedFormat++;
+        continue;
+      }
+      if (data.byteLength > MAX_FILE_BYTES) continue;
+      out.push({ safePath: `${entry.safePath}/${safe}`, extension: ext, data });
+      found++;
+    }
+    if (found > 0) {
+      warnings.push(`.3ml espanso (${found} file estratti): ${entry.safePath}`);
+    } else {
+      warnings.push(
+        `.3ml aperto ma senza file utili estraibili${skippedFormat > 0 ? ` (${skippedFormat} interni non in whitelist)` : ""}: ${entry.safePath}`
+      );
+    }
+  }
+  return { entries: out, warnings };
+}
+function extractZipSafely(buffer) {
+  const warnings = [];
+  let unzipped;
+  try {
+    unzipped = unzipSync(buffer);
+  } catch {
+    return { ok: false, fatal: "ZIP non valido o corrotto.", warnings };
+  }
+  const nonemptyKeys = Object.keys(unzipped).filter((k) => {
+    const chunk = unzipped[k];
+    return chunk !== void 0 && chunk.byteLength > 0;
+  });
+  if (nonemptyKeys.length > MAX_ZIP_ENTRIES) {
+    return {
+      ok: false,
+      fatal: `Troppi file nel ZIP (limite ${MAX_ZIP_ENTRIES}).`,
+      warnings
+    };
+  }
+  let totalSize = 0;
+  const entries = [];
+  for (const rawPath of nonemptyKeys) {
+    const data = unzipped[rawPath];
+    const safe = sanitizeZipEntryPath(rawPath);
+    if (safe === null) {
+      warnings.push(`Percorso ZIP non sicuro ignorato: ${rawPath}`);
+      continue;
+    }
+    if (data.byteLength > MAX_FILE_BYTES) {
+      return {
+        ok: false,
+        fatal: `File troppo grande nello ZIP (limite 250 MB): ${safe}`,
+        warnings
+      };
+    }
+    totalSize += data.byteLength;
+    if (totalSize > MAX_TOTAL_EXTRACTED_BYTES) {
+      return {
+        ok: false,
+        fatal: "Volume totale estratto oltre il limite di 1 GB.",
+        warnings
+      };
+    }
+    const ext = extensionFromSafePath(safe);
+    if (!ext) {
+      warnings.push(`Estensione assente, ignorato: ${safe}`);
+      continue;
+    }
+    if (BLOCKED.has(ext)) {
+      warnings.push(`File bloccato (tipo rischioso .${ext}): ${safe}`);
+      continue;
+    }
+    if (!WHITELIST.has(ext)) {
+      warnings.push(`File fuori whitelist ignorato: ${safe}`);
+      continue;
+    }
+    entries.push({ safePath: safe, extension: ext, data });
+  }
+  if (entries.length === 0) {
+    return {
+      ok: false,
+      fatal: "Nessun file operativo estratto dal ZIP (solo voci ignorate, vuote o non consent).",
+      warnings
+    };
+  }
+  return { ok: true, entries, warnings };
+}
+export {
+  MAX_FILE_BYTES,
+  MAX_TOTAL_EXTRACTED_BYTES,
+  MAX_ZIP_ENTRIES,
+  MAX_ZIP_PACKAGE_BYTES,
+  buildExocadSummary,
+  buildThreeShapeSummary,
+  classifyExocadFile,
+  classifyThreeShapeFile,
+  collectCadMetadataFromZipEntries,
+  detectExocadFiles,
+  detectThreeShapeFiles,
+  expandThreeShape3mlEntries,
+  extractReadableStringsFromBinary,
+  extractStringsFromDentalCAD,
+  extractZipSafely,
+  findDentalCadKeywords,
+  inferGeometryCode,
+  inferManufacturerFromIdsAndNames,
+  inferStlRole,
+  isCadSidecarFileName,
+  isExocadPackage,
+  isThreeShapePackage,
+  mergeCadProjectParseResults,
+  mergeExternalReferences,
+  normalizeImplantComponent,
+  normalizeImplantComponents,
+  normalizeRestorationType,
+  parseCadDcm,
+  parseCadSidecarBytes,
+  parseConstructionInfo,
+  parseDentalProject,
+  parseExternalModels,
+  parseMainOrderXml,
+  parseMaterialsXml,
+  parseModelInfo,
+  parsePrintableOrderForm,
+  parseScans,
+  sanitizeZipEntryPath,
+  zipPackageTooLargeMessage
+};
+//# sourceMappingURL=index.js.map