@toolpath/dfm 0.3.1 → 0.5.0

package/dist/model/index.js

@@ -1,8 +1,11 @@
 import {
   CRITICAL_COLOR,
   FILE_KIND,
+  ID_KINDS,
   LENGTH_PLACES,
+  MILLING_RULES,
   RULE_COLORS,
+  TURNING_RULES,
   TYPE_SUBJECT,
   WARNING_COLOR,
   breaks,
@@ -26,10 +29,12 @@ import {
   runStart,
   sameDepth,
   serializeRuleSet,
+  subjectInfo,
   trimmedCurve,
+  turnedTypeLabel,
   unitLabel,
   worseUpward
-} from "../chunk-5MPHT7BC.js";
+} from "../chunk-4IRNLDE6.js";
 
 // src/model/broken-rules.ts
 var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
@@ -41,12 +46,12 @@ var worstHits = (hits) => {
     return true;
   });
 };
-var brokenRules = (check, tag, units) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
+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),
+    text: describeRule(hit.rule, units, vocabulary),
     ...figure ? { figure } : {}
   };
 });
@@ -106,9 +111,9 @@ var featureIs = (subject, featureType, sheet) => {
       return false;
   }
 };
-var at = (record, path) => path.split(".").reduce(
+var at = (record2, path) => path.split(".").reduce(
   (value, key) => typeof value === "object" && value !== null ? value[key] : void 0,
-  record
+  record2
 );
 var readPath = (datasheet, metric) => {
   for (const path of metric.path ?? []) {
@@ -217,6 +222,22 @@ var requiredTags = (features) => {
     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) => {
@@ -226,7 +247,6 @@ var featureComplexity = (featureType) => {
 };
 var CONTOUR = "contour_surface";
 var unavoidableFaces = (features, hitsByTag, regionAreas) => {
-  const worstColor = (feature) => hitsByTag.get(feature.tag.toLowerCase())?.map((hit) => hit.rule.color).sort(compareColors)[0];
   const areaOf = (feature) => [...new Set(feature.regionIdxs)].reduce(
     (sum, region) => sum + (regionAreas.get(region) ?? 0),
     0
@@ -242,7 +262,7 @@ var unavoidableFaces = (features, hitsByTag, regionAreas) => {
   for (const [region, candidates] of owners) {
     const colored = candidates.map((feature) => ({
       feature,
-      color: worstColor(feature),
+      color: worstColor(hitsByTag.get(feature.tag.toLowerCase())),
       area: areaOf(feature)
     }));
     const isContour = ({ feature }) => feature.featureType === CONTOUR;
@@ -269,10 +289,10 @@ var unavoidableFaces = (features, hitsByTag, regionAreas) => {
 };
 var withSurroundedFaces = (check, features, adjacency) => {
   const paintedFor = new Map(check.paintedFaces);
-  const regionsOf = /* @__PURE__ */ new Map();
+  const regionsOf2 = /* @__PURE__ */ new Map();
   for (const feature of features) {
     const key = feature.tag.toLowerCase();
-    regionsOf.set(key, new Set(feature.regionIdxs));
+    regionsOf2.set(key, new Set(feature.regionIdxs));
     const whole = check.paintedWhole.get(key);
     if (whole) {
       for (const region of feature.regionIdxs)
@@ -290,7 +310,7 @@ var withSurroundedFaces = (check, features, adjacency) => {
       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 && regionsOf.get(key)?.has(region)).map(([, { paint: paint2 }]) => paint2).sort((a, b) => compareColors(a.color, b.color));
+    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;
@@ -304,29 +324,172 @@ var checkPart = (features, sources, rules) => {
       featureHits(features, feature, sources, rules)
     ])
   );
-  const byRule = 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)
-    };
-  });
   return {
     hitsByTag,
     required,
-    byRule,
+    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 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 } : {},
+    ...threading ? { threading } : {},
+    ...undercut ? { undercut } : {}
+  };
+};
+
 // src/model/feature-details.ts
 import { MM_PER_INCH } from "@toolpath/tool-support";
 var mm = (value) => `${trim(value, 4)} mm`;
@@ -375,6 +538,11 @@ var maxBallDiameter = (sheet) => {
 };
 var ROW_ORDER = [
   "featureDepth",
+  "undercutWidth",
+  "floorWidth",
+  "openingWidth",
+  "undercutDepth",
+  "taper",
   "diameter",
   "cornerRadius",
   "filletRadius",
@@ -383,6 +551,8 @@ var ROW_ORDER = [
   "thread",
   "bevelAngle",
   "finishTool",
+  "undercutCutter",
+  "maxShaft",
   "pinch",
   "fitCornerRadius",
   "maxBull",
@@ -406,6 +576,7 @@ var featureMeasurements = ({
   });
   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);
@@ -419,7 +590,7 @@ var featureMeasurements = ({
       derivation: [topLine, `Top \u2212 zMin = ${mm(top)} \u2212 ${mm(bottom)} = ${mm(top - bottom)}`]
     });
   }
-  if (sheet?.zMax !== void 0 && bottom !== void 0) {
+  if (sheet?.zMax !== void 0 && bottom !== void 0 && !(undercut && sheet?.kind === "Tslot")) {
     rows.push({
       key: "featureDepth",
       label: "Feature depth",
@@ -435,7 +606,7 @@ var featureMeasurements = ({
       derivation: [`facts.diameter = ${mm(sheet.diameter)}`]
     });
   }
-  if (sheet?.cornerRadius !== void 0) {
+  if (sheet?.cornerRadius !== void 0 && !undercut) {
     const radius = length(sheet.cornerRadius);
     rows.push({
       key: "cornerRadius",
@@ -449,7 +620,7 @@ var featureMeasurements = ({
       ]
     });
   }
-  if (!sheet?.sharpCorners) {
+  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);
@@ -479,6 +650,7 @@ var featureMeasurements = ({
       });
     }
   }
+  if (sheet && undercut) rows.push(...undercutRows(sheet, undercut, top, length));
   const surface = SURFACE_TYPES.has(feature.featureType);
   if (surface && sheet) {
     const diameter = sheet.fitToolDiameter;
@@ -544,12 +716,12 @@ var featureMeasurements = ({
       });
     }
   }
-  const ld = featureLd(features, feature, sheets);
+  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 ratio = (depth / ld.across).toFixed(3);
-      return ld.atLeast ? `\u2265 ${ratio}` : ratio;
+      const ratio2 = (depth / ld.across).toFixed(3);
+      return ld.atLeast ? `\u2265 ${ratio2}` : ratio2;
     };
     if (ld.drilling) {
       rows.push({
@@ -641,141 +813,173 @@ var featureMeasurements = ({
   }
   return rows.sort((a, b) => ROW_ORDER.indexOf(a.key) - ROW_ORDER.indexOf(b.key));
 };
-
-// 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 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 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 ? `${trim(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
   });
-};
-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 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 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 } : {},
-    ...threading ? { threading } : {}
-  };
+  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/pinch-mark.ts
@@ -1009,14 +1213,217 @@ var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 })
     across: asVec(across)
   };
 };
+
+// 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 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 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 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 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 {
+    hitsByTag,
+    required,
+    byRule: ruleResults(rules, stretches, hitsByTag, required),
+    paintedFaces,
+    paintedWhole: /* @__PURE__ */ new Map()
+  };
+};
 export {
   CRITICAL_COLOR,
   FILE_KIND,
+  MILLING_RULES,
   PINCH_TOOL_MM,
   RULE_COLORS,
+  TURNING_RULES,
   WARNING_COLOR,
   brokenRules,
   checkPart,
+  checkTurnedPart,
   compareColors,
   describeRule,
   dfmFeatures,
@@ -1043,5 +1450,7 @@ export {
   sameDepth,
   serializeRuleSet,
   trimmedCurve,
+  turnedStretches,
+  turnedTypeLabel,
   withSurroundedFaces
 };