@toolpath/dfm 0.4.0 → 1.0.0

package/dist/chunk-XHYPKN4E.js

@@ -0,0 +1,3422 @@
+// src/model/dfm-metrics.ts
+import { MM_PER_INCH } from "@toolpath/tool-support";
+
+// src/model/direction-label.ts
+var EPSILON = 1e-6;
+var trim = (value) => Number.parseFloat(value.toFixed(3)).toString();
+var directionLabel = (direction) => {
+  const axes = [
+    ["X", direction.x],
+    ["Y", direction.y],
+    ["Z", direction.z]
+  ];
+  const nonZero = axes.filter(([, value]) => Math.abs(value) > EPSILON);
+  const [axis] = nonZero;
+  if (nonZero.length === 1 && axis && Math.abs(Math.abs(axis[1]) - 1) < EPSILON) {
+    return `${axis[1] > 0 ? "+" : "\u2212"}${axis[0]}`;
+  }
+  return axes.map(([, value]) => trim(value)).join(", ");
+};
+
+// src/model/geometry.ts
+var dfmFeatures = (features) => {
+  const read = features.map(
+    ({ featureTag, featureType, machiningDirection: { x, y, z }, regionIdxs }) => ({
+      tag: featureTag,
+      featureType,
+      machiningDirection: { x, y, z },
+      regionIdxs
+    })
+  );
+  const directions = [];
+  read.forEach(({ machiningDirection }) => {
+    if (!directions.some((each) => sameDirection(each, machiningDirection)))
+      directions.push(machiningDirection);
+  });
+  const numbered = directions.flatMap(
+    (direction) => read.filter((feature) => sameDirection(feature.machiningDirection, direction))
+  );
+  const numberOf = new Map(numbered.map((feature, index) => [feature, index + 1]));
+  return read.map((feature) => ({ ...feature, number: numberOf.get(feature) ?? 0 }));
+};
+var TOLERANCE = 1e-6;
+var sameDirection = (a, b) => Math.abs(a.x - b.x) < TOLERANCE && Math.abs(a.y - b.y) < TOLERANCE && Math.abs(a.z - b.z) < TOLERANCE;
+var featureTypeLabel = (featureType) => {
+  const words = featureType.replace(/_/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+var partTop = (features, sheets, direction) => {
+  let top = null;
+  for (const other of features) {
+    const zMax = sheets[other.tag.toLowerCase()]?.extendedZMax;
+    if (zMax !== void 0 && sameDirection(other.machiningDirection, direction)) {
+      top = top === null ? zMax : Math.max(top, zMax);
+    }
+  }
+  return top;
+};
+var FLAT_TIP_DEG = 0.5;
+var isDrilled = (sheet) => sheet?.diameter !== void 0 && sheet.diameter > 0 && !(sheet.tipAngle !== void 0 && sheet.tipAngle >= 180 - FLAT_TIP_DEG);
+var featureLd = (features, feature, sheets) => {
+  const sheet = sheets[feature.tag.toLowerCase()];
+  const top = sheet ? partTop(features, sheets, feature.machiningDirection) : null;
+  const bottom = sheet?.zMin;
+  if (!sheet || top === null || bottom === void 0) return null;
+  const drilling = isDrilled(sheet);
+  const [basis, across] = sheet.diameter !== void 0 ? ["bore", sheet.diameter] : sheet.pinchDiameter !== void 0 ? ["pinch", sheet.pinchDiameter] : [
+    "radius",
+    sheet.sharpCorners || sheet.cornerRadius === void 0 ? void 0 : 2 * sheet.cornerRadius
+  ];
+  if (across === void 0 || across <= 0) return null;
+  const atLeast = basis !== "bore" && sheet.cornerRadiusUnresolved === true;
+  return {
+    ratio: (top - bottom) / across,
+    ...sheet.zMax !== void 0 ? { featureRatio: (sheet.zMax - bottom) / across } : {},
+    drilling,
+    atLeast,
+    basis,
+    across
+  };
+};
+
+// src/model/dfm-metrics.ts
+var define = ({ start, path, ...spec }) => ({
+  ...spec,
+  start: typeof start === "number" ? { mm: start, inch: start } : start,
+  ...path === void 0 ? {} : { path: typeof path === "string" ? [path] : path }
+});
+var SMALL = { mm: 1, inch: 1.27 };
+var TOOL = { mm: 3, inch: 3.175 };
+var DEEP = { mm: 50, inch: 50.8 };
+var AREA = { mm: 1e3, inch: 645.16 };
+var cd = (band, bound) => [
+  `facts.cd.${band}.${bound}`,
+  `facts.three.cd.${band}.${bound}`
+];
+var ALWAYS = "Always";
+var SIZE = "Size and depth";
+var TOOLS = "Tool access";
+var AREAS = "Surface area";
+var MAKE = "Machining";
+var HOLE = "Holes";
+var THREAD = "Threads";
+var CHAMFER = "Chamfers";
+var OUTLINES = "Floors, fillets and outlines";
+var FACES = "Faces and profiles";
+var SURFACE = "3D surfaces";
+var UNDERCUT = "Undercuts";
+var PRESENCE_METRIC = define({
+  key: "present",
+  label: "any size",
+  group: ALWAYS,
+  quantity: "presence",
+  op: "gte",
+  start: 0,
+  hint: "Flags every feature of this type, whatever its geometry"
+});
+var LD_METRIC = define({
+  key: "ld",
+  label: "L/D to top of part",
+  group: SIZE,
+  quantity: "ratio",
+  op: "gte",
+  start: 5,
+  hint: "How far down the tool reaches: depth below the top of the part over its minimum clearance \u2014 a hole\u2019s over its bore; twice its inside corner radius where there are no pinch points. None for a sharp corner with no clearance"
+});
+var FEATURE_LD_METRIC = define({
+  key: "featureLd",
+  label: "feature L/D",
+  group: SIZE,
+  quantity: "ratio",
+  op: "gte",
+  start: 5,
+  hint: "The feature\u2019s own depth (its top to its bottom) over the same clearance as L/D to top of part: what its walls ask of the cutter, however deep in the part it sits"
+});
+var FEATURE_METRICS = [
+  PRESENCE_METRIC,
+  LD_METRIC,
+  FEATURE_LD_METRIC,
+  define({
+    key: "depthBelowTop",
+    label: "depth below top",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: DEEP,
+    hint: "How far below the top of the part the feature bottoms out"
+  }),
+  define({
+    key: "featureDepth",
+    label: "feature depth",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 25, inch: MM_PER_INCH },
+    hint: "The feature\u2019s own depth, top to bottom"
+  }),
+  define({
+    key: "faceCount",
+    label: "number of faces",
+    group: SIZE,
+    quantity: "count",
+    op: "gte",
+    start: 10,
+    hint: "How many faces of the model make it up"
+  }),
+  define({
+    key: "zMin",
+    label: "bottom (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "lte",
+    start: 0,
+    signed: true,
+    path: "zMin",
+    hint: "The feature\u2019s bottom along its tool axis, in the Engine\u2019s frame"
+  }),
+  define({
+    key: "zMax",
+    label: "top (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "zMax",
+    hint: "The feature\u2019s top along its tool axis, in the Engine\u2019s frame"
+  }),
+  define({
+    key: "extendedZMin",
+    label: "pass bottom (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "lte",
+    start: 0,
+    signed: true,
+    path: "extendedZMin",
+    hint: "Where a pass over it runs out: its bottom, or lower where a chamfer on a far edge deepens it"
+  }),
+  define({
+    key: "extendedZMax",
+    label: "pass top (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "extendedZMax",
+    hint: "Where a pass over it starts: its top, or higher where a chamfer or fillet sits on its mouth"
+  }),
+  define({
+    key: "reachHeight",
+    label: "material height beside it",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: DEEP,
+    hint: "The highest the material stands anywhere outboard of it (its reach curve), which a tool\u2019s holder must clear"
+  }),
+  define({
+    key: "maxTool",
+    label: "largest tool that fits",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("ignore", "min"),
+    hint: "The widest cutter that still reaches every point"
+  }),
+  define({
+    key: "cornerRadius",
+    label: "inside corner radius",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    hint: "The radius of its tightest corner between walls, as drawn \u2014 zero when sharp. Not a floor fillet"
+  }),
+  define({
+    key: "maxToolSomewhere",
+    label: "largest tool that fits anywhere",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("ignore", "max"),
+    hint: "The widest cutter that fits somewhere in it"
+  }),
+  define({
+    key: "maxToolDeviate",
+    label: "largest tool within tolerance",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("deviate", "min"),
+    hint: "The widest cutter that reaches every point, allowing the reported tolerance band"
+  }),
+  define({
+    key: "maxToolAdaptive",
+    label: "largest adaptive tool",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("effectiveAdaptive", "min"),
+    hint: "The widest cutter that reaches every point once adaptive-cutting allowances are applied"
+  }),
+  define({
+    key: "terminalCornerRadius",
+    label: "finishing corner radius limit",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.cd.terminalCornerRadius", "facts.three.cd.terminalCornerRadius"],
+    hint: "The corner radius a finishing tool must not exceed"
+  }),
+  define({
+    key: "maxBottomDiameter",
+    label: "largest tool bottom",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.maxBottomDiameter", "facts.three.maxBottomDiameter"],
+    kinds: ["Pocket", "Boss", "Face", "Three", "Chamfer"],
+    hint: "The widest bottom a finishing tool may have"
+  }),
+  define({
+    key: "pinchPoints",
+    label: "tight spots",
+    group: TOOLS,
+    quantity: "count",
+    op: "gte",
+    start: 2,
+    hint: "How many places it narrows to its tightest clearance (the Engine reports up to ten)"
+  }),
+  define({
+    key: "pinchDiameter",
+    label: "minimum clearance",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    hint: "The widest circle that fits where it is tightest: its smallest pinch disc, the Engine\u2019s tolerance taken out. Only for the kinds the Engine reports pinch points for; a sharp corner is its own rule"
+  }),
+  define({
+    key: "sharpCorner",
+    label: "a sharp inside corner",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "A vertical corner between its walls with no radius, which no end mill makes. Not a floor fillet"
+  }),
+  define({
+    key: "noToolFits",
+    label: "no room for any tool",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "No cutter fits anywhere in it"
+  }),
+  define({
+    key: "tilted",
+    label: "a tilted tool axis",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "Machined along a direction that is not one of the part\u2019s six square ones: a 5-axis setup"
+  }),
+  define({
+    key: "surfaceArea",
+    label: "surface area",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    hint: "Its whole surface: the Engine\u2019s partition of it, or its faces\u2019 areas together"
+  }),
+  define({
+    key: "projectedFloorArea",
+    label: "floor area (projected)",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: ["projectedFloorArea", "floorishArea"],
+    hint: "Area machined floor-wise, square to the tool axis"
+  }),
+  define({
+    key: "projectedWallArea",
+    label: "wall area (projected)",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: ["projectedWallArea", "wallishArea"],
+    hint: "Area machined wall-wise, along the tool axis"
+  }),
+  define({
+    key: "floorArea",
+    label: "floor surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.floorArea",
+    hint: "Surface square to the tool axis"
+  }),
+  define({
+    key: "wallArea",
+    label: "wall surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.wallArea",
+    hint: "Surface running along the tool axis"
+  }),
+  define({
+    key: "filletArea",
+    label: "fillet surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.filletArea",
+    hint: "The concave rounds between floors and walls"
+  }),
+  define({
+    key: "chamferArea",
+    label: "chamfer surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.chamferArea",
+    hint: "The bevels"
+  }),
+  define({
+    key: "contourArea",
+    label: "3D surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.contourArea",
+    hint: "Surface with no flat to stand on"
+  }),
+  define({
+    key: "hasFloor",
+    label: "a floor",
+    group: MAKE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "hasFloor",
+    hint: "It has a floor machined square to the tool axis"
+  }),
+  define({
+    key: "hasWall",
+    label: "a wall",
+    group: MAKE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "hasWall",
+    hint: "It has a wall machined along the tool axis"
+  }),
+  define({
+    key: "axialStock",
+    label: "axial stock to leave",
+    group: MAKE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 0.1, inch: 0.127 },
+    path: "axialStockToLeave",
+    hint: "Material left along the tool axis for a later operation"
+  }),
+  define({
+    key: "radialStock",
+    label: "radial stock to leave",
+    group: MAKE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 0.1, inch: 0.127 },
+    path: "radialStockToLeave",
+    hint: "Material left radially for a later operation"
+  }),
+  define({
+    key: "tolIgnore",
+    label: "ignored tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.01, inch: 0.0127 },
+    path: "toleranceBand.atolIgnore",
+    hint: "Deviation at or below this is ignored"
+  }),
+  define({
+    key: "tolDeviate",
+    label: "reported tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.02, inch: 0.0254 },
+    path: "toleranceBand.atolDeviate",
+    hint: "Deviation up to this is reported"
+  }),
+  define({
+    key: "tolMax",
+    label: "tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.05, inch: 0.0508 },
+    path: "toleranceBand.atolMax",
+    hint: "The most it may deviate from the model"
+  }),
+  define({
+    key: "passLength",
+    label: "pass length",
+    group: OUTLINES,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 500, inch: 508 },
+    path: ["facts.wallLength.length", "facts.length"],
+    kinds: ["Pocket", "Boss", "Wall", "Profile"],
+    hint: "How far a pass around its outline travels, with a tool of no width"
+  }),
+  define({
+    key: "diameter",
+    label: "diameter",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 1.5, inch: 1.5875 },
+    path: "facts.diameter",
+    kinds: ["Hole"],
+    hint: "What the hole is drilled to \u2014 narrower than modelled for a threaded hole"
+  }),
+  define({
+    key: "coneAngle",
+    label: "tip angle",
+    group: HOLE,
+    quantity: "angle",
+    op: "lte",
+    start: 118,
+    path: "facts.fullConeDeg",
+    kinds: ["Hole"],
+    hint: "The full angle of the cone at its bottom; 180\xB0 for a flat bottom"
+  }),
+  define({
+    key: "counterbore",
+    label: "a counterbore",
+    group: HOLE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isCounterbore",
+    kinds: ["Hole"],
+    hint: "A larger bore at its mouth"
+  }),
+  define({
+    key: "maxSpot",
+    label: "largest spot drill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxSpotDiameter",
+    kinds: ["Hole"],
+    hint: "The widest spot drill that reaches it without collision"
+  }),
+  define({
+    key: "minDrill",
+    label: "smallest drill",
+    group: HOLE,
+    quantity: "length",
+    op: "gte",
+    start: TOOL,
+    path: "facts.minDrillDiameter",
+    kinds: ["Hole"],
+    hint: "The narrowest drill that leaves it within its undersize"
+  }),
+  define({
+    key: "maxDrill",
+    label: "largest drill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxDrillDiameter",
+    kinds: ["Hole"],
+    hint: "The widest drill that leaves it within its oversize"
+  }),
+  define({
+    key: "maxEndmill",
+    label: "largest endmill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxEndmillDiameter",
+    kinds: ["Hole"],
+    hint: "The widest endmill that can machine it"
+  }),
+  define({
+    key: "floorFillet",
+    label: "floor fillet",
+    group: OUTLINES,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.5, inch: 0.396875 },
+    path: "facts.filletRadius",
+    kinds: ["Hole", "Pocket", "Boss", "Dovetail", "Tslot"],
+    hint: "The radius where the floor meets the walls; zero when sharp"
+  }),
+  define({
+    key: "filletHeight",
+    label: "floor fillet height",
+    group: OUTLINES,
+    quantity: "length",
+    op: "gte",
+    start: SMALL,
+    path: "facts.filletHeight",
+    kinds: ["Hole", "Pocket", "Boss"],
+    hint: "How high the floor blend runs; zero when sharp"
+  }),
+  define({
+    key: "threaded",
+    label: "a thread",
+    group: THREAD,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.threading.spec.threadPitch",
+    kinds: ["Hole"],
+    hint: "The model threads it"
+  }),
+  define({
+    key: "threadPitch",
+    label: "thread pitch",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.5, inch: 0.4536 },
+    path: "facts.threading.spec.threadPitch",
+    kinds: ["Hole"],
+    hint: "A modelled thread\u2019s pitch (0.454 mm is 56 TPI)"
+  }),
+  define({
+    key: "threadDiameter",
+    label: "thread size",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 3, inch: 3.175 },
+    path: "facts.threading.spec.basicDiameter",
+    kinds: ["Hole"],
+    hint: "The thread\u2019s nominal major diameter"
+  }),
+  define({
+    key: "threadMinorMin",
+    label: "thread minor diameter (min)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.minMinorDiameter",
+    kinds: ["Hole"],
+    hint: "The smallest minor diameter allowed"
+  }),
+  define({
+    key: "threadMinorMax",
+    label: "thread minor diameter (max)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.maxMinorDiameter",
+    kinds: ["Hole"],
+    hint: "The largest minor diameter allowed"
+  }),
+  define({
+    key: "threadMajorMin",
+    label: "thread major diameter (min)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.minMajorDiameter",
+    kinds: ["Hole"],
+    hint: "The smallest major diameter allowed"
+  }),
+  define({
+    key: "threadPercentage",
+    label: "thread percentage",
+    group: THREAD,
+    quantity: "percent",
+    op: "gte",
+    start: 75,
+    path: "facts.threading.spec.threadPercentage",
+    kinds: ["Hole"],
+    hint: "How much of the theoretical thread depth is to be formed"
+  }),
+  define({
+    key: "chamferAngle",
+    label: "chamfer angle",
+    group: CHAMFER,
+    quantity: "angle",
+    op: "gte",
+    start: 60,
+    path: "facts.bevel.angleDeg",
+    kinds: ["Chamfer"],
+    hint: "Between the bevel and the tool axis: the half angle of the tool that cuts it. A standard 90\xB0 chamfer mill is 45\xB0"
+  }),
+  define({
+    key: "chamferSlant",
+    label: "bevel length",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 2, inch: 2.54 },
+    path: "facts.bevel.slant",
+    kinds: ["Chamfer"],
+    hint: "How far the bevel runs along its slope: the cutting edge a tool needs to span it in one pass"
+  }),
+  define({
+    key: "chamferRoom",
+    label: "room under the bevel (tool-axis Z)",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "facts.bevel.lowerAdjacentZMin",
+    kinds: ["Chamfer"],
+    hint: "The highest bottom among the features it stands on: how far a tool can overshoot below it"
+  }),
+  define({
+    key: "openPocketEdge",
+    label: "an open pocket edge",
+    group: CHAMFER,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.bevel.isOpenPocketBottom",
+    kinds: ["Chamfer"],
+    hint: "It breaks the edge along an open pocket\u2019s floor"
+  }),
+  define({
+    key: "countersink",
+    label: "a countersink",
+    group: CHAMFER,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.bevel.countersink.outerRadius",
+    kinds: ["Chamfer"],
+    hint: "The bevel is a countersink of revolution"
+  }),
+  define({
+    key: "countersinkOuter",
+    label: "countersink radius",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: TOOL,
+    path: "facts.bevel.countersink.outerRadius",
+    kinds: ["Chamfer"],
+    hint: "The radius it opens to at its upper edge"
+  }),
+  define({
+    key: "countersinkInner",
+    label: "countersink pilot radius",
+    group: CHAMFER,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: "facts.bevel.countersink.innerRadius",
+    kinds: ["Chamfer"],
+    hint: "The radius of the pilot hole it starts from"
+  }),
+  define({
+    key: "topFace",
+    label: "the top face",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isTopFace",
+    kinds: ["Face"],
+    hint: "The highest surface of the part along the tool axis"
+  }),
+  define({
+    key: "facing",
+    label: "facing",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isFacing",
+    kinds: ["Face"],
+    hint: "A top face that is to be faced off"
+  }),
+  define({
+    key: "modifiedProfile",
+    label: "a bridged outline",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isModified",
+    kinds: ["Profile"],
+    hint: "The outline is a bridged reading of the part\u2019s silhouette"
+  }),
+  define({
+    key: "surfaceRadius",
+    label: "surface blend radius",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    signed: true,
+    path: ["facts.filletRadius", "facts.three.filletRadius"],
+    kinds: ["Three", "Chamfer"],
+    hint: "Signed by which way it turns: positive over an edge, negative into a corner"
+  }),
+  define({
+    key: "maxStepdown",
+    label: "largest stepdown",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.maxStepdown", "facts.three.maxStepdown"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The deepest cut taken in one pass down it"
+  }),
+  define({
+    key: "cuspHeight",
+    label: "finish scallop",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.01, inch: 0.0127 },
+    path: ["facts.surfaceFinishCuspHeight", "facts.three.surfaceFinishCuspHeight"],
+    kinds: ["Three", "Chamfer"],
+    hint: "How much scallop the finishing pass may leave"
+  }),
+  define({
+    key: "surfaceSharpCorner",
+    label: "a sharp surface corner",
+    group: SURFACE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: ["facts.hasSharpCorner", "facts.three.hasSharpCorner"],
+    kinds: ["Three", "Chamfer"],
+    hint: "It includes a sharp corner a tool must respect"
+  }),
+  define({
+    key: "ballOnly",
+    label: "ball-only finishing",
+    group: SURFACE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: ["facts.useOnlyBallToolsForFinish", "facts.three.useOnlyBallToolsForFinish"],
+    kinds: ["Three", "Chamfer"],
+    hint: "Only ball tools suit the finishing pass"
+  }),
+  define({
+    key: "fitCornerRadius",
+    label: "surface corner radius",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.toolFit.cornerRadius", "facts.three.toolFit.cornerRadius"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The corner radius its shape admits"
+  }),
+  define({
+    key: "fitToolDiameter",
+    label: "largest tool its shape admits",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.toolFit.toolDiameter", "facts.three.toolFit.toolDiameter"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The widest full-diameter tool its shape admits"
+  }),
+  define({
+    key: "fitToolBottom",
+    label: "largest tool bottom its shape admits",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.toolFit.toolBottomDiameter", "facts.three.toolFit.toolBottomDiameter"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The widest tool bottom its shape admits"
+  }),
+  define({
+    key: "undercutDepth",
+    label: "undercut depth",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 5, inch: 5.08 },
+    path: "facts.undercutDepth",
+    kinds: ["Tslot"],
+    hint: "How far the groove runs back from its opening"
+  }),
+  define({
+    key: "maxEntry",
+    label: "largest tool that gets in",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.maxEntryCd",
+    kinds: ["Tslot"],
+    hint: "The widest tool that can come down through the opening above it"
+  }),
+  define({
+    key: "closedSlot",
+    label: "a closed outline",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isClosed",
+    kinds: ["Tslot"],
+    hint: "Its walls close on themselves in plan view"
+  }),
+  define({
+    key: "externalUndercut",
+    label: "an external undercut",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isExternal",
+    kinds: ["Tslot", "Dovetail"],
+    hint: "It runs around material standing in it, or runs out somewhere"
+  }),
+  define({
+    key: "taper",
+    label: "dovetail taper",
+    group: UNDERCUT,
+    quantity: "angle",
+    op: "gte",
+    start: 45,
+    path: "facts.taperDeg",
+    kinds: ["Dovetail"],
+    hint: "Between the overhanging wall and the tool axis"
+  }),
+  define({
+    key: "floorWidth",
+    label: "dovetail floor width",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.floorWidth",
+    kinds: ["Dovetail"],
+    hint: "The widest clearance over the floor"
+  }),
+  define({
+    key: "topOpening",
+    label: "dovetail top opening",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.topOpeningWidth",
+    kinds: ["Dovetail"],
+    hint: "The clearance through the opening at its top"
+  }),
+  define({
+    key: "bottomOpening",
+    label: "dovetail bottom opening",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.bottomOpeningWidth",
+    kinds: ["Dovetail"],
+    hint: "The clearance just above the floor, under the overhangs"
+  }),
+  define({
+    key: "invalidDovetail",
+    label: "unmeasured geometry",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isInvalidGeometry",
+    kinds: ["Dovetail"],
+    hint: "A width could not be measured, so no tool is offered on its figures"
+  })
+];
+var HOLE_KINDS = ["Hole"];
+var POCKET_KINDS = ["Pocket"];
+var SURFACE_KINDS = ["Three"];
+var UNDERCUT_KINDS = ["Tslot", "Dovetail"];
+var GROUP_SUBJECTS = [
+  { value: "any", label: "Any feature", group: "Groups" },
+  { value: "milled", label: "Milled features", group: "Groups" },
+  { value: "drilled", label: "Drilled features", group: "Groups", kinds: HOLE_KINDS },
+  { value: "hole", label: "Holes", group: "Groups", kinds: HOLE_KINDS },
+  { value: "threadedHole", label: "Threaded holes", group: "Groups", kinds: HOLE_KINDS },
+  { value: "pocket", label: "Pockets", group: "Groups", kinds: POCKET_KINDS },
+  { value: "slot", label: "Slots", group: "Groups", kinds: UNDERCUT_KINDS },
+  { value: "undercut", label: "Undercuts", group: "Groups", kinds: UNDERCUT_KINDS },
+  { value: "boss", label: "Bosses", group: "Groups", kinds: ["Boss"] },
+  { value: "countersink", label: "Countersinks", group: "Groups", kinds: ["Hole", "Chamfer"] },
+  { value: "profile", label: "Profiles", group: "Groups", kinds: ["Profile"] },
+  { value: "contour", label: "3D surfaces", group: "Groups", kinds: SURFACE_KINDS },
+  { value: "wall", label: "Walls", group: "Groups", kinds: ["Wall"] },
+  { value: "face", label: "Faces", group: "Groups", kinds: ["Face", "Three"] },
+  { value: "fillet", label: "Fillets", group: "Groups", kinds: SURFACE_KINDS },
+  { value: "chamfer", label: "Chamfers", group: "Groups", kinds: ["Chamfer"] }
+];
+var TYPES = [
+  ["through_hole", "Through holes", HOLE_KINDS],
+  ["blind_hole", "Blind holes", HOLE_KINDS],
+  ["filleted_blind_hole", "Filleted blind holes", HOLE_KINDS],
+  ["tapered_through_hole", "Tapered through holes", HOLE_KINDS],
+  ["threaded_through_hole", "Threaded through holes", HOLE_KINDS],
+  ["threaded_blind_hole", "Threaded blind holes", HOLE_KINDS],
+  ["synthetic_hole", "Synthetic holes", HOLE_KINDS],
+  ["thread", "Threads", HOLE_KINDS],
+  ["sink", "Countersinks", ["Hole", "Chamfer"]],
+  ["back_sink", "Back countersinks", ["Hole", "Chamfer"]],
+  ["pocket", "Closed pockets", POCKET_KINDS],
+  ["open_pocket", "Open pockets", POCKET_KINDS],
+  ["through_pocket", "Through pockets", POCKET_KINDS],
+  ["filleted_pocket", "Filleted pockets", POCKET_KINDS],
+  ["filleted_open_pocket", "Filleted open pockets", POCKET_KINDS],
+  ["boss", "Bosses", ["Boss"]],
+  ["filleted_boss", "Filleted bosses", ["Boss"]],
+  ["wall", "Wall features", ["Wall"]],
+  ["face", "Face features", ["Face"]],
+  ["slanted_face", "Slanted faces", ["Face", "Three"]],
+  ["profile", "Profiles", ["Profile"]],
+  ["chamfer", "Chamfer features", ["Chamfer"]],
+  ["back_chamfer", "Back chamfers", ["Chamfer"]],
+  ["fillet", "Fillet features", SURFACE_KINDS],
+  ["inner_fillet", "Inner fillets", SURFACE_KINDS],
+  ["outer_fillet", "Outer fillets", SURFACE_KINDS],
+  ["contour_surface", "Contour surfaces", SURFACE_KINDS],
+  ["u_slot", "U-slots", UNDERCUT_KINDS],
+  ["undercut_wall", "Undercut walls", UNDERCUT_KINDS],
+  ["undercut_tslot", "Undercut T-slots", ["Tslot"]],
+  ["undercut_filleted_tslot", "Filleted undercut T-slots", ["Tslot"]],
+  ["undercut_dovetail", "Undercut dovetails", ["Dovetail"]],
+  ["undercut_filleted_dovetail", "Filleted undercut dovetails", ["Dovetail"]]
+];
+var TYPE_SUBJECT = "type:";
+var FEATURE_SUBJECTS = [
+  ...GROUP_SUBJECTS,
+  ...TYPES.map(([type, label, kinds]) => ({
+    value: `${TYPE_SUBJECT}${type}`,
+    label,
+    group: "Feature types",
+    kinds
+  }))
+];
+var QUICK_SUBJECTS = [
+  "any",
+  "milled",
+  "hole",
+  "threadedHole",
+  "countersink",
+  "pocket",
+  "boss",
+  "wall",
+  "face",
+  "profile",
+  "undercut",
+  "fillet",
+  "chamfer",
+  "contour"
+];
+var QUICK_METRICS = [
+  "present",
+  "ld",
+  "featureLd",
+  "depthBelowTop",
+  "featureDepth",
+  "diameter",
+  "cornerRadius",
+  "maxTool",
+  "pinchDiameter",
+  "sharpCorner",
+  "surfaceArea",
+  "floorFillet",
+  "threadPitch",
+  "chamferAngle",
+  "undercutDepth",
+  "tilted"
+];
+var MILLING_RULES = {
+  process: "milling",
+  metrics: FEATURE_METRICS,
+  subjects: FEATURE_SUBJECTS,
+  quickSubjects: QUICK_SUBJECTS,
+  quickMetrics: QUICK_METRICS,
+  fallbackMetric: LD_METRIC,
+  featureLabel: (feature) => ({
+    name: featureTypeLabel(feature.featureType),
+    detail: `from ${directionLabel(feature.machiningDirection)}`
+  }),
+  considerationsTitle: "Milling considerations",
+  fileName: "dfm-rules.json"
+};
+var subjectInfo = (value, vocabulary = MILLING_RULES) => vocabulary.subjects.find((each) => each.value === value);
+var metricInfo = (key, vocabulary = MILLING_RULES) => vocabulary.metrics.find((each) => each.key === key);
+var metricsForSubject = (subject, vocabulary = MILLING_RULES) => {
+  const kinds = subjectInfo(subject, vocabulary)?.kinds;
+  if (!kinds) return vocabulary.metrics;
+  return vocabulary.metrics.filter(
+    (each) => !each.kinds || each.kinds.some((kind) => kinds.includes(kind))
+  );
+};
+
+// src/model/dfm-rules.ts
+import { MM_PER_INCH as MM_PER_INCH3 } from "@toolpath/tool-support";
+
+// src/model/units.ts
+import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
+var LENGTH_PLACES = { mm: 3, inch: 3 };
+var FIELD_LENGTH_PLACES = { mm: 3, inch: 4 };
+var UNIT_LABELS = { mm: "mm", inch: "in" };
+var inUnits = (mm2, units) => units === "inch" ? mm2 / MM_PER_INCH2 : mm2;
+var lengthValue = (mm2, units) => inUnits(mm2, units).toFixed(LENGTH_PLACES[units]);
+var unitLabel = (units) => UNIT_LABELS[units];
+
+// src/model/dfm-rules.ts
+var EQUAL_TOLERANCE = 5e-3;
+var OPS = ["gte", "gt", "lte", "lt", "eq", "ne", "between"];
+var OP_SYMBOLS = {
+  gte: "\u2265",
+  gt: ">",
+  lte: "\u2264",
+  lt: "<",
+  eq: "=",
+  ne: "\u2260",
+  between: "range"
+};
+var RANGE_LOWS = ["gte", "gt"];
+var RANGE_HIGHS = ["lt", "lte"];
+var opSymbol = (op) => OP_SYMBOLS[op];
+var RULE_COLORS = [
+  { name: "Red", value: "#e5484d" },
+  { name: "Orange", value: "#f76b15" },
+  { name: "Yellow", value: "#ffd60a" },
+  { name: "Purple", value: "#8e4ec6" },
+  { name: "Green", value: "#30a46c" },
+  { name: "Cyan", value: "#00a2c7" }
+];
+var compareColors = (a, b) => {
+  const rank = (color) => {
+    const at2 = RULE_COLORS.findIndex((each) => each.value === color);
+    return at2 === -1 ? RULE_COLORS.length : at2;
+  };
+  return rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0);
+};
+var CRITICAL_COLOR = "#e5484d";
+var WARNING_COLOR = "#ffd60a";
+var RETIRED_COLORS = {
+  // Taken out of this palette.
+  "#e93d82": CRITICAL_COLOR,
+  "#99d52a": "#30a46c",
+  // The first palette.
+  "#dc2626": CRITICAL_COLOR,
+  "#f97316": "#f76b15",
+  "#eab308": WARNING_COLOR,
+  "#16a34a": "#30a46c",
+  "#0d9488": "#00a2c7",
+  "#2563eb": "#00a2c7",
+  "#9333ea": "#8e4ec6",
+  "#db2777": CRITICAL_COLOR,
+  // The Toolpath tokens.
+  "#ba5b4b": CRITICAL_COLOR,
+  "#843e32": CRITICAL_COLOR,
+  "#e07a48": "#f76b15",
+  "#d6632a": "#f76b15",
+  "#cd8e04": WARNING_COLOR,
+  "#ffe066": WARNING_COLOR,
+  "#68b688": "#30a46c",
+  "#6bb0b3": "#00a2c7"
+};
+var subjectLabel = (value, vocabulary = MILLING_RULES) => subjectInfo(value, vocabulary)?.label ?? value;
+var trim2 = (value, places) => String(Number(value.toFixed(places)));
+var SQUARE_MM_PER_SQUARE_INCH = MM_PER_INCH3 ** 2;
+var quantityUnit = (quantity, units) => {
+  switch (quantity) {
+    case "length":
+      return units === "inch" ? "in" : "mm";
+    case "area":
+      return units === "inch" ? "in\xB2" : "mm\xB2";
+    case "angle":
+      return "\xB0";
+    case "percent":
+      return "%";
+    default:
+      return "";
+  }
+};
+var withUnit = (value, unit2) => unit2 === "" ? value : unit2 === "\xB0" || unit2 === "%" ? `${value}${unit2}` : `${value} ${unit2}`;
+var toUnits = (quantity, value, units) => units !== "inch" ? value : quantity === "length" ? value / MM_PER_INCH3 : quantity === "area" ? value / SQUARE_MM_PER_SQUARE_INCH : value;
+var toField = (quantity, value, units) => {
+  const shown = toUnits(quantity, value, units);
+  return quantity === "length" ? trim2(shown, FIELD_LENGTH_PLACES[units]) : quantity === "count" ? trim2(shown, 0) : trim2(shown, 3);
+};
+var fromField = (metric, text, units) => {
+  const parsed = Number(text.trim());
+  if (text.trim() === "" || !Number.isFinite(parsed) || parsed < 0 && !metric.signed) return null;
+  if (metric.quantity === "count" && !Number.isInteger(parsed)) return null;
+  if (units !== "inch") return parsed;
+  return metric.quantity === "length" ? parsed * MM_PER_INCH3 : metric.quantity === "area" ? parsed * SQUARE_MM_PER_SQUARE_INCH : parsed;
+};
+var formatMeasured = (quantity, value, units) => {
+  const shown = toUnits(quantity, value, units);
+  switch (quantity) {
+    case "length":
+      return units === "inch" ? `${trim2(shown, LENGTH_PLACES.inch)}"` : `${trim2(shown, LENGTH_PLACES.mm)} mm`;
+    case "area":
+      return `${Number(shown.toFixed(3)).toLocaleString(void 0, { maximumFractionDigits: 3 })} ${quantityUnit("area", units)}`;
+    case "angle":
+      return `${trim2(shown, 3)}\xB0`;
+    case "percent":
+      return `${trim2(shown, 3)}%`;
+    case "count":
+      return trim2(shown, 0);
+    case "flag":
+    case "presence":
+      return "";
+    default:
+      return trim2(shown, 3);
+  }
+};
+var describeRule = (rule, units, vocabulary = MILLING_RULES) => {
+  const info = metricInfo(rule.metric, vocabulary);
+  const subject = subjectLabel(rule.subject, vocabulary);
+  if (!info) return subject;
+  if (info.quantity === "presence") return `${subject}, ${info.label}`;
+  if (info.quantity === "flag") return `${subject} with ${info.label}`;
+  const unit2 = quantityUnit(info.quantity, units);
+  const shown = (value) => withUnit(toField(info.quantity, value, units), unit2);
+  return rule.op === "between" ? `${subject} with ${shown(rule.value)} ${lowOf(rule) === "gt" ? "<" : "\u2264"} ${info.label} ${opSymbol(highOf(rule))} ${shown(upperOf(rule))}` : `${subject} with ${info.label} ${opSymbol(rule.op)} ${shown(rule.value)}`;
+};
+var newRuleId = () => Math.random().toString(36).slice(2, 10);
+var makeRule = (subject, metricKey, units, color = WARNING_COLOR, vocabulary = MILLING_RULES) => {
+  const info = metricInfo(metricKey, vocabulary) ?? vocabulary.fallbackMetric;
+  return {
+    id: newRuleId(),
+    subject,
+    metric: info.key,
+    op: info.op,
+    value: info.start[units],
+    color
+  };
+};
+var upperOf = (rule) => rule.max ?? rule.value + Math.max(Math.abs(rule.value), 1);
+var lowOf = (rule) => rule.lowOp ?? "gte";
+var highOf = (rule) => rule.highOp ?? "lt";
+var withoutRange = ({ max: _max, lowOp: _low, highOp: _high, ...rest }) => rest;
+var withMetric = (rule, metricKey, units, vocabulary = MILLING_RULES) => {
+  const info = metricInfo(metricKey, vocabulary);
+  if (!info) return rule;
+  return { ...withoutRange(rule), metric: info.key, op: info.op, value: info.start[units] };
+};
+var withOp = (rule, op) => op === "between" ? { ...rule, op, max: upperOf(rule), lowOp: lowOf(rule), highOp: highOf(rule) } : { ...withoutRange(rule), op };
+var withSubject = (rule, subject, units, vocabulary = MILLING_RULES) => {
+  const metrics = metricsForSubject(subject, vocabulary);
+  const moved = { ...rule, subject };
+  return metrics.some((each) => each.key === rule.metric) ? moved : withMetric(moved, (metrics[0] ?? vocabulary.fallbackMetric).key, units, vocabulary);
+};
+var breaks = (rule, quantity, value) => {
+  if (quantity === "presence") return true;
+  if (quantity === "flag") return value > 0;
+  if (rule.op === "gte") return value >= rule.value;
+  if (rule.op === "gt") return value > rule.value;
+  if (rule.op === "lte") return value <= rule.value;
+  if (rule.op === "lt") return value < rule.value;
+  if (rule.op === "between") {
+    const high = upperOf(rule);
+    const aboveLow = lowOf(rule) === "gt" ? value > rule.value : value >= rule.value;
+    const belowHigh = highOf(rule) === "lte" ? value <= high : value < high;
+    return aboveLow && belowHigh;
+  }
+  const equal = Math.abs(value - rule.value) <= Math.max(Math.abs(rule.value) * EQUAL_TOLERANCE, 1e-6);
+  return rule.op === "ne" ? !equal : equal;
+};
+var worseUpward = (rule, metric) => rule.op === "gte" || rule.op === "gt" ? true : rule.op === "lte" || rule.op === "lt" ? false : metric.op !== "lte" && metric.op !== "lt";
+var COLOR = /^#[0-9a-f]{6}$/i;
+var isValue = (value, metric) => typeof value === "number" && Number.isFinite(value) && (value >= 0 || metric?.signed === true) && (metric?.quantity !== "count" || Number.isInteger(value));
+var parseRule = (raw, vocabulary) => {
+  if (!raw || typeof raw !== "object") return null;
+  const {
+    id,
+    subject,
+    metric: key,
+    op,
+    value,
+    max,
+    lowOp,
+    highOp,
+    color
+  } = raw;
+  const info = typeof key === "string" ? metricInfo(key, vocabulary) : void 0;
+  const valid = typeof id === "string" && typeof subject === "string" && subjectInfo(subject, vocabulary) !== void 0 && typeof key === "string" && info !== void 0 && OPS.includes(op) && isValue(value, info) && (op !== "between" || isValue(max, info)) && typeof color === "string" && COLOR.test(color);
+  if (!valid) return null;
+  const hex = color.toLowerCase();
+  return {
+    id,
+    subject,
+    metric: key,
+    op,
+    value,
+    ...op === "between" ? {
+      max,
+      ...RANGE_LOWS.includes(lowOp) ? { lowOp } : {},
+      ...RANGE_HIGHS.includes(highOp) ? { highOp } : {}
+    } : {},
+    color: RETIRED_COLORS[hex] ?? hex
+  };
+};
+var parseRules = (raw, vocabulary = MILLING_RULES) => Array.isArray(raw) ? raw.flatMap((each) => parseRule(each, vocabulary) ?? []) : null;
+
+// src/model/dfm-explain.ts
+var figureless = (hit) => hit.metric.quantity === "flag" || hit.metric.quantity === "presence";
+var hitFigure = (hit, units) => figureless(hit) ? "" : formatMeasured(hit.metric.quantity, hit.value, units);
+
+// src/model/broken-rules.ts
+var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
+var worstHits = (hits) => {
+  const seen = /* @__PURE__ */ new Set();
+  return byColor(hits).filter((hit) => {
+    if (seen.has(hit.metric.key)) return false;
+    seen.add(hit.metric.key);
+    return true;
+  });
+};
+var brokenRules = (check, tag, units, vocabulary = MILLING_RULES) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
+  const figure = hitFigure(hit, units);
+  return {
+    key: hit.rule.id,
+    color: hit.rule.color,
+    text: describeRule(hit.rule, units, vocabulary),
+    ...figure ? { figure } : {}
+  };
+});
+var featureColor = (check, tag, region = null) => {
+  const key = tag.toLowerCase();
+  const face = region === null ? void 0 : check.paintedFaces.get(region);
+  if (face && face.tag.toLowerCase() === key) return face.color;
+  const whole = check.paintedWhole.get(key);
+  if (whole) return whole.color;
+  if (!check.required.has(key)) return void 0;
+  return byColor(check.hitsByTag.get(key) ?? [])[0]?.rule.color;
+};
+
+// src/model/dfm-flags.ts
+var howCut = (sheet) => {
+  const drilled = isDrilled(sheet);
+  return { drilled, milled: !drilled };
+};
+var featureIs = (subject, featureType, sheet) => {
+  const type = featureType.toLowerCase();
+  const kind = sheet?.kind?.toLowerCase() ?? "";
+  if (subject.startsWith(TYPE_SUBJECT)) return type === subject.slice(TYPE_SUBJECT.length);
+  switch (subject) {
+    case "any":
+      return true;
+    case "milled":
+      return howCut(sheet).milled;
+    case "drilled":
+      return howCut(sheet).drilled;
+    case "hole":
+      return type.includes("hole") || kind === "hole";
+    case "threadedHole":
+      return sheet?.threading !== void 0;
+    case "pocket":
+      return type.includes("pocket") || kind === "pocket";
+    case "slot":
+      return type.includes("slot") || kind === "tslot";
+    case "undercut":
+      return kind === "tslot" || type.includes("undercut") || type.includes("tslot");
+    case "contour":
+      return type.includes("contour") || kind.includes("contour");
+    case "wall":
+      return type.includes("wall") || kind === "wall";
+    case "face":
+      return type === "face" || kind === "face";
+    case "fillet":
+      return type.split("_").includes("fillet") || kind.includes("fillet");
+    case "chamfer":
+      return type.includes("chamfer") || kind === "chamfer";
+    case "boss":
+      return type.includes("boss") || kind === "boss";
+    case "countersink":
+      return type === "sink";
+    case "profile":
+      return type === "profile" || kind === "profile";
+    default:
+      return false;
+  }
+};
+var at = (record2, path) => path.split(".").reduce(
+  (value, key) => typeof value === "object" && value !== null ? value[key] : void 0,
+  record2
+);
+var readPath = (datasheet, metric) => {
+  for (const path of metric.path ?? []) {
+    const value = at(datasheet, path);
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (metric.quantity === "flag") return 1;
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    return null;
+  }
+  return metric.quantity === "flag" && metric.path ? 0 : null;
+};
+var TILT = 1e-6;
+var isTilted = ({ x, y, z }) => [x, y, z].filter((each) => Math.abs(each) > TILT).length > 1;
+var featureMeasure = (metric, features, feature, { sheets, datasheets, regionAreas }) => {
+  const tag = feature.tag.toLowerCase();
+  const sheet = sheets[tag];
+  const datasheet = datasheets[tag];
+  const positive = (value) => value !== void 0 && value > 0 ? { value } : null;
+  switch (metric.key) {
+    case "present":
+      return { value: 1 };
+    case "tilted":
+      return { value: isTilted(feature.machiningDirection) ? 1 : 0 };
+    case "faceCount":
+      return { value: new Set(feature.regionIdxs).size };
+    case "ld": {
+      const ld = featureLd(features, feature, sheets);
+      return ld ? { value: ld.ratio, drilling: ld.drilling } : null;
+    }
+    case "featureLd": {
+      const ld = featureLd(features, feature, sheets);
+      return ld?.featureRatio !== void 0 ? { value: ld.featureRatio, drilling: ld.drilling } : null;
+    }
+    case "depthBelowTop": {
+      const top = partTop(features, sheets, feature.machiningDirection);
+      return top !== null && sheet?.zMin !== void 0 ? { value: top - sheet.zMin } : null;
+    }
+    case "featureDepth":
+      return sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? { value: sheet.zMax - sheet.zMin } : null;
+    // Zero is no measure at all for these: no bore, no tool, a sharp floor rather than a tiny fillet.
+    case "diameter":
+      return positive(sheet?.diameter);
+    // Zero is a measure here: a sharp corner, which a "radius ≤" rule is most of all about.
+    case "cornerRadius":
+      return sheet?.cornerRadius === void 0 ? null : { value: sheet.cornerRadius };
+    case "maxTool":
+      return positive(sheet?.maxTool);
+    case "floorFillet":
+      return positive(sheet?.filletRadius);
+    case "sharpCorner":
+      return sheet ? { value: sheet.sharpCorners ? 1 : 0 } : null;
+    case "noToolFits":
+      return sheet ? { value: sheet.noToolFits ? 1 : 0 } : null;
+    case "pinchPoints": {
+      const points = at(datasheet, "pinchPoints");
+      return Array.isArray(points) ? { value: points.length } : null;
+    }
+    // A disc under a hundredth is a sharp corner, which `sharpCorner` is for: see `pinchDiameter`.
+    case "pinchDiameter":
+      return positive(sheet?.pinchDiameter);
+    case "reachHeight": {
+      const heights = at(datasheet, "reachCurve.verticalOffset");
+      const numbers2 = Array.isArray(heights) ? heights.filter(
+        (each) => typeof each === "number" && Number.isFinite(each)
+      ) : [];
+      return numbers2.length > 0 ? { value: Math.max(...numbers2) } : null;
+    }
+    case "surfaceArea": {
+      const areas = at(datasheet, "areas");
+      if (typeof areas === "object" && areas !== null) {
+        const parts = Object.values(areas).filter(
+          (each) => typeof each === "number" && Number.isFinite(each)
+        );
+        if (parts.length > 0) return { value: parts.reduce((sum, each) => sum + each, 0) };
+      }
+      const faces = [...new Set(feature.regionIdxs)].flatMap(
+        (region) => regionAreas.get(region) ?? []
+      );
+      return faces.length > 0 ? { value: faces.reduce((sum, each) => sum + each, 0) } : null;
+    }
+    default: {
+      if (!datasheet) return null;
+      const value = readPath(datasheet, metric);
+      return value === null ? null : { value };
+    }
+  }
+};
+var featureHits = (features, feature, sources, rules) => {
+  const sheet = sources.sheets[feature.tag.toLowerCase()];
+  return rules.flatMap((rule) => {
+    const info = metricInfo(rule.metric);
+    if (!info || !featureIs(rule.subject, feature.featureType, sheet)) return [];
+    const measured = featureMeasure(info, features, feature, sources);
+    if (!measured || !breaks(rule, info.quantity, measured.value)) return [];
+    return [{ rule, metric: info, ...measured }];
+  });
+};
+var requiredTags = (features) => {
+  const owners = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const region of new Set(feature.regionIdxs))
+      owners.set(region, (owners.get(region) ?? 0) + 1);
+  }
+  return new Set(
+    features.filter((feature) => feature.regionIdxs.some((region) => owners.get(region) === 1)).map((feature) => feature.tag.toLowerCase())
+  );
+};
+var worstColor = (hits) => hits?.map((hit) => hit.rule.color).sort(compareColors)[0];
+var ruleResults = (rules, features, hitsByTag, required) => rules.map((rule) => {
+  const hits = features.flatMap((feature) => {
+    const tag = feature.tag.toLowerCase();
+    const hit = hitsByTag.get(tag)?.find((each) => each.rule.id === rule.id);
+    return hit ? [{ tag: feature.tag, value: hit.value, metric: hit.metric, required: required.has(tag) }] : [];
+  });
+  const [first] = hits;
+  const up = first ? worseUpward(rule, first.metric) : true;
+  hits.sort((a, b) => up ? b.value - a.value : a.value - b.value);
+  return {
+    rule,
+    tags: hits.filter((hit) => hit.required).map((hit) => hit.tag),
+    otherTags: hits.filter((hit) => !hit.required).map((hit) => hit.tag)
+  };
+});
+var QUALIFIERS = ["undercut", "filleted", "tslot", "dovetail"];
+var EDGE_TYPES = ["fillet", "chamfer", "sink"];
+var featureComplexity = (featureType) => {
+  const words = featureType.toLowerCase().split("_");
+  const edge = EDGE_TYPES.some((type) => words.includes(type)) ? 1 : 0;
+  return edge + QUALIFIERS.filter((word) => words.includes(word)).length;
+};
+var CONTOUR = "contour_surface";
+var unavoidableFaces = (features, hitsByTag, regionAreas) => {
+  const areaOf = (feature) => [...new Set(feature.regionIdxs)].reduce(
+    (sum, region) => sum + (regionAreas.get(region) ?? 0),
+    0
+  );
+  const owners = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const region of new Set(feature.regionIdxs)) {
+      owners.set(region, [...owners.get(region) ?? [], feature]);
+    }
+  }
+  const faces = /* @__PURE__ */ new Map();
+  const whole = /* @__PURE__ */ new Map();
+  for (const [region, candidates] of owners) {
+    const colored = candidates.map((feature) => ({
+      feature,
+      color: worstColor(hitsByTag.get(feature.tag.toLowerCase())),
+      area: areaOf(feature)
+    }));
+    const isContour = ({ feature }) => feature.featureType === CONTOUR;
+    const machined = colored.filter((each) => !isContour(each));
+    const pool = machined.length > 0 ? machined : colored;
+    if (pool.some(({ color }) => color === void 0)) continue;
+    const contour = colored.filter(isContour).reduce((kept, each) => kept === void 0 || each.area > kept.area ? each : kept, void 0);
+    if (contour?.color && colored.every(({ color }) => color !== void 0)) {
+      whole.set(contour.feature.tag.toLowerCase(), {
+        tag: contour.feature.tag,
+        color: contour.color
+      });
+      continue;
+    }
+    const best = pool.reduce((kept, each) => {
+      const plainer = featureComplexity(kept.feature.featureType) - featureComplexity(each.feature.featureType);
+      if (plainer !== 0) return plainer > 0 ? each : kept;
+      const milder = compareColors(each.color ?? "", kept.color ?? "");
+      return milder > 0 || milder === 0 && each.area > kept.area ? each : kept;
+    });
+    if (best.color) faces.set(region, { tag: best.feature.tag, color: best.color });
+  }
+  return { paintedFaces: faces, paintedWhole: whole };
+};
+var withSurroundedFaces = (check, features, adjacency) => {
+  const paintedFor = new Map(check.paintedFaces);
+  const regionsOf2 = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = feature.tag.toLowerCase();
+    regionsOf2.set(key, new Set(feature.regionIdxs));
+    const whole = check.paintedWhole.get(key);
+    if (whole) {
+      for (const region of feature.regionIdxs)
+        if (!paintedFor.has(region)) paintedFor.set(region, whole);
+    }
+  }
+  const surrounded = /* @__PURE__ */ new Map();
+  for (const [region, neighbours] of adjacency) {
+    if (paintedFor.has(region)) continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const neighbour of neighbours) {
+      const paint2 = neighbour === region ? void 0 : paintedFor.get(neighbour);
+      if (!paint2) continue;
+      const key = paint2.tag.toLowerCase();
+      counts.set(key, { paint: paint2, count: (counts.get(key)?.count ?? 0) + 1 });
+    }
+    const most = Math.max(0, ...[...counts.values()].map(({ count }) => count));
+    const [paint] = [...counts].filter(([key, { count }]) => count === most && regionsOf2.get(key)?.has(region)).map(([, { paint: paint2 }]) => paint2).sort((a, b) => compareColors(a.color, b.color));
+    if (paint) surrounded.set(region, paint);
+  }
+  if (surrounded.size === 0) return check;
+  return { ...check, paintedFaces: new Map([...check.paintedFaces, ...surrounded]) };
+};
+var checkPart = (features, sources, rules) => {
+  const required = requiredTags(features);
+  const hitsByTag = new Map(
+    features.map((feature) => [
+      feature.tag.toLowerCase(),
+      featureHits(features, feature, sources, rules)
+    ])
+  );
+  return {
+    hitsByTag,
+    required,
+    byRule: ruleResults(rules, features, hitsByTag, required),
+    ...unavoidableFaces(features, hitsByTag, sources.regionAreas)
+  };
+};
+
+// src/model/pinch.ts
+var asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf = (value) => typeof value === "object" && value !== null ? value : {};
+var clearanceFit = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const facts = recordOf(sheet.facts);
+  const chamfer = facts.kind === "Chamfer";
+  const band = recordOf(chamfer ? recordOf(facts.three).cd : facts.cd);
+  const tolerance = recordOf(sheet.toleranceBand);
+  const strict = asNumber(recordOf(band.ignore).min);
+  if (strict === void 0) return void 0;
+  const bandPath = chamfer ? "facts.three.cd" : "facts.cd";
+  const loose = asNumber(recordOf(band.deviate).min);
+  const atStrict = asNumber(tolerance.atolIgnore);
+  const atLoose = asNumber(tolerance.atolDeviate);
+  const source = { bandPath, strict, loose, atStrict, atLoose };
+  if (loose === void 0 || atStrict === void 0 || atLoose === void 0 || atLoose <= atStrict)
+    return { ...source, slack: 0, resolved: false };
+  const growth = (loose - strict) / (atLoose - atStrict);
+  const slack = growth > 0 ? Math.min(growth * atStrict, strict) : 0;
+  return { ...source, slack, resolved: true };
+};
+var readPinch = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const zMin = asNumber(sheet.zMin);
+  const zMax = asNumber(sheet.zMax);
+  if (zMin === void 0 || zMax === void 0 || !Array.isArray(sheet.pinchPoints)) return null;
+  const fit = clearanceFit(datasheet);
+  const slack = fit?.slack ?? 0;
+  const discs = sheet.pinchPoints.flatMap((point) => {
+    const centre = recordOf(recordOf(point).center);
+    const x = asNumber(centre.x);
+    const y = asNumber(centre.y);
+    const diameter = asNumber(recordOf(point).diameter);
+    return x === void 0 || y === void 0 || diameter === void 0 || diameter < 0 ? [] : [{ x, y, diameter: Math.max(diameter - slack, 0) }];
+  });
+  if (discs.length === 0) return null;
+  return { discs, zMin, zMax, ...fit && !fit.resolved ? { unresolved: true } : {} };
+};
+
+// src/model/feature-sheet.ts
+var SHARP_MM = 0.1;
+var SHARP_RADIUS_MM = 0.01;
+var PINCH_TOOL_MM = 0.01;
+var asNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf2 = (value) => typeof value === "object" && value !== null ? value : {};
+var definedOnly = (fields) => Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+var undercutOf = (facts) => {
+  const unmeasured = facts.isInvalidGeometry === true || recordOf2(facts.cd).measurementFailed === true ? true : void 0;
+  if (facts.kind === "Tslot")
+    return definedOnly({
+      undercutDepth: asNumber2(facts.undercutDepth),
+      maxEntry: asNumber2(facts.maxEntryCd),
+      isClosed: facts.isClosed === true ? true : void 0,
+      unmeasured
+    });
+  if (facts.kind === "Dovetail")
+    return definedOnly({
+      taperDeg: asNumber2(facts.taperDeg),
+      floorWidth: asNumber2(facts.floorWidth),
+      topOpeningWidth: asNumber2(facts.topOpeningWidth),
+      isExternal: facts.isExternal === true ? true : void 0,
+      unmeasured
+    });
+  return void 0;
+};
+var threadingOf = (facts) => {
+  const spec = recordOf2(recordOf2(facts.threading).spec);
+  const basicDiameter = asNumber2(spec.basicDiameter);
+  const threadPitch = asNumber2(spec.threadPitch);
+  if (basicDiameter === void 0 || threadPitch === void 0 || threadPitch <= 0) return void 0;
+  return { basicDiameter, threadPitch };
+};
+var noToolFits = (band) => {
+  const { max } = band;
+  if (typeof max === "string") return /^-inf/i.test(max.trim());
+  return typeof max === "number" && (max === Number.NEGATIVE_INFINITY || Number.isFinite(max) && max < SHARP_MM);
+};
+var insideCornerRadius = (fit) => Math.max((fit.strict - fit.slack) / 2, 0);
+var pinchCentres = (points) => Array.isArray(points) ? points.flatMap((point) => {
+  const centre = recordOf2(recordOf2(point).center);
+  const x = asNumber2(centre.x);
+  const y = asNumber2(centre.y);
+  return x === void 0 || y === void 0 ? [] : [{ x, y }];
+}) : [];
+var ZERO_MM = 5e-5;
+var isCutterlessTslot = (datasheet) => {
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  if (facts.kind !== "Tslot") return false;
+  const leaves = (value) => typeof value === "object" && value !== null ? Object.values(value).flatMap(leaves) : [value];
+  const band = leaves(facts.cd);
+  return band.length > 0 && band.every((each) => {
+    const value = typeof each === "string" && each.trim() !== "" ? Number(each) : each;
+    return typeof value === "number" && Math.abs(value) < ZERO_MM;
+  });
+};
+var isSharpCorneredFillet = (featureType, datasheet) => {
+  if (typeof featureType !== "string" || !featureType.toLowerCase().split("_").includes("fillet"))
+    return false;
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  return facts.hasSharpCorner === true || recordOf2(facts.three).hasSharpCorner === true;
+};
+var isNoReading = (featureType, datasheet) => isCutterlessTslot(datasheet) || isSharpCorneredFillet(featureType, datasheet);
+var featureSheet = (datasheet) => {
+  const sheet = recordOf2(datasheet);
+  const facts = recordOf2(sheet.facts);
+  const kind = typeof facts.kind === "string" ? facts.kind : void 0;
+  const band = recordOf2(kind === "Chamfer" ? recordOf2(facts.three).cd : facts.cd);
+  const ignoreBand = recordOf2(band.ignore);
+  const fit = clearanceFit(datasheet);
+  const fields = {
+    kind,
+    zMin: asNumber2(sheet.zMin),
+    zMax: asNumber2(sheet.zMax),
+    extendedZMax: asNumber2(sheet.extendedZMax),
+    maxTool: asNumber2(ignoreBand.min),
+    diameter: kind === "Hole" ? asNumber2(facts.diameter) : void 0,
+    tipAngle: kind === "Hole" ? asNumber2(facts.fullConeDeg) : void 0,
+    filletRadius: asNumber2(facts.filletRadius),
+    // A bevel's angle wherever the facts carry one: a chamfer's, and any other kind that bevels.
+    chamferAngle: asNumber2(recordOf2(facts.bevel).angleDeg)
+  };
+  const toolFitPath = facts.toolFit !== void 0 ? "facts.toolFit" : "facts.three.toolFit";
+  const toolFit = recordOf2(facts.toolFit ?? recordOf2(facts.three).toolFit);
+  fields.fitToolDiameter = asNumber2(toolFit.toolDiameter);
+  fields.fitCornerRadius = asNumber2(toolFit.cornerRadius);
+  const ballOnly = (facts.useOnlyBallToolsForFinish ?? recordOf2(facts.three).useOnlyBallToolsForFinish) === true;
+  const 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 as MM_PER_INCH4 } from "@toolpath/tool-support";
+var mm = (value) => `${trim3(value, 4)} mm`;
+var tol = (value) => `${trim3(value, 6)} mm`;
+var clearanceDerivation = (fit, clearance) => {
+  const { bandPath, strict, loose, atStrict, atLoose } = fit;
+  const lines = [`\u2300\u2081 = ${bandPath}.ignore.min = ${mm(strict)}`];
+  if (loose === void 0 || atStrict === void 0 || atLoose === void 0 || atLoose <= atStrict) {
+    lines.push(
+      `${bandPath}.deviate.min or a tolerance is missing, so the tolerance cannot be taken out:`,
+      `clearance \u2264 \u2300\u2081 = ${mm(clearance)}`
+    );
+    return lines;
+  }
+  const growth = (loose - strict) / (atLoose - atStrict);
+  lines.push(
+    `   at t\u2081 = toleranceBand.atolIgnore = ${tol(atStrict)}`,
+    `\u2300\u2082 = ${bandPath}.deviate.min = ${mm(loose)}`,
+    `   at t\u2082 = toleranceBand.atolDeviate = ${tol(atLoose)}`
+  );
+  if (growth <= 0) {
+    lines.push("The tool does not grow with tolerance (a gap, not a corner): clearance = \u2300\u2081");
+  } else {
+    lines.push(
+      `k = (\u2300\u2082 \u2212 \u2300\u2081) / (t\u2082 \u2212 t\u2081) = ${trim3(growth, 3)}`,
+      `slack = k \xD7 t\u2081 = ${mm(growth * atStrict)}, what the tolerance adds to every tool`,
+      `clearance = \u2300\u2081 \u2212 slack`
+    );
+  }
+  lines.push(`clearance = ${mm(clearance)}`);
+  return lines;
+};
+var trim3 = (value, places) => String(Number(value.toFixed(places)));
+var formatLength = (mm2, units, inchMark = false) => units === "inch" ? `${trim3(mm2 / MM_PER_INCH4, LENGTH_PLACES.inch)}${inchMark ? '"' : " in"}` : `${trim3(mm2, LENGTH_PLACES.mm)} mm`;
+var SURFACE_TYPES = /* @__PURE__ */ new Set([
+  "contour_surface",
+  "inner_fillet",
+  "outer_fillet",
+  "fillet"
+]);
+var isSurfaceType = (featureType) => SURFACE_TYPES.has(featureType);
+var maxBallDiameter = (sheet) => {
+  const { fitToolDiameter: diameter, fitCornerRadius: corner } = sheet;
+  if (corner === void 0 || corner <= 0) return void 0;
+  return diameter !== void 0 && diameter > 0 ? Math.min(diameter, 2 * corner) : 2 * corner;
+};
+var ROW_ORDER = [
+  "featureDepth",
+  "undercutWidth",
+  "floorWidth",
+  "openingWidth",
+  "undercutDepth",
+  "taper",
+  "diameter",
+  "cornerRadius",
+  "filletRadius",
+  "floorFillet",
+  "tipAngle",
+  "thread",
+  "bevelAngle",
+  "finishTool",
+  "undercutCutter",
+  "maxShaft",
+  "pinch",
+  "fitCornerRadius",
+  "maxBull",
+  "maxBall",
+  "depthBelowTop",
+  "ld",
+  "featureLd",
+  "topLd"
+];
+var featureMeasurements = ({
+  features,
+  feature,
+  sheets,
+  units,
+  inchMark = false
+}) => {
+  const other = units === "inch" ? "mm" : "inch";
+  const length = (mm2) => ({
+    value: formatLength(mm2, units, inchMark),
+    alt: formatLength(mm2, other, inchMark)
+  });
+  const sheet = sheets[feature.tag.toLowerCase()];
+  const rows = [];
+  const undercut = sheet?.undercut;
+  const top = sheet ? partTop(features, sheets, feature.machiningDirection) : null;
+  const bottom = sheet?.zMin;
+  const topFrom = top === null ? void 0 : features.find((each) => sheets[each.tag.toLowerCase()]?.extendedZMax === top);
+  const topLine = top === null ? "" : `Top of part = the highest extendedZMax of the features machined from this direction = ${mm(top)}${topFrom ? ` (${featureTypeLabel(topFrom.featureType)} ${topFrom.tag})` : ""}`;
+  if (top !== null && bottom !== void 0) {
+    rows.push({
+      key: "depthBelowTop",
+      label: "Depth below top of part",
+      milling: true,
+      ...length(top - bottom),
+      derivation: [topLine, `Top \u2212 zMin = ${mm(top)} \u2212 ${mm(bottom)} = ${mm(top - bottom)}`]
+    });
+  }
+  if (sheet?.zMax !== void 0 && bottom !== void 0 && !(undercut && sheet?.kind === "Tslot")) {
+    rows.push({
+      key: "featureDepth",
+      label: "Feature depth",
+      ...length(sheet.zMax - bottom),
+      derivation: [`zMax \u2212 zMin = ${mm(sheet.zMax)} \u2212 ${mm(bottom)} = ${mm(sheet.zMax - bottom)}`]
+    });
+  }
+  if (sheet?.diameter !== void 0) {
+    rows.push({
+      key: "diameter",
+      label: "Diameter",
+      ...length(sheet.diameter),
+      derivation: [`facts.diameter = ${mm(sheet.diameter)}`]
+    });
+  }
+  if (sheet?.cornerRadius !== void 0 && !undercut) {
+    const radius = length(sheet.cornerRadius);
+    rows.push({
+      key: "cornerRadius",
+      label: sheet.sharpCorners ? "Minimum radius (sharp)" : "Minimum radius",
+      // Measured at one tolerance only, it is the most the modelled radius can be, not the radius itself.
+      ...sheet.cornerRadiusUnresolved ? { value: `\u2264 ${radius.value}`, alt: `\u2264 ${radius.alt}` } : radius,
+      derivation: [
+        "The tightest corner between walls: half the minimum clearance, the widest tool that reaches every point with the tolerance it was measured to taken out.",
+        ...sheet.clearance ? clearanceDerivation(sheet.clearance, 2 * sheet.cornerRadius) : [],
+        `R = clearance / 2 = ${mm(sheet.cornerRadius)}${sheet.sharpCorners ? " (under 0.01 mm: sharp)" : ""}`
+      ]
+    });
+  }
+  if (!sheet?.sharpCorners && !undercut) {
+    const clearance = sheet?.pinchDiameter ?? (sheet?.cornerRadius !== void 0 ? 2 * sheet.cornerRadius : void 0);
+    if (clearance !== void 0) {
+      const width = length(clearance);
+      const places = sheet?.pinchPlaces;
+      const floor = !SURFACE_TYPES.has(feature.featureType) && sheet?.filletRadius !== void 0 && sheet.filletRadius > 0 ? length(sheet.filletRadius) : void 0;
+      const atMost = sheet?.cornerRadiusUnresolved ? "\u2264 " : "";
+      rows.push({
+        key: "pinch",
+        label: "Max tool diameter",
+        milling: true,
+        // Measured at one tolerance only, it is the most the clearance can be, not the clearance itself.
+        value: `${atMost}\u2300 ${width.value}${floor ? ` \xB7 R ${floor.value}` : ""}`,
+        alt: `${atMost}\u2300 ${width.alt}${floor ? ` \xB7 R ${floor.alt}` : ""}`,
+        derivation: [
+          "The widest circle that fits where the feature is tightest: twice an inside corner\u2019s radius, or the width of a gap between walls.",
+          ...places !== void 0 ? [
+            `pinchPoints: where the feature narrows to its tightest clearance, a disc each; ${places} ${places === 1 ? "place" : "places"} that tight, the tightest drawn.`,
+            `min(pinchPoints[].diameter) is the cutter band\u2019s min, measured to a tolerance (t) the widest tool grows with: run back to none from two tolerances.`
+          ] : [
+            "No pinch points reported: the cutter band\u2019s min, measured to a tolerance (t) the widest tool grows with, run back to none from two tolerances."
+          ],
+          ...sheet?.clearance ? clearanceDerivation(sheet.clearance, clearance) : [],
+          ...floor && sheet?.filletRadius !== void 0 ? [
+            `A bull nose, its corner radius the floor fillet\u2019s: facts.filletRadius = ${mm(sheet.filletRadius)}`
+          ] : []
+        ]
+      });
+    }
+  }
+  if (sheet && undercut) rows.push(...undercutRows(sheet, undercut, top, length));
+  const surface = SURFACE_TYPES.has(feature.featureType);
+  if (surface && sheet) {
+    const diameter = sheet.fitToolDiameter;
+    const corner = sheet.fitCornerRadius;
+    const fit = sheet.toolFitPath ?? "facts.toolFit";
+    const ball = maxBallDiameter(sheet);
+    rows.push({
+      key: "finishTool",
+      label: "Finishing tool",
+      milling: true,
+      value: sheet.ballOnly ? "Ball end mill" : "Ball or bull nose",
+      derivation: [
+        `facts.useOnlyBallToolsForFinish (or facts.three.\u2026) is ${sheet.ballOnly ? "true" : "not true"}`
+      ]
+    });
+    if (corner !== void 0 && corner > 0) {
+      rows.push({
+        key: "fitCornerRadius",
+        label: "Max corner radius",
+        milling: true,
+        ...length(corner),
+        derivation: [
+          "The tightest the surface turns inward: a tool with a larger corner radius cannot follow it.",
+          `${fit}.cornerRadius = ${mm(corner)}`
+        ]
+      });
+    }
+    const sized = diameter !== void 0 && diameter > 0;
+    if (!sheet.ballOnly && corner !== void 0 && corner > 0 && (!sized || ball === void 0 || ball < diameter)) {
+      const size = sized ? length(diameter) : void 0;
+      const radius = length(corner);
+      rows.push({
+        key: "maxBull",
+        label: "Max bull nose",
+        milling: true,
+        // Drawable only at a diameter the fit gives: "any" is no size to draw.
+        ...sized ? { tool: "bull" } : {},
+        value: `${size ? `\u2300 ${size.value}` : "any \u2300"} \xB7 R ${radius.value}`,
+        alt: `${size ? `\u2300 ${size.alt}` : "any \u2300"} \xB7 R ${radius.alt}`,
+        derivation: [
+          sized ? "The largest full-diameter tool the surface\u2019s shape admits, with the largest corner radius it admits." : "The surface limits only the tool\u2019s corner radius, not its diameter: a bull nose of any size with a corner no larger than this.",
+          ...sized ? [`\u2300 = ${fit}.toolDiameter = ${mm(diameter)}`] : [`${fit}.toolDiameter is not reported`],
+          `R = ${fit}.cornerRadius = ${mm(corner)}`
+        ]
+      });
+    }
+    if (ball !== void 0 && corner !== void 0) {
+      const size = length(ball);
+      rows.push({
+        key: "maxBall",
+        label: "Max ball nose",
+        milling: true,
+        tool: "ball",
+        value: `\u2300 ${size.value}`,
+        alt: `\u2300 ${size.alt}`,
+        derivation: [
+          "A ball\u2019s corner radius is half its diameter, so it must fit under the corner limit, and the diameter limit where there is one:",
+          ...diameter !== void 0 && diameter > 0 ? [
+            `min(${fit}.toolDiameter, 2 \xD7 ${fit}.cornerRadius)`,
+            `= min(${mm(diameter)}, ${mm(2 * corner)}) = ${mm(ball)}`
+          ] : [`2 \xD7 ${fit}.cornerRadius = ${mm(ball)} (${fit}.toolDiameter is not reported)`]
+        ]
+      });
+    }
+  }
+  const ld = undercut ? null : featureLd(features, feature, sheets);
+  if (ld && top !== null && bottom !== void 0) {
+    const across = ld.basis === "bore" ? `D = facts.diameter = ${mm(ld.across)}` : ld.basis === "pinch" ? `D = widest tool (the tightest pinch disc, tolerance taken out) = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""}` : `D = widest tool = 2 \xD7 inside corner radius = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""} (no pinch points reported)`;
+    const ratioOf = (depth) => {
+      const ratio2 = (depth / ld.across).toFixed(3);
+      return ld.atLeast ? `\u2265 ${ratio2}` : ratio2;
+    };
+    if (ld.drilling) {
+      rows.push({
+        key: "ld",
+        label: "Drilling L/D",
+        milling: true,
+        value: ratioOf(top - bottom),
+        derivation: [
+          `L = depth below top of part = ${mm(top - bottom)}`,
+          across,
+          `L / D = ${mm(top - bottom)} / ${mm(ld.across)} = ${ld.ratio.toFixed(3)}`
+        ]
+      });
+    } else {
+      if (sheet?.zMax !== void 0) {
+        rows.push({
+          key: "featureLd",
+          label: "Feature L/D",
+          milling: true,
+          value: ratioOf(sheet.zMax - bottom),
+          derivation: [
+            `L = feature depth = zMax \u2212 zMin = ${mm(sheet.zMax - bottom)}`,
+            across,
+            `L / D = ${mm(sheet.zMax - bottom)} / ${mm(ld.across)} = ${((sheet.zMax - bottom) / ld.across).toFixed(3)}`
+          ]
+        });
+      }
+      rows.push({
+        key: "topLd",
+        label: "L/D to top of part",
+        milling: true,
+        value: ratioOf(top - bottom),
+        derivation: [
+          `L = depth below top of part = ${mm(top - bottom)}`,
+          across,
+          `L / D = ${mm(top - bottom)} / ${mm(ld.across)} = ${ld.ratio.toFixed(3)}`
+        ]
+      });
+    }
+  }
+  if (sheet?.tipAngle !== void 0) {
+    const flat = Math.abs(sheet.tipAngle - 180) < 0.05;
+    rows.push({
+      key: "tipAngle",
+      label: "Tip angle",
+      value: `${trim3(sheet.tipAngle, 3)}\xB0${flat ? " (flat)" : ""}`,
+      derivation: [
+        `facts.fullConeDeg = ${trim3(sheet.tipAngle, 3)}\xB0${flat ? " (180\xB0: flat bottom)" : ""}`
+      ]
+    });
+  }
+  if (sheet?.threading) {
+    rows.push({
+      key: "thread",
+      label: "Thread",
+      value: `${formatLength(sheet.threading.basicDiameter, units, inchMark)} \xD7 ${formatLength(sheet.threading.threadPitch, units, inchMark)} pitch`,
+      derivation: [
+        `facts.threading.spec.basicDiameter = ${mm(sheet.threading.basicDiameter)}`,
+        `facts.threading.spec.threadPitch = ${mm(sheet.threading.threadPitch)}`
+      ]
+    });
+  }
+  if (surface) {
+    if (sheet?.filletRadius !== void 0 && sheet.filletRadius !== 0) {
+      rows.push({
+        key: "filletRadius",
+        label: "Fillet radius",
+        ...length(Math.abs(sheet.filletRadius)),
+        derivation: [
+          `|facts.filletRadius| = |${mm(sheet.filletRadius)}| (signed: + over an edge, \u2212 into a corner)`
+        ]
+      });
+    }
+  } else if (sheet?.filletRadius !== void 0 && sheet.filletRadius > 0) {
+    rows.push({
+      key: "floorFillet",
+      label: "Floor fillet radius",
+      ...length(sheet.filletRadius),
+      derivation: [`facts.filletRadius = ${mm(sheet.filletRadius)}`]
+    });
+  }
+  if (sheet?.chamferAngle !== void 0) {
+    rows.push({
+      key: "bevelAngle",
+      label: "Chamfer angle",
+      value: `${sheet.chamferAngle.toFixed(3)}\xB0`,
+      derivation: [`facts.bevel.angleDeg = ${trim3(sheet.chamferAngle, 3)}\xB0`]
+    });
+  }
+  return rows.sort((a, b) => ROW_ORDER.indexOf(a.key) - ROW_ORDER.indexOf(b.key));
+};
+var undercutRows = (sheet, undercut, top, length) => {
+  const rows = [];
+  const tslot = sheet.kind === "Tslot";
+  const { zMin, zMax } = sheet;
+  const { floorWidth: floor, topOpeningWidth: opening } = undercut;
+  const angle = undercut.taperDeg !== void 0 ? `${trim3(undercut.taperDeg, 3)}\xB0` : void 0;
+  if (tslot && zMin !== void 0 && zMax !== void 0) {
+    rows.push({
+      key: "undercutWidth",
+      label: "Undercut width",
+      ...length(zMax - zMin),
+      derivation: [
+        "The groove\u2019s height along the tool: the widest cutter it takes in one pass.",
+        `zMax \u2212 zMin = ${mm(zMax)} \u2212 ${mm(zMin)} = ${mm(zMax - zMin)}`
+      ]
+    });
+  }
+  if (floor !== void 0) {
+    rows.push({
+      key: "floorWidth",
+      label: "Floor width",
+      ...length(floor),
+      derivation: ["The widest clearance over the floor", `facts.floorWidth = ${mm(floor)}`]
+    });
+  }
+  if (opening !== void 0) {
+    rows.push({
+      key: "openingWidth",
+      label: "Opening width",
+      ...length(opening),
+      derivation: [
+        "The clearance through the opening at the top of the groove",
+        `facts.topOpeningWidth = ${mm(opening)}`
+      ]
+    });
+  }
+  let depth = undercut.undercutDepth;
+  let depthLine = depth !== void 0 ? `facts.undercutDepth = ${mm(depth)}` : "";
+  if (depth === void 0 && floor !== void 0 && opening !== void 0) {
+    if (floor > opening && !undercut.isExternal) {
+      depth = (floor - opening) / 2;
+      depthLine = `(facts.floorWidth \u2212 facts.topOpeningWidth) / 2 = (${mm(floor)} \u2212 ${mm(opening)}) / 2 = ${mm(depth)}`;
+    }
+  }
+  if (depth !== void 0) {
+    rows.push({
+      key: "undercutDepth",
+      label: "Undercut depth",
+      ...length(depth),
+      derivation: [
+        "How far the groove runs back from its opening: what the cutter\u2019s head reaches past its shaft.",
+        depthLine
+      ]
+    });
+  }
+  if (angle) {
+    rows.push({
+      key: "taper",
+      label: "Dovetail angle",
+      value: `${angle} from the tool axis`,
+      derivation: [`facts.taperDeg = ${angle}, between the overhanging wall and the tool axis`]
+    });
+  }
+  const cutter = (value, derivation, alt) => ({
+    key: "undercutCutter",
+    label: "Max cutting diameter",
+    milling: true,
+    value,
+    ...alt !== void 0 ? { alt } : {},
+    derivation
+  });
+  if (undercut.unmeasured) {
+    return [
+      ...rows,
+      cutter("Not measured", [
+        "The Engine could not measure the groove (facts.isInvalidGeometry or facts.cd.measurementFailed), so its figures offer no cutter."
+      ])
+    ];
+  }
+  if (sheet.noToolFits) {
+    return [
+      ...rows,
+      cutter("None fits", [
+        "facts.cd.ignore.max is next to nothing: no cutter fits anywhere in the groove."
+      ])
+    ];
+  }
+  const band = sheet.maxTool !== void 0 && sheet.maxTool > 0 ? sheet.maxTool : void 0;
+  const dropIn = undercut.isClosed ? undercut.maxEntry : void 0;
+  const head = band === void 0 ? void 0 : Math.min(band, dropIn ?? Infinity);
+  const opensTo = undercut.maxEntry ?? opening;
+  const behind = head !== void 0 && depth !== void 0 ? head - 2 * depth : void 0;
+  const limits = [opensTo, behind].filter((each) => each !== void 0);
+  const shaft = limits.length > 0 ? Math.max(Math.min(...limits), 0) : void 0;
+  const shaftLines = [
+    "The most the cutter\u2019s shaft can be: what comes down through the opening above the groove, and leaves the head reaching the back of it.",
+    ...opensTo !== void 0 ? [`Opening: ${tslot ? "facts.maxEntryCd" : "facts.topOpeningWidth"} = ${mm(opensTo)}`] : [],
+    ...behind !== void 0 && head !== void 0 && depth !== void 0 ? [
+      `Reach: max cutting diameter \u2212 2 \xD7 undercut depth = ${mm(head)} \u2212 2 \xD7 ${mm(depth)} = ${mm(behind)}`
+    ] : [],
+    ...shaft !== void 0 ? [`Max shaft = ${mm(shaft)}`] : []
+  ];
+  if (head !== void 0 && band !== void 0) {
+    const headLines = [
+      "The biggest head that reaches every point of the groove.",
+      `facts.cd.ignore.min = ${mm(band)}`,
+      ...dropIn !== void 0 ? [
+        `A closed slot: the head comes down through the opening above it, facts.maxEntryCd = ${mm(dropIn)}`
+      ] : [],
+      `\u2300 = ${mm(head)}`
+    ];
+    if (head < SHARP_MM || shaft !== void 0 && shaft < SHARP_MM) {
+      return [
+        ...rows,
+        cutter("None fits", [
+          ...headLines,
+          ...shaft !== void 0 ? shaftLines : [],
+          "No head that fits the groove leaves room for a shaft to carry it."
+        ])
+      ];
+    }
+    const size = length(head);
+    const filletRadius = sheet.filletRadius !== void 0 && sheet.filletRadius > 0 ? sheet.filletRadius : void 0;
+    const fillet = filletRadius !== void 0 ? length(filletRadius) : void 0;
+    const describe = (unit2) => [`\u2300 ${size[unit2]}`, ...angle ? [angle] : [], ...fillet ? [`R ${fillet[unit2]}`] : []].join(
+      " \xB7 "
+    );
+    rows.push(
+      cutter(
+        describe("value"),
+        [
+          ...headLines,
+          ...angle ? [`Angle = facts.taperDeg = ${angle}, from the tool axis`] : [],
+          ...filletRadius !== void 0 ? [`R = facts.filletRadius = ${mm(filletRadius)}, the blend the head\u2019s corners cut`] : []
+        ],
+        describe("alt")
+      )
+    );
+    if (top !== null && zMin !== void 0) {
+      const reach = top - zMin;
+      const ratio2 = (reach / head).toFixed(3);
+      rows.push({
+        key: "topLd",
+        label: "L/D to top of part",
+        milling: true,
+        value: ratio2,
+        derivation: [
+          `L = depth below top of part = ${mm(reach)}`,
+          `D = max cutting diameter = ${mm(head)}`,
+          `L / D = ${mm(reach)} / ${mm(head)} = ${ratio2}`
+        ]
+      });
+    }
+  }
+  if (shaft !== void 0 || tslot) {
+    const size = shaft !== void 0 ? length(shaft) : void 0;
+    rows.push({
+      key: "maxShaft",
+      label: "Max shaft diameter",
+      milling: true,
+      ...size ? { value: `\u2300 ${size.value}`, alt: `\u2300 ${size.alt}` } : { value: "No limit" },
+      derivation: size ? shaftLines : [
+        "facts.maxEntryCd is not reported and the head or undercut depth is not known: nothing limits the shaft."
+      ]
+    });
+  }
+  return rows;
+};
+
+// src/model/feature-record.ts
+var MAX_DATASHEET_FIELDS = 500;
+var formatLeaf = (value) => typeof value === "number" ? String(Number(value.toFixed(4))) : typeof value === "string" ? value : value === null ? "null" : String(value);
+var datasheetFields = (datasheet) => {
+  const fields = [];
+  let more = false;
+  const walk = (value, path) => {
+    if (fields.length >= MAX_DATASHEET_FIELDS) {
+      more = true;
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (value.every((each) => typeof each !== "object" || each === null)) {
+        fields.push({ path, value: value.length === 0 ? "[]" : value.map(formatLeaf).join(", ") });
+      } else {
+        value.forEach((each, index) => walk(each, `${path}[${index}]`));
+      }
+    } else if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) fields.push({ path, value: "{}" });
+      for (const [key, each] of entries) walk(each, path ? `${path}.${key}` : key);
+    } else {
+      fields.push({ path, value: formatLeaf(value) });
+    }
+  };
+  if (datasheet !== null && datasheet !== void 0) walk(datasheet, "");
+  return { fields, more };
+};
+
+// src/model/hole-groups.ts
+var holeSize = (sheets, tag) => {
+  const sheet = sheets[tag.toLowerCase()];
+  if (sheet?.kind !== "Hole" || sheet.diameter === void 0 || sheet.zMin === void 0 || sheet.zMax === void 0) {
+    return null;
+  }
+  return { diameter: sheet.diameter, depth: sheet.zMax - sheet.zMin };
+};
+var SAME_DEPTH = 0.05;
+var DEPTH_FLOOR = 0.01;
+var TOLERANCE2 = 1e-6;
+var sameDepth = (a, b) => Math.abs(a - b) <= Math.max(DEPTH_FLOOR, Math.max(Math.abs(a), Math.abs(b)) * SAME_DEPTH);
+var sameDirection2 = (a, b) => Math.abs(a.x - b.x) < TOLERANCE2 && Math.abs(a.y - b.y) < TOLERANCE2 && Math.abs(a.z - b.z) < TOLERANCE2;
+var sameHoleSets = (features, sheets) => {
+  const sizes = features.map((feature) => holeSize(sheets, feature.tag));
+  const root = features.map((_, at2) => at2);
+  const find = (at2) => {
+    let top = at2;
+    while (root[top] !== top) top = root[top] ?? top;
+    root[at2] = top;
+    return top;
+  };
+  for (let a = 0; a < features.length; a += 1) {
+    for (let b = a + 1; b < features.length; b += 1) {
+      const [first, second] = [sizes[a], sizes[b]];
+      const [one, other] = [features[a], features[b]];
+      if (first && second && one && other && sameDirection2(one.machiningDirection, other.machiningDirection) && first.diameter.toFixed(3) === second.diameter.toFixed(3) && sameDepth(first.depth, second.depth)) {
+        const [low, high] = [find(a), find(b)].sort((x, y) => x - y);
+        if (high !== void 0 && low !== void 0) root[high] = low;
+      }
+    }
+  }
+  const sets = /* @__PURE__ */ new Map();
+  features.forEach((feature, at2) => {
+    const top = find(at2);
+    sets.set(top, [...sets.get(top) ?? [], feature]);
+  });
+  return [...sets.values()];
+};
+var featureRows = (tags, features, sheets) => {
+  const byTag = new Map(features.map((feature) => [feature.tag, feature]));
+  const listed = tags.flatMap((tag) => byTag.get(tag) ?? []);
+  const holes = listed.filter((feature) => holeSize(sheets, feature.tag));
+  const setOf = /* @__PURE__ */ new Map();
+  for (const set of sameHoleSets(holes, sheets)) {
+    if (set.length > 1) for (const feature of set) setOf.set(feature.tag, set);
+  }
+  const placed = /* @__PURE__ */ new Set();
+  return tags.flatMap((tag) => {
+    const set = setOf.get(tag);
+    if (!set) return [{ kind: "feature", tag }];
+    const [first, ...rest] = set;
+    if (!first || placed.has(first.tag)) return [];
+    placed.add(first.tag);
+    return [
+      {
+        kind: "holes",
+        key: first.tag,
+        tags: [first.tag, ...rest.map((feature) => feature.tag)],
+        diameter: holeSize(sheets, first.tag)?.diameter ?? 0
+      }
+    ];
+  });
+};
+
+// src/model/pinch-mark.ts
+import { MM_PER_INCH as MM_PER_INCH5 } from "@toolpath/tool-support";
+var MAX_DRAWN_TOOL_MM = 3 * MM_PER_INCH5;
+var pinchMark = (datasheet, sheet, featureType) => {
+  const pinch = readPinch(datasheet);
+  const discs = pinch?.discs.filter(
+    (disc) => disc.diameter >= PINCH_TOOL_MM && disc.diameter <= MAX_DRAWN_TOOL_MM
+  ) ?? [];
+  if (!pinch || discs.length === 0) return null;
+  const fillet = sheet?.filletRadius;
+  const corner = !isSurfaceType(featureType) && fillet !== void 0 && fillet > 0 ? fillet : void 0;
+  return { ...pinch, discs, ...corner !== void 0 ? { corner } : {} };
+};
+var pinchLabel = (mark, units) => {
+  const length = (mm2) => `${lengthValue(mm2, units)} ${unitLabel(units)}`;
+  const tightest = Math.min(...mark.discs.map((disc) => disc.diameter));
+  const tool = mark.corner !== void 0 ? `bull nose R ${length(mark.corner)}` : "widest tool";
+  const places = mark.discs.length;
+  return {
+    label: `${mark.unresolved ? "\u2264 " : ""}\u2300 ${length(tightest)}`,
+    note: places > 1 ? `${tool} \xB7 ${places} places` : tool
+  };
+};
+
+// src/model/tool-frame.ts
+var extent = (values) => {
+  let low = Infinity;
+  let high = -Infinity;
+  for (const value of values) {
+    if (value < low) low = value;
+    if (value > high) high = value;
+  }
+  return { low, high };
+};
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var scale = (a, by) => [a[0] * by, a[1] * by, a[2] * by];
+var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+var unit = (a) => scale(a, 1 / Math.hypot(a[0], a[1], a[2]));
+var ON_DEPTH_MM = 0.05;
+var ON_CORNER_MM = 0.02;
+var POINT_DISC_MM = 0.01;
+var ON_WALL_MM = 0.1;
+var ON_WALL_SHARE = 0.02;
+var WALL_NORMAL_ALONG = 0.7;
+var SAME_PLACE_MM = 0.05;
+var MIN_HEIGHT_MM = 0.05;
+var readTriangles = ({ positions, normals }, origin) => {
+  const triangles = [];
+  for (let at2 = 0; at2 + 8 < positions.length; at2 += 9) {
+    const corner = (k) => [
+      (positions[at2 + k] ?? 0) - origin[0],
+      (positions[at2 + k + 1] ?? 0) - origin[1],
+      (positions[at2 + k + 2] ?? 0) - origin[2]
+    ];
+    const n = at2 / 9 * 3;
+    triangles.push({
+      a: corner(0),
+      b: corner(3),
+      c: corner(6),
+      normal: [normals[n] ?? 0, normals[n + 1] ?? 0, normals[n + 2] ?? 0]
+    });
+  }
+  return triangles;
+};
+var pointsOf = (triangles) => triangles.flatMap(({ a, b, c }) => [a, b, c]);
+var flatten = (point, { u, v }) => ({ x: dot(point, u), y: dot(point, v) });
+var wallSegments = (triangles, frame) => triangles.filter(({ normal }) => Math.abs(dot(normal, frame.w)) < WALL_NORMAL_ALONG).flatMap(({ a, b, c, normal }) => {
+  const [fa, fb, fc] = [flatten(a, frame), flatten(b, frame), flatten(c, frame)];
+  const air = flatten(normal, frame);
+  return [
+    { p: fa, q: fb, air },
+    { p: fb, q: fc, air },
+    { p: fc, q: fa, air }
+  ];
+});
+var nearestOn = ({ p, q }, at2) => {
+  const dx = q.x - p.x;
+  const dy = q.y - p.y;
+  const length = dx * dx + dy * dy;
+  const t = length === 0 ? 0 : Math.min(1, Math.max(0, ((at2.x - p.x) * dx + (at2.y - p.y) * dy) / length));
+  return { x: p.x + t * dx, y: p.y + t * dy };
+};
+var nearestWall = (segments, at2) => segments.reduce((best, segment) => {
+  const point = nearestOn(segment, at2);
+  const distance2 = Math.hypot(point.x - at2.x, point.y - at2.y);
+  if (best && distance2 >= best.distance) return best;
+  const open = (at2.x - point.x) * segment.air.x + (at2.y - point.y) * segment.air.y >= 0;
+  return { point, distance: distance2, open };
+}, null);
+var fitsDiscs = (triangles, frame, discs) => {
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    const onCorners = points.every(
+      (disc) => flat.some((point) => Math.hypot(point.x - disc.x, point.y - disc.y) <= ON_CORNER_MM)
+    );
+    if (!onCorners) return false;
+  }
+  if (wide.length === 0) return points.length > 0;
+  const segments = wallSegments(triangles, frame);
+  if (segments.length === 0) return false;
+  let touches = false;
+  for (const disc of wide) {
+    const nearest = nearestWall(segments, disc);
+    if (!nearest || !nearest.open) return false;
+    const slack = ON_WALL_MM + ON_WALL_SHARE * disc.diameter;
+    const radius = disc.diameter / 2;
+    if (nearest.distance < radius - slack) return false;
+    if (nearest.distance <= radius + slack) touches = true;
+  }
+  return touches;
+};
+var placeInFrame = ({ u, v, w }, x, y, z) => add(add(scale(u, x), scale(v, y)), scale(w, z));
+var AXES = [
+  [1, 0, 0],
+  [0, 1, 0],
+  [0, 0, 1]
+];
+var candidateFrames = (points, zMin, zMax, direction, strict = true) => {
+  const along = unit(direction);
+  const frames = [];
+  for (const sign of [1, -1]) {
+    const w = scale(along, sign);
+    const { low, high } = extent(points.map((point) => dot(point, w)));
+    if (strict && (Math.abs(low - zMin) > ON_DEPTH_MM || Math.abs(high - zMax) > ON_DEPTH_MM)) {
+      continue;
+    }
+    const across = AXES.reduce(
+      (best, axis) => Math.abs(dot(axis, w)) < Math.abs(dot(best, w)) ? axis : best
+    );
+    const u0 = unit(add(across, scale(w, -dot(across, w))));
+    const v0 = cross(w, u0);
+    for (let quarter = 0; quarter < 4; quarter++) {
+      const angle = quarter * Math.PI / 2;
+      const u = add(scale(u0, Math.cos(angle)), scale(v0, Math.sin(angle)));
+      for (const hand of [1, -1]) frames.push({ u, v: scale(cross(w, u), hand), w });
+    }
+  }
+  return frames;
+};
+var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var exactFrame = (triangles, discs, zMin, zMax, direction) => {
+  const fits = candidateFrames(pointsOf(triangles), zMin, zMax, direction).filter(
+    (frame) => fitsDiscs(triangles, frame, discs)
+  );
+  const [first] = fits;
+  if (!first) return null;
+  const placed = (frame) => discs.map((disc) => placeInFrame(frame, disc.x, disc.y, zMin));
+  const firstPlaces = placed(first);
+  const agree = fits.every(
+    (frame) => placed(frame).every((at2, index) => distance(at2, firstPlaces[index] ?? at2) <= SAME_PLACE_MM)
+  );
+  return agree ? first : null;
+};
+var discMiss = (triangles, frame, discs) => {
+  let miss = 0;
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    for (const disc of points) {
+      miss += extent(flat.map((point) => Math.hypot(point.x - disc.x, point.y - disc.y))).low;
+    }
+  }
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (wide.length === 0) return miss;
+  const segments = wallSegments(triangles, frame);
+  let touch = Infinity;
+  for (const disc of wide) {
+    const radius = disc.diameter / 2;
+    const nearest = nearestWall(segments, disc);
+    if (!nearest) return Infinity;
+    if (!nearest.open) miss += disc.diameter * 4;
+    miss += Math.max(0, radius - nearest.distance);
+    touch = Math.min(touch, Math.abs(nearest.distance - radius));
+  }
+  return miss + touch;
+};
+var bestFrame = (triangles, discs, zMin, zMax, direction) => {
+  if (triangles.length === 0 || discs.length === 0) return null;
+  const exact = exactFrame(triangles, discs, zMin, zMax, direction);
+  if (exact) return { frame: exact, lift: 0 };
+  const points = pointsOf(triangles);
+  const fitting = candidateFrames(points, zMin, zMax, direction);
+  const frames = fitting.length > 0 ? fitting : candidateFrames(points, zMin, zMax, direction, false);
+  const best = frames.reduce((was, frame) => {
+    const miss = discMiss(triangles, frame, discs);
+    return !was || miss < was.miss ? { frame, miss } : was;
+  }, null);
+  if (!best) return null;
+  const { low } = extent(points.map((point) => dot(point, best.frame.w)));
+  return { frame: best.frame, lift: fitting.length > 0 ? 0 : low - zMin };
+};
+var asVec = ([x, y, z]) => ({ x, y, z });
+var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 }) => {
+  const shift = [origin.x, origin.y, origin.z];
+  const faces = readTriangles(triangles, shift);
+  const found = bestFrame(faces, mark.discs, mark.zMin, mark.zMax, [
+    direction.x,
+    direction.y,
+    direction.z
+  ]);
+  const disc = mark.discs.reduce(
+    (tightest, each) => !tightest || each.diameter < tightest.diameter ? each : tightest,
+    null
+  );
+  if (!found || !disc) return null;
+  const { frame, lift } = found;
+  const radius = disc.diameter / 2;
+  const base = add(placeInFrame(frame, disc.x, disc.y, mark.zMin + lift), shift);
+  const contact = nearestWall(wallSegments(faces, frame), disc)?.point;
+  const toward = contact ? { x: contact.x - disc.x, y: contact.y - disc.y } : { x: 1, y: 0 };
+  const length = Math.hypot(toward.x, toward.y);
+  const across = add(
+    scale(frame.u, length > 1e-9 ? toward.x / length : 1),
+    scale(frame.v, length > 1e-9 ? toward.y / length : 0)
+  );
+  return {
+    base: asVec(base),
+    axis: asVec(frame.w),
+    diameter: disc.diameter,
+    height: Math.max(mark.zMax - mark.zMin, MIN_HEIGHT_MM),
+    cornerRadius: Math.min(Math.max(mark.corner ?? 0, 0), radius),
+    across: asVec(across)
+  };
+};
+
+// src/model/reach.ts
+var numbers = (value) => Array.isArray(value) && value.every((each) => typeof each === "number" && Number.isFinite(each)) ? value : null;
+var readReachCurve = (datasheet) => {
+  const curve = datasheet?.reachCurve;
+  const offsets = numbers(curve?.horizontalOffset);
+  const heights = numbers(curve?.verticalOffset);
+  if (!offsets || !heights || offsets.length === 0 || offsets.length !== heights.length) return null;
+  return { offsets, heights };
+};
+var runStart = ({ offsets }, index) => index === 0 ? 0 : offsets[index - 1] ?? 0;
+var peakHeight = ({ heights }) => Math.max(0, ...heights);
+var TAIL_MM = 12.7;
+var peakSlack = (peak) => Math.max(0.05, peak * 0.01);
+var peakStart = (curve) => {
+  const peak = peakHeight(curve);
+  const slack = peakSlack(peak);
+  const index = curve.heights.findIndex((height) => height >= peak - slack);
+  return runStart(curve, index === -1 ? 0 : index);
+};
+var trimmedCurve = (curve) => {
+  const last = curve.offsets[curve.offsets.length - 1] ?? 0;
+  const extent2 = peakStart(curve) + TAIL_MM;
+  if (extent2 >= last) return { curve, cut: false };
+  const keep = curve.offsets.findIndex((offset) => offset >= extent2);
+  return {
+    curve: {
+      offsets: [...curve.offsets.slice(0, keep), extent2],
+      heights: curve.heights.slice(0, keep + 1)
+    },
+    cut: true
+  };
+};
+var featureAcross = (sheet) => {
+  if (sheet?.diameter !== void 0 && sheet.diameter > 0)
+    return { width: sheet.diameter, kind: "diameter" };
+  if (sheet?.pinchDiameter !== void 0 && sheet.pinchDiameter > 0)
+    return { width: sheet.pinchDiameter, kind: "clearance" };
+  return null;
+};
+var isThroughType = (featureType) => /(^|_)through(_|$)/.test(featureType.toLowerCase());
+var featureProfile = (sheet, featureType) => {
+  const depth = sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? sheet.zMax - sheet.zMin : null;
+  return {
+    across: featureAcross(sheet),
+    depth: depth !== null && depth > 0 ? depth : null,
+    through: isThroughType(featureType)
+  };
+};
+
+// src/model/rule-set-file.ts
+var FILE_KIND = "toolpath-dfm-rules";
+var serializeRuleSet = (rules, meta = {}, vocabulary = MILLING_RULES) => JSON.stringify(
+  {
+    kind: FILE_KIND,
+    version: 1,
+    process: vocabulary.process,
+    ...meta.name ? { name: meta.name } : {},
+    ...meta.description ? { description: meta.description } : {},
+    units: "mm",
+    rules: [...rules]
+  },
+  null,
+  2
+);
+var PROCESS_NAMES = { milling: "Milling", turning: "Turning" };
+var fileProcess = (raw) => {
+  if (Array.isArray(raw) || typeof raw !== "object" || raw === null) return "milling";
+  const { process } = raw;
+  return process === void 0 || process === null ? "milling" : process;
+};
+var parseRuleSetFile = (text, vocabulary = MILLING_RULES) => {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { error: "This is not JSON." };
+  }
+  const list = Array.isArray(raw) ? raw : typeof raw === "object" && raw !== null && Array.isArray(raw.rules) ? raw.rules : null;
+  if (!list) return { error: 'No rules in it: expected an object with a "rules" list.' };
+  const units = Array.isArray(raw) ? void 0 : raw.units;
+  if (units !== void 0 && units !== "mm")
+    return { error: `Its lengths are in ${JSON.stringify(units)}; only "mm" can be read.` };
+  const process = fileProcess(raw);
+  if (process !== vocabulary.process) {
+    return process === "milling" || process === "turning" ? {
+      error: `This is a ${process} rule set \u2014 import it in ${PROCESS_NAMES[process]} mode.`
+    } : {
+      error: `Its process is ${JSON.stringify(process)}; only "milling" or "turning" can be read.`
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const withIds = list.map((each) => {
+    if (typeof each !== "object" || each === null) return each;
+    const rule = each;
+    const id = typeof rule.id === "string" && !seen.has(rule.id) ? rule.id : newRuleId();
+    seen.add(id);
+    return { ...rule, id };
+  });
+  const rules = parseRules(withIds, vocabulary) ?? [];
+  if (rules.length === 0) return { error: "None of its rules could be read." };
+  const name = typeof raw === "object" && raw !== null && typeof raw.name === "string" ? raw.name : void 0;
+  return { rules, skipped: list.length - rules.length, ...name ? { name } : {} };
+};
+var OP_WORDS = {
+  gte: "at or above (\u2265)",
+  gt: "above (>)",
+  lte: "at or below (\u2264)",
+  lt: "below (<)",
+  eq: "equal, within half a percent (=)",
+  ne: "not equal (\u2260)",
+  between: "in a range: `value` \u2264 x < `max` by default; `lowOp` (gte|gt) and `highOp` (lt|lte) change the ends"
+};
+var SCRIPTS = {
+  milling: {
+    intro: "You are helping a machinist or designer set up design-for-manufacturing (DFM) checks for CNC-milled parts in the Toolpath CAD viewer. Interview them, then produce ONE JSON document in the format below.",
+    opening: "Begin the interview in your very first reply \u2014 do not summarise this prompt, ask whether to start, or explain the format. Run it in four rounds, in a conversational tone, following up where an answer needs it: an opening round about the shop, then a milling round, then a drilling round, then a closing round. Ask only about things the metrics below can measure from the model geometry: depths, diameters, corner radii, tool sizes, areas, feature kinds. Do not ask about surface finish, tolerances, material hardness, fixturing, quantities or lead time \u2014 nothing here measures them.",
+    rounds: [
+      "### Round 1 \u2014 the shop",
+      "1. What they make and in what materials. This sets the defaults, not a rule.",
+      "2. Examples of features that have challenged them before: a deep pocket that snapped a tool, a hole that needed a special drill, a corner radius that forced a re-quote, an undercut nobody saw until CAM. Ask for the feature and its rough size, then turn each into one rule: a deep pocket is `pocket` with `featureLd` or `depthBelowTop`; a small hole is `hole` with `diameter`; a deep hole is `hole` with `ld`; a tight corner is `milled` with `cornerRadius` or `maxTool`. If no metric below measures the example, say so and move on; never invent a metric.",
+      "",
+      "### Round 2 \u2014 milling (pockets, slots, walls, bosses, profiles, 3D surfaces)",
+      "3. The smallest end mill they are happy to run: `milled` with `maxTool` below it, and `milled` with `cornerRadius` below half of it.",
+      "4. The depth-to-diameter ratio where milled work starts to cost them, and where it becomes a problem: two or three bands of `milled` with `ld` (warning, caution, critical).",
+      "5. The deepest their end mills reach below the top of the part: `milled` with `depthBelowTop`. Whether they also want a feature's own depth capped: `milled` with `featureDepth`.",
+      "6. Sharp inside corners: whether every one should be flagged (`milled` with `sharpCorner`), or only on certain feature kinds.",
+      "7. Floor fillets: whether a floor fillet larger than their ball or bull-nose tooling should be flagged (`pocket` with `floorFillet` above a radius).",
+      "8. Milled features to call out on sight regardless of size: `undercut` with `present`; `contour` with `present` for 3D surfaces; `any` with `tilted` for 5-axis work; `boss` with `present` for thin standing material.",
+      "9. Large features that drive cycle time, if they quote: `pocket` with `projectedFloorArea` or `milled` with `surfaceArea` above a size.",
+      "",
+      "### Round 3 \u2014 drilling (holes, threads, countersinks)",
+      "10. The smallest drill they stock: `hole` with `diameter` below it. Whether they want holes that have no drill fit, so must be milled, called out: `hole` with `maxDrill` at 0.",
+      "11. The depth-to-diameter ratio where holes get hard, and where they need gun drilling or a second setup: two bands of `hole` with `ld`, usually looser than milled work.",
+      "12. Threads: the smallest thread they tap (`hole` with `threadDiameter` below it), and whether every threaded hole should be marked (`threadedHole` with `present`).",
+      "13. Countersinks and counterbores: whether to call out countersinks (`chamfer` with `countersink`) or counterbored holes (`hole` with `counterbore`).",
+      "",
+      "### Round 4 \u2014 closing",
+      "14. Anything they want flagged across every feature, milled or drilled \u2014 for example one overall depth below the top of the part their longest tooling cannot reach: `any` with `depthBelowTop`.",
+      "15. Which of the rules so far are critical (red), which are cautions (orange) and which are just worth a look (yellow)."
+    ],
+    counting: "A rule only fires on features that have the measurement; a feature that lacks it is not flagged. Only *required* features count \u2014 ones that own a face no other feature could machine.",
+    example: [
+      { id: "r1", subject: "hole", metric: "ld", op: "gte", value: 8, color: "#ffd60a" },
+      {
+        id: "r2",
+        subject: "milled",
+        metric: "featureLd",
+        op: "between",
+        value: 4,
+        max: 8,
+        lowOp: "gte",
+        highOp: "lt",
+        color: "#f76b15"
+      },
+      { id: "r3", subject: "milled", metric: "sharpCorner", op: "gte", value: 0, color: "#e5484d" },
+      { id: "r4", subject: "undercut", metric: "present", op: "gte", value: 0, color: "#8e4ec6" }
+    ]
+  },
+  turning: {
+    intro: "You are helping a machinist or designer set up design-for-manufacturing (DFM) checks for parts turned on a lathe in the Toolpath CAD viewer. Interview them, then produce ONE JSON document in the format below.",
+    opening: "Begin the interview in your very first reply \u2014 do not summarise this prompt, ask whether to start, or explain the format. Run it in three rounds, in a conversational tone, following up where an answer needs it: an opening round about the shop, then a turning round, then a closing round. Ask only about things the metrics below can measure from the model geometry: diameters, lengths, grooves, threads, axial holes, inside corner radii, tolerance, feature kinds. Do not ask about surface finish, material hardness, workholding, quantities or lead time \u2014 nothing here measures them.",
+    rounds: [
+      "### Round 1 \u2014 the shop",
+      "1. What they make, in what materials, and on what lathes: the largest bar or chuck, and whether they have live tooling. This sets the defaults, not a rule.",
+      "2. Examples of turned features that have challenged them before: a narrow groove that broke an insert, a long small bore that chattered, a fine thread, a sharp inside corner no insert could make. Ask for the feature and its rough size, then turn each into one rule: a narrow groove is `groove` with `grooveWidth`; a deep bore is `id` with `ld`; a fine thread is `thread` with `threadPitch`; a small drilled hole is `hole` with `holeDiameter`. If no metric below measures the example, say so and move on; never invent a metric.",
+      "",
+      "### Round 2 \u2014 turning (outside, inside, faces, grooves, threads, axial holes)",
+      "3. The largest diameter their lathes take: `any` with `maxDiameter` above it. The longest stretch they turn without support: `od` with `length`.",
+      "4. Grooves: the narrowest grooving insert they stock (`groove` with `grooveWidth` below it), and how far they can plunge (`groove` with `grooveDepth`, or `grooveAspect` for depth over width).",
+      "5. Boring: the depth-to-diameter ratio where a boring bar starts to chatter, and where it becomes a problem: two bands of `id` with `ld`. The narrowest bore their smallest bar passes: `id` with `entryDiameter` below it.",
+      "6. Threads: the finest pitch they cut (`thread` with `threadPitch` below it), and the smallest thread (`thread` with `threadDiameter` below it).",
+      "7. Axial holes: the smallest drill they stock (`hole` with `holeDiameter` below it), the deepest they drill (`hole` with `holeDepth`, or `hole` with `ld`), and whether to call out stepped holes (`hole` with `holeSteps`), flat bottoms (`blindHole` with `flatBottom`) or tapped holes (`threadedHole` with `present`).",
+      "8. Inside corners: the smallest nose radius they run (`any` with `cornerRadius` below it), and whether every sharp inside corner should be flagged (`any` with `sharpCorner`).",
+      "9. Turned features to call out on sight regardless of size: `face` with `axialTool` for work only an axially mounted tool reaches; `type:unknown` with `present` for a stretch the Engine could not name.",
+      "",
+      "### Round 3 \u2014 closing",
+      "10. The tightest tolerance they hold without special care: `any` with `tolerance` below it.",
+      "11. Which of the rules so far are critical (red), which are cautions (orange) and which are just worth a look (yellow)."
+    ],
+    counting: "A rule only fires on features that have the measurement; a feature that lacks it is not flagged. A stretch both ends of the part reach is one feature, and breaks a rule only if it breaks it from both ends.",
+    example: [
+      {
+        id: "r1",
+        subject: "groove",
+        metric: "grooveWidth",
+        op: "lte",
+        value: 1.5,
+        color: "#ffd60a"
+      },
+      {
+        id: "r2",
+        subject: "id",
+        metric: "ld",
+        op: "between",
+        value: 4,
+        max: 8,
+        lowOp: "gte",
+        highOp: "lt",
+        color: "#f76b15"
+      },
+      { id: "r3", subject: "any", metric: "sharpCorner", op: "gte", value: 0, color: "#e5484d" },
+      { id: "r4", subject: "thread", metric: "present", op: "gte", value: 0, color: "#8e4ec6" }
+    ]
+  }
+};
+var llmRulePrompt = (current = [], vocabulary = MILLING_RULES) => {
+  const script = SCRIPTS[vocabulary.process];
+  const groups = vocabulary.subjects.filter((each) => !each.value.startsWith(TYPE_SUBJECT));
+  const types = vocabulary.subjects.filter((each) => each.value.startsWith(TYPE_SUBJECT));
+  const metricLines = vocabulary.metrics.map((metric) => {
+    const unit2 = quantityUnit(metric.quantity, "mm");
+    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit2 ? `, in ${unit2}` : ""}; a new rule usually starts around ${metric.start.mm}`;
+    const kinds = metric.kinds ? ` Only features of kind ${metric.kinds.join("/")} report it.` : "";
+    return `- \`${metric.key}\` \u2014 "${metric.label}" (${kind}). ${metric.hint}.${kinds}`;
+  });
+  const example = serializeRuleSet(
+    script.example,
+    { name: "Example set", description: "Shows one rule of each shape" },
+    vocabulary
+  );
+  return [
+    "# Write a Toolpath DFM rule set",
+    "",
+    script.intro,
+    "",
+    script.opening,
+    "",
+    'Where the user has current rules (listed at the end), do not ask whether to keep them. Weave each one into the relevant question as a suggested starting point \u2014 "your set currently warns at 4\xD7D; where does deep work start to cost you?" \u2014 so the user accepts, adjusts or drops it in their own words. The finished set should feel like theirs, not a copy of the old one.',
+    "",
+    "Each question is tied to the subject and metric it becomes. Skip one when an earlier answer has already settled it, and offer sensible defaults from their answers rather than asking about every metric. Every rule needs an `op` and a `value`, even a yes/no one.",
+    "",
+    ...script.rounds,
+    "",
+    `The user may stop at any point \u2014 "that's enough", "just give me the rules", "generate it" \u2014 and you then finish from what you have: rules for every answer so far, their current rules carried over for anything not yet discussed, and sensible defaults from the shop description for the rest. Never insist on completing a round first, and never leave a placeholder for an unanswered question.`,
+    "",
+    "Finishing: when the questions are answered or the user stops, list the rules you intend to write in plain words, one line each with its colour, and ask the user to confirm or change them. Once they confirm, output the JSON in a single ```json code block and nothing after it. The user will paste it into the viewer (DFM Rules \u2192 Import), so the block must be the complete file in the format below \u2014 no comments, no trailing text, no placeholder values.",
+    "",
+    "## Format",
+    "",
+    `Top level: \`{"kind":"toolpath-dfm-rules","version":1,"process":"${vocabulary.process}","name":"\u2026","description":"\u2026","units":"mm","rules":[\u2026]}\`.`,
+    "Every length is in millimetres, areas in mm\xB2, angles in degrees, ratios plain. Convert from inches yourself (1 in = 25.4 mm).",
+    "",
+    "Each rule is one sentence \u2014 *{subject} with {metric} {op} {value}* \u2014 with the fields:",
+    "- `id`: a short unique string.",
+    "- `subject`: which features (a value from the list below).",
+    "- `metric`: what is measured (a key from the list below).",
+    "- `op`: one of " + OPS.map((op) => `\`${op}\``).join(", ") + ".",
+    ...OPS.map((op) => `  - \`${op}\`: ${OP_WORDS[op]}`),
+    "- `value`: the threshold (canonical units). For `between`, the low end; add `max` for the high end.",
+    "- `color`: `#rrggbb`, from the palette: " + RULE_COLORS.map((each) => `${each.name} \`${each.value}\``).join(", ") + ". Red for critical, orange for caution, yellow for warning; purple, green and cyan for anything else. Where a feature breaks several rules the part shows the earliest palette colour.",
+    "",
+    script.counting,
+    "",
+    "## Subjects (`subject`)",
+    "",
+    "Broad groups:",
+    ...groups.map((each) => `- \`${each.value}\` \u2014 ${each.label}`),
+    "",
+    "One exact Engine feature type:",
+    ...types.map((each) => `- \`${each.value}\` \u2014 ${each.label}`),
+    "",
+    "## Metrics (`metric`)",
+    "",
+    ...metricLines,
+    "",
+    "## Example",
+    "",
+    "```json",
+    example,
+    "```",
+    ...current.length > 0 ? [
+      "",
+      "## The user's current rules",
+      "",
+      "Use these as the suggested starting points in your questions, as described above. Do not ask whether to keep them; do not copy them unchanged unless the user confirms each threshold:",
+      "",
+      "```json",
+      serializeRuleSet(current, {}, vocabulary),
+      "```"
+    ] : [],
+    ""
+  ].join("\n");
+};
+
+// src/model/turning-metrics.ts
+var OD_KINDS = ["OdProfile", "OdGroove", "OdThread"];
+var ID_KINDS = ["IdProfile", "IdGroove", "IdThread"];
+var FACE_KINDS = ["Face", "FaceProfile", "FaceGroove"];
+var GROOVE_KINDS = ["OdGroove", "IdGroove", "FaceGroove"];
+var THREAD_KINDS = ["OdThread", "IdThread", "AxialHole"];
+var PROFILE_KINDS = ["OdProfile", "IdProfile", "FaceProfile"];
+var HOLE_KINDS2 = ["AxialHole"];
+var SIZE2 = "Size";
+var GROOVES = "Grooves";
+var THREADS = "Threads";
+var HOLES = "Holes";
+var TOOLS2 = "Tool access";
+var TOLERANCE3 = "Tolerance";
+var TURNING_METRICS = [
+  PRESENCE_METRIC,
+  define({
+    key: "maxDiameter",
+    label: "diameter",
+    group: SIZE2,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 100, inch: 101.6 },
+    hint: "Its largest diameter: what the lathe must swing, or the bar it is cut from"
+  }),
+  define({
+    key: "minDiameter",
+    label: "smallest diameter",
+    group: SIZE2,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    kinds: ["OdProfile", "IdProfile", "OdGroove", "IdGroove", "OdThread", "IdThread", "AxialHole"],
+    hint: "Its smallest diameter: how thin the outside gets, or how narrow a bore. Not for faces"
+  }),
+  define({
+    key: "length",
+    label: "length along the axis",
+    group: SIZE2,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 50, inch: 50.8 },
+    kinds: [
+      "AxialHole",
+      "FaceGroove",
+      "FaceProfile",
+      "IdGroove",
+      "IdProfile",
+      "IdThread",
+      "OdGroove",
+      "OdProfile",
+      "OdThread",
+      "Unknown"
+    ],
+    hint: "How far it runs along the spindle axis. None for a flat face"
+  }),
+  define({
+    key: "ld",
+    label: "L/D from the end",
+    group: SIZE2,
+    quantity: "ratio",
+    op: "gte",
+    start: 4,
+    kinds: ["AxialHole", "IdProfile", "IdGroove", "IdThread"],
+    hint: "How far in a boring bar or drill reaches over the bore it goes through: a hole\u2019s depth over its narrowest step; inside work, from the end it is cut from to its far end, over its entry diameter. Cut from both ends, the easier end"
+  }),
+  define({
+    key: "grooveWidth",
+    label: "groove width",
+    group: GROOVES,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 1.5, inch: 1.5875 },
+    kinds: GROOVE_KINDS,
+    hint: "How wide the groove is: the narrowest insert that cuts it in one plunge"
+  }),
+  define({
+    key: "grooveDepth",
+    label: "groove depth",
+    group: GROOVES,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 5, inch: 5.08 },
+    kinds: GROOVE_KINDS,
+    hint: "How far the groove goes in: radially on the outside or in a bore, along the axis in a face"
+  }),
+  define({
+    key: "grooveAspect",
+    label: "groove depth/width",
+    group: GROOVES,
+    quantity: "ratio",
+    op: "gte",
+    start: 3,
+    kinds: GROOVE_KINDS,
+    hint: "Its depth over its width: how far a grooving insert reaches past its own width"
+  }),
+  define({
+    key: "threadPitch",
+    label: "thread pitch",
+    group: THREADS,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.5, inch: 0.4233 },
+    kinds: THREAD_KINDS,
+    hint: "The distance between thread crests (0.423 mm is 60 TPI)"
+  }),
+  define({
+    key: "threadDiameter",
+    label: "thread diameter",
+    group: THREADS,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    kinds: THREAD_KINDS,
+    hint: "The catalog thread\u2019s nominal major diameter. None where the catalog lists no thread for it"
+  }),
+  define({
+    key: "threadDepth",
+    label: "thread depth",
+    group: THREADS,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 1, inch: 1.27 },
+    kinds: ["OdThread", "IdThread"],
+    hint: "How deep the thread form is cut"
+  }),
+  define({
+    key: "holeDiameter",
+    label: "hole diameter",
+    group: HOLES,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 3, inch: 3.175 },
+    kinds: HOLE_KINDS2,
+    hint: "Its narrowest step: the drill it is drilled with"
+  }),
+  define({
+    key: "holeDepth",
+    label: "hole depth",
+    group: HOLES,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 50, inch: 50.8 },
+    kinds: HOLE_KINDS2,
+    hint: "How far it runs along the axis"
+  }),
+  define({
+    key: "holeSteps",
+    label: "number of steps",
+    group: HOLES,
+    quantity: "count",
+    op: "gte",
+    start: 2,
+    kinds: HOLE_KINDS2,
+    hint: "How many diameters it steps through, from the mouth inward"
+  }),
+  define({
+    key: "flatBottom",
+    label: "a flat bottom",
+    group: HOLES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    kinds: HOLE_KINDS2,
+    hint: "A blind hole that ends flat rather than in a drill point"
+  }),
+  define({
+    key: "cornerRadius",
+    label: "inside corner radius",
+    group: TOOLS2,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.4, inch: 0.3969 },
+    hint: "The radius of its tightest concave corner, which an insert\u2019s nose radius must fit \u2014 zero when sharp. None where it has no inside corner"
+  }),
+  define({
+    key: "sharpCorner",
+    label: "a sharp inside corner",
+    group: TOOLS2,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "A concave corner with no radius, which no insert makes"
+  }),
+  define({
+    key: "entryDiameter",
+    label: "entry diameter",
+    group: TOOLS2,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 10, inch: 9.525 },
+    hint: "For a feature in a hole, the narrowest diameter a bar passes on its way in from the end it is cut from. None where nothing stands between"
+  }),
+  define({
+    key: "axialTool",
+    label: "an axially mounted tool",
+    group: TOOLS2,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "Only a tool mounted along the spindle axis reaches it: a drill, or a face-grooving tool"
+  }),
+  define({
+    key: "tolerance",
+    label: "tolerance",
+    group: TOLERANCE3,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.01, inch: 0.0127 },
+    hint: "The most it may deviate from the model"
+  })
+];
+var GROUP_SUBJECTS2 = [
+  { value: "any", label: "Any turned feature", group: "Groups" },
+  { value: "od", label: "Outside (OD) features", group: "Groups", kinds: OD_KINDS },
+  { value: "id", label: "Inside (ID) features", group: "Groups", kinds: ID_KINDS },
+  { value: "face", label: "End-face features", group: "Groups", kinds: FACE_KINDS },
+  { value: "groove", label: "Grooves", group: "Groups", kinds: GROOVE_KINDS },
+  { value: "thread", label: "Threads", group: "Groups", kinds: THREAD_KINDS },
+  { value: "hole", label: "Axial holes", group: "Groups", kinds: HOLE_KINDS2 },
+  { value: "throughHole", label: "Through holes", group: "Groups", kinds: HOLE_KINDS2 },
+  { value: "blindHole", label: "Blind holes", group: "Groups", kinds: HOLE_KINDS2 },
+  { value: "threadedHole", label: "Threaded holes", group: "Groups", kinds: HOLE_KINDS2 },
+  { value: "profile", label: "Profiles", group: "Groups", kinds: PROFILE_KINDS }
+];
+var TYPES2 = [
+  ["od_profile", "OD profiles", "OdProfile"],
+  ["od_groove", "OD grooves", "OdGroove"],
+  ["od_thread", "OD threads", "OdThread"],
+  ["face", "Faces", "Face"],
+  ["face_profile", "Face profiles", "FaceProfile"],
+  ["face_groove", "Face grooves", "FaceGroove"],
+  ["axial_hole", "Axial hole features", "AxialHole"],
+  ["id_profile", "ID profiles", "IdProfile"],
+  ["id_groove", "ID grooves", "IdGroove"],
+  ["id_thread", "ID threads", "IdThread"],
+  ["unknown", "Unknown features", "Unknown"]
+];
+var TURNING_SUBJECTS = [
+  ...GROUP_SUBJECTS2,
+  ...TYPES2.map(([type, label, kind]) => ({
+    value: `${TYPE_SUBJECT}${type}`,
+    label,
+    group: "Feature types",
+    kinds: [kind]
+  }))
+];
+var QUICK_TURNING_SUBJECTS = [
+  "any",
+  "od",
+  "id",
+  "face",
+  "groove",
+  "thread",
+  "hole"
+];
+var QUICK_TURNING_METRICS = [
+  "present",
+  "maxDiameter",
+  "length",
+  "ld",
+  "grooveWidth",
+  "grooveDepth",
+  "threadPitch",
+  "holeDiameter",
+  "holeDepth",
+  "cornerRadius",
+  "sharpCorner",
+  "entryDiameter"
+];
+var CAPITALS = { od: "OD", id: "ID" };
+var turnedTypeLabel = (featureType) => {
+  const words = featureType.split("_").filter((word) => word !== "").map((word) => CAPITALS[word] ?? word).join(" ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+var endLabel = (feature) => {
+  const approaches = "approaches" in feature && Array.isArray(feature.approaches) ? feature.approaches : feature.machiningDirection.z > 0 ? ["PlusZ"] : feature.machiningDirection.z < 0 ? ["MinusZ"] : [];
+  const plus = approaches.includes("PlusZ");
+  const minus = approaches.includes("MinusZ");
+  return plus && minus ? "from both ends" : plus ? "from the +Z end" : minus ? "from the \u2212Z end" : "";
+};
+var TURNING_RULES = {
+  process: "turning",
+  metrics: TURNING_METRICS,
+  subjects: TURNING_SUBJECTS,
+  quickSubjects: QUICK_TURNING_SUBJECTS,
+  quickMetrics: QUICK_TURNING_METRICS,
+  fallbackMetric: PRESENCE_METRIC,
+  featureLabel: (feature) => ({
+    name: turnedTypeLabel(feature.featureType),
+    detail: endLabel(feature)
+  }),
+  considerationsTitle: "Turning considerations",
+  fileName: "dfm-turning-rules.json"
+};
+
+// 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 {
+  directionLabel,
+  dfmFeatures,
+  featureTypeLabel,
+  PRESENCE_METRIC,
+  QUICK_SUBJECTS,
+  MILLING_RULES,
+  metricInfo,
+  metricsForSubject,
+  lengthValue,
+  unitLabel,
+  OPS,
+  RANGE_LOWS,
+  RANGE_HIGHS,
+  opSymbol,
+  RULE_COLORS,
+  compareColors,
+  CRITICAL_COLOR,
+  WARNING_COLOR,
+  subjectLabel,
+  quantityUnit,
+  toField,
+  fromField,
+  formatMeasured,
+  describeRule,
+  makeRule,
+  upperOf,
+  lowOf,
+  highOf,
+  withMetric,
+  withOp,
+  withSubject,
+  parseRules,
+  hitFigure,
+  brokenRules,
+  featureColor,
+  withSurroundedFaces,
+  checkPart,
+  readPinch,
+  PINCH_TOOL_MM,
+  isNoReading,
+  featureSheet,
+  isSurfaceType,
+  maxBallDiameter,
+  featureMeasurements,
+  MAX_DATASHEET_FIELDS,
+  datasheetFields,
+  sameDepth,
+  featureRows,
+  pinchMark,
+  pinchLabel,
+  placePinchTool,
+  readReachCurve,
+  runStart,
+  peakHeight,
+  trimmedCurve,
+  featureProfile,
+  FILE_KIND,
+  serializeRuleSet,
+  parseRuleSetFile,
+  llmRulePrompt,
+  turnedTypeLabel,
+  TURNING_RULES,
+  turnedStretches,
+  checkTurnedPart
+};