@toolpath/dfm 0.4.0 → 0.5.0

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

@@ -1,5 +1,85 @@
+// 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
 import { MM_PER_INCH } from "@toolpath/tool-support";
+
+// src/model/direction-label.ts
+var EPSILON = 1e-6;
+var trim = (value) => Number.parseFloat(value.toFixed(3)).toString();
+var directionLabel = (direction) => {
+  const axes = [
+    ["X", direction.x],
+    ["Y", direction.y],
+    ["Z", direction.z]
+  ];
+  const nonZero = axes.filter(([, value]) => Math.abs(value) > EPSILON);
+  const [axis] = nonZero;
+  if (nonZero.length === 1 && axis && Math.abs(Math.abs(axis[1]) - 1) < EPSILON) {
+    return `${axis[1] > 0 ? "+" : "\u2212"}${axis[0]}`;
+  }
+  return axes.map(([, value]) => trim(value)).join(", ");
+};
+
+// src/model/dfm-metrics.ts
 var define = ({ start, path, ...spec }) => ({
   ...spec,
   start: typeof start === "number" ? { mm: start, inch: start } : start,
@@ -988,12 +1068,26 @@ var QUICK_METRICS = [
   "undercutDepth",
   "tilted"
 ];
-var subjectInfo = (value) => FEATURE_SUBJECTS.find((each) => each.value === value);
-var metricInfo = (key) => FEATURE_METRICS.find((each) => each.key === key);
-var metricsForSubject = (subject) => {
-  const kinds = subjectInfo(subject)?.kinds;
-  if (!kinds) return FEATURE_METRICS;
-  return FEATURE_METRICS.filter(
+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))
   );
 };
@@ -1065,8 +1159,8 @@ var RETIRED_COLORS = {
   "#68b688": "#30a46c",
   "#6bb0b3": "#00a2c7"
 };
-var subjectLabel = (value) => subjectInfo(value)?.label ?? value;
-var trim = (value, places) => String(Number(value.toFixed(places)));
+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) {
@@ -1086,7 +1180,7 @@ var withUnit = (value, unit) => unit === "" ? value : unit === "\xB0" || unit ==
 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" ? trim(shown, FIELD_LENGTH_PLACES[units]) : quantity === "count" ? trim(shown, 0) : trim(shown, 3);
+  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());
@@ -1099,25 +1193,25 @@ var formatMeasured = (quantity, value, units) => {
   const shown = toUnits(quantity, value, units);
   switch (quantity) {
     case "length":
-      return units === "inch" ? `${trim(shown, LENGTH_PLACES.inch)}"` : `${trim(shown, LENGTH_PLACES.mm)} mm`;
+      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 `${trim(shown, 3)}\xB0`;
+      return `${trim2(shown, 3)}\xB0`;
     case "percent":
-      return `${trim(shown, 3)}%`;
+      return `${trim2(shown, 3)}%`;
     case "count":
-      return trim(shown, 0);
+      return trim2(shown, 0);
     case "flag":
     case "presence":
       return "";
     default:
-      return trim(shown, 3);
+      return trim2(shown, 3);
   }
 };
