@toolpath/dfm 0.3.1 → 0.4.0

package/dist/{feature-record-BUoFFjN6.d.ts → feature-record-DHbkVpx0.d.ts}

@@ -232,6 +232,38 @@ interface FeatureSheet {
     noToolFits?: true;
     /** For a hole the model threads: its thread. */
     threading?: FeatureThreading;
+    /** For an undercut — a T-slot or a dovetail: what its cutter is held to. */
+    undercut?: FeatureUndercut;
+}
+/**
+ * An undercut's own figures, from its `facts`: a T-slot's or a dovetail's.
+ * Millimetres and degrees. Each is left out where the Engine did not measure
+ * it, or where nothing limits it.
+ */
+interface FeatureUndercut {
+    /** T-slot: how far the groove runs back from its opening, radially (`facts.undercutDepth`). */
+    undercutDepth?: number;
+    /**
+     * T-slot: the widest tool that comes down through the opening above it
+     * (`facts.maxEntryCd`), which holds the cutter's shaft. Left out where
+     * nothing above limits it; zero where nothing fits.
+     */
+    maxEntry?: number;
+    /** Dovetail: between the overhanging wall and the tool axis, degrees (`facts.taperDeg`). */
+    taperDeg?: number;
+    /** Dovetail: the widest clearance over the floor, the width the groove cuts at. */
+    floorWidth?: number;
+    /** Dovetail: the clearance through the opening at the top of the groove. */
+    topOpeningWidth?: number;
+    /** Dovetail: the groove's widths vary from place to place — it runs out somewhere. */
+    isExternal?: true;
+    /** T-slot: its walls close on themselves in plan view, so a cutter's head comes down through its opening. */
+    isClosed?: true;
+    /**
+     * The Engine could not measure it (`facts.isInvalidGeometry` or
+     * `facts.cd.measurementFailed`), so its figures offer no cutter.
+     */
+    unmeasured?: true;
 }
 /** A modelled thread, from a hole's `facts.threading`. Millimetres. */
 interface FeatureThreading {
@@ -500,4 +532,4 @@ interface FeatureRecord {
     readonly datasheet: unknown;
 }
 
-export { featureColor as A, type BrokenRule as B, CRITICAL_COLOR as C, type DfmRule as D, featureMeasurements as E, type FeatureSheets as F, featureProfile as G, featureSheet as H, featureTypeLabel as I, isNoReading as J, isSurfaceType as K, makeRule as L, type Measurement as M, maxBallDiameter as N, parseRules as O, PINCH_TOOL_MM as P, peakHeight as Q, type ReachCurve as R, type SurfaceToolKind as S, readPinch as T, type Units as U, readReachCurve as V, WARNING_COLOR as W, runStart as X, trimmedCurve as Y, withSurroundedFaces as Z, type DfmCheck as a, type DfmFeature as b, type FeatureProfile as c, type FeatureRecord as d, type DfmHit as e, type FeaturePinch as f, type FeatureSheet as g, type ClearanceFit as h, type DfmMetric as i, type DfmOp as j, type DfmQuantity as k, type DfmSources as l, type FactsKind as m, type FeatureAcross as n, type FeatureThreading as o, type PinchDisc as p, RULE_COLORS as q, type RangeHigh as r, type RangeLow as s, type ReportFeature as t, type RuleResult as u, brokenRules as v, checkPart as w, compareColors as x, describeRule as y, dfmFeatures as z };
+export { dfmFeatures as A, type BrokenRule as B, CRITICAL_COLOR as C, type DfmRule as D, featureColor as E, type FeatureSheets as F, featureMeasurements as G, featureProfile as H, featureSheet as I, featureTypeLabel as J, isNoReading as K, isSurfaceType as L, type Measurement as M, makeRule as N, maxBallDiameter as O, PINCH_TOOL_MM as P, parseRules as Q, type ReachCurve as R, type SurfaceToolKind as S, peakHeight as T, type Units as U, readPinch as V, WARNING_COLOR as W, readReachCurve as X, runStart as Y, trimmedCurve as Z, withSurroundedFaces as _, type DfmCheck as a, type DfmFeature as b, type FeatureProfile as c, type FeatureRecord as d, type DfmHit as e, type FeaturePinch as f, type FeatureSheet as g, type ClearanceFit as h, type DfmMetric as i, type DfmOp as j, type DfmQuantity as k, type DfmSources as l, type FactsKind as m, type FeatureAcross as n, type FeatureThreading as o, type FeatureUndercut as p, type PinchDisc as q, RULE_COLORS as r, type RangeHigh as s, type RangeLow as t, type ReportFeature as u, type RuleResult as v, brokenRules as w, checkPart as x, compareColors as y, describeRule as z };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { ReactNode, FC, KeyboardEvent, Ref, ComponentType, ReactElement, HTMLAttributes } from 'react';
-import { D as DfmRule, a as DfmCheck, b as DfmFeature, F as FeatureSheets, U as Units, R as ReachCurve, c as FeatureProfile, B as BrokenRule, M as Measurement, d as FeatureRecord } from './feature-record-BUoFFjN6.js';
+import { D as DfmRule, a as DfmCheck, b as DfmFeature, F as FeatureSheets, U as Units, R as ReachCurve, c as FeatureProfile, B as BrokenRule, M as Measurement, d as FeatureRecord } from './feature-record-DHbkVpx0.js';
 
 /**
  * The rules the list shows, and how to change them. The app owns them —

package/dist/model/index.d.ts

@@ -1,5 +1,5 @@
-import { e as DfmHit, U as Units, f as FeaturePinch, g as FeatureSheet, D as DfmRule } from '../feature-record-BUoFFjN6.js';
-export { B as BrokenRule, C as CRITICAL_COLOR, h as ClearanceFit, a as DfmCheck, b as DfmFeature, i as DfmMetric, j as DfmOp, k as DfmQuantity, l as DfmSources, m as FactsKind, n as FeatureAcross, c as FeatureProfile, d as FeatureRecord, F as FeatureSheets, o as FeatureThreading, M as Measurement, P as PINCH_TOOL_MM, p as PinchDisc, q as RULE_COLORS, r as RangeHigh, s as RangeLow, R as ReachCurve, t as ReportFeature, u as RuleResult, S as SurfaceToolKind, W as WARNING_COLOR, v as brokenRules, w as checkPart, x as compareColors, y as describeRule, z as dfmFeatures, A as featureColor, E as featureMeasurements, G as featureProfile, H as featureSheet, I as featureTypeLabel, J as isNoReading, K as isSurfaceType, L as makeRule, N as maxBallDiameter, O as parseRules, Q as peakHeight, T as readPinch, V as readReachCurve, X as runStart, Y as trimmedCurve, Z as withSurroundedFaces } from '../feature-record-BUoFFjN6.js';
+import { e as DfmHit, U as Units, f as FeaturePinch, g as FeatureSheet, D as DfmRule } from '../feature-record-DHbkVpx0.js';
+export { B as BrokenRule, C as CRITICAL_COLOR, h as ClearanceFit, a as DfmCheck, b as DfmFeature, i as DfmMetric, j as DfmOp, k as DfmQuantity, l as DfmSources, m as FactsKind, n as FeatureAcross, c as FeatureProfile, d as FeatureRecord, F as FeatureSheets, o as FeatureThreading, p as FeatureUndercut, M as Measurement, P as PINCH_TOOL_MM, q as PinchDisc, r as RULE_COLORS, s as RangeHigh, t as RangeLow, R as ReachCurve, u as ReportFeature, v as RuleResult, S as SurfaceToolKind, W as WARNING_COLOR, w as brokenRules, x as checkPart, y as compareColors, z as describeRule, A as dfmFeatures, E as featureColor, G as featureMeasurements, H as featureProfile, I as featureSheet, J as featureTypeLabel, K as isNoReading, L as isSurfaceType, N as makeRule, O as maxBallDiameter, Q as parseRules, T as peakHeight, V as readPinch, X as readReachCurve, Y as runStart, Z as trimmedCurve, _ as withSurroundedFaces } from '../feature-record-DHbkVpx0.js';
 
 /** The figure that broke a rule, bare: `7.5`, `0.05"`. Empty for a yes/no or "any size". */
 declare const hitFigure: (hit: DfmHit, units: Units) => string;

package/dist/model/index.js

@@ -327,6 +327,164 @@ var checkPart = (features, sources, rules) => {
   };
 };
 
