@toolpath/dfm 0.1.0 → 0.2.0

package/dist/model/index.d.ts

@@ -1,57 +1,76 @@
-import { d as DfmHit, U as Units, b as DfmFeature, F as FeatureSheets, e as FeatureSheet, D as DfmRule } from '../reach-CfmYU_yQ.js';
-export { C as CRITICAL_COLOR, f as ClearanceFit, a as DfmCheck, g as DfmMetric, h as DfmOp, i as DfmQuantity, j as DfmSources, k as FactsKind, l as FeatureAcross, m as FeaturePinch, c as FeatureProfile, n as FeatureThreading, P as PINCH_TOOL_MM, o as PinchDisc, p as RULE_COLORS, q as RangeHigh, r as RangeLow, R as ReachCurve, s as ReportFeature, t as RuleResult, W as WARNING_COLOR, u as checkPart, v as compareColors, w as describeRule, x as dfmFeatures, y as featureProfile, z as featureSheet, A as featureTypeLabel, B as isNoReading, E as makeRule, G as parseRules, H as peakHeight, I as readPinch, J as readReachCurve, K as runStart, L as trimmedCurve, M as withSurroundedFaces } from '../reach-CfmYU_yQ.js';
+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';
 
 /** 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;
 
-/** One row of a feature's details. */
-interface Measurement {
-    /** Stable, so a list can key its rows. */
-    readonly key: string;
-    readonly label: string;
-    readonly value: string;
-    /** The same number in the other unit. Absent on a ratio or a count. */
-    readonly alt?: string;
-    /**
-     * How it was worked out from the datasheet, a line at a time: the fields it
-     * reads, by their path in the raw record, and the arithmetic, in the
-     * Engine's millimetres.
-     */
-    readonly derivation: readonly string[];
+/** Whether two depths are one depth, as the quoting app counts them: within a twentieth, or a hundredth of a mm. */
+declare const sameDepth: (a: number, b: number) => boolean;
+
+/**
+ * A feature's pinch discs as the widest tool that fits stands in them: the
+ * datasheet's discs a tool can stand in, in its tool frame, mm, with how deep
+ * the feature runs and the corner the tool has.
+ */
+interface PinchMark extends FeaturePinch {
     /**
-     * A machining consideration rather than a measurement of the feature's own
-     * shape: the tool that cuts it, and how far it has to reach. The panel lists
-     * these under their own heading, for every kind of feature.
+     * The radius on the tool's corner, mm: a filleted pocket's floor fillet,
+     * which a bull nose of that radius cuts. Absent for a flat-bottomed tool.
      */
-    readonly milling?: true;
-    /** A row that stands for a tool the viewer can draw on the part, by its kind. */
-    readonly tool?: SurfaceToolKind;
+    readonly corner?: number;
 }
-/** Which of a surface's finishing tools: a ball nose, or a bull nose with a flat between its corners. */
-type SurfaceToolKind = 'ball' | 'bull';
-/** Whether a feature type is read as a surface: see `SURFACE_TYPES`. */
-declare const isSurfaceType: (featureType: string) => boolean;
 /**
- * The biggest ball nose a surface admits, mm: a ball's corner radius is half
- * its diameter, so it is held under the tool fit's diameter and corner radius
- * at once. None where the surface reports no fit, or admits no corner at all.
+ * The pinch discs worth drawing a tool in: none for a feature with no discs,
+ * only a sharp corner's (no tool at all), or tools wider than
+ * {@link MAX_DRAWN_TOOL_MM}. A walled feature's floor fillet rounds the tool's
+ * corner; a surface's fillet radius is its own shape, and does not.
  */
-declare const maxBallDiameter: (sheet: Pick<FeatureSheet, "fitToolDiameter" | "fitCornerRadius">) => number | undefined;
+declare const pinchMark: (datasheet: unknown, sheet: FeatureSheet | undefined, featureType: string) => PinchMark | null;
 /**
- * The rows a feature gets, in {@link ROW_ORDER}: its own geometry first, then
- * where it sits in the part and the reach that makes, then the tools a
- * surface admits. A row is left out rather than shown empty: "—" against a
- * field this kind never reports reads as a measurement that failed.
+ * What a pinch mark's tool is labelled: its diameter at the tightest disc —
+ * "≤" where the clearance was measured at one tolerance only — and, quieter,
+ * the kind of tool and how many places are that tight.
  */
-declare const featureMeasurements: ({ features, feature, sheets, units, }: {
-    features: readonly DfmFeature[];
-    feature: DfmFeature;
-    sheets: FeatureSheets;
-    units: Units;
-}) => Measurement[];
+declare const pinchLabel: (mark: PinchMark, units: Units) => {
+    label: string;
+    note: string;
+};
 
-/** Whether two depths are one depth, as the quoting app counts them: within a twentieth, or a hundredth of a mm. */
-declare const sameDepth: (a: number, b: number) => boolean;
+/** A direction or a point. */
+interface Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/** A feature's faces as triangles: nine numbers each for the corners, three for the outward normal. */
+interface FaceTriangles {
+    readonly positions: ArrayLike<number>;
+    readonly normals: ArrayLike<number>;
+}
+/** The widest tool a feature admits, placed on the part: what to draw, in the drawn coordinates. */
+interface PlacedTool {
+    /** The centre of the tool's bottom, on the feature's floor. */
+    readonly base: Vec3;
+    /** Up the tool. */
+    readonly axis: Vec3;
+    readonly diameter: number;
+    readonly height: number;
+    /** The radius on its corner: a filleted floor's, no more than the tool's own radius. */
+    readonly cornerRadius: number;
+    /** Across the tool, toward where it touches the wall. */
+    readonly across: Vec3;
+}
+/**
+ * The widest tool a feature admits, standing on its tightest pinch disc, ready
+ * to draw: the datasheet's frame found against the feature's faces, the disc
+ * placed in it, and the tool turned toward the wall that pinches it.
+ *
+ * `origin` is where the CAD file's own zero sits in the coordinates the part
+ * is drawn in — moved by whatever centred it — since a datasheet is in the
+ * file's coordinates and the triangles and the answer are in the drawn ones.
+ * Null for a feature with no faces or no discs.
+ */
+declare const placePinchTool: (mark: PinchMark, triangles: FaceTriangles, direction: Vec3, origin?: Vec3) => PlacedTool | null;
 
 /**
  * A set of DFM rules as a file: what Export writes, Import reads, and what
@@ -106,4 +125,4 @@ declare const parseRuleSetFile: (text: string) => {
  */
 declare const llmRulePrompt: (current?: readonly DfmRule[]) => string;
 
-export { DfmFeature, DfmHit, DfmRule, FILE_KIND, FeatureSheet, FeatureSheets, type Measurement, type RuleSetFile, type SurfaceToolKind, Units, featureMeasurements, hitFigure, isSurfaceType, llmRulePrompt, maxBallDiameter, parseRuleSetFile, sameDepth, serializeRuleSet };
+export { DfmHit, DfmRule, FILE_KIND, type FaceTriangles, FeaturePinch, FeatureSheet, type PinchMark, type PlacedTool, type RuleSetFile, Units, type Vec3, hitFigure, llmRulePrompt, parseRuleSetFile, pinchLabel, pinchMark, placePinchTool, sameDepth, serializeRuleSet };

package/dist/model/index.js

@@ -14,6 +14,7 @@ import {
   featureTypeLabel,
   hitFigure,
   isDrilled,
+  lengthValue,
   llmRulePrompt,
   makeRule,
   metricInfo,
@@ -26,9 +27,39 @@ import {
   sameDepth,
   serializeRuleSet,
   trimmedCurve,
+  unitLabel,
   worseUpward
 } from "../chunk-5MPHT7BC.js";
 
+// 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) => 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),
+    ...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);
@@ -329,7 +360,7 @@ var clearanceDerivation = (fit, clearance) => {
   return lines;
 };
 var trim = (value, places) => String(Number(value.toFixed(places)));
-var formatLength = (mm2, units) => units === "inch" ? `${trim(mm2 / MM_PER_INCH, LENGTH_PLACES.inch)} in` : `${trim(mm2, LENGTH_PLACES.mm)} mm`;
+var formatLength = (mm2, units, inchMark = false) => units === "inch" ? `${trim(mm2 / MM_PER_INCH, LENGTH_PLACES.inch)}${inchMark ? '"' : " in"}` : `${trim(mm2, LENGTH_PLACES.mm)} mm`;
 var SURFACE_TYPES = /* @__PURE__ */ new Set([
   "contour_surface",
   "inner_fillet",
@@ -365,10 +396,14 @@ var featureMeasurements = ({
   features,
   feature,
   sheets,
-  units
+  units,
+  inchMark = false
 }) => {
   const other = units === "inch" ? "mm" : "inch";
-  const length = (mm2) => ({ value: formatLength(mm2, units), alt: formatLength(mm2, other) });
+  const length = (mm2) => ({
+    value: formatLength(mm2, units, inchMark),
+    alt: formatLength(mm2, other, inchMark)
+  });
   const sheet = sheets[feature.tag.toLowerCase()];
   const rows = [];
   const top = sheet ? partTop(features, sheets, feature.machiningDirection) : null;
@@ -570,7 +605,7 @@ var featureMeasurements = ({
     rows.push({
       key: "thread",
       label: "Thread",
-      value: `${formatLength(sheet.threading.basicDiameter, units)} \xD7 ${formatLength(sheet.threading.threadPitch, units)} pitch`,
+      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)}`
@@ -742,16 +777,250 @@ var featureSheet = (datasheet) => {
     ...threading ? { threading } : {}
   };
 };
+
+// src/model/pinch-mark.ts
+import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
+var MAX_DRAWN_TOOL_MM = 3 * MM_PER_INCH2;
+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)
+  };
+};
 export {
   CRITICAL_COLOR,
   FILE_KIND,
   PINCH_TOOL_MM,
   RULE_COLORS,
   WARNING_COLOR,
+  brokenRules,
   checkPart,
   compareColors,
   describeRule,
   dfmFeatures,
+  featureColor,
   featureMeasurements,
   featureProfile,
   featureSheet,
@@ -765,6 +1034,9 @@ export {
   parseRuleSetFile,
   parseRules,
   peakHeight,
+  pinchLabel,
+  pinchMark,
+  placePinchTool,
   readPinch,
   readReachCurve,
   runStart,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@toolpath/dfm",
-  "version": "0.1.0",
-  "description": "Toolpath DFM rules: the rule list component, the rules and the part checker",
+  "version": "0.2.0",
+  "description": "Toolpath DFM rules: the rule list, the rules and the part checker, and the feature panel",
   "license": "MIT",
   "engines": {
     "node": ">=20"