@toolpath/dfm 0.0.0-stage → 0.1.0

package/dist/model/index.js

@@ -0,0 +1,775 @@
+import {
+  CRITICAL_COLOR,
+  FILE_KIND,
+  LENGTH_PLACES,
+  RULE_COLORS,
+  TYPE_SUBJECT,
+  WARNING_COLOR,
+  breaks,
+  compareColors,
+  describeRule,
+  dfmFeatures,
+  featureLd,
+  featureProfile,
+  featureTypeLabel,
+  hitFigure,
+  isDrilled,
+  llmRulePrompt,
+  makeRule,
+  metricInfo,
+  parseRuleSetFile,
+  parseRules,
+  partTop,
+  peakHeight,
+  readReachCurve,
+  runStart,
+  sameDepth,
+  serializeRuleSet,
+  trimmedCurve,
+  worseUpward
+} from "../chunk-5MPHT7BC.js";
+
+// 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 = (record, path) => path.split(".").reduce(
+  (value, key) => typeof value === "object" && value !== null ? value[key] : void 0,
+  record
+);
+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 numbers = Array.isArray(heights) ? heights.filter(
+        (each) => typeof each === "number" && Number.isFinite(each)
+      ) : [];
+      return numbers.length > 0 ? { value: Math.max(...numbers) } : 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 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 worstColor = (feature) => hitsByTag.get(feature.tag.toLowerCase())?.map((hit) => hit.rule.color).sort(compareColors)[0];
+  const areaOf = (feature) => [...new Set(feature.regionIdxs)].reduce(
+    (sum, region) => sum + (regionAreas.get(region) ?? 0),
+    0
+  );
+  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(feature),
+      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 regionsOf = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = feature.tag.toLowerCase();
+    regionsOf.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 && regionsOf.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)
+    ])
+  );
+  const byRule = rules.map((rule) => {
+    const hits = features.flatMap((feature) => {
+      const tag = feature.tag.toLowerCase();
+      const hit = hitsByTag.get(tag)?.find((each) => each.rule.id === rule.id);
+      return hit ? [{ tag: feature.tag, value: hit.value, metric: hit.metric, required: required.has(tag) }] : [];
+    });
+    const [first] = hits;
+    const up = first ? worseUpward(rule, first.metric) : true;
+    hits.sort((a, b) => up ? b.value - a.value : a.value - b.value);
+    return {
+      rule,
+      tags: hits.filter((hit) => hit.required).map((hit) => hit.tag),
+      otherTags: hits.filter((hit) => !hit.required).map((hit) => hit.tag)
+    };
+  });
+  return {
+    hitsByTag,
+    required,
+    byRule,
+    ...unavoidableFaces(features, hitsByTag, sources.regionAreas)
+  };
+};
+
+// src/model/feature-details.ts
+import { MM_PER_INCH } from "@toolpath/tool-support";
+var mm = (value) => `${trim(value, 4)} mm`;
+var tol = (value) => `${trim(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) = ${trim(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 trim = (value, places) => String(Number(value.toFixed(places)));
+var formatLength = (mm2, units) => units === "inch" ? `${trim(mm2 / MM_PER_INCH, LENGTH_PLACES.inch)} in` : `${trim(mm2, LENGTH_PLACES.mm)} mm`;
+var 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",
+  "diameter",
+  "cornerRadius",
+  "filletRadius",
+  "floorFillet",
+  "tipAngle",
+  "thread",
+  "bevelAngle",
+  "finishTool",
+  "pinch",
+  "fitCornerRadius",
+  "maxBull",
+  "maxBall",
+  "depthBelowTop",
+  "ld",
+  "featureLd",
+  "topLd"
+];
+var featureMeasurements = ({
+  features,
+  feature,
+  sheets,
+  units
+}) => {
+  const other = units === "inch" ? "mm" : "inch";
+  const length = (mm2) => ({ value: formatLength(mm2, units), alt: formatLength(mm2, other) });
+  const sheet = sheets[feature.tag.toLowerCase()];
+  const rows = [];
+  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) {
+    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) {
+    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) {
+    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)}`
+          ] : []
+        ]
+      });
+    }
+  }
+  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 = featureLd(features, feature, sheets);
+  if (ld && top !== null && bottom !== void 0) {
+    const across = ld.basis === "bore" ? `D = facts.diameter = ${mm(ld.across)}` : ld.basis === "pinch" ? `D = widest tool (the tightest pinch disc, tolerance taken out) = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""}` : `D = widest tool = 2 \xD7 inside corner radius = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""} (no pinch points reported)`;
+    const ratioOf = (depth) => {
+      const ratio = (depth / ld.across).toFixed(3);
+      return ld.atLeast ? `\u2265 ${ratio}` : ratio;
+    };
+    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: `${trim(sheet.tipAngle, 3)}\xB0${flat ? " (flat)" : ""}`,
+      derivation: [
+        `facts.fullConeDeg = ${trim(sheet.tipAngle, 3)}\xB0${flat ? " (180\xB0: flat bottom)" : ""}`
+      ]
+    });
+  }
+  if (sheet?.threading) {
+    rows.push({
+      key: "thread",
+      label: "Thread",
+      value: `${formatLength(sheet.threading.basicDiameter, units)} \xD7 ${formatLength(sheet.threading.threadPitch, units)} 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 = ${trim(sheet.chamferAngle, 3)}\xB0`]
+    });
+  }
+  return rows.sort((a, b) => ROW_ORDER.indexOf(a.key) - ROW_ORDER.indexOf(b.key));
+};
+
+// src/model/pinch.ts
+var asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf = (value) => typeof value === "object" && value !== null ? value : {};
+var clearanceFit = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const facts = recordOf(sheet.facts);
+  const chamfer = facts.kind === "Chamfer";
+  const band = recordOf(chamfer ? recordOf(facts.three).cd : facts.cd);
+  const tolerance = recordOf(sheet.toleranceBand);
+  const strict = asNumber(recordOf(band.ignore).min);
+  if (strict === void 0) return void 0;
+  const bandPath = chamfer ? "facts.three.cd" : "facts.cd";
+  const loose = asNumber(recordOf(band.deviate).min);
+  const atStrict = asNumber(tolerance.atolIgnore);
+  const atLoose = asNumber(tolerance.atolDeviate);
+  const source = { bandPath, strict, loose, atStrict, atLoose };
+  if (loose === void 0 || atStrict === void 0 || atLoose === void 0 || atLoose <= atStrict)
+    return { ...source, slack: 0, resolved: false };
+  const growth = (loose - strict) / (atLoose - atStrict);
+  const slack = growth > 0 ? Math.min(growth * atStrict, strict) : 0;
+  return { ...source, slack, resolved: true };
+};
+var readPinch = (datasheet) => {
+  const sheet = recordOf(datasheet);
+  const zMin = asNumber(sheet.zMin);
+  const zMax = asNumber(sheet.zMax);
+  if (zMin === void 0 || zMax === void 0 || !Array.isArray(sheet.pinchPoints)) return null;
+  const fit = clearanceFit(datasheet);
+  const slack = fit?.slack ?? 0;
+  const discs = sheet.pinchPoints.flatMap((point) => {
+    const centre = recordOf(recordOf(point).center);
+    const x = asNumber(centre.x);
+    const y = asNumber(centre.y);
+    const diameter = asNumber(recordOf(point).diameter);
+    return x === void 0 || y === void 0 || diameter === void 0 || diameter < 0 ? [] : [{ x, y, diameter: Math.max(diameter - slack, 0) }];
+  });
+  if (discs.length === 0) return null;
+  return { discs, zMin, zMax, ...fit && !fit.resolved ? { unresolved: true } : {} };
+};
+
+// src/model/feature-sheet.ts
+var SHARP_MM = 0.1;
+var SHARP_RADIUS_MM = 0.01;
+var PINCH_TOOL_MM = 0.01;
+var asNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var recordOf2 = (value) => typeof value === "object" && value !== null ? value : {};
+var threadingOf = (facts) => {
+  const spec = recordOf2(recordOf2(facts.threading).spec);
+  const basicDiameter = asNumber2(spec.basicDiameter);
+  const threadPitch = asNumber2(spec.threadPitch);
+  if (basicDiameter === void 0 || threadPitch === void 0 || threadPitch <= 0) return void 0;
+  return { basicDiameter, threadPitch };
+};
+var noToolFits = (band) => {
+  const { max } = band;
+  if (typeof max === "string") return /^-inf/i.test(max.trim());
+  return typeof max === "number" && (max === Number.NEGATIVE_INFINITY || Number.isFinite(max) && max < SHARP_MM);
+};
+var insideCornerRadius = (fit) => Math.max((fit.strict - fit.slack) / 2, 0);
+var pinchCentres = (points) => Array.isArray(points) ? points.flatMap((point) => {
+  const centre = recordOf2(recordOf2(point).center);
+  const x = asNumber2(centre.x);
+  const y = asNumber2(centre.y);
+  return x === void 0 || y === void 0 ? [] : [{ x, y }];
+}) : [];
+var ZERO_MM = 5e-5;
+var isCutterlessTslot = (datasheet) => {
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  if (facts.kind !== "Tslot") return false;
+  const leaves = (value) => typeof value === "object" && value !== null ? Object.values(value).flatMap(leaves) : [value];
+  const band = leaves(facts.cd);
+  return band.length > 0 && band.every((each) => {
+    const value = typeof each === "string" && each.trim() !== "" ? Number(each) : each;
+    return typeof value === "number" && Math.abs(value) < ZERO_MM;
+  });
+};
+var isSharpCorneredFillet = (featureType, datasheet) => {
+  if (typeof featureType !== "string" || !featureType.toLowerCase().split("_").includes("fillet"))
+    return false;
+  const facts = recordOf2(recordOf2(datasheet).facts);
+  return facts.hasSharpCorner === true || recordOf2(facts.three).hasSharpCorner === true;
+};
+var isNoReading = (featureType, datasheet) => isCutterlessTslot(datasheet) || isSharpCorneredFillet(featureType, datasheet);
+var featureSheet = (datasheet) => {
+  const sheet = recordOf2(datasheet);
+  const facts = recordOf2(sheet.facts);
+  const kind = typeof facts.kind === "string" ? facts.kind : void 0;
+  const band = recordOf2(kind === "Chamfer" ? recordOf2(facts.three).cd : facts.cd);
+  const ignoreBand = recordOf2(band.ignore);
+  const fit = clearanceFit(datasheet);
+  const fields = {
+    kind,
+    zMin: asNumber2(sheet.zMin),
+    zMax: asNumber2(sheet.zMax),
+    extendedZMax: asNumber2(sheet.extendedZMax),
+    maxTool: asNumber2(ignoreBand.min),
+    diameter: kind === "Hole" ? asNumber2(facts.diameter) : void 0,
+    tipAngle: kind === "Hole" ? asNumber2(facts.fullConeDeg) : void 0,
+    filletRadius: asNumber2(facts.filletRadius),
+    // A bevel's angle wherever the facts carry one: a chamfer's, and any other kind that bevels.
+    chamferAngle: asNumber2(recordOf2(facts.bevel).angleDeg)
+  };
+  const toolFitPath = facts.toolFit !== void 0 ? "facts.toolFit" : "facts.three.toolFit";
+  const toolFit = recordOf2(facts.toolFit ?? recordOf2(facts.three).toolFit);
+  fields.fitToolDiameter = asNumber2(toolFit.toolDiameter);
+  fields.fitCornerRadius = asNumber2(toolFit.cornerRadius);
+  const ballOnly = (facts.useOnlyBallToolsForFinish ?? recordOf2(facts.three).useOnlyBallToolsForFinish) === true;
+  const measured = Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== void 0)
+  );
+  const cramped = Object.keys(ignoreBand).length > 0 && noToolFits(ignoreBand);
+  const walled = kind !== "Hole" && sheet.hasWall === true;
+  const clearance = walled ? fit : void 0;
+  const cornerRadius = clearance ? insideCornerRadius(clearance) : void 0;
+  const sharp = cornerRadius !== void 0 && cornerRadius < SHARP_RADIUS_MM && !cramped;
+  const threading = kind === "Hole" ? threadingOf(facts) : void 0;
+  const pinched = (readPinch(datasheet)?.discs ?? []).filter(
+    (disc) => disc.diameter >= PINCH_TOOL_MM
+  );
+  return {
+    ...measured,
+    ...pinched.length > 0 ? {
+      pinchDiameter: Math.min(...pinched.map((disc) => disc.diameter)),
+      pinchPlaces: pinched.length
+    } : {},
+    ...cornerRadius !== void 0 ? { cornerRadius } : {},
+    ...clearance && !clearance.resolved ? { cornerRadiusUnresolved: true } : {},
+    ...clearance ? { clearance } : {},
+    ...Object.keys(toolFit).length > 0 ? { toolFitPath } : {},
+    ...sharp ? { sharpCorners: pinchCentres(sheet.pinchPoints) } : {},
+    ...cramped ? { noToolFits: true } : {},
+    ...ballOnly ? { ballOnly: true } : {},
+    ...threading ? { threading } : {}
+  };
+};
+export {
+  CRITICAL_COLOR,
+  FILE_KIND,
+  PINCH_TOOL_MM,
+  RULE_COLORS,
+  WARNING_COLOR,
+  checkPart,
+  compareColors,
+  describeRule,
+  dfmFeatures,
+  featureMeasurements,
+  featureProfile,
+  featureSheet,
+  featureTypeLabel,
+  hitFigure,
+  isNoReading,
+  isSurfaceType,
+  llmRulePrompt,
+  makeRule,
+  maxBallDiameter,
+  parseRuleSetFile,
+  parseRules,
+  peakHeight,
+  readPinch,
+  readReachCurve,
+  runStart,
+  sameDepth,
+  serializeRuleSet,
+  trimmedCurve,
+  withSurroundedFaces
+};