@toolpath/dfm 0.5.0 → 1.1.0

package/dist/{chunk-4IRNLDE6.js → chunk-IB42AM6A.js}

@@ -1,3 +1,23 @@
+// src/model/dfm-metrics.ts
+import { MM_PER_INCH } from "@toolpath/tool-support";
+
+// src/model/direction-label.ts
+var EPSILON = 1e-6;
+var trim = (value) => Number.parseFloat(value.toFixed(3)).toString();
+var directionLabel = (direction) => {
+  const axes = [
+    ["X", direction.x],
+    ["Y", direction.y],
+    ["Z", direction.z]
+  ];
+  const nonZero = axes.filter(([, value]) => Math.abs(value) > EPSILON);
+  const [axis] = nonZero;
+  if (nonZero.length === 1 && axis && Math.abs(Math.abs(axis[1]) - 1) < EPSILON) {
+    return `${axis[1] > 0 ? "+" : "\u2212"}${axis[0]}`;
+  }
+  return axes.map(([, value]) => trim(value)).join(", ");
+};
+
 // src/model/geometry.ts
 var dfmFeatures = (features) => {
   const read = features.map(
@@ -59,26 +79,6 @@ var featureLd = (features, feature, sheets) => {
   };
 };
 
-// src/model/dfm-metrics.ts
-import { MM_PER_INCH } from "@toolpath/tool-support";
-
-// src/model/direction-label.ts
-var EPSILON = 1e-6;
-var trim = (value) => Number.parseFloat(value.toFixed(3)).toString();
-var directionLabel = (direction) => {
-  const axes = [
-    ["X", direction.x],
-    ["Y", direction.y],
-    ["Z", direction.z]
-  ];
-  const nonZero = axes.filter(([, value]) => Math.abs(value) > EPSILON);
-  const [axis] = nonZero;
-  if (nonZero.length === 1 && axis && Math.abs(Math.abs(axis[1]) - 1) < EPSILON) {
-    return `${axis[1] > 0 ? "+" : "\u2212"}${axis[0]}`;
-  }
-  return axes.map(([, value]) => trim(value)).join(", ");
-};
-
 // src/model/dfm-metrics.ts
 var define = ({ start, path, ...spec }) => ({
   ...spec,
@@ -488,7 +488,7 @@ var FEATURE_METRICS = [
     op: "gte",
     start: { mm: 500, inch: 508 },
     path: ["facts.wallLength.length", "facts.length"],
-    kinds: ["Pocket", "Boss", "Wall", "Profile"],
+    kinds: ["Pocket", "Boss", "Wall", "CircularWall", "Profile"],
     hint: "How far a pass around its outline travels, with a tool of no width"
   }),
   define({
@@ -980,11 +980,11 @@ var GROUP_SUBJECTS = [
   { value: "pocket", label: "Pockets", group: "Groups", kinds: POCKET_KINDS },
   { value: "slot", label: "Slots", group: "Groups", kinds: UNDERCUT_KINDS },
   { value: "undercut", label: "Undercuts", group: "Groups", kinds: UNDERCUT_KINDS },
-  { value: "boss", label: "Bosses", group: "Groups", kinds: ["Boss"] },
+  { value: "boss", label: "Bosses", group: "Groups", kinds: ["Boss", "CircularWall"] },
   { value: "countersink", label: "Countersinks", group: "Groups", kinds: ["Hole", "Chamfer"] },
   { value: "profile", label: "Profiles", group: "Groups", kinds: ["Profile"] },
   { value: "contour", label: "3D surfaces", group: "Groups", kinds: SURFACE_KINDS },
-  { value: "wall", label: "Walls", group: "Groups", kinds: ["Wall"] },
+  { value: "wall", label: "Walls", group: "Groups", kinds: ["Wall", "CircularWall"] },
   { value: "face", label: "Faces", group: "Groups", kinds: ["Face", "Three"] },
   { value: "fillet", label: "Fillets", group: "Groups", kinds: SURFACE_KINDS },
   { value: "chamfer", label: "Chamfers", group: "Groups", kinds: ["Chamfer"] }
@@ -1007,6 +1007,7 @@ var TYPES = [
   ["filleted_open_pocket", "Filleted open pockets", POCKET_KINDS],
   ["boss", "Bosses", ["Boss"]],
   ["filleted_boss", "Filleted bosses", ["Boss"]],
+  ["circular_wall", "Circular walls", ["CircularWall"]],
   ["wall", "Wall features", ["Wall"]],
   ["face", "Face features", ["Face"]],
   ["slanted_face", "Slanted faces", ["Face", "Three"]],
@@ -1100,8 +1101,8 @@ import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
 var LENGTH_PLACES = { mm: 3, inch: 3 };
 var FIELD_LENGTH_PLACES = { mm: 3, inch: 4 };
 var UNIT_LABELS = { mm: "mm", inch: "in" };
-var inUnits = (mm, units) => units === "inch" ? mm / MM_PER_INCH2 : mm;
-var lengthValue = (mm, units) => inUnits(mm, units).toFixed(LENGTH_PLACES[units]);
+var inUnits = (mm2, units) => units === "inch" ? mm2 / MM_PER_INCH2 : mm2;
+var lengthValue = (mm2, units) => inUnits(mm2, units).toFixed(LENGTH_PLACES[units]);
 var unitLabel = (units) => UNIT_LABELS[units];
 
 // src/model/dfm-rules.ts
@@ -1129,8 +1130,8 @@ var RULE_COLORS = [
 ];
 var compareColors = (a, b) => {
   const rank = (color) => {
-    const at = RULE_COLORS.findIndex((each) => each.value === color);
-    return at === -1 ? RULE_COLORS.length : at;
+    const at2 = RULE_COLORS.findIndex((each) => each.value === color);
+    return at2 === -1 ? RULE_COLORS.length : at2;
   };
   return rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0);
 };
@@ -1176,7 +1177,7 @@ var quantityUnit = (quantity, units) => {
       return "";
   }
 };
-var withUnit = (value, unit) => unit === "" ? value : unit === "\xB0" || unit === "%" ? `${value}${unit}` : `${value} ${unit}`;
+var withUnit = (value, unit2) => unit2 === "" ? value : unit2 === "\xB0" || unit2 === "%" ? `${value}${unit2}` : `${value} ${unit2}`;
 var toUnits = (quantity, value, units) => units !== "inch" ? value : quantity === "length" ? value / MM_PER_INCH3 : quantity === "area" ? value / SQUARE_MM_PER_SQUARE_INCH : value;
 var toField = (quantity, value, units) => {
   const shown = toUnits(quantity, value, units);
@@ -1215,8 +1216,8 @@ var describeRule = (rule, units, vocabulary = MILLING_RULES) => {
   if (!info) return subject;
   if (info.quantity === "presence") return `${subject}, ${info.label}`;
   if (info.quantity === "flag") return `${subject} with ${info.label}`;
-  const unit = quantityUnit(info.quantity, units);
-  const shown = (value) => withUnit(toField(info.quantity, value, units), unit);
+  const unit2 = quantityUnit(info.quantity, units);
+  const shown = (value) => withUnit(toField(info.quantity, value, units), unit2);
   return rule.op === "between" ? `${subject} with ${shown(rule.value)} ${lowOf(rule) === "gt" ? "<" : "\u2264"} ${info.label} ${opSymbol(highOf(rule))} ${shown(upperOf(rule))}` : `${subject} with ${info.label} ${opSymbol(rule.op)} ${shown(rule.value)}`;
 };
 var newRuleId = () => Math.random().toString(36).slice(2, 10);
@@ -1298,6 +1299,988 @@ var parseRule = (raw, vocabulary) => {
 };
 var parseRules = (raw, vocabulary = MILLING_RULES) => Array.isArray(raw) ? raw.flatMap((each) => parseRule(each, vocabulary) ?? []) : null;
 
+// src/model/dfm-explain.ts
+var figureless = (hit) => hit.metric.quantity === "flag" || hit.metric.quantity === "presence";
+var hitFigure = (hit, units) => figureless(hit) ? "" : formatMeasured(hit.metric.quantity, hit.value, units);
+
+// src/model/broken-rules.ts
+var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
+var worstHits = (hits) => {
+  const seen = /* @__PURE__ */ new Set();
+  return byColor(hits).filter((hit) => {
+    if (seen.has(hit.metric.key)) return false;
+    seen.add(hit.metric.key);
+    return true;
+  });
+};
+var brokenRules = (check, tag, units, vocabulary = MILLING_RULES) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
+  const figure = hitFigure(hit, units);
+  return {
+    key: hit.rule.id,
+    color: hit.rule.color,
+    text: describeRule(hit.rule, units, vocabulary),
+    ...figure ? { figure } : {}
+  };
+});
+var featureColor = (check, tag, region = null) => {
+  const key = tag.toLowerCase();
+  const face = region === null ? void 0 : check.paintedFaces.get(region);
+  if (face && face.tag.toLowerCase() === key) return face.color;
+  const whole = check.paintedWhole.get(key);
+  if (whole) return whole.color;
+  if (!check.required.has(key)) return void 0;
+  return byColor(check.hitsByTag.get(key) ?? [])[0]?.rule.color;
+};
+
+// src/model/dfm-flags.ts
+var howCut = (sheet) => {
+  const drilled = isDrilled(sheet);
+  return { drilled, milled: !drilled };
+};
+var featureIs = (subject, featureType, sheet) => {
+  const type = featureType.toLowerCase();
+  const kind = sheet?.kind?.toLowerCase() ?? "";
+  const boss = sheet?.standsOnAFloor === true;
+  if (subject.startsWith(TYPE_SUBJECT)) return type === subject.slice(TYPE_SUBJECT.length);
+  switch (subject) {
+    case "any":
+      return true;
+    case "milled":
+      return howCut(sheet).milled;
+    case "drilled":
+      return howCut(sheet).drilled;
+    case "hole":
+      return type.includes("hole") || kind === "hole";
+    case "threadedHole":
+      return sheet?.threading !== void 0;
+    case "pocket":
+      return type.includes("pocket") || kind === "pocket";
+    case "slot":
+      return type.includes("slot") || kind === "tslot";
+    case "undercut":
+      return kind === "tslot" || type.includes("undercut") || type.includes("tslot");
+    case "contour":
+      return type.includes("contour") || kind.includes("contour");
+    case "wall":
+      return !boss && (type.includes("wall") || kind === "wall");
+    case "face":
+      return type === "face" || kind === "face";
+    case "fillet":
+      return type.split("_").includes("fillet") || kind.includes("fillet");
+    case "chamfer":
+      return type.includes("chamfer") || kind === "chamfer";
+    case "boss":
+      return boss || type.includes("boss") || kind === "boss";
+    case "countersink":
+      return type === "sink";
+    case "profile":
+      return type === "profile" || kind === "profile";
+    default:
+      return false;
+  }
+};
+var at = (record2, path) => path.split(".").reduce(
+  (value, key) => typeof value === "object" && value !== null ? value[key] : void 0,
+  record2
+);
+var readPath = (datasheet, metric) => {
+  for (const path of metric.path ?? []) {
+    const value = at(datasheet, path);
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (metric.quantity === "flag") return 1;
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    return null;
+  }
+  return metric.quantity === "flag" && metric.path ? 0 : null;
+};
+var TILT = 1e-6;
+var isTilted = ({ x, y, z }) => [x, y, z].filter((each) => Math.abs(each) > TILT).length > 1;
+var featureMeasure = (metric, features, feature, { sheets, datasheets, regionAreas }) => {
+  const tag = feature.tag.toLowerCase();
+  const sheet = sheets[tag];
+  const datasheet = datasheets[tag];
+  const positive = (value) => value !== void 0 && value > 0 ? { value } : null;
+  switch (metric.key) {
+    case "present":
+      return { value: 1 };
+    case "tilted":
+      return { value: isTilted(feature.machiningDirection) ? 1 : 0 };
+    case "faceCount":
+      return { value: new Set(feature.regionIdxs).size };
+    case "ld": {
+      const ld = featureLd(features, feature, sheets);
+      return ld ? { value: ld.ratio, drilling: ld.drilling } : null;
+    }
+    case "featureLd": {
+      const ld = featureLd(features, feature, sheets);
+      return ld?.featureRatio !== void 0 ? { value: ld.featureRatio, drilling: ld.drilling } : null;
+    }
+    case "depthBelowTop": {
+      const top = partTop(features, sheets, feature.machiningDirection);
+      return top !== null && sheet?.zMin !== void 0 ? { value: top - sheet.zMin } : null;
+    }
+    case "featureDepth":
+      return sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? { value: sheet.zMax - sheet.zMin } : null;
+    // Zero is no measure at all for these: no bore, no tool, a sharp floor rather than a tiny fillet.
+    case "diameter":
+      return positive(sheet?.diameter);
+    // Zero is a measure here: a sharp corner, which a "radius ≤" rule is most of all about.
+    case "cornerRadius":
+      return sheet?.cornerRadius === void 0 ? null : { value: sheet.cornerRadius };
+    case "maxTool":
+      return positive(sheet?.maxTool);
+    case "floorFillet":
+      return positive(sheet?.filletRadius);
+    case "sharpCorner":
+      return sheet ? { value: sheet.sharpCorners ? 1 : 0 } : null;
+    case "noToolFits":
+      return sheet ? { value: sheet.noToolFits ? 1 : 0 } : null;
+    case "pinchPoints": {
+      const points = at(datasheet, "pinchPoints");
+      return Array.isArray(points) ? { value: points.length } : null;
+    }
+    // A disc under a hundredth is a sharp corner, which `sharpCorner` is for: see `pinchDiameter`.
+    case "pinchDiameter":
+      return positive(sheet?.pinchDiameter);
+    case "reachHeight": {
+      const heights = at(datasheet, "reachCurve.verticalOffset");
+      const numbers2 = Array.isArray(heights) ? heights.filter(
+        (each) => typeof each === "number" && Number.isFinite(each)
+      ) : [];
+      return numbers2.length > 0 ? { value: Math.max(...numbers2) } : null;
+    }
+    case "surfaceArea": {
+      const areas = at(datasheet, "areas");
+      if (typeof areas === "object" && areas !== null) {
+        const parts = Object.values(areas).filter(
+          (each) => typeof each === "number" && Number.isFinite(each)
+        );
+        if (parts.length > 0) return { value: parts.reduce((sum, each) => sum + each, 0) };
+      }
+      const faces = [...new Set(feature.regionIdxs)].flatMap(
+        (region) => regionAreas.get(region) ?? []
+      );
+      return faces.length > 0 ? { value: faces.reduce((sum, each) => sum + each, 0) } : null;
+    }
+    default: {
+      if (!datasheet) return null;
+      const value = readPath(datasheet, metric);
+      return value === null ? null : { value };
+    }
+  }
+};
+var featureHits = (features, feature, sources, rules) => {
+  const sheet = sources.sheets[feature.tag.toLowerCase()];
+  return rules.flatMap((rule) => {
+    const info = metricInfo(rule.metric);
+    if (!info || !featureIs(rule.subject, feature.featureType, sheet)) return [];
+    const measured = featureMeasure(info, features, feature, sources);
+    if (!measured || !breaks(rule, info.quantity, measured.value)) return [];
+    return [{ rule, metric: info, ...measured }];
+  });
+};
+var requiredTags = (features) => {
+  const owners = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const region of new Set(feature.regionIdxs))
+      owners.set(region, (owners.get(region) ?? 0) + 1);
+  }
+  return new Set(
+    features.filter((feature) => feature.regionIdxs.some((region) => owners.get(region) === 1)).map((feature) => feature.tag.toLowerCase())
+  );
+};
+var worstColor = (hits) => hits?.map((hit) => hit.rule.color).sort(compareColors)[0];
+var ruleResults = (rules, features, hitsByTag, required) => rules.map((rule) => {
+  const hits = features.flatMap((feature) => {
+    const tag = feature.tag.toLowerCase();
+    const hit = hitsByTag.get(tag)?.find((each) => each.rule.id === rule.id);
+    return hit ? [{ tag: feature.tag, value: hit.value, metric: hit.metric, required: required.has(tag) }] : [];
+  });
+  const [first] = hits;
+  const up = first ? worseUpward(rule, first.metric) : true;
+  hits.sort((a, b) => up ? b.value - a.value : a.value - b.value);
+  return {
+    rule,
+    tags: hits.filter((hit) => hit.required).map((hit) => hit.tag),
+    otherTags: hits.filter((hit) => !hit.required).map((hit) => hit.tag)
+  };
+});
+var QUALIFIERS = ["undercut", "filleted", "tslot", "dovetail"];
+var EDGE_TYPES = ["fillet", "chamfer", "sink"];
+var featureComplexity = (featureType) => {
+  const words = featureType.toLowerCase().split("_");
+  const edge = EDGE_TYPES.some((type) => words.includes(type)) ? 1 : 0;
+  return edge + QUALIFIERS.filter((word) => words.includes(word)).length;
+};
+var CONTOUR = "contour_surface";
+var unavoidableFaces = (features, hitsByTag, regionAreas) => {
+  const areaOf = (feature) => [...new Set(feature.regionIdxs)].reduce(
+    (sum, region) => sum + (regionAreas.get(region) ?? 0),
+    0
+  );
+  const owners = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const region of new Set(feature.regionIdxs)) {
+      owners.set(region, [...owners.get(region) ?? [], feature]);
+    }
+  }
+  const faces = /* @__PURE__ */ new Map();
+  const whole = /* @__PURE__ */ new Map();
+  for (const [region, candidates] of owners) {
+    const colored = candidates.map((feature) => ({
+      feature,
+      color: worstColor(hitsByTag.get(feature.tag.toLowerCase())),
+      area: areaOf(feature)
+    }));
+    const isContour = ({ feature }) => feature.featureType === CONTOUR;
+    const machined = colored.filter((each) => !isContour(each));
+    const pool = machined.length > 0 ? machined : colored;
+    if (pool.some(({ color }) => color === void 0)) continue;
+    const contour = colored.filter(isContour).reduce((kept, each) => kept === void 0 || each.area > kept.area ? each : kept, void 0);
+    if (contour?.color && colored.every(({ color }) => color !== void 0)) {
+      whole.set(contour.feature.tag.toLowerCase(), {
+        tag: contour.feature.tag,
+        color: contour.color
+      });
+      continue;
+    }
+    const best = pool.reduce((kept, each) => {
+      const plainer = featureComplexity(kept.feature.featureType) - featureComplexity(each.feature.featureType);
+      if (plainer !== 0) return plainer > 0 ? each : kept;
+      const milder = compareColors(each.color ?? "", kept.color ?? "");
+      return milder > 0 || milder === 0 && each.area > kept.area ? each : kept;
+    });
+    if (best.color) faces.set(region, { tag: best.feature.tag, color: best.color });
+  }
+  return { paintedFaces: faces, paintedWhole: whole };
+};
+var withSurroundedFaces = (check, features, adjacency) => {
+  const paintedFor = new Map(check.paintedFaces);
+  const regionsOf2 = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = feature.tag.toLowerCase();
+    regionsOf2.set(key, new Set(feature.regionIdxs));
+    const whole = check.paintedWhole.get(key);
+    if (whole) {
+      for (const region of feature.regionIdxs)
+        if (!paintedFor.has(region)) paintedFor.set(region, whole);
+    }
+  }
+  const surrounded = /* @__PURE__ */ new Map();
+  for (const [region, neighbours] of adjacency) {
+    if (paintedFor.has(region)) continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const neighbour of neighbours) {
+      const paint2 = neighbour === region ? void 0 : paintedFor.get(neighbour);
+      if (!paint2) continue;
+      const key = paint2.tag.toLowerCase();
+      counts.set(key, { paint: paint2, count: (counts.get(key)?.count ?? 0) + 1 });
+    }
+    const most = Math.max(0, ...[...counts.values()].map(({ count }) => count));
+    const [paint] = [...counts].filter(([key, { count }]) => count === most && regionsOf2.get(key)?.has(region)).map(([, { paint: paint2 }]) => paint2).sort((a, b) => compareColors(a.color, b.color));
+    if (paint) surrounded.set(region, paint);
+  }
+  if (surrounded.size === 0) return check;
+  return { ...check, paintedFaces: new Map([...check.paintedFaces, ...surrounded]) };
+};
+var checkPart = (features, sources, rules) => {
+  const required = requiredTags(features);
+  const hitsByTag = new Map(
+    features.map((feature) => [
+      feature.tag.toLowerCase(),
+      featureHits(features, feature, sources, rules)
+    ])
+  );
+  return {
+    hitsByTag,
+    required,
+    byRule: ruleResults(rules, features, hitsByTag, required),
+    ...unavoidableFaces(features, hitsByTag, sources.regionAreas)
+  };
+};
+
+// src/model/pinch.ts
+var asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf = (value) => typeof value === "object" && value !== null ? value : {};
+var clearanceFit = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const facts = recordOf(sheet.facts);
+  const chamfer = facts.kind === "Chamfer";
+  const band = recordOf(chamfer ? recordOf(facts.three).cd : facts.cd);
+  const tolerance = recordOf(sheet.toleranceBand);
+  const strict = asNumber(recordOf(band.ignore).min);
+  if (strict === void 0) return void 0;
+  const bandPath = chamfer ? "facts.three.cd" : "facts.cd";
+  const loose = asNumber(recordOf(band.deviate).min);
+  const atStrict = asNumber(tolerance.atolIgnore);
+  const atLoose = asNumber(tolerance.atolDeviate);
+  const source = { bandPath, strict, loose, atStrict, atLoose };
+  if (loose === void 0 || atStrict === void 0 || atLoose === void 0 || atLoose <= atStrict)
+    return { ...source, slack: 0, resolved: false };
+  const growth = (loose - strict) / (atLoose - atStrict);
+  const slack = growth > 0 ? Math.min(growth * atStrict, strict) : 0;
+  return { ...source, slack, resolved: true };
+};
+var readPinch = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const zMin = asNumber(sheet.zMin);
+  const zMax = asNumber(sheet.zMax);
+  if (zMin === void 0 || zMax === void 0 || !Array.isArray(sheet.pinchPoints)) return null;
+  const fit = clearanceFit(datasheet);
+  const slack = fit?.slack ?? 0;
+  const discs = sheet.pinchPoints.flatMap((point) => {
+    const centre = recordOf(recordOf(point).center);
+    const x = asNumber(centre.x);
+    const y = asNumber(centre.y);
+    const diameter = asNumber(recordOf(point).diameter);
+    return x === void 0 || y === void 0 || diameter === void 0 || diameter < 0 ? [] : [{ x, y, diameter: Math.max(diameter - slack, 0) }];
+  });
+  if (discs.length === 0) return null;
+  return { discs, zMin, zMax, ...fit && !fit.resolved ? { unresolved: true } : {} };
+};
+
+// src/model/feature-sheet.ts
+var SHARP_MM = 0.1;
+var SHARP_RADIUS_MM = 0.01;
+var PINCH_TOOL_MM = 0.01;
+var asNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf2 = (value) => typeof value === "object" && value !== null ? value : {};
+var definedOnly = (fields) => Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+var undercutOf = (facts) => {
+  const unmeasured = facts.isInvalidGeometry === true || recordOf2(facts.cd).measurementFailed === true ? true : void 0;
+  if (facts.kind === "Tslot")
+    return definedOnly({
+      undercutDepth: asNumber2(facts.undercutDepth),
+      maxEntry: asNumber2(facts.maxEntryCd),
+      isClosed: facts.isClosed === true ? true : void 0,
+      unmeasured
+    });
+  if (facts.kind === "Dovetail")
+    return definedOnly({
+      taperDeg: asNumber2(facts.taperDeg),
+      floorWidth: asNumber2(facts.floorWidth),
+      topOpeningWidth: asNumber2(facts.topOpeningWidth),
+      isExternal: facts.isExternal === true ? true : void 0,
+      unmeasured
+    });
+  return void 0;
+};
+var threadingOf = (facts) => {
+  const spec = recordOf2(recordOf2(facts.threading).spec);
+  const basicDiameter = asNumber2(spec.basicDiameter);
+  const threadPitch = asNumber2(spec.threadPitch);
+  if (basicDiameter === void 0 || threadPitch === void 0 || threadPitch <= 0) return void 0;
+  return { basicDiameter, threadPitch };
+};
+var noToolFits = (band) => {
+  const { max } = band;
+  if (typeof max === "string") return /^-inf/i.test(max.trim());
+  return typeof max === "number" && (max === Number.NEGATIVE_INFINITY || Number.isFinite(max) && max < SHARP_MM);
+};
+var insideCornerRadius = (fit) => Math.max((fit.strict - fit.slack) / 2, 0);
+var pinchCentres = (points) => Array.isArray(points) ? points.flatMap((point) => {
+  const centre = recordOf2(recordOf2(point).center);
+  const x = asNumber2(centre.x);
+  const y = asNumber2(centre.y);
+  return x === void 0 || y === void 0 ? [] : [{ x, y }];
+}) : [];
+var ZERO_MM = 5e-5;
+var isCutterlessTslot = (datasheet) => {
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  if (facts.kind !== "Tslot") return false;
+  const leaves = (value) => typeof value === "object" && value !== null ? Object.values(value).flatMap(leaves) : [value];
+  const band = leaves(facts.cd);
+  return band.length > 0 && band.every((each) => {
+    const value = typeof each === "string" && each.trim() !== "" ? Number(each) : each;
+    return typeof value === "number" && Math.abs(value) < ZERO_MM;
+  });
+};
+var isSharpCorneredFillet = (featureType, datasheet) => {
+  if (typeof featureType !== "string" || !featureType.toLowerCase().split("_").includes("fillet"))
+    return false;
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  return facts.hasSharpCorner === true || recordOf2(facts.three).hasSharpCorner === true;
+};
+var isNoReading = (featureType, datasheet) => isCutterlessTslot(datasheet) || isSharpCorneredFillet(featureType, datasheet);
+var featureSheet = (datasheet) => {
+  const sheet = recordOf2(datasheet);
+  const facts = recordOf2(sheet.facts);
+  const kind = typeof facts.kind === "string" ? facts.kind : void 0;
+  const band = recordOf2(kind === "Chamfer" ? recordOf2(facts.three).cd : facts.cd);
+  const ignoreBand = recordOf2(band.ignore);
+  const fit = clearanceFit(datasheet);
+  const fields = {
+    kind,
+    zMin: asNumber2(sheet.zMin),
+    zMax: asNumber2(sheet.zMax),
+    extendedZMax: asNumber2(sheet.extendedZMax),
+    maxTool: asNumber2(ignoreBand.min),
+    diameter: kind === "Hole" ? asNumber2(facts.diameter) : void 0,
+    tipAngle: kind === "Hole" ? asNumber2(facts.fullConeDeg) : void 0,
+    filletRadius: asNumber2(facts.filletRadius),
+    // A bevel's angle wherever the facts carry one: a chamfer's, and any other kind that bevels.
+    chamferAngle: asNumber2(recordOf2(facts.bevel).angleDeg)
+  };
+  const toolFitPath = facts.toolFit !== void 0 ? "facts.toolFit" : "facts.three.toolFit";
+  const toolFit = recordOf2(facts.toolFit ?? recordOf2(facts.three).toolFit);
+  fields.fitToolDiameter = asNumber2(toolFit.toolDiameter);
+  fields.fitCornerRadius = asNumber2(toolFit.cornerRadius);
+  const ballOnly = (facts.useOnlyBallToolsForFinish ?? recordOf2(facts.three).useOnlyBallToolsForFinish) === true;
+  const standsOnAFloor = kind === "CircularWall" && facts.standsOnAFloor === true;
+  const measured = Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== void 0)
+  );
+  const cramped = Object.keys(ignoreBand).length > 0 && noToolFits(ignoreBand);
+  const walled = kind !== "Hole" && sheet.hasWall === true;
+  const clearance = walled ? fit : void 0;
+  const cornerRadius = clearance ? insideCornerRadius(clearance) : void 0;
+  const sharp = cornerRadius !== void 0 && cornerRadius < SHARP_RADIUS_MM && !cramped;
+  const threading = kind === "Hole" ? threadingOf(facts) : void 0;
+  const undercut = undercutOf(facts);
+  const pinched = (readPinch(datasheet)?.discs ?? []).filter(
+    (disc) => disc.diameter >= PINCH_TOOL_MM
+  );
+  return {
+    ...measured,
+    ...pinched.length > 0 ? {
+      pinchDiameter: Math.min(...pinched.map((disc) => disc.diameter)),
+      pinchPlaces: pinched.length
+    } : {},
+    ...cornerRadius !== void 0 ? { cornerRadius } : {},
+    ...clearance && !clearance.resolved ? { cornerRadiusUnresolved: true } : {},
+    ...clearance ? { clearance } : {},
+    ...Object.keys(toolFit).length > 0 ? { toolFitPath } : {},
+    ...sharp ? { sharpCorners: pinchCentres(sheet.pinchPoints) } : {},
+    ...cramped ? { noToolFits: true } : {},
+    ...ballOnly ? { ballOnly: true } : {},
+    ...standsOnAFloor ? { standsOnAFloor: true } : {},
+    ...threading ? { threading } : {},
+    ...undercut ? { undercut } : {}
+  };
+};
+
+// src/model/feature-details.ts
+import { MM_PER_INCH as MM_PER_INCH4 } from "@toolpath/tool-support";
+var mm = (value) => `${trim3(value, 4)} mm`;
+var tol = (value) => `${trim3(value, 6)} mm`;
+var clearanceDerivation = (fit, clearance) => {
+  const { bandPath, strict, loose, atStrict, atLoose } = fit;
+  const lines = [`\u2300\u2081 = ${bandPath}.ignore.min = ${mm(strict)}`];
+  if (loose === void 0 || atStrict === void 0 || atLoose === void 0 || atLoose <= atStrict) {
+    lines.push(
+      `${bandPath}.deviate.min or a tolerance is missing, so the tolerance cannot be taken out:`,
+      `clearance \u2264 \u2300\u2081 = ${mm(clearance)}`
+    );
+    return lines;
+  }
+  const growth = (loose - strict) / (atLoose - atStrict);
+  lines.push(
+    `   at t\u2081 = toleranceBand.atolIgnore = ${tol(atStrict)}`,
+    `\u2300\u2082 = ${bandPath}.deviate.min = ${mm(loose)}`,
+    `   at t\u2082 = toleranceBand.atolDeviate = ${tol(atLoose)}`
+  );
+  if (growth <= 0) {
+    lines.push("The tool does not grow with tolerance (a gap, not a corner): clearance = \u2300\u2081");
+  } else {
+    lines.push(
+      `k = (\u2300\u2082 \u2212 \u2300\u2081) / (t\u2082 \u2212 t\u2081) = ${trim3(growth, 3)}`,
+      `slack = k \xD7 t\u2081 = ${mm(growth * atStrict)}, what the tolerance adds to every tool`,
+      `clearance = \u2300\u2081 \u2212 slack`
+    );
+  }
+  lines.push(`clearance = ${mm(clearance)}`);
+  return lines;
+};
+var trim3 = (value, places) => String(Number(value.toFixed(places)));
+var formatLength = (mm2, units, inchMark = false) => units === "inch" ? `${trim3(mm2 / MM_PER_INCH4, LENGTH_PLACES.inch)}${inchMark ? '"' : " in"}` : `${trim3(mm2, LENGTH_PLACES.mm)} mm`;
+var SURFACE_TYPES = /* @__PURE__ */ new Set([
+  "contour_surface",
+  "inner_fillet",
+  "outer_fillet",
+  "fillet"
+]);
+var isSurfaceType = (featureType) => SURFACE_TYPES.has(featureType);
+var maxBallDiameter = (sheet) => {
+  const { fitToolDiameter: diameter, fitCornerRadius: corner } = sheet;
+  if (corner === void 0 || corner <= 0) return void 0;
+  return diameter !== void 0 && diameter > 0 ? Math.min(diameter, 2 * corner) : 2 * corner;
+};
+var ROW_ORDER = [
+  "featureDepth",
+  "undercutWidth",
+  "floorWidth",
+  "openingWidth",
+  "undercutDepth",
+  "taper",
+  "diameter",
+  "cornerRadius",
+  "filletRadius",
+  "floorFillet",
+  "tipAngle",
+  "thread",
+  "bevelAngle",
+  "finishTool",
+  "undercutCutter",
+  "maxShaft",
+  "pinch",
+  "fitCornerRadius",
+  "maxBull",
+  "maxBall",
+  "depthBelowTop",
+  "ld",
+  "featureLd",
+  "topLd"
+];
+var featureMeasurements = ({
+  features,
+  feature,
+  sheets,
+  units,
+  inchMark = false
+}) => {
+  const other = units === "inch" ? "mm" : "inch";
+  const length = (mm2) => ({
+    value: formatLength(mm2, units, inchMark),
+    alt: formatLength(mm2, other, inchMark)
+  });
+  const sheet = sheets[feature.tag.toLowerCase()];
+  const rows = [];
+  const undercut = sheet?.undercut;
+  const top = sheet ? partTop(features, sheets, feature.machiningDirection) : null;
+  const bottom = sheet?.zMin;
+  const topFrom = top === null ? void 0 : features.find((each) => sheets[each.tag.toLowerCase()]?.extendedZMax === top);
+  const topLine = top === null ? "" : `Top of part = the highest extendedZMax of the features machined from this direction = ${mm(top)}${topFrom ? ` (${featureTypeLabel(topFrom.featureType)} ${topFrom.tag})` : ""}`;
+  if (top !== null && bottom !== void 0) {
+    rows.push({
+      key: "depthBelowTop",
+      label: "Depth below top of part",
+      milling: true,
+      ...length(top - bottom),
+      derivation: [topLine, `Top \u2212 zMin = ${mm(top)} \u2212 ${mm(bottom)} = ${mm(top - bottom)}`]
+    });
+  }
+  if (sheet?.zMax !== void 0 && bottom !== void 0 && !(undercut && sheet?.kind === "Tslot")) {
+    rows.push({
+      key: "featureDepth",
+      label: "Feature depth",
+      ...length(sheet.zMax - bottom),
+      derivation: [`zMax \u2212 zMin = ${mm(sheet.zMax)} \u2212 ${mm(bottom)} = ${mm(sheet.zMax - bottom)}`]
+    });
+  }
+  if (sheet?.diameter !== void 0) {
+    rows.push({
+      key: "diameter",
+      label: "Diameter",
+      ...length(sheet.diameter),
+      derivation: [`facts.diameter = ${mm(sheet.diameter)}`]
+    });
+  }
+  if (sheet?.cornerRadius !== void 0 && !undercut) {
+    const radius = length(sheet.cornerRadius);
+    rows.push({
+      key: "cornerRadius",
+      label: sheet.sharpCorners ? "Minimum radius (sharp)" : "Minimum radius",
+      // Measured at one tolerance only, it is the most the modelled radius can be, not the radius itself.
+      ...sheet.cornerRadiusUnresolved ? { value: `\u2264 ${radius.value}`, alt: `\u2264 ${radius.alt}` } : radius,
+      derivation: [
+        "The tightest corner between walls: half the minimum clearance, the widest tool that reaches every point with the tolerance it was measured to taken out.",
+        ...sheet.clearance ? clearanceDerivation(sheet.clearance, 2 * sheet.cornerRadius) : [],
+        `R = clearance / 2 = ${mm(sheet.cornerRadius)}${sheet.sharpCorners ? " (under 0.01 mm: sharp)" : ""}`
+      ]
+    });
+  }
+  if (!sheet?.sharpCorners && !undercut) {
+    const clearance = sheet?.pinchDiameter ?? (sheet?.cornerRadius !== void 0 ? 2 * sheet.cornerRadius : void 0);
+    if (clearance !== void 0) {
+      const width = length(clearance);
+      const places = sheet?.pinchPlaces;
+      const floor = !SURFACE_TYPES.has(feature.featureType) && sheet?.filletRadius !== void 0 && sheet.filletRadius > 0 ? length(sheet.filletRadius) : void 0;
+      const atMost = sheet?.cornerRadiusUnresolved ? "\u2264 " : "";
+      rows.push({
+        key: "pinch",
+        label: "Max tool diameter",
+        milling: true,
+        // Measured at one tolerance only, it is the most the clearance can be, not the clearance itself.
+        value: `${atMost}\u2300 ${width.value}${floor ? ` \xB7 R ${floor.value}` : ""}`,
+        alt: `${atMost}\u2300 ${width.alt}${floor ? ` \xB7 R ${floor.alt}` : ""}`,
+        derivation: [
+          "The widest circle that fits where the feature is tightest: twice an inside corner\u2019s radius, or the width of a gap between walls.",
+          ...places !== void 0 ? [
+            `pinchPoints: where the feature narrows to its tightest clearance, a disc each; ${places} ${places === 1 ? "place" : "places"} that tight, the tightest drawn.`,
+            `min(pinchPoints[].diameter) is the cutter band\u2019s min, measured to a tolerance (t) the widest tool grows with: run back to none from two tolerances.`
+          ] : [
+            "No pinch points reported: the cutter band\u2019s min, measured to a tolerance (t) the widest tool grows with, run back to none from two tolerances."
+          ],
+          ...sheet?.clearance ? clearanceDerivation(sheet.clearance, clearance) : [],
+          ...floor && sheet?.filletRadius !== void 0 ? [
+            `A bull nose, its corner radius the floor fillet\u2019s: facts.filletRadius = ${mm(sheet.filletRadius)}`
+          ] : []
+        ]
+      });
+    }
+  }
+  if (sheet && undercut) rows.push(...undercutRows(sheet, undercut, top, length));
+  const surface = SURFACE_TYPES.has(feature.featureType);
+  if (surface && sheet) {
+    const diameter = sheet.fitToolDiameter;
+    const corner = sheet.fitCornerRadius;
+    const fit = sheet.toolFitPath ?? "facts.toolFit";
+    const ball = maxBallDiameter(sheet);
+    rows.push({
+      key: "finishTool",
+      label: "Finishing tool",
+      milling: true,
+      value: sheet.ballOnly ? "Ball end mill" : "Ball or bull nose",
+      derivation: [
+        `facts.useOnlyBallToolsForFinish (or facts.three.\u2026) is ${sheet.ballOnly ? "true" : "not true"}`
+      ]
+    });
+    if (corner !== void 0 && corner > 0) {
+      rows.push({
+        key: "fitCornerRadius",
+        label: "Max corner radius",
+        milling: true,
+        ...length(corner),
+        derivation: [
+          "The tightest the surface turns inward: a tool with a larger corner radius cannot follow it.",
+          `${fit}.cornerRadius = ${mm(corner)}`
+        ]
+      });
+    }
+    const sized = diameter !== void 0 && diameter > 0;
+    if (!sheet.ballOnly && corner !== void 0 && corner > 0 && (!sized || ball === void 0 || ball < diameter)) {
+      const size = sized ? length(diameter) : void 0;
+      const radius = length(corner);
+      rows.push({
+        key: "maxBull",
+        label: "Max bull nose",
+        milling: true,
+        // Drawable only at a diameter the fit gives: "any" is no size to draw.
+        ...sized ? { tool: "bull" } : {},
+        value: `${size ? `\u2300 ${size.value}` : "any \u2300"} \xB7 R ${radius.value}`,
+        alt: `${size ? `\u2300 ${size.alt}` : "any \u2300"} \xB7 R ${radius.alt}`,
+        derivation: [
+          sized ? "The largest full-diameter tool the surface\u2019s shape admits, with the largest corner radius it admits." : "The surface limits only the tool\u2019s corner radius, not its diameter: a bull nose of any size with a corner no larger than this.",
+          ...sized ? [`\u2300 = ${fit}.toolDiameter = ${mm(diameter)}`] : [`${fit}.toolDiameter is not reported`],
+          `R = ${fit}.cornerRadius = ${mm(corner)}`
+        ]
+      });
+    }
+    if (ball !== void 0 && corner !== void 0) {
+      const size = length(ball);
+      rows.push({
+        key: "maxBall",
+        label: "Max ball nose",
+        milling: true,
+        tool: "ball",
+        value: `\u2300 ${size.value}`,
+        alt: `\u2300 ${size.alt}`,
+        derivation: [
+          "A ball\u2019s corner radius is half its diameter, so it must fit under the corner limit, and the diameter limit where there is one:",
+          ...diameter !== void 0 && diameter > 0 ? [
+            `min(${fit}.toolDiameter, 2 \xD7 ${fit}.cornerRadius)`,
+            `= min(${mm(diameter)}, ${mm(2 * corner)}) = ${mm(ball)}`
+          ] : [`2 \xD7 ${fit}.cornerRadius = ${mm(ball)} (${fit}.toolDiameter is not reported)`]
+        ]
+      });
+    }
+  }
+  const ld = undercut ? null : featureLd(features, feature, sheets);
+  if (ld && top !== null && bottom !== void 0) {
+    const across = ld.basis === "bore" ? `D = facts.diameter = ${mm(ld.across)}` : ld.basis === "pinch" ? `D = widest tool (the tightest pinch disc, tolerance taken out) = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""}` : `D = widest tool = 2 \xD7 inside corner radius = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""} (no pinch points reported)`;
+    const ratioOf = (depth) => {
+      const ratio2 = (depth / ld.across).toFixed(3);
+      return ld.atLeast ? `\u2265 ${ratio2}` : ratio2;
+    };
+    if (ld.drilling) {
+      rows.push({
+        key: "ld",
+        label: "Drilling L/D",
+        milling: true,
+        value: ratioOf(top - bottom),
+        derivation: [
+          `L = depth below top of part = ${mm(top - bottom)}`,
+          across,
+          `L / D = ${mm(top - bottom)} / ${mm(ld.across)} = ${ld.ratio.toFixed(3)}`
+        ]
+      });
+    } else {
+      if (sheet?.zMax !== void 0) {
+        rows.push({
+          key: "featureLd",
+          label: "Feature L/D",
+          milling: true,
+          value: ratioOf(sheet.zMax - bottom),
+          derivation: [
+            `L = feature depth = zMax \u2212 zMin = ${mm(sheet.zMax - bottom)}`,
+            across,
+            `L / D = ${mm(sheet.zMax - bottom)} / ${mm(ld.across)} = ${((sheet.zMax - bottom) / ld.across).toFixed(3)}`
+          ]
+        });
+      }
+      rows.push({
+        key: "topLd",
+        label: "L/D to top of part",
+        milling: true,
+        value: ratioOf(top - bottom),
+        derivation: [
+          `L = depth below top of part = ${mm(top - bottom)}`,
+          across,
+          `L / D = ${mm(top - bottom)} / ${mm(ld.across)} = ${ld.ratio.toFixed(3)}`
+        ]
+      });
+    }
+  }
+  if (sheet?.tipAngle !== void 0) {
+    const flat = Math.abs(sheet.tipAngle - 180) < 0.05;
+    rows.push({
+      key: "tipAngle",
+      label: "Tip angle",
+      value: `${trim3(sheet.tipAngle, 3)}\xB0${flat ? " (flat)" : ""}`,
+      derivation: [
+        `facts.fullConeDeg = ${trim3(sheet.tipAngle, 3)}\xB0${flat ? " (180\xB0: flat bottom)" : ""}`
+      ]
+    });
+  }
+  if (sheet?.threading) {
+    rows.push({
+      key: "thread",
+      label: "Thread",
+      value: `${formatLength(sheet.threading.basicDiameter, units, inchMark)} \xD7 ${formatLength(sheet.threading.threadPitch, units, inchMark)} pitch`,
+      derivation: [
+        `facts.threading.spec.basicDiameter = ${mm(sheet.threading.basicDiameter)}`,
+        `facts.threading.spec.threadPitch = ${mm(sheet.threading.threadPitch)}`
+      ]
+    });
+  }
+  if (surface) {
+    if (sheet?.filletRadius !== void 0 && sheet.filletRadius !== 0) {
+      rows.push({
+        key: "filletRadius",
+        label: "Fillet radius",
+        ...length(Math.abs(sheet.filletRadius)),
+        derivation: [
+          `|facts.filletRadius| = |${mm(sheet.filletRadius)}| (signed: + over an edge, \u2212 into a corner)`
+        ]
+      });
+    }
+  } else if (sheet?.filletRadius !== void 0 && sheet.filletRadius > 0) {
+    rows.push({
+      key: "floorFillet",
+      label: "Floor fillet radius",
+      ...length(sheet.filletRadius),
+      derivation: [`facts.filletRadius = ${mm(sheet.filletRadius)}`]
+    });
+  }
+  if (sheet?.chamferAngle !== void 0) {
+    rows.push({
+      key: "bevelAngle",
+      label: "Chamfer angle",
+      value: `${sheet.chamferAngle.toFixed(3)}\xB0`,
+      derivation: [`facts.bevel.angleDeg = ${trim3(sheet.chamferAngle, 3)}\xB0`]
+    });
+  }
+  return rows.sort((a, b) => ROW_ORDER.indexOf(a.key) - ROW_ORDER.indexOf(b.key));
+};
+var undercutRows = (sheet, undercut, top, length) => {
+  const rows = [];
+  const tslot = sheet.kind === "Tslot";
+  const { zMin, zMax } = sheet;
+  const { floorWidth: floor, topOpeningWidth: opening } = undercut;
+  const angle = undercut.taperDeg !== void 0 ? `${trim3(undercut.taperDeg, 3)}\xB0` : void 0;
+  if (tslot && zMin !== void 0 && zMax !== void 0) {
+    rows.push({
+      key: "undercutWidth",
+      label: "Undercut width",
+      ...length(zMax - zMin),
+      derivation: [
+        "The groove\u2019s height along the tool: the widest cutter it takes in one pass.",
+        `zMax \u2212 zMin = ${mm(zMax)} \u2212 ${mm(zMin)} = ${mm(zMax - zMin)}`
+      ]
+    });
+  }
+  if (floor !== void 0) {
+    rows.push({
+      key: "floorWidth",
+      label: "Floor width",
+      ...length(floor),
+      derivation: ["The widest clearance over the floor", `facts.floorWidth = ${mm(floor)}`]
+    });
+  }
+  if (opening !== void 0) {
+    rows.push({
+      key: "openingWidth",
+      label: "Opening width",
+      ...length(opening),
+      derivation: [
+        "The clearance through the opening at the top of the groove",
+        `facts.topOpeningWidth = ${mm(opening)}`
+      ]
+    });
+  }
+  let depth = undercut.undercutDepth;
+  let depthLine = depth !== void 0 ? `facts.undercutDepth = ${mm(depth)}` : "";
+  if (depth === void 0 && floor !== void 0 && opening !== void 0) {
+    if (floor > opening && !undercut.isExternal) {
+      depth = (floor - opening) / 2;
+      depthLine = `(facts.floorWidth \u2212 facts.topOpeningWidth) / 2 = (${mm(floor)} \u2212 ${mm(opening)}) / 2 = ${mm(depth)}`;
+    }
+  }
+  if (depth !== void 0) {
+    rows.push({
+      key: "undercutDepth",
+      label: "Undercut depth",
+      ...length(depth),
+      derivation: [
+        "How far the groove runs back from its opening: what the cutter\u2019s head reaches past its shaft.",
+        depthLine
+      ]
+    });
+  }
+  if (angle) {
+    rows.push({
+      key: "taper",
+      label: "Dovetail angle",
+      value: `${angle} from the tool axis`,
+      derivation: [`facts.taperDeg = ${angle}, between the overhanging wall and the tool axis`]
+    });
+  }
+  const cutter = (value, derivation, alt) => ({
+    key: "undercutCutter",
+    label: "Max cutting diameter",
+    milling: true,
+    value,
+    ...alt !== void 0 ? { alt } : {},
+    derivation
+  });
+  if (undercut.unmeasured) {
+    return [
+      ...rows,
+      cutter("Not measured", [
+        "The Engine could not measure the groove (facts.isInvalidGeometry or facts.cd.measurementFailed), so its figures offer no cutter."
+      ])
+    ];
+  }
+  if (sheet.noToolFits) {
+    return [
+      ...rows,
+      cutter("None fits", [
+        "facts.cd.ignore.max is next to nothing: no cutter fits anywhere in the groove."
+      ])
+    ];
+  }
+  const band = sheet.maxTool !== void 0 && sheet.maxTool > 0 ? sheet.maxTool : void 0;
+  const dropIn = undercut.isClosed ? undercut.maxEntry : void 0;
+  const head = band === void 0 ? void 0 : Math.min(band, dropIn ?? Infinity);
+  const opensTo = undercut.maxEntry ?? opening;
+  const behind = head !== void 0 && depth !== void 0 ? head - 2 * depth : void 0;
+  const limits = [opensTo, behind].filter((each) => each !== void 0);
+  const shaft = limits.length > 0 ? Math.max(Math.min(...limits), 0) : void 0;
+  const shaftLines = [
+    "The most the cutter\u2019s shaft can be: what comes down through the opening above the groove, and leaves the head reaching the back of it.",
+    ...opensTo !== void 0 ? [`Opening: ${tslot ? "facts.maxEntryCd" : "facts.topOpeningWidth"} = ${mm(opensTo)}`] : [],
+    ...behind !== void 0 && head !== void 0 && depth !== void 0 ? [
+      `Reach: max cutting diameter \u2212 2 \xD7 undercut depth = ${mm(head)} \u2212 2 \xD7 ${mm(depth)} = ${mm(behind)}`
+    ] : [],
+    ...shaft !== void 0 ? [`Max shaft = ${mm(shaft)}`] : []
+  ];
+  if (head !== void 0 && band !== void 0) {
+    const headLines = [
+      "The biggest head that reaches every point of the groove.",
+      `facts.cd.ignore.min = ${mm(band)}`,
+      ...dropIn !== void 0 ? [
+        `A closed slot: the head comes down through the opening above it, facts.maxEntryCd = ${mm(dropIn)}`
+      ] : [],
+      `\u2300 = ${mm(head)}`
+    ];
+    if (head < SHARP_MM || shaft !== void 0 && shaft < SHARP_MM) {
+      return [
+        ...rows,
+        cutter("None fits", [
+          ...headLines,
+          ...shaft !== void 0 ? shaftLines : [],
+          "No head that fits the groove leaves room for a shaft to carry it."
+        ])
+      ];
+    }
+    const size = length(head);
+    const filletRadius = sheet.filletRadius !== void 0 && sheet.filletRadius > 0 ? sheet.filletRadius : void 0;
+    const fillet = filletRadius !== void 0 ? length(filletRadius) : void 0;
+    const describe = (unit2) => [`\u2300 ${size[unit2]}`, ...angle ? [angle] : [], ...fillet ? [`R ${fillet[unit2]}`] : []].join(
+      " \xB7 "
+    );
+    rows.push(
+      cutter(
+        describe("value"),
+        [
+          ...headLines,
+          ...angle ? [`Angle = facts.taperDeg = ${angle}, from the tool axis`] : [],
+          ...filletRadius !== void 0 ? [`R = facts.filletRadius = ${mm(filletRadius)}, the blend the head\u2019s corners cut`] : []
+        ],
+        describe("alt")
+      )
+    );
+    if (top !== null && zMin !== void 0) {
+      const reach = top - zMin;
+      const ratio2 = (reach / head).toFixed(3);
+      rows.push({
+        key: "topLd",
+        label: "L/D to top of part",
+        milling: true,
+        value: ratio2,
+        derivation: [
+          `L = depth below top of part = ${mm(reach)}`,
+          `D = max cutting diameter = ${mm(head)}`,
+          `L / D = ${mm(reach)} / ${mm(head)} = ${ratio2}`
+        ]
+      });
+    }
+  }
+  if (shaft !== void 0 || tslot) {
+    const size = shaft !== void 0 ? length(shaft) : void 0;
+    rows.push({
+      key: "maxShaft",
+      label: "Max shaft diameter",
+      milling: true,
+      ...size ? { value: `\u2300 ${size.value}`, alt: `\u2300 ${size.alt}` } : { value: "No limit" },
+      derivation: size ? shaftLines : [
+        "facts.maxEntryCd is not reported and the head or undercut depth is not known: nothing limits the shaft."
+      ]
+    });
+  }
+  return rows;
+};
+
+// src/model/feature-record.ts
+var MAX_DATASHEET_FIELDS = 500;
+var formatLeaf = (value) => typeof value === "number" ? String(Number(value.toFixed(4))) : typeof value === "string" ? value : value === null ? "null" : String(value);
+var datasheetFields = (datasheet) => {
+  const fields = [];
+  let more = false;
+  const walk = (value, path) => {
+    if (fields.length >= MAX_DATASHEET_FIELDS) {
+      more = true;
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (value.every((each) => typeof each !== "object" || each === null)) {
+        fields.push({ path, value: value.length === 0 ? "[]" : value.map(formatLeaf).join(", ") });
+      } else {
+        value.forEach((each, index) => walk(each, `${path}[${index}]`));
+      }
+    } else if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) fields.push({ path, value: "{}" });
+      for (const [key, each] of entries) walk(each, path ? `${path}.${key}` : key);
+    } else {
+      fields.push({ path, value: formatLeaf(value) });
+    }
+  };
+  if (datasheet !== null && datasheet !== void 0) walk(datasheet, "");
+  return { fields, more };
+};
+
 // src/model/hole-groups.ts
 var holeSize = (sheets, tag) => {
   const sheet = sheets[tag.toLowerCase()];
@@ -1313,11 +2296,11 @@ var sameDepth = (a, b) => Math.abs(a - b) <= Math.max(DEPTH_FLOOR, Math.max(Math
 var sameDirection2 = (a, b) => Math.abs(a.x - b.x) < TOLERANCE2 && Math.abs(a.y - b.y) < TOLERANCE2 && Math.abs(a.z - b.z) < TOLERANCE2;
 var sameHoleSets = (features, sheets) => {
   const sizes = features.map((feature) => holeSize(sheets, feature.tag));
-  const root = features.map((_, at) => at);
-  const find = (at) => {
-    let top = at;
+  const root = features.map((_, at2) => at2);
+  const find = (at2) => {
+    let top = at2;
     while (root[top] !== top) top = root[top] ?? top;
-    root[at] = top;
+    root[at2] = top;
     return top;
   };
   for (let a = 0; a < features.length; a += 1) {
@@ -1331,8 +2314,8 @@ var sameHoleSets = (features, sheets) => {
     }
   }
   const sets = /* @__PURE__ */ new Map();
-  features.forEach((feature, at) => {
-    const top = find(at);
+  features.forEach((feature, at2) => {
+    const top = find(at2);
     sets.set(top, [...sets.get(top) ?? [], feature]);
   });
   return [...sets.values()];
@@ -1363,9 +2346,286 @@ var featureRows = (tags, features, sheets) => {
   });
 };
 
-// src/model/dfm-explain.ts
-var figureless = (hit) => hit.metric.quantity === "flag" || hit.metric.quantity === "presence";
-var hitFigure = (hit, units) => figureless(hit) ? "" : formatMeasured(hit.metric.quantity, hit.value, units);
+// src/model/pinch-mark.ts
+import { MM_PER_INCH as MM_PER_INCH5 } from "@toolpath/tool-support";
+var MAX_DRAWN_TOOL_MM = 3 * MM_PER_INCH5;
+var pinchMark = (datasheet, sheet, featureType) => {
+  const pinch = readPinch(datasheet);
+  const discs = pinch?.discs.filter(
+    (disc) => disc.diameter >= PINCH_TOOL_MM && disc.diameter <= MAX_DRAWN_TOOL_MM
+  ) ?? [];
+  if (!pinch || discs.length === 0) return null;
+  const fillet = sheet?.filletRadius;
+  const corner = !isSurfaceType(featureType) && fillet !== void 0 && fillet > 0 ? fillet : void 0;
+  return { ...pinch, discs, ...corner !== void 0 ? { corner } : {} };
+};
+var pinchLabel = (mark, units) => {
+  const length = (mm2) => `${lengthValue(mm2, units)} ${unitLabel(units)}`;
+  const tightest = Math.min(...mark.discs.map((disc) => disc.diameter));
+  const tool = mark.corner !== void 0 ? `bull nose R ${length(mark.corner)}` : "widest tool";
+  const places = mark.discs.length;
+  return {
+    label: `${mark.unresolved ? "\u2264 " : ""}\u2300 ${length(tightest)}`,
+    note: places > 1 ? `${tool} \xB7 ${places} places` : tool
+  };
+};
+
+// src/model/tool-frame.ts
+var extent = (values) => {
+  let low = Infinity;
+  let high = -Infinity;
+  for (const value of values) {
+    if (value < low) low = value;
+    if (value > high) high = value;
+  }
+  return { low, high };
+};
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var scale = (a, by) => [a[0] * by, a[1] * by, a[2] * by];
+var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+var unit = (a) => scale(a, 1 / Math.hypot(a[0], a[1], a[2]));
+var ON_DEPTH_MM = 0.05;
+var ON_CORNER_MM = 0.02;
+var POINT_DISC_MM = 0.01;
+var ON_WALL_MM = 0.1;
+var ON_WALL_SHARE = 0.02;
+var WALL_NORMAL_ALONG = 0.7;
+var SAME_PLACE_MM = 0.05;
+var MIN_HEIGHT_MM = 0.05;
+var readTriangles = ({ positions, normals }, origin) => {
+  const triangles = [];
+  for (let at2 = 0; at2 + 8 < positions.length; at2 += 9) {
+    const corner = (k) => [
+      (positions[at2 + k] ?? 0) - origin[0],
+      (positions[at2 + k + 1] ?? 0) - origin[1],
+      (positions[at2 + k + 2] ?? 0) - origin[2]
+    ];
+    const n = at2 / 9 * 3;
+    triangles.push({
+      a: corner(0),
+      b: corner(3),
+      c: corner(6),
+      normal: [normals[n] ?? 0, normals[n + 1] ?? 0, normals[n + 2] ?? 0]
+    });
+  }
+  return triangles;
+};
+var pointsOf = (triangles) => triangles.flatMap(({ a, b, c }) => [a, b, c]);
+var flatten = (point, { u, v }) => ({ x: dot(point, u), y: dot(point, v) });
+var wallSegments = (triangles, frame) => triangles.filter(({ normal }) => Math.abs(dot(normal, frame.w)) < WALL_NORMAL_ALONG).flatMap(({ a, b, c, normal }) => {
+  const [fa, fb, fc] = [flatten(a, frame), flatten(b, frame), flatten(c, frame)];
+  const air = flatten(normal, frame);
+  return [
+    { p: fa, q: fb, air },
+    { p: fb, q: fc, air },
+    { p: fc, q: fa, air }
+  ];
+});
+var nearestOn = ({ p, q }, at2) => {
+  const dx = q.x - p.x;
+  const dy = q.y - p.y;
+  const length = dx * dx + dy * dy;
+  const t = length === 0 ? 0 : Math.min(1, Math.max(0, ((at2.x - p.x) * dx + (at2.y - p.y) * dy) / length));
+  return { x: p.x + t * dx, y: p.y + t * dy };
+};
+var nearestWall = (segments, at2) => segments.reduce((best, segment) => {
+  const point = nearestOn(segment, at2);
+  const distance2 = Math.hypot(point.x - at2.x, point.y - at2.y);
+  if (best && distance2 >= best.distance) return best;
+  const open = (at2.x - point.x) * segment.air.x + (at2.y - point.y) * segment.air.y >= 0;
+  return { point, distance: distance2, open };
+}, null);
+var fitsDiscs = (triangles, frame, discs) => {
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    const onCorners = points.every(
+      (disc) => flat.some((point) => Math.hypot(point.x - disc.x, point.y - disc.y) <= ON_CORNER_MM)
+    );
+    if (!onCorners) return false;
+  }
+  if (wide.length === 0) return points.length > 0;
+  const segments = wallSegments(triangles, frame);
+  if (segments.length === 0) return false;
+  let touches = false;
+  for (const disc of wide) {
+    const nearest = nearestWall(segments, disc);
+    if (!nearest || !nearest.open) return false;
+    const slack = ON_WALL_MM + ON_WALL_SHARE * disc.diameter;
+    const radius = disc.diameter / 2;
+    if (nearest.distance < radius - slack) return false;
+    if (nearest.distance <= radius + slack) touches = true;
+  }
+  return touches;
+};
+var placeInFrame = ({ u, v, w }, x, y, z) => add(add(scale(u, x), scale(v, y)), scale(w, z));
+var AXES = [
+  [1, 0, 0],
+  [0, 1, 0],
+  [0, 0, 1]
+];
+var candidateFrames = (points, zMin, zMax, direction, strict = true) => {
+  const along = unit(direction);
+  const frames = [];
+  for (const sign of [1, -1]) {
+    const w = scale(along, sign);
+    const { low, high } = extent(points.map((point) => dot(point, w)));
+    if (strict && (Math.abs(low - zMin) > ON_DEPTH_MM || Math.abs(high - zMax) > ON_DEPTH_MM)) {
+      continue;
+    }
+    const across = AXES.reduce(
+      (best, axis) => Math.abs(dot(axis, w)) < Math.abs(dot(best, w)) ? axis : best
+    );
+    const u0 = unit(add(across, scale(w, -dot(across, w))));
+    const v0 = cross(w, u0);
+    for (let quarter = 0; quarter < 4; quarter++) {
+      const angle = quarter * Math.PI / 2;
+      const u = add(scale(u0, Math.cos(angle)), scale(v0, Math.sin(angle)));
+      for (const hand of [1, -1]) frames.push({ u, v: scale(cross(w, u), hand), w });
+    }
+  }
+  return frames;
+};
+var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var exactFrame = (triangles, discs, zMin, zMax, direction) => {
+  const fits = candidateFrames(pointsOf(triangles), zMin, zMax, direction).filter(
+    (frame) => fitsDiscs(triangles, frame, discs)
+  );
+  const [first] = fits;
+  if (!first) return null;
+  const placed = (frame) => discs.map((disc) => placeInFrame(frame, disc.x, disc.y, zMin));
+  const firstPlaces = placed(first);
+  const agree = fits.every(
+    (frame) => placed(frame).every((at2, index) => distance(at2, firstPlaces[index] ?? at2) <= SAME_PLACE_MM)
+  );
+  return agree ? first : null;
+};
+var discMiss = (triangles, frame, discs) => {
+  let miss = 0;
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    for (const disc of points) {
+      miss += extent(flat.map((point) => Math.hypot(point.x - disc.x, point.y - disc.y))).low;
+    }
+  }
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (wide.length === 0) return miss;
+  const segments = wallSegments(triangles, frame);
+  let touch = Infinity;
+  for (const disc of wide) {
+    const radius = disc.diameter / 2;
+    const nearest = nearestWall(segments, disc);
+    if (!nearest) return Infinity;
+    if (!nearest.open) miss += disc.diameter * 4;
+    miss += Math.max(0, radius - nearest.distance);
+    touch = Math.min(touch, Math.abs(nearest.distance - radius));
+  }
+  return miss + touch;
+};
+var bestFrame = (triangles, discs, zMin, zMax, direction) => {
+  if (triangles.length === 0 || discs.length === 0) return null;
+  const exact = exactFrame(triangles, discs, zMin, zMax, direction);
+  if (exact) return { frame: exact, lift: 0 };
+  const points = pointsOf(triangles);
+  const fitting = candidateFrames(points, zMin, zMax, direction);
+  const frames = fitting.length > 0 ? fitting : candidateFrames(points, zMin, zMax, direction, false);
+  const best = frames.reduce((was, frame) => {
+    const miss = discMiss(triangles, frame, discs);
+    return !was || miss < was.miss ? { frame, miss } : was;
+  }, null);
+  if (!best) return null;
+  const { low } = extent(points.map((point) => dot(point, best.frame.w)));
+  return { frame: best.frame, lift: fitting.length > 0 ? 0 : low - zMin };
+};
+var asVec = ([x, y, z]) => ({ x, y, z });
+var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 }) => {
+  const shift = [origin.x, origin.y, origin.z];
+  const faces = readTriangles(triangles, shift);
+  const found = bestFrame(faces, mark.discs, mark.zMin, mark.zMax, [
+    direction.x,
+    direction.y,
+    direction.z
+  ]);
+  const disc = mark.discs.reduce(
+    (tightest, each) => !tightest || each.diameter < tightest.diameter ? each : tightest,
+    null
+  );
+  if (!found || !disc) return null;
+  const { frame, lift } = found;
+  const radius = disc.diameter / 2;
+  const base = add(placeInFrame(frame, disc.x, disc.y, mark.zMin + lift), shift);
+  const contact = nearestWall(wallSegments(faces, frame), disc)?.point;
+  const toward = contact ? { x: contact.x - disc.x, y: contact.y - disc.y } : { x: 1, y: 0 };
+  const length = Math.hypot(toward.x, toward.y);
+  const across = add(
+    scale(frame.u, length > 1e-9 ? toward.x / length : 1),
+    scale(frame.v, length > 1e-9 ? toward.y / length : 0)
+  );
+  return {
+    base: asVec(base),
+    axis: asVec(frame.w),
+    diameter: disc.diameter,
+    height: Math.max(mark.zMax - mark.zMin, MIN_HEIGHT_MM),
+    cornerRadius: Math.min(Math.max(mark.corner ?? 0, 0), radius),
+    across: asVec(across)
+  };
+};
+
+// src/model/reach.ts
+var numbers = (value) => Array.isArray(value) && value.every((each) => typeof each === "number" && Number.isFinite(each)) ? value : null;
+var readReachCurve = (datasheet) => {
+  const curve = datasheet?.reachCurve;
+  const offsets = numbers(curve?.horizontalOffset);
+  const heights = numbers(curve?.verticalOffset);
+  if (!offsets || !heights || offsets.length === 0 || offsets.length !== heights.length) return null;
+  return { offsets, heights };
+};
+var runStart = ({ offsets }, index) => index === 0 ? 0 : offsets[index - 1] ?? 0;
+var peakHeight = ({ heights }) => Math.max(0, ...heights);
+var TAIL_MM = 12.7;
+var peakSlack = (peak) => Math.max(0.05, peak * 0.01);
+var peakStart = (curve) => {
+  const peak = peakHeight(curve);
+  const slack = peakSlack(peak);
+  const index = curve.heights.findIndex((height) => height >= peak - slack);
+  return runStart(curve, index === -1 ? 0 : index);
+};
+var trimmedCurve = (curve) => {
+  const last = curve.offsets[curve.offsets.length - 1] ?? 0;
+  const extent2 = peakStart(curve) + TAIL_MM;
+  if (extent2 >= last) return { curve, cut: false };
+  const keep = curve.offsets.findIndex((offset) => offset >= extent2);
+  return {
+    curve: {
+      offsets: [...curve.offsets.slice(0, keep), extent2],
+      heights: curve.heights.slice(0, keep + 1)
+    },
+    cut: true
+  };
+};
+var featureAcross = (sheet) => {
+  if (sheet?.diameter !== void 0 && sheet.diameter > 0)
+    return { width: sheet.diameter, kind: "diameter" };
+  if (sheet?.pinchDiameter !== void 0 && sheet.pinchDiameter > 0)
+    return { width: sheet.pinchDiameter, kind: "clearance" };
+  return null;
+};
+var isThroughType = (featureType) => /(^|_)through(_|$)/.test(featureType.toLowerCase());
+var featureProfile = (sheet, featureType) => {
+  const depth = sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? sheet.zMax - sheet.zMin : null;
+  return {
+    across: featureAcross(sheet),
+    depth: depth !== null && depth > 0 ? depth : null,
+    through: isThroughType(featureType)
+  };
+};
 
 // src/model/rule-set-file.ts
 var FILE_KIND = "toolpath-dfm-rules";
@@ -1528,8 +2788,8 @@ var llmRulePrompt = (current = [], vocabulary = MILLING_RULES) => {
   const groups = vocabulary.subjects.filter((each) => !each.value.startsWith(TYPE_SUBJECT));
   const types = vocabulary.subjects.filter((each) => each.value.startsWith(TYPE_SUBJECT));
   const metricLines = vocabulary.metrics.map((metric) => {
-    const unit = quantityUnit(metric.quantity, "mm");
-    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit ? `, in ${unit}` : ""}; a new rule usually starts around ${metric.start.mm}`;
+    const unit2 = quantityUnit(metric.quantity, "mm");
+    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit2 ? `, in ${unit2}` : ""}; a new rule usually starts around ${metric.start.mm}`;
     const kinds = metric.kinds ? ` Only features of kind ${metric.kinds.join("/")} report it.` : "";
     return `- \`${metric.key}\` \u2014 "${metric.label}" (${kind}). ${metric.hint}.${kinds}`;
   });
@@ -1898,52 +3158,203 @@ var TURNING_RULES = {
   fileName: "dfm-turning-rules.json"
 };
 
-// src/model/reach.ts
-var numbers = (value) => Array.isArray(value) && value.every((each) => typeof each === "number" && Number.isFinite(each)) ? value : null;
-var readReachCurve = (datasheet) => {
-  const curve = datasheet?.reachCurve;
-  const offsets = numbers(curve?.horizontalOffset);
-  const heights = numbers(curve?.verticalOffset);
-  if (!offsets || !heights || offsets.length === 0 || offsets.length !== heights.length) return null;
-  return { offsets, heights };
+// src/model/turned-check.ts
+var regionsOf = (feature) => Array.isArray(feature.regionIdxs) ? feature.regionIdxs : [];
+var stretchKey = (feature) => {
+  const regions = regionsOf(feature);
+  return regions.length === 0 ? `tag:${feature.featureTag}` : `${feature.featureType}:${[...regions].sort((a, b) => a - b).join(",")}`;
 };
-var runStart = ({ offsets }, index) => index === 0 ? 0 : offsets[index - 1] ?? 0;
-var peakHeight = ({ heights }) => Math.max(0, ...heights);
-var TAIL_MM = 12.7;
-var peakSlack = (peak) => Math.max(0.05, peak * 0.01);
-var peakStart = (curve) => {
-  const peak = peakHeight(curve);
-  const slack = peakSlack(peak);
-  const index = curve.heights.findIndex((height) => height >= peak - slack);
-  return runStart(curve, index === -1 ? 0 : index);
+var isApproach = (value) => value === "PlusZ" || value === "MinusZ";
+var turnedStretches = (features) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = stretchKey(feature);
+    groups.set(key, [...groups.get(key) ?? [], feature]);
+  }
+  const merged = [...groups.values()].flatMap((copies) => {
+    const [first] = copies;
+    if (!first) return [];
+    const approaches = [...new Set(copies.map((each) => each.approach).filter(isApproach))];
+    const only = approaches.length === 1 ? approaches[0] : void 0;
+    const z = only === "PlusZ" ? 1 : only === "MinusZ" ? -1 : 0;
+    return [{ first, copies, approaches, machiningDirection: { x: 0, y: 0, z } }];
+  });
+  const numbered = dfmFeatures(
+    merged.map(({ first, machiningDirection }) => ({
+      featureTag: first.featureTag,
+      featureType: first.featureType,
+      machiningDirection,
+      regionIdxs: regionsOf(first)
+    }))
+  );
+  return merged.flatMap(({ copies, approaches }, at2) => {
+    const feature = numbered[at2];
+    return feature ? [{ ...feature, copies, approaches }] : [];
+  });
 };
-var trimmedCurve = (curve) => {
-  const last = curve.offsets[curve.offsets.length - 1] ?? 0;
-  const extent = peakStart(curve) + TAIL_MM;
-  if (extent >= last) return { curve, cut: false };
-  const keep = curve.offsets.findIndex((offset) => offset >= extent);
-  return {
-    curve: {
-      offsets: [...curve.offsets.slice(0, keep), extent],
-      heights: curve.heights.slice(0, keep + 1)
-    },
-    cut: true
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+var finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var ratio = (top, bottom) => top !== null && bottom !== null && bottom > 0 ? top / bottom : null;
+var narrowestStep = (facts) => {
+  const steps = Array.isArray(facts.steps) ? facts.steps : [];
+  const diameters = steps.map((step) => finite(record(step)?.diameter)).filter((each) => each !== null && each > 0);
+  return diameters.length > 0 ? Math.min(...diameters) : null;
+};
+var threadSpec = (facts, field) => finite(record(facts.threadSpec)?.[field]) ?? finite(record(record(facts.thread)?.threadSpec)?.[field]);
+var partEnds = (stretches) => {
+  const zs = stretches.flatMap(
+    (stretch) => stretch.copies.flatMap((copy) => {
+      const sheet = record(copy.datasheet);
+      return [finite(sheet?.zMin), finite(sheet?.zMax)].filter(
+        (each) => each !== null
+      );
+    })
+  );
+  return zs.length > 0 ? { low: Math.min(...zs), high: Math.max(...zs) } : null;
+};
+var turnedLd = (sheet, facts, kind, approach, ends) => {
+  if (kind === "AxialHole") return ratio(finite(facts.depth), narrowestStep(facts));
+  const inside = ID_KINDS;
+  if (!kind || !inside.includes(kind) || !ends || !approach) return null;
+  const zMin = finite(sheet.zMin);
+  const zMax = finite(sheet.zMax);
+  const reach = approach === "PlusZ" ? zMin === null ? null : ends.high - zMin : zMax === null ? null : zMax - ends.low;
+  const rMin = finite(sheet.rMin);
+  const bore = finite(sheet.entryDiameter) ?? (rMin === null ? null : 2 * rMin);
+  return ratio(reach, bore);
+};
+var HAIR = 1e-3;
+var FLAT_CONE = 179.5;
+var copyMeasure = (metric, copy, ends) => {
+  const sheet = record(copy.datasheet);
+  if (!sheet) return null;
+  const facts = record(sheet.facts) ?? {};
+  const kind = typeof facts.kind === "string" ? facts.kind : kindOfType(copy.featureType);
+  const kinds = metric.kinds;
+  if (kinds && !(kind && kinds.includes(kind))) return null;
+  const doubled = (value) => {
+    const radius = finite(value);
+    return radius === null ? null : 2 * radius;
   };
+  switch (metric.key) {
+    case "maxDiameter":
+      return doubled(sheet.rMax);
+    case "minDiameter":
+      return doubled(sheet.rMin);
+    case "length": {
+      const zMin = finite(sheet.zMin);
+      const zMax = finite(sheet.zMax);
+      return zMin === null || zMax === null || zMax - zMin < HAIR ? null : zMax - zMin;
+    }
+    case "ld":
+      return turnedLd(sheet, facts, kind, copy.approach ?? null, ends);
+    case "grooveWidth":
+      return finite(facts.width);
+    case "grooveDepth":
+    case "threadDepth":
+    case "holeDepth":
+      return finite(facts.depth);
+    case "grooveAspect":
+      return ratio(finite(facts.depth), finite(facts.width));
+    case "threadPitch":
+      return finite(facts.pitch) ?? threadSpec(facts, "threadPitch");
+    case "threadDiameter":
+      return threadSpec(facts, "basicDiameter");
+    case "holeDiameter":
+      return narrowestStep(facts);
+    case "holeSteps":
+      return Array.isArray(facts.steps) ? facts.steps.length : null;
+    case "flatBottom": {
+      if (facts.bottom === void 0) return 0;
+      const cone = finite(record(facts.bottom)?.coneDeg);
+      return cone === null ? null : cone >= FLAT_CONE ? 1 : 0;
+    }
+    // Zero is a figure here: a sharp corner, which a "radius ≤" rule is most of all about.
+    case "cornerRadius":
+      return finite(sheet.minConcaveRadius);
+    case "sharpCorner": {
+      const radius = finite(sheet.minConcaveRadius);
+      return radius === null ? 0 : radius <= HAIR ? 1 : 0;
+    }
+    // Absent where nothing stands between the feature and its end: nothing to pass, so clean.
+    case "entryDiameter":
+      return finite(sheet.entryDiameter);
+    case "axialTool":
+      return typeof sheet.mounting === "string" ? sheet.mounting === "Axial" ? 1 : 0 : null;
+    case "tolerance":
+      return finite(record(sheet.toleranceBand)?.atolMax);
+    default:
+      return null;
+  }
 };
-var featureAcross = (sheet) => {
-  if (sheet?.diameter !== void 0 && sheet.diameter > 0)
-    return { width: sheet.diameter, kind: "diameter" };
-  if (sheet?.pinchDiameter !== void 0 && sheet.pinchDiameter > 0)
-    return { width: sheet.pinchDiameter, kind: "clearance" };
-  return null;
+var kindOfType = (featureType) => featureType.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+var stretchFacts = (stretch) => stretch.copies.map((copy) => record(record(copy.datasheet)?.facts)).find((each) => each !== void 0);
+var stretchIs = (subject, stretch) => {
+  const type = stretch.featureType.toLowerCase();
+  if (subject.startsWith(TYPE_SUBJECT)) return type === subject.slice(TYPE_SUBJECT.length);
+  const facts = stretchFacts(stretch);
+  const kind = typeof facts?.kind === "string" ? facts.kind : kindOfType(type);
+  const hole = kind === "AxialHole";
+  switch (subject) {
+    case "any":
+      return true;
+    case "thread":
+      return kind === "OdThread" || kind === "IdThread" || hole && record(facts?.thread) !== void 0;
+    case "throughHole":
+      return hole && facts?.through === true;
+    case "blindHole":
+      return hole && facts?.through === false;
+    case "threadedHole":
+      return hole && record(facts?.thread) !== void 0;
+    default: {
+      const kinds = subjectInfo(subject, TURNING_RULES)?.kinds;
+      return kinds !== void 0 && kinds.includes(kind);
+    }
+  }
 };
-var isThroughType = (featureType) => /(^|_)through(_|$)/.test(featureType.toLowerCase());
-var featureProfile = (sheet, featureType) => {
-  const depth = sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? sheet.zMax - sheet.zMin : null;
+var stretchHit = (stretch, rule, metric, ends) => {
+  if (metric.quantity === "presence") return { rule, metric, value: 1 };
+  const measured = stretch.copies.filter((copy) => record(copy.datasheet) !== void 0);
+  if (measured.length === 0) return null;
+  const values = [];
+  for (const copy of measured) {
+    const value2 = copyMeasure(metric, copy, ends);
+    if (value2 === null || !breaks(rule, metric.quantity, value2)) return null;
+    values.push(value2);
+  }
+  const value = worseUpward(rule, metric) ? Math.min(...values) : Math.max(...values);
+  return { rule, metric, value };
+};
+var checkTurnedPart = (stretches, rules) => {
+  const ends = partEnds(stretches);
+  const hitsByTag = new Map(
+    stretches.map((stretch) => [
+      stretch.tag.toLowerCase(),
+      rules.flatMap((rule) => {
+        const metric = metricInfo(rule.metric, TURNING_RULES);
+        if (!metric || !stretchIs(rule.subject, stretch)) return [];
+        const hit = stretchHit(stretch, rule, metric, ends);
+        return hit ? [hit] : [];
+      })
+    ])
+  );
+  const required = new Set(stretches.map((stretch) => stretch.tag.toLowerCase()));
+  const paintedFaces = /* @__PURE__ */ new Map();
+  for (const stretch of stretches) {
+    const color = worstColor(hitsByTag.get(stretch.tag.toLowerCase()));
+    if (!color) continue;
+    for (const region of stretch.regionIdxs) {
+      const painted = paintedFaces.get(region);
+      if (!painted || compareColors(color, painted.color) < 0)
+        paintedFaces.set(region, { tag: stretch.tag, color });
+    }
+  }
   return {
-    across: featureAcross(sheet),
-    depth: depth !== null && depth > 0 ? depth : null,
-    through: isThroughType(featureType)
+    hitsByTag,
+    required,
+    byRule: ruleResults(rules, stretches, hitsByTag, required),
+    paintedFaces,
+    paintedWhole: /* @__PURE__ */ new Map()
   };
 };
 
@@ -1951,16 +3362,11 @@ export {
   directionLabel,
   dfmFeatures,
   featureTypeLabel,
-  partTop,
-  isDrilled,
-  featureLd,
   PRESENCE_METRIC,
-  TYPE_SUBJECT,
+  QUICK_SUBJECTS,
   MILLING_RULES,
-  subjectInfo,
   metricInfo,
   metricsForSubject,
-  LENGTH_PLACES,
   lengthValue,
   unitLabel,
   OPS,
@@ -1984,22 +3390,37 @@ export {
   withMetric,
   withOp,
   withSubject,
-  breaks,
-  worseUpward,
   parseRules,
+  hitFigure,
+  brokenRules,
+  featureColor,
+  withSurroundedFaces,
+  checkPart,
+  readPinch,
+  PINCH_TOOL_MM,
+  isNoReading,
+  featureSheet,
+  isSurfaceType,
+  maxBallDiameter,
+  featureMeasurements,
+  MAX_DATASHEET_FIELDS,
+  datasheetFields,
   sameDepth,
   featureRows,
-  hitFigure,
+  pinchMark,
+  pinchLabel,
+  placePinchTool,
+  readReachCurve,
+  runStart,
+  peakHeight,
+  trimmedCurve,
+  featureProfile,
   FILE_KIND,
   serializeRuleSet,
   parseRuleSetFile,
   llmRulePrompt,
-  ID_KINDS,
   turnedTypeLabel,
   TURNING_RULES,
-  readReachCurve,
-  runStart,
-  peakHeight,
-  trimmedCurve,
-  featureProfile
+  turnedStretches,
+  checkTurnedPart
 };