+// 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 +533,11 @@ var maxBallDiameter = (sheet) => {
 };
 var ROW_ORDER = [
   "featureDepth",
+  "undercutWidth",
+  "floorWidth",
+  "openingWidth",
+  "undercutDepth",
+  "taper",
   "diameter",
   "cornerRadius",
   "filletRadius",
@@ -383,6 +546,8 @@ var ROW_ORDER = [
   "thread",
   "bevelAngle",
   "finishTool",
+  "undercutCutter",
+  "maxShaft",
   "pinch",
   "fitCornerRadius",
   "maxBull",
@@ -406,6 +571,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 +585,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 +601,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 +615,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 +645,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,7 +711,7 @@ 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) => {
@@ -641,141 +808,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 ratio = (reach / head).toFixed(3);
+      rows.push({
+        key: "topLd",
+        label: "L/D to top of part",
+        milling: true,
+        value: ratio,
+        derivation: [
+          `L = depth below top of part = ${mm(reach)}`,
+          `D = max cutting diameter = ${mm(head)}`,
+          `L / D = ${mm(reach)} / ${mm(head)} = ${ratio}`
+        ]
+      });
+    }
+  }
+  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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/dfm",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Toolpath DFM rules: the rule list, the rules and the part checker, and the feature panel",
   "license": "MIT",
   "engines": {
@@ -64,8 +64,8 @@
     "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.1.10",
-    "@toolpath/api": "^0.7.0",
-    "@toolpath/ui": "^1.0.0"
+    "@toolpath/ui": "^1.0.0",
+    "@toolpath/api": "^0.7.0"
   },
   "scripts": {
     "build": "tsup src/index.ts src/model/index.ts --format esm --dts --clean --external react --external react-dom --external @toolpath/ui",