@toolpath/dfm 0.5.0 → 1.0.0

package/dist/model/index.js

@@ -1,1423 +1,80 @@
 import {
   CRITICAL_COLOR,
   FILE_KIND,
-  ID_KINDS,
-  LENGTH_PLACES,
+  MAX_DATASHEET_FIELDS,
   MILLING_RULES,
+  OPS,
+  PINCH_TOOL_MM,
+  PRESENCE_METRIC,
+  QUICK_SUBJECTS,
+  RANGE_HIGHS,
+  RANGE_LOWS,
   RULE_COLORS,
   TURNING_RULES,
-  TYPE_SUBJECT,
   WARNING_COLOR,
-  breaks,
+  brokenRules,
+  checkPart,
+  checkTurnedPart,
   compareColors,
+  datasheetFields,
   describeRule,
   dfmFeatures,
-  featureLd,
+  directionLabel,
+  featureColor,
+  featureMeasurements,
   featureProfile,
+  featureRows,
+  featureSheet,
   featureTypeLabel,
+  formatMeasured,
+  fromField,
+  highOf,
   hitFigure,
-  isDrilled,
+  isNoReading,
+  isSurfaceType,
   lengthValue,
   llmRulePrompt,
+  lowOf,
   makeRule,
+  maxBallDiameter,
   metricInfo,
+  metricsForSubject,
+  opSymbol,
   parseRuleSetFile,
   parseRules,
-  partTop,
   peakHeight,
+  pinchLabel,
+  pinchMark,
+  placePinchTool,
+  quantityUnit,
+  readPinch,
   readReachCurve,
   runStart,
   sameDepth,
   serializeRuleSet,
-  subjectInfo,
+  subjectLabel,
+  toField,
   trimmedCurve,
+  turnedStretches,
   turnedTypeLabel,
   unitLabel,
-  worseUpward
-} from "../chunk-4IRNLDE6.js";
-
-// src/model/broken-rules.ts
-var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
-var worstHits = (hits) => {
-  const seen = /* @__PURE__ */ new Set();
-  return byColor(hits).filter((hit) => {
-    if (seen.has(hit.metric.key)) return false;
-    seen.add(hit.metric.key);
-    return true;
-  });
-};
-var brokenRules = (check, tag, units, 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 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 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 } 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, inchMark = false) => units === "inch" ? `${trim(mm2 / MM_PER_INCH, LENGTH_PLACES.inch)}${inchMark ? '"' : " in"}` : `${trim(mm2, LENGTH_PLACES.mm)} mm`;
-var SURFACE_TYPES = /* @__PURE__ */ new Set([
-  "contour_surface",
-  "inner_fillet",
-  "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: `${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, 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 = ${trim(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 ? `${trim(undercut.taperDeg, 3)}\xB0` : void 0;
-  if (tslot && zMin !== void 0 && zMax !== void 0) {
-    rows.push({
-      key: "undercutWidth",
-      label: "Undercut width",
-      ...length(zMax - zMin),
-      derivation: [
-        "The groove\u2019s height along the tool: the widest cutter it takes in one pass.",
-        `zMax \u2212 zMin = ${mm(zMax)} \u2212 ${mm(zMin)} = ${mm(zMax - zMin)}`
-      ]
-    });
-  }
-  if (floor !== void 0) {
-    rows.push({
-      key: "floorWidth",
-      label: "Floor width",
-      ...length(floor),
-      derivation: ["The widest clearance over the floor", `facts.floorWidth = ${mm(floor)}`]
-    });
-  }
-  if (opening !== void 0) {
-    rows.push({
-      key: "openingWidth",
-      label: "Opening width",
-      ...length(opening),
-      derivation: [
-        "The clearance through the opening at the top of the groove",
-        `facts.topOpeningWidth = ${mm(opening)}`
-      ]
-    });
-  }
-  let depth = undercut.undercutDepth;
-  let depthLine = depth !== void 0 ? `facts.undercutDepth = ${mm(depth)}` : "";
-  if (depth === void 0 && floor !== void 0 && opening !== void 0) {
-    if (floor > opening && !undercut.isExternal) {
-      depth = (floor - opening) / 2;
-      depthLine = `(facts.floorWidth \u2212 facts.topOpeningWidth) / 2 = (${mm(floor)} \u2212 ${mm(opening)}) / 2 = ${mm(depth)}`;
-    }
-  }
-  if (depth !== void 0) {
-    rows.push({
-      key: "undercutDepth",
-      label: "Undercut depth",
-      ...length(depth),
-      derivation: [
-        "How far the groove runs back from its opening: what the cutter\u2019s head reaches past its shaft.",
-        depthLine
-      ]
-    });
-  }
-  if (angle) {
-    rows.push({
-      key: "taper",
-      label: "Dovetail angle",
-      value: `${angle} from the tool axis`,
-      derivation: [`facts.taperDeg = ${angle}, between the overhanging wall and the tool axis`]
-    });
-  }
-  const cutter = (value, derivation, alt) => ({
-    key: "undercutCutter",
-    label: "Max cutting diameter",
-    milling: true,
-    value,
-    ...alt !== void 0 ? { alt } : {},
-    derivation
-  });
-  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/pinch-mark.ts
-import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
-var MAX_DRAWN_TOOL_MM = 3 * MM_PER_INCH2;
-var pinchMark = (datasheet, sheet, featureType) => {
-  const pinch = readPinch(datasheet);
-  const discs = pinch?.discs.filter(
-    (disc) => disc.diameter >= PINCH_TOOL_MM && disc.diameter <= MAX_DRAWN_TOOL_MM
-  ) ?? [];
-  if (!pinch || discs.length === 0) return null;
-  const fillet = sheet?.filletRadius;
-  const corner = !isSurfaceType(featureType) && fillet !== void 0 && fillet > 0 ? fillet : void 0;
-  return { ...pinch, discs, ...corner !== void 0 ? { corner } : {} };
-};
-var pinchLabel = (mark, units) => {
-  const length = (mm2) => `${lengthValue(mm2, units)} ${unitLabel(units)}`;
-  const tightest = Math.min(...mark.discs.map((disc) => disc.diameter));
-  const tool = mark.corner !== void 0 ? `bull nose R ${length(mark.corner)}` : "widest tool";
-  const places = mark.discs.length;
-  return {
-    label: `${mark.unresolved ? "\u2264 " : ""}\u2300 ${length(tightest)}`,
-    note: places > 1 ? `${tool} \xB7 ${places} places` : tool
-  };
-};
-
-// src/model/tool-frame.ts
-var extent = (values) => {
-  let low = Infinity;
-  let high = -Infinity;
-  for (const value of values) {
-    if (value < low) low = value;
-    if (value > high) high = value;
-  }
-  return { low, high };
-};
-var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-var cross = (a, b) => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0]
-];
-var scale = (a, by) => [a[0] * by, a[1] * by, a[2] * by];
-var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-var unit = (a) => scale(a, 1 / Math.hypot(a[0], a[1], a[2]));
-var ON_DEPTH_MM = 0.05;
-var ON_CORNER_MM = 0.02;
-var POINT_DISC_MM = 0.01;
-var ON_WALL_MM = 0.1;
-var ON_WALL_SHARE = 0.02;
-var WALL_NORMAL_ALONG = 0.7;
-var SAME_PLACE_MM = 0.05;
-var MIN_HEIGHT_MM = 0.05;
-var readTriangles = ({ positions, normals }, origin) => {
-  const triangles = [];
-  for (let at2 = 0; at2 + 8 < positions.length; at2 += 9) {
-    const corner = (k) => [
-      (positions[at2 + k] ?? 0) - origin[0],
-      (positions[at2 + k + 1] ?? 0) - origin[1],
-      (positions[at2 + k + 2] ?? 0) - origin[2]
-    ];
-    const n = at2 / 9 * 3;
-    triangles.push({
-      a: corner(0),
-      b: corner(3),
-      c: corner(6),
-      normal: [normals[n] ?? 0, normals[n + 1] ?? 0, normals[n + 2] ?? 0]
-    });
-  }
-  return triangles;
-};
-var pointsOf = (triangles) => triangles.flatMap(({ a, b, c }) => [a, b, c]);
-var flatten = (point, { u, v }) => ({ x: dot(point, u), y: dot(point, v) });
-var wallSegments = (triangles, frame) => triangles.filter(({ normal }) => Math.abs(dot(normal, frame.w)) < WALL_NORMAL_ALONG).flatMap(({ a, b, c, normal }) => {
-  const [fa, fb, fc] = [flatten(a, frame), flatten(b, frame), flatten(c, frame)];
-  const air = flatten(normal, frame);
-  return [
-    { p: fa, q: fb, air },
-    { p: fb, q: fc, air },
-    { p: fc, q: fa, air }
-  ];
-});
-var nearestOn = ({ p, q }, at2) => {
-  const dx = q.x - p.x;
-  const dy = q.y - p.y;
-  const length = dx * dx + dy * dy;
-  const t = length === 0 ? 0 : Math.min(1, Math.max(0, ((at2.x - p.x) * dx + (at2.y - p.y) * dy) / length));
-  return { x: p.x + t * dx, y: p.y + t * dy };
-};
-var nearestWall = (segments, at2) => segments.reduce((best, segment) => {
-  const point = nearestOn(segment, at2);
-  const distance2 = Math.hypot(point.x - at2.x, point.y - at2.y);
-  if (best && distance2 >= best.distance) return best;
-  const open = (at2.x - point.x) * segment.air.x + (at2.y - point.y) * segment.air.y >= 0;
-  return { point, distance: distance2, open };
-}, null);
-var fitsDiscs = (triangles, frame, discs) => {
-  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
-  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
-  if (points.length > 0) {
-    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
-    const onCorners = points.every(
-      (disc) => flat.some((point) => Math.hypot(point.x - disc.x, point.y - disc.y) <= ON_CORNER_MM)
-    );
-    if (!onCorners) return false;
-  }
-  if (wide.length === 0) return points.length > 0;
-  const segments = wallSegments(triangles, frame);
-  if (segments.length === 0) return false;
-  let touches = false;
-  for (const disc of wide) {
-    const nearest = nearestWall(segments, disc);
-    if (!nearest || !nearest.open) return false;
-    const slack = ON_WALL_MM + ON_WALL_SHARE * disc.diameter;
-    const radius = disc.diameter / 2;
-    if (nearest.distance < radius - slack) return false;
-    if (nearest.distance <= radius + slack) touches = true;
-  }
-  return touches;
-};
-var placeInFrame = ({ u, v, w }, x, y, z) => add(add(scale(u, x), scale(v, y)), scale(w, z));
-var AXES = [
-  [1, 0, 0],
-  [0, 1, 0],
-  [0, 0, 1]
-];
-var candidateFrames = (points, zMin, zMax, direction, strict = true) => {
-  const along = unit(direction);
-  const frames = [];
-  for (const sign of [1, -1]) {
-    const w = scale(along, sign);
-    const { low, high } = extent(points.map((point) => dot(point, w)));
-    if (strict && (Math.abs(low - zMin) > ON_DEPTH_MM || Math.abs(high - zMax) > ON_DEPTH_MM)) {
-      continue;
-    }
-    const across = AXES.reduce(
-      (best, axis) => Math.abs(dot(axis, w)) < Math.abs(dot(best, w)) ? axis : best
-    );
-    const u0 = unit(add(across, scale(w, -dot(across, w))));
-    const v0 = cross(w, u0);
-    for (let quarter = 0; quarter < 4; quarter++) {
-      const angle = quarter * Math.PI / 2;
-      const u = add(scale(u0, Math.cos(angle)), scale(v0, Math.sin(angle)));
-      for (const hand of [1, -1]) frames.push({ u, v: scale(cross(w, u), hand), w });
-    }
-  }
-  return frames;
-};
-var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-var exactFrame = (triangles, discs, zMin, zMax, direction) => {
-  const fits = candidateFrames(pointsOf(triangles), zMin, zMax, direction).filter(
-    (frame) => fitsDiscs(triangles, frame, discs)
-  );
-  const [first] = fits;
-  if (!first) return null;
-  const placed = (frame) => discs.map((disc) => placeInFrame(frame, disc.x, disc.y, zMin));
-  const firstPlaces = placed(first);
-  const agree = fits.every(
-    (frame) => placed(frame).every((at2, index) => distance(at2, firstPlaces[index] ?? at2) <= SAME_PLACE_MM)
-  );
-  return agree ? first : null;
-};
-var discMiss = (triangles, frame, discs) => {
-  let miss = 0;
-  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
-  if (points.length > 0) {
-    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
-    for (const disc of points) {
-      miss += extent(flat.map((point) => Math.hypot(point.x - disc.x, point.y - disc.y))).low;
-    }
-  }
-  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
-  if (wide.length === 0) return miss;
-  const segments = wallSegments(triangles, frame);
-  let touch = Infinity;
-  for (const disc of wide) {
-    const radius = disc.diameter / 2;
-    const nearest = nearestWall(segments, disc);
-    if (!nearest) return Infinity;
-    if (!nearest.open) miss += disc.diameter * 4;
-    miss += Math.max(0, radius - nearest.distance);
-    touch = Math.min(touch, Math.abs(nearest.distance - radius));
-  }
-  return miss + touch;
-};
-var bestFrame = (triangles, discs, zMin, zMax, direction) => {
-  if (triangles.length === 0 || discs.length === 0) return null;
-  const exact = exactFrame(triangles, discs, zMin, zMax, direction);
-  if (exact) return { frame: exact, lift: 0 };
-  const points = pointsOf(triangles);
-  const fitting = candidateFrames(points, zMin, zMax, direction);
-  const frames = fitting.length > 0 ? fitting : candidateFrames(points, zMin, zMax, direction, false);
-  const best = frames.reduce((was, frame) => {
-    const miss = discMiss(triangles, frame, discs);
-    return !was || miss < was.miss ? { frame, miss } : was;
-  }, null);
-  if (!best) return null;
-  const { low } = extent(points.map((point) => dot(point, best.frame.w)));
-  return { frame: best.frame, lift: fitting.length > 0 ? 0 : low - zMin };
-};
-var asVec = ([x, y, z]) => ({ x, y, z });
-var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 }) => {
-  const shift = [origin.x, origin.y, origin.z];
-  const faces = readTriangles(triangles, shift);
-  const found = bestFrame(faces, mark.discs, mark.zMin, mark.zMax, [
-    direction.x,
-    direction.y,
-    direction.z
-  ]);
-  const disc = mark.discs.reduce(
-    (tightest, each) => !tightest || each.diameter < tightest.diameter ? each : tightest,
-    null
-  );
-  if (!found || !disc) return null;
-  const { frame, lift } = found;
-  const radius = disc.diameter / 2;
-  const base = add(placeInFrame(frame, disc.x, disc.y, mark.zMin + lift), shift);
-  const contact = nearestWall(wallSegments(faces, frame), disc)?.point;
-  const toward = contact ? { x: contact.x - disc.x, y: contact.y - disc.y } : { x: 1, y: 0 };
-  const length = Math.hypot(toward.x, toward.y);
-  const across = add(
-    scale(frame.u, length > 1e-9 ? toward.x / length : 1),
-    scale(frame.v, length > 1e-9 ? toward.y / length : 0)
-  );
-  return {
-    base: asVec(base),
-    axis: asVec(frame.w),
-    diameter: disc.diameter,
-    height: Math.max(mark.zMax - mark.zMin, MIN_HEIGHT_MM),
-    cornerRadius: Math.min(Math.max(mark.corner ?? 0, 0), radius),
-    across: asVec(across)
-  };
-};
-
-// 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()
-  };
-};
+  upperOf,
+  withMetric,
+  withOp,
+  withSubject,
+  withSurroundedFaces
+} from "../chunk-XHYPKN4E.js";
 export {
   CRITICAL_COLOR,
   FILE_KIND,
+  MAX_DATASHEET_FIELDS,
   MILLING_RULES,
+  OPS,
   PINCH_TOOL_MM,
+  PRESENCE_METRIC,
+  QUICK_SUBJECTS,
+  RANGE_HIGHS,
+  RANGE_LOWS,
   RULE_COLORS,
   TURNING_RULES,
   WARNING_COLOR,
@@ -1425,32 +82,51 @@ export {
   checkPart,
   checkTurnedPart,
   compareColors,
+  datasheetFields,
   describeRule,
   dfmFeatures,
+  directionLabel,
   featureColor,
   featureMeasurements,
   featureProfile,
+  featureRows,
   featureSheet,
   featureTypeLabel,
+  formatMeasured,
+  fromField,
+  highOf,
   hitFigure,
   isNoReading,
   isSurfaceType,
+  lengthValue,
   llmRulePrompt,
+  lowOf,
   makeRule,
   maxBallDiameter,
+  metricInfo,
+  metricsForSubject,
+  opSymbol,
   parseRuleSetFile,
   parseRules,
   peakHeight,
   pinchLabel,
   pinchMark,
   placePinchTool,
+  quantityUnit,
   readPinch,
   readReachCurve,
   runStart,
   sameDepth,
   serializeRuleSet,
+  subjectLabel,
+  toField,
   trimmedCurve,
   turnedStretches,
   turnedTypeLabel,
+  unitLabel,
+  upperOf,
+  withMetric,
+  withOp,
+  withSubject,
   withSurroundedFaces
 };