@toolpath/dfm 0.0.0-stage → 0.2.0

package/dist/model/index.js

@@ -0,0 +1,1047 @@
+import {
+  CRITICAL_COLOR,
+  FILE_KIND,
+  LENGTH_PLACES,
+  RULE_COLORS,
+  TYPE_SUBJECT,
+  WARNING_COLOR,
+  breaks,
+  compareColors,
+  describeRule,
+  dfmFeatures,
+  featureLd,
+  featureProfile,
+  featureTypeLabel,
+  hitFigure,
+  isDrilled,
+  lengthValue,
+  llmRulePrompt,
+  makeRule,
+  metricInfo,
+  parseRuleSetFile,
+  parseRules,
+  partTop,
+  peakHeight,
+  readReachCurve,
+  runStart,
+  sameDepth,
+  serializeRuleSet,
+  trimmedCurve,
+  unitLabel,
+  worseUpward
+} from "../chunk-5MPHT7BC.js";
+
+// src/model/broken-rules.ts
+var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
+var worstHits = (hits) => {
+  const seen = /* @__PURE__ */ new Set();
+  return byColor(hits).filter((hit) => {
+    if (seen.has(hit.metric.key)) return false;
+    seen.add(hit.metric.key);
+    return true;
+  });
+};
+var brokenRules = (check, tag, units) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
+  const figure = hitFigure(hit, units);
+  return {
+    key: hit.rule.id,
+    color: hit.rule.color,
+    text: describeRule(hit.rule, units),
+    ...figure ? { figure } : {}
+  };
+});
+var featureColor = (check, tag, region = null) => {
+  const key = tag.toLowerCase();
+  const face = region === null ? void 0 : check.paintedFaces.get(region);
+  if (face && face.tag.toLowerCase() === key) return face.color;
+  const whole = check.paintedWhole.get(key);
+  if (whole) return whole.color;
+  if (!check.required.has(key)) return void 0;
+  return byColor(check.hitsByTag.get(key) ?? [])[0]?.rule.color;
+};
+
+// src/model/dfm-flags.ts
+var howCut = (sheet) => {
+  const drilled = isDrilled(sheet);
+  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, 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",
+  "diameter",
+  "cornerRadius",
+  "filletRadius",
+  "floorFillet",
+  "tipAngle",
+  "thread",
+  "bevelAngle",
+  "finishTool",
+  "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 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, 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));
+};
+
+// 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 } : {}
+  };
+};
+
+// src/model/pinch-mark.ts
+import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
+var MAX_DRAWN_TOOL_MM = 3 * MM_PER_INCH2;
+var pinchMark = (datasheet, sheet, featureType) => {
+  const pinch = readPinch(datasheet);
+  const discs = pinch?.discs.filter(
+    (disc) => disc.diameter >= PINCH_TOOL_MM && disc.diameter <= MAX_DRAWN_TOOL_MM
+  ) ?? [];
+  if (!pinch || discs.length === 0) return null;
+  const fillet = sheet?.filletRadius;
+  const corner = !isSurfaceType(featureType) && fillet !== void 0 && fillet > 0 ? fillet : void 0;
+  return { ...pinch, discs, ...corner !== void 0 ? { corner } : {} };
+};
+var pinchLabel = (mark, units) => {
+  const length = (mm2) => `${lengthValue(mm2, units)} ${unitLabel(units)}`;
+  const tightest = Math.min(...mark.discs.map((disc) => disc.diameter));
+  const tool = mark.corner !== void 0 ? `bull nose R ${length(mark.corner)}` : "widest tool";
+  const places = mark.discs.length;
+  return {
+    label: `${mark.unresolved ? "\u2264 " : ""}\u2300 ${length(tightest)}`,
+    note: places > 1 ? `${tool} \xB7 ${places} places` : tool
+  };
+};
+
+// src/model/tool-frame.ts
+var extent = (values) => {
+  let low = Infinity;
+  let high = -Infinity;
+  for (const value of values) {
+    if (value < low) low = value;
+    if (value > high) high = value;
+  }
+  return { low, high };
+};
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var scale = (a, by) => [a[0] * by, a[1] * by, a[2] * by];
+var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+var unit = (a) => scale(a, 1 / Math.hypot(a[0], a[1], a[2]));
+var ON_DEPTH_MM = 0.05;
+var ON_CORNER_MM = 0.02;
+var POINT_DISC_MM = 0.01;
+var ON_WALL_MM = 0.1;
+var ON_WALL_SHARE = 0.02;
+var WALL_NORMAL_ALONG = 0.7;
+var SAME_PLACE_MM = 0.05;
+var MIN_HEIGHT_MM = 0.05;
+var readTriangles = ({ positions, normals }, origin) => {
+  const triangles = [];
+  for (let at2 = 0; at2 + 8 < positions.length; at2 += 9) {
+    const corner = (k) => [
+      (positions[at2 + k] ?? 0) - origin[0],
+      (positions[at2 + k + 1] ?? 0) - origin[1],
+      (positions[at2 + k + 2] ?? 0) - origin[2]
+    ];
+    const n = at2 / 9 * 3;
+    triangles.push({
+      a: corner(0),
+      b: corner(3),
+      c: corner(6),
+      normal: [normals[n] ?? 0, normals[n + 1] ?? 0, normals[n + 2] ?? 0]
+    });
+  }
+  return triangles;
+};
+var pointsOf = (triangles) => triangles.flatMap(({ a, b, c }) => [a, b, c]);
+var flatten = (point, { u, v }) => ({ x: dot(point, u), y: dot(point, v) });
+var wallSegments = (triangles, frame) => triangles.filter(({ normal }) => Math.abs(dot(normal, frame.w)) < WALL_NORMAL_ALONG).flatMap(({ a, b, c, normal }) => {
+  const [fa, fb, fc] = [flatten(a, frame), flatten(b, frame), flatten(c, frame)];
+  const air = flatten(normal, frame);
+  return [
+    { p: fa, q: fb, air },
+    { p: fb, q: fc, air },
+    { p: fc, q: fa, air }
+  ];
+});
+var nearestOn = ({ p, q }, at2) => {
+  const dx = q.x - p.x;
+  const dy = q.y - p.y;
+  const length = dx * dx + dy * dy;
+  const t = length === 0 ? 0 : Math.min(1, Math.max(0, ((at2.x - p.x) * dx + (at2.y - p.y) * dy) / length));
+  return { x: p.x + t * dx, y: p.y + t * dy };
+};
+var nearestWall = (segments, at2) => segments.reduce((best, segment) => {
+  const point = nearestOn(segment, at2);
+  const distance2 = Math.hypot(point.x - at2.x, point.y - at2.y);
+  if (best && distance2 >= best.distance) return best;
+  const open = (at2.x - point.x) * segment.air.x + (at2.y - point.y) * segment.air.y >= 0;
+  return { point, distance: distance2, open };
+}, null);
+var fitsDiscs = (triangles, frame, discs) => {
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    const onCorners = points.every(
+      (disc) => flat.some((point) => Math.hypot(point.x - disc.x, point.y - disc.y) <= ON_CORNER_MM)
+    );
+    if (!onCorners) return false;
+  }
+  if (wide.length === 0) return points.length > 0;
+  const segments = wallSegments(triangles, frame);
+  if (segments.length === 0) return false;
+  let touches = false;
+  for (const disc of wide) {
+    const nearest = nearestWall(segments, disc);
+    if (!nearest || !nearest.open) return false;
+    const slack = ON_WALL_MM + ON_WALL_SHARE * disc.diameter;
+    const radius = disc.diameter / 2;
+    if (nearest.distance < radius - slack) return false;
+    if (nearest.distance <= radius + slack) touches = true;
+  }
+  return touches;
+};
+var placeInFrame = ({ u, v, w }, x, y, z) => add(add(scale(u, x), scale(v, y)), scale(w, z));
+var AXES = [
+  [1, 0, 0],
+  [0, 1, 0],
+  [0, 0, 1]
+];
+var candidateFrames = (points, zMin, zMax, direction, strict = true) => {
+  const along = unit(direction);
+  const frames = [];
+  for (const sign of [1, -1]) {
+    const w = scale(along, sign);
+    const { low, high } = extent(points.map((point) => dot(point, w)));
+    if (strict && (Math.abs(low - zMin) > ON_DEPTH_MM || Math.abs(high - zMax) > ON_DEPTH_MM)) {
+      continue;
+    }
+    const across = AXES.reduce(
+      (best, axis) => Math.abs(dot(axis, w)) < Math.abs(dot(best, w)) ? axis : best
+    );
+    const u0 = unit(add(across, scale(w, -dot(across, w))));
+    const v0 = cross(w, u0);
+    for (let quarter = 0; quarter < 4; quarter++) {
+      const angle = quarter * Math.PI / 2;
+      const u = add(scale(u0, Math.cos(angle)), scale(v0, Math.sin(angle)));
+      for (const hand of [1, -1]) frames.push({ u, v: scale(cross(w, u), hand), w });
+    }
+  }
+  return frames;
+};
+var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var exactFrame = (triangles, discs, zMin, zMax, direction) => {
+  const fits = candidateFrames(pointsOf(triangles), zMin, zMax, direction).filter(
+    (frame) => fitsDiscs(triangles, frame, discs)
+  );
+  const [first] = fits;
+  if (!first) return null;
+  const placed = (frame) => discs.map((disc) => placeInFrame(frame, disc.x, disc.y, zMin));
+  const firstPlaces = placed(first);
+  const agree = fits.every(
+    (frame) => placed(frame).every((at2, index) => distance(at2, firstPlaces[index] ?? at2) <= SAME_PLACE_MM)
+  );
+  return agree ? first : null;
+};
+var discMiss = (triangles, frame, discs) => {
+  let miss = 0;
+  const points = discs.filter((disc) => disc.diameter < POINT_DISC_MM);
+  if (points.length > 0) {
+    const flat = pointsOf(triangles).map((point) => flatten(point, frame));
+    for (const disc of points) {
+      miss += extent(flat.map((point) => Math.hypot(point.x - disc.x, point.y - disc.y))).low;
+    }
+  }
+  const wide = discs.filter((disc) => disc.diameter >= POINT_DISC_MM);
+  if (wide.length === 0) return miss;
+  const segments = wallSegments(triangles, frame);
+  let touch = Infinity;
+  for (const disc of wide) {
+    const radius = disc.diameter / 2;
+    const nearest = nearestWall(segments, disc);
+    if (!nearest) return Infinity;
+    if (!nearest.open) miss += disc.diameter * 4;
+    miss += Math.max(0, radius - nearest.distance);
+    touch = Math.min(touch, Math.abs(nearest.distance - radius));
+  }
+  return miss + touch;
+};
+var bestFrame = (triangles, discs, zMin, zMax, direction) => {
+  if (triangles.length === 0 || discs.length === 0) return null;
+  const exact = exactFrame(triangles, discs, zMin, zMax, direction);
+  if (exact) return { frame: exact, lift: 0 };
+  const points = pointsOf(triangles);
+  const fitting = candidateFrames(points, zMin, zMax, direction);
+  const frames = fitting.length > 0 ? fitting : candidateFrames(points, zMin, zMax, direction, false);
+  const best = frames.reduce((was, frame) => {
+    const miss = discMiss(triangles, frame, discs);
+    return !was || miss < was.miss ? { frame, miss } : was;
+  }, null);
+  if (!best) return null;
+  const { low } = extent(points.map((point) => dot(point, best.frame.w)));
+  return { frame: best.frame, lift: fitting.length > 0 ? 0 : low - zMin };
+};
+var asVec = ([x, y, z]) => ({ x, y, z });
+var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 }) => {
+  const shift = [origin.x, origin.y, origin.z];
+  const faces = readTriangles(triangles, shift);
+  const found = bestFrame(faces, mark.discs, mark.zMin, mark.zMax, [
+    direction.x,
+    direction.y,
+    direction.z
+  ]);
+  const disc = mark.discs.reduce(
+    (tightest, each) => !tightest || each.diameter < tightest.diameter ? each : tightest,
+    null
+  );
+  if (!found || !disc) return null;
+  const { frame, lift } = found;
+  const radius = disc.diameter / 2;
+  const base = add(placeInFrame(frame, disc.x, disc.y, mark.zMin + lift), shift);
+  const contact = nearestWall(wallSegments(faces, frame), disc)?.point;
+  const toward = contact ? { x: contact.x - disc.x, y: contact.y - disc.y } : { x: 1, y: 0 };
+  const length = Math.hypot(toward.x, toward.y);
+  const across = add(
+    scale(frame.u, length > 1e-9 ? toward.x / length : 1),
+    scale(frame.v, length > 1e-9 ? toward.y / length : 0)
+  );
+  return {
+    base: asVec(base),
+    axis: asVec(frame.w),
+    diameter: disc.diameter,
+    height: Math.max(mark.zMax - mark.zMin, MIN_HEIGHT_MM),
+    cornerRadius: Math.min(Math.max(mark.corner ?? 0, 0), radius),
+    across: asVec(across)
+  };
+};
+export {
+  CRITICAL_COLOR,
+  FILE_KIND,
+  PINCH_TOOL_MM,
+  RULE_COLORS,
+  WARNING_COLOR,
+  brokenRules,
+  checkPart,
+  compareColors,
+  describeRule,
+  dfmFeatures,
+  featureColor,
+  featureMeasurements,
+  featureProfile,
+  featureSheet,
+  featureTypeLabel,
+  hitFigure,
+  isNoReading,
+  isSurfaceType,
+  llmRulePrompt,
+  makeRule,
+  maxBallDiameter,
+  parseRuleSetFile,
+  parseRules,
+  peakHeight,
+  pinchLabel,
+  pinchMark,
+  placePinchTool,
+  readPinch,
+  readReachCurve,
+  runStart,
+  sameDepth,
+  serializeRuleSet,
+  trimmedCurve,
+  withSurroundedFaces
+};