-var describeRule = (rule, units) => {
-  const info = metricInfo(rule.metric);
-  const subject = subjectLabel(rule.subject);
+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}`;
@@ -1126,8 +1220,8 @@ var describeRule = (rule, units) => {
   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) => {
-  const info = metricInfo(metricKey) ?? LD_METRIC;
+var makeRule = (subject, metricKey, units, color = WARNING_COLOR, vocabulary = MILLING_RULES) => {
+  const info = metricInfo(metricKey, vocabulary) ?? vocabulary.fallbackMetric;
   return {
     id: newRuleId(),
     subject,
@@ -1141,16 +1235,16 @@ var upperOf = (rule) => rule.max ?? rule.value + Math.max(Math.abs(rule.value),
 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) => {
-  const info = metricInfo(metricKey);
+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) => {
-  const metrics = metricsForSubject(subject);
+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] ?? LD_METRIC).key, units);
+  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;
@@ -1171,7 +1265,7 @@ var breaks = (rule, quantity, value) => {
 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) => {
+var parseRule = (raw, vocabulary) => {
   if (!raw || typeof raw !== "object") return null;
   const {
     id,
@@ -1184,8 +1278,8 @@ var parseRule = (raw) => {
     highOp,
     color
   } = raw;
-  const info = typeof key === "string" ? metricInfo(key) : void 0;
-  const valid = typeof id === "string" && typeof subject === "string" && subjectInfo(subject) !== 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);
+  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 {
@@ -1202,7 +1296,7 @@ var parseRule = (raw) => {
     color: RETIRED_COLORS[hex] ?? hex
   };
 };
-var parseRules = (raw) => Array.isArray(raw) ? raw.flatMap((each) => parseRule(each) ?? []) : null;
+var parseRules = (raw, vocabulary = MILLING_RULES) => Array.isArray(raw) ? raw.flatMap((each) => parseRule(each, vocabulary) ?? []) : null;
 
 // src/model/hole-groups.ts
 var holeSize = (sheets, tag) => {
@@ -1214,9 +1308,9 @@ var holeSize = (sheets, tag) => {
 };
 var SAME_DEPTH = 0.05;
 var DEPTH_FLOOR = 0.01;
-var TOLERANCE = 1e-6;
+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 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 sameDirection2 = (a, b) => Math.abs(a.x - b.x) < TOLERANCE2 && Math.abs(a.y - b.y) < TOLERANCE2 && Math.abs(a.z - b.z) < TOLERANCE2;
 var sameHoleSets = (features, sheets) => {
   const sizes = features.map((feature) => holeSize(sheets, feature.tag));
   const root = features.map((_, at) => at);
@@ -1230,7 +1324,7 @@ var sameHoleSets = (features, sheets) => {
     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 && sameDirection(one.machiningDirection, other.machiningDirection) && first.diameter.toFixed(3) === second.diameter.toFixed(3) && sameDepth(first.depth, second.depth)) {
+      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;
       }
@@ -1269,77 +1363,17 @@ var featureRows = (tags, features, sheets) => {
   });
 };
 
-// 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) => sameDirection2(each, machiningDirection)))
-      directions.push(machiningDirection);
-  });
-  const numbered = directions.flatMap(
-    (direction) => read.filter((feature) => sameDirection2(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 TOLERANCE2 = 1e-6;
-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 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 && sameDirection2(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-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/rule-set-file.ts
 var FILE_KIND = "toolpath-dfm-rules";
-var serializeRuleSet = (rules, meta = {}) => JSON.stringify(
+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",
@@ -1348,7 +1382,13 @@ var serializeRuleSet = (rules, meta = {}) => JSON.stringify(
   null,
   2
 );
-var parseRuleSetFile = (text) => {
+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);
@@ -1360,6 +1400,14 @@ var parseRuleSetFile = (text) => {
   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;
@@ -1368,7 +1416,7 @@ var parseRuleSetFile = (text) => {
     seen.add(id);
     return { ...rule, id };
   });
-  const rules = parseRules(withIds) ?? [];
+  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 } : {} };
@@ -1382,17 +1430,36 @@ var OP_WORDS = {
   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 llmRulePrompt = (current = []) => {
-  const groups = FEATURE_SUBJECTS.filter((each) => !each.value.startsWith(TYPE_SUBJECT));
-  const types = FEATURE_SUBJECTS.filter((each) => each.value.startsWith(TYPE_SUBJECT));
-  const metricLines = FEATURE_METRICS.map((metric) => {
-    const unit = quantityUnit(metric.quantity, "mm");
-    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit ? `, in ${unit}` : ""}; a new rule usually starts around ${metric.start.mm}`;
-    const 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(
-    [
+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",
@@ -1407,42 +1474,82 @@ var llmRulePrompt = (current = []) => {
       },
       { 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)."
     ],
-    { name: "Example set", description: "Shows one rule of each shape" }
+    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 unit = quantityUnit(metric.quantity, "mm");
+    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit ? `, in ${unit}` : ""}; a new rule usually starts around ${metric.start.mm}`;
+    const 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",
     "",
-    "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.",
+    script.intro,
     "",
-    "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.",
+    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.",
     "",
-    "### 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).",
+    ...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.`,
     "",
@@ -1450,7 +1557,7 @@ var llmRulePrompt = (current = []) => {
     "",
     "## Format",
     "",
-    'Top level: `{"kind":"toolpath-dfm-rules","version":1,"name":"\u2026","description":"\u2026","units":"mm","rules":[\u2026]}`.',
+    `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:",
@@ -1462,7 +1569,7 @@ var llmRulePrompt = (current = []) => {
     "- `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.",
     "",
-    "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.",
+    script.counting,
     "",
     "## Subjects (`subject`)",
     "",
@@ -1488,13 +1595,309 @@ var llmRulePrompt = (current = []) => {
       "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),
+      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/reach.ts
 var numbers = (value) => Array.isArray(value) && value.every((each) => typeof each === "number" && Number.isFinite(each)) ? value : null;
 var readReachCurve = (datasheet) => {
@@ -1545,11 +1948,16 @@ var featureProfile = (sheet, featureType) => {
 };
 
 export {
+  directionLabel,
+  dfmFeatures,
+  featureTypeLabel,
+  partTop,
+  isDrilled,
+  featureLd,
   PRESENCE_METRIC,
   TYPE_SUBJECT,
-  FEATURE_SUBJECTS,
-  QUICK_SUBJECTS,
-  QUICK_METRICS,
+  MILLING_RULES,
+  subjectInfo,
   metricInfo,
   metricsForSubject,
   LENGTH_PLACES,
@@ -1581,16 +1989,14 @@ export {
   parseRules,
   sameDepth,
   featureRows,
-  dfmFeatures,
-  featureTypeLabel,
-  partTop,
-  isDrilled,
-  featureLd,
   hitFigure,
   FILE_KIND,
   serializeRuleSet,
   parseRuleSetFile,
   llmRulePrompt,
+  ID_KINDS,
+  turnedTypeLabel,
+  TURNING_RULES,
   readReachCurve,
   runStart,
   peakHeight,