@toolpath/dfm 0.0.0-stage → 0.2.0

package/dist/chunk-5MPHT7BC.js

@@ -0,0 +1,1599 @@
+// src/model/dfm-metrics.ts
+import { MM_PER_INCH } from "@toolpath/tool-support";
+var define = ({ start, path, ...spec }) => ({
+  ...spec,
+  start: typeof start === "number" ? { mm: start, inch: start } : start,
+  ...path === void 0 ? {} : { path: typeof path === "string" ? [path] : path }
+});
+var SMALL = { mm: 1, inch: 1.27 };
+var TOOL = { mm: 3, inch: 3.175 };
+var DEEP = { mm: 50, inch: 50.8 };
+var AREA = { mm: 1e3, inch: 645.16 };
+var cd = (band, bound) => [
+  `facts.cd.${band}.${bound}`,
+  `facts.three.cd.${band}.${bound}`
+];
+var ALWAYS = "Always";
+var SIZE = "Size and depth";
+var TOOLS = "Tool access";
+var AREAS = "Surface area";
+var MAKE = "Machining";
+var HOLE = "Holes";
+var THREAD = "Threads";
+var CHAMFER = "Chamfers";
+var OUTLINES = "Floors, fillets and outlines";
+var FACES = "Faces and profiles";
+var SURFACE = "3D surfaces";
+var UNDERCUT = "Undercuts";
+var PRESENCE_METRIC = define({
+  key: "present",
+  label: "any size",
+  group: ALWAYS,
+  quantity: "presence",
+  op: "gte",
+  start: 0,
+  hint: "Flags every feature of this type, whatever its geometry"
+});
+var LD_METRIC = define({
+  key: "ld",
+  label: "L/D to top of part",
+  group: SIZE,
+  quantity: "ratio",
+  op: "gte",
+  start: 5,
+  hint: "How far down the tool reaches: depth below the top of the part over its minimum clearance \u2014 a hole\u2019s over its bore; twice its inside corner radius where there are no pinch points. None for a sharp corner with no clearance"
+});
+var FEATURE_LD_METRIC = define({
+  key: "featureLd",
+  label: "feature L/D",
+  group: SIZE,
+  quantity: "ratio",
+  op: "gte",
+  start: 5,
+  hint: "The feature\u2019s own depth (its top to its bottom) over the same clearance as L/D to top of part: what its walls ask of the cutter, however deep in the part it sits"
+});
+var FEATURE_METRICS = [
+  PRESENCE_METRIC,
+  LD_METRIC,
+  FEATURE_LD_METRIC,
+  define({
+    key: "depthBelowTop",
+    label: "depth below top",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: DEEP,
+    hint: "How far below the top of the part the feature bottoms out"
+  }),
+  define({
+    key: "featureDepth",
+    label: "feature depth",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 25, inch: MM_PER_INCH },
+    hint: "The feature\u2019s own depth, top to bottom"
+  }),
+  define({
+    key: "faceCount",
+    label: "number of faces",
+    group: SIZE,
+    quantity: "count",
+    op: "gte",
+    start: 10,
+    hint: "How many faces of the model make it up"
+  }),
+  define({
+    key: "zMin",
+    label: "bottom (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "lte",
+    start: 0,
+    signed: true,
+    path: "zMin",
+    hint: "The feature\u2019s bottom along its tool axis, in the Engine\u2019s frame"
+  }),
+  define({
+    key: "zMax",
+    label: "top (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "zMax",
+    hint: "The feature\u2019s top along its tool axis, in the Engine\u2019s frame"
+  }),
+  define({
+    key: "extendedZMin",
+    label: "pass bottom (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "lte",
+    start: 0,
+    signed: true,
+    path: "extendedZMin",
+    hint: "Where a pass over it runs out: its bottom, or lower where a chamfer on a far edge deepens it"
+  }),
+  define({
+    key: "extendedZMax",
+    label: "pass top (tool-axis Z)",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "extendedZMax",
+    hint: "Where a pass over it starts: its top, or higher where a chamfer or fillet sits on its mouth"
+  }),
+  define({
+    key: "reachHeight",
+    label: "material height beside it",
+    group: SIZE,
+    quantity: "length",
+    op: "gte",
+    start: DEEP,
+    hint: "The highest the material stands anywhere outboard of it (its reach curve), which a tool\u2019s holder must clear"
+  }),
+  define({
+    key: "maxTool",
+    label: "largest tool that fits",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("ignore", "min"),
+    hint: "The widest cutter that still reaches every point"
+  }),
+  define({
+    key: "cornerRadius",
+    label: "inside corner radius",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    hint: "The radius of its tightest corner between walls, as drawn \u2014 zero when sharp. Not a floor fillet"
+  }),
+  define({
+    key: "maxToolSomewhere",
+    label: "largest tool that fits anywhere",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("ignore", "max"),
+    hint: "The widest cutter that fits somewhere in it"
+  }),
+  define({
+    key: "maxToolDeviate",
+    label: "largest tool within tolerance",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("deviate", "min"),
+    hint: "The widest cutter that reaches every point, allowing the reported tolerance band"
+  }),
+  define({
+    key: "maxToolAdaptive",
+    label: "largest adaptive tool",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: cd("effectiveAdaptive", "min"),
+    hint: "The widest cutter that reaches every point once adaptive-cutting allowances are applied"
+  }),
+  define({
+    key: "terminalCornerRadius",
+    label: "finishing corner radius limit",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.cd.terminalCornerRadius", "facts.three.cd.terminalCornerRadius"],
+    hint: "The corner radius a finishing tool must not exceed"
+  }),
+  define({
+    key: "maxBottomDiameter",
+    label: "largest tool bottom",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.maxBottomDiameter", "facts.three.maxBottomDiameter"],
+    kinds: ["Pocket", "Boss", "Face", "Three", "Chamfer"],
+    hint: "The widest bottom a finishing tool may have"
+  }),
+  define({
+    key: "pinchPoints",
+    label: "tight spots",
+    group: TOOLS,
+    quantity: "count",
+    op: "gte",
+    start: 2,
+    hint: "How many places it narrows to its tightest clearance (the Engine reports up to ten)"
+  }),
+  define({
+    key: "pinchDiameter",
+    label: "minimum clearance",
+    group: TOOLS,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    hint: "The widest circle that fits where it is tightest: its smallest pinch disc, the Engine\u2019s tolerance taken out. Only for the kinds the Engine reports pinch points for; a sharp corner is its own rule"
+  }),
+  define({
+    key: "sharpCorner",
+    label: "a sharp inside corner",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "A vertical corner between its walls with no radius, which no end mill makes. Not a floor fillet"
+  }),
+  define({
+    key: "noToolFits",
+    label: "no room for any tool",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "No cutter fits anywhere in it"
+  }),
+  define({
+    key: "tilted",
+    label: "a tilted tool axis",
+    group: TOOLS,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    hint: "Machined along a direction that is not one of the part\u2019s six square ones: a 5-axis setup"
+  }),
+  define({
+    key: "surfaceArea",
+    label: "surface area",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    hint: "Its whole surface: the Engine\u2019s partition of it, or its faces\u2019 areas together"
+  }),
+  define({
+    key: "projectedFloorArea",
+    label: "floor area (projected)",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: ["projectedFloorArea", "floorishArea"],
+    hint: "Area machined floor-wise, square to the tool axis"
+  }),
+  define({
+    key: "projectedWallArea",
+    label: "wall area (projected)",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: ["projectedWallArea", "wallishArea"],
+    hint: "Area machined wall-wise, along the tool axis"
+  }),
+  define({
+    key: "floorArea",
+    label: "floor surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.floorArea",
+    hint: "Surface square to the tool axis"
+  }),
+  define({
+    key: "wallArea",
+    label: "wall surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.wallArea",
+    hint: "Surface running along the tool axis"
+  }),
+  define({
+    key: "filletArea",
+    label: "fillet surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.filletArea",
+    hint: "The concave rounds between floors and walls"
+  }),
+  define({
+    key: "chamferArea",
+    label: "chamfer surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.chamferArea",
+    hint: "The bevels"
+  }),
+  define({
+    key: "contourArea",
+    label: "3D surface",
+    group: AREAS,
+    quantity: "area",
+    op: "gte",
+    start: AREA,
+    path: "areas.contourArea",
+    hint: "Surface with no flat to stand on"
+  }),
+  define({
+    key: "hasFloor",
+    label: "a floor",
+    group: MAKE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "hasFloor",
+    hint: "It has a floor machined square to the tool axis"
+  }),
+  define({
+    key: "hasWall",
+    label: "a wall",
+    group: MAKE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "hasWall",
+    hint: "It has a wall machined along the tool axis"
+  }),
+  define({
+    key: "axialStock",
+    label: "axial stock to leave",
+    group: MAKE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 0.1, inch: 0.127 },
+    path: "axialStockToLeave",
+    hint: "Material left along the tool axis for a later operation"
+  }),
+  define({
+    key: "radialStock",
+    label: "radial stock to leave",
+    group: MAKE,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 0.1, inch: 0.127 },
+    path: "radialStockToLeave",
+    hint: "Material left radially for a later operation"
+  }),
+  define({
+    key: "tolIgnore",
+    label: "ignored tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.01, inch: 0.0127 },
+    path: "toleranceBand.atolIgnore",
+    hint: "Deviation at or below this is ignored"
+  }),
+  define({
+    key: "tolDeviate",
+    label: "reported tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.02, inch: 0.0254 },
+    path: "toleranceBand.atolDeviate",
+    hint: "Deviation up to this is reported"
+  }),
+  define({
+    key: "tolMax",
+    label: "tolerance",
+    group: MAKE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.05, inch: 0.0508 },
+    path: "toleranceBand.atolMax",
+    hint: "The most it may deviate from the model"
+  }),
+  define({
+    key: "passLength",
+    label: "pass length",
+    group: OUTLINES,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 500, inch: 508 },
+    path: ["facts.wallLength.length", "facts.length"],
+    kinds: ["Pocket", "Boss", "Wall", "Profile"],
+    hint: "How far a pass around its outline travels, with a tool of no width"
+  }),
+  define({
+    key: "diameter",
+    label: "diameter",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 1.5, inch: 1.5875 },
+    path: "facts.diameter",
+    kinds: ["Hole"],
+    hint: "What the hole is drilled to \u2014 narrower than modelled for a threaded hole"
+  }),
+  define({
+    key: "coneAngle",
+    label: "tip angle",
+    group: HOLE,
+    quantity: "angle",
+    op: "lte",
+    start: 118,
+    path: "facts.fullConeDeg",
+    kinds: ["Hole"],
+    hint: "The full angle of the cone at its bottom; 180\xB0 for a flat bottom"
+  }),
+  define({
+    key: "counterbore",
+    label: "a counterbore",
+    group: HOLE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isCounterbore",
+    kinds: ["Hole"],
+    hint: "A larger bore at its mouth"
+  }),
+  define({
+    key: "maxSpot",
+    label: "largest spot drill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxSpotDiameter",
+    kinds: ["Hole"],
+    hint: "The widest spot drill that reaches it without collision"
+  }),
+  define({
+    key: "minDrill",
+    label: "smallest drill",
+    group: HOLE,
+    quantity: "length",
+    op: "gte",
+    start: TOOL,
+    path: "facts.minDrillDiameter",
+    kinds: ["Hole"],
+    hint: "The narrowest drill that leaves it within its undersize"
+  }),
+  define({
+    key: "maxDrill",
+    label: "largest drill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxDrillDiameter",
+    kinds: ["Hole"],
+    hint: "The widest drill that leaves it within its oversize"
+  }),
+  define({
+    key: "maxEndmill",
+    label: "largest endmill",
+    group: HOLE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.maxEndmillDiameter",
+    kinds: ["Hole"],
+    hint: "The widest endmill that can machine it"
+  }),
+  define({
+    key: "floorFillet",
+    label: "floor fillet",
+    group: OUTLINES,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.5, inch: 0.396875 },
+    path: "facts.filletRadius",
+    kinds: ["Hole", "Pocket", "Boss", "Dovetail", "Tslot"],
+    hint: "The radius where the floor meets the walls; zero when sharp"
+  }),
+  define({
+    key: "filletHeight",
+    label: "floor fillet height",
+    group: OUTLINES,
+    quantity: "length",
+    op: "gte",
+    start: SMALL,
+    path: "facts.filletHeight",
+    kinds: ["Hole", "Pocket", "Boss"],
+    hint: "How high the floor blend runs; zero when sharp"
+  }),
+  define({
+    key: "threaded",
+    label: "a thread",
+    group: THREAD,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.threading.spec.threadPitch",
+    kinds: ["Hole"],
+    hint: "The model threads it"
+  }),
+  define({
+    key: "threadPitch",
+    label: "thread pitch",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.5, inch: 0.4536 },
+    path: "facts.threading.spec.threadPitch",
+    kinds: ["Hole"],
+    hint: "A modelled thread\u2019s pitch (0.454 mm is 56 TPI)"
+  }),
+  define({
+    key: "threadDiameter",
+    label: "thread size",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 3, inch: 3.175 },
+    path: "facts.threading.spec.basicDiameter",
+    kinds: ["Hole"],
+    hint: "The thread\u2019s nominal major diameter"
+  }),
+  define({
+    key: "threadMinorMin",
+    label: "thread minor diameter (min)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.minMinorDiameter",
+    kinds: ["Hole"],
+    hint: "The smallest minor diameter allowed"
+  }),
+  define({
+    key: "threadMinorMax",
+    label: "thread minor diameter (max)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.maxMinorDiameter",
+    kinds: ["Hole"],
+    hint: "The largest minor diameter allowed"
+  }),
+  define({
+    key: "threadMajorMin",
+    label: "thread major diameter (min)",
+    group: THREAD,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: "facts.threading.spec.minMajorDiameter",
+    kinds: ["Hole"],
+    hint: "The smallest major diameter allowed"
+  }),
+  define({
+    key: "threadPercentage",
+    label: "thread percentage",
+    group: THREAD,
+    quantity: "percent",
+    op: "gte",
+    start: 75,
+    path: "facts.threading.spec.threadPercentage",
+    kinds: ["Hole"],
+    hint: "How much of the theoretical thread depth is to be formed"
+  }),
+  define({
+    key: "chamferAngle",
+    label: "chamfer angle",
+    group: CHAMFER,
+    quantity: "angle",
+    op: "gte",
+    start: 60,
+    path: "facts.bevel.angleDeg",
+    kinds: ["Chamfer"],
+    hint: "Between the bevel and the tool axis: the half angle of the tool that cuts it. A standard 90\xB0 chamfer mill is 45\xB0"
+  }),
+  define({
+    key: "chamferSlant",
+    label: "bevel length",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 2, inch: 2.54 },
+    path: "facts.bevel.slant",
+    kinds: ["Chamfer"],
+    hint: "How far the bevel runs along its slope: the cutting edge a tool needs to span it in one pass"
+  }),
+  define({
+    key: "chamferRoom",
+    label: "room under the bevel (tool-axis Z)",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: 0,
+    signed: true,
+    path: "facts.bevel.lowerAdjacentZMin",
+    kinds: ["Chamfer"],
+    hint: "The highest bottom among the features it stands on: how far a tool can overshoot below it"
+  }),
+  define({
+    key: "openPocketEdge",
+    label: "an open pocket edge",
+    group: CHAMFER,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.bevel.isOpenPocketBottom",
+    kinds: ["Chamfer"],
+    hint: "It breaks the edge along an open pocket\u2019s floor"
+  }),
+  define({
+    key: "countersink",
+    label: "a countersink",
+    group: CHAMFER,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.bevel.countersink.outerRadius",
+    kinds: ["Chamfer"],
+    hint: "The bevel is a countersink of revolution"
+  }),
+  define({
+    key: "countersinkOuter",
+    label: "countersink radius",
+    group: CHAMFER,
+    quantity: "length",
+    op: "gte",
+    start: TOOL,
+    path: "facts.bevel.countersink.outerRadius",
+    kinds: ["Chamfer"],
+    hint: "The radius it opens to at its upper edge"
+  }),
+  define({
+    key: "countersinkInner",
+    label: "countersink pilot radius",
+    group: CHAMFER,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: "facts.bevel.countersink.innerRadius",
+    kinds: ["Chamfer"],
+    hint: "The radius of the pilot hole it starts from"
+  }),
+  define({
+    key: "topFace",
+    label: "the top face",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isTopFace",
+    kinds: ["Face"],
+    hint: "The highest surface of the part along the tool axis"
+  }),
+  define({
+    key: "facing",
+    label: "facing",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isFacing",
+    kinds: ["Face"],
+    hint: "A top face that is to be faced off"
+  }),
+  define({
+    key: "modifiedProfile",
+    label: "a bridged outline",
+    group: FACES,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isModified",
+    kinds: ["Profile"],
+    hint: "The outline is a bridged reading of the part\u2019s silhouette"
+  }),
+  define({
+    key: "surfaceRadius",
+    label: "surface blend radius",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    signed: true,
+    path: ["facts.filletRadius", "facts.three.filletRadius"],
+    kinds: ["Three", "Chamfer"],
+    hint: "Signed by which way it turns: positive over an edge, negative into a corner"
+  }),
+  define({
+    key: "maxStepdown",
+    label: "largest stepdown",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.maxStepdown", "facts.three.maxStepdown"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The deepest cut taken in one pass down it"
+  }),
+  define({
+    key: "cuspHeight",
+    label: "finish scallop",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 0.01, inch: 0.0127 },
+    path: ["facts.surfaceFinishCuspHeight", "facts.three.surfaceFinishCuspHeight"],
+    kinds: ["Three", "Chamfer"],
+    hint: "How much scallop the finishing pass may leave"
+  }),
+  define({
+    key: "surfaceSharpCorner",
+    label: "a sharp surface corner",
+    group: SURFACE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: ["facts.hasSharpCorner", "facts.three.hasSharpCorner"],
+    kinds: ["Three", "Chamfer"],
+    hint: "It includes a sharp corner a tool must respect"
+  }),
+  define({
+    key: "ballOnly",
+    label: "ball-only finishing",
+    group: SURFACE,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: ["facts.useOnlyBallToolsForFinish", "facts.three.useOnlyBallToolsForFinish"],
+    kinds: ["Three", "Chamfer"],
+    hint: "Only ball tools suit the finishing pass"
+  }),
+  define({
+    key: "fitCornerRadius",
+    label: "surface corner radius",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: SMALL,
+    path: ["facts.toolFit.cornerRadius", "facts.three.toolFit.cornerRadius"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The corner radius its shape admits"
+  }),
+  define({
+    key: "fitToolDiameter",
+    label: "largest tool its shape admits",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.toolFit.toolDiameter", "facts.three.toolFit.toolDiameter"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The widest full-diameter tool its shape admits"
+  }),
+  define({
+    key: "fitToolBottom",
+    label: "largest tool bottom its shape admits",
+    group: SURFACE,
+    quantity: "length",
+    op: "lte",
+    start: TOOL,
+    path: ["facts.toolFit.toolBottomDiameter", "facts.three.toolFit.toolBottomDiameter"],
+    kinds: ["Three", "Chamfer"],
+    hint: "The widest tool bottom its shape admits"
+  }),
+  define({
+    key: "undercutDepth",
+    label: "undercut depth",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "gte",
+    start: { mm: 5, inch: 5.08 },
+    path: "facts.undercutDepth",
+    kinds: ["Tslot"],
+    hint: "How far the groove runs back from its opening"
+  }),
+  define({
+    key: "maxEntry",
+    label: "largest tool that gets in",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.maxEntryCd",
+    kinds: ["Tslot"],
+    hint: "The widest tool that can come down through the opening above it"
+  }),
+  define({
+    key: "closedSlot",
+    label: "a closed outline",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isClosed",
+    kinds: ["Tslot"],
+    hint: "Its walls close on themselves in plan view"
+  }),
+  define({
+    key: "externalUndercut",
+    label: "an external undercut",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isExternal",
+    kinds: ["Tslot", "Dovetail"],
+    hint: "It runs around material standing in it, or runs out somewhere"
+  }),
+  define({
+    key: "taper",
+    label: "dovetail taper",
+    group: UNDERCUT,
+    quantity: "angle",
+    op: "gte",
+    start: 45,
+    path: "facts.taperDeg",
+    kinds: ["Dovetail"],
+    hint: "Between the overhanging wall and the tool axis"
+  }),
+  define({
+    key: "floorWidth",
+    label: "dovetail floor width",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.floorWidth",
+    kinds: ["Dovetail"],
+    hint: "The widest clearance over the floor"
+  }),
+  define({
+    key: "topOpening",
+    label: "dovetail top opening",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.topOpeningWidth",
+    kinds: ["Dovetail"],
+    hint: "The clearance through the opening at its top"
+  }),
+  define({
+    key: "bottomOpening",
+    label: "dovetail bottom opening",
+    group: UNDERCUT,
+    quantity: "length",
+    op: "lte",
+    start: { mm: 6, inch: 6.35 },
+    path: "facts.bottomOpeningWidth",
+    kinds: ["Dovetail"],
+    hint: "The clearance just above the floor, under the overhangs"
+  }),
+  define({
+    key: "invalidDovetail",
+    label: "unmeasured geometry",
+    group: UNDERCUT,
+    quantity: "flag",
+    op: "gte",
+    start: 0,
+    path: "facts.isInvalidGeometry",
+    kinds: ["Dovetail"],
+    hint: "A width could not be measured, so no tool is offered on its figures"
+  })
+];
+var HOLE_KINDS = ["Hole"];
+var POCKET_KINDS = ["Pocket"];
+var SURFACE_KINDS = ["Three"];
+var UNDERCUT_KINDS = ["Tslot", "Dovetail"];
+var GROUP_SUBJECTS = [
+  { value: "any", label: "Any feature", group: "Groups" },
+  { value: "milled", label: "Milled features", group: "Groups" },
+  { value: "drilled", label: "Drilled features", group: "Groups", kinds: HOLE_KINDS },
+  { value: "hole", label: "Holes", group: "Groups", kinds: HOLE_KINDS },
+  { value: "threadedHole", label: "Threaded holes", group: "Groups", kinds: HOLE_KINDS },
+  { value: "pocket", label: "Pockets", group: "Groups", kinds: POCKET_KINDS },
+  { value: "slot", label: "Slots", group: "Groups", kinds: UNDERCUT_KINDS },
+  { value: "undercut", label: "Undercuts", group: "Groups", kinds: UNDERCUT_KINDS },
+  { value: "boss", label: "Bosses", group: "Groups", kinds: ["Boss"] },
+  { value: "countersink", label: "Countersinks", group: "Groups", kinds: ["Hole", "Chamfer"] },
+  { value: "profile", label: "Profiles", group: "Groups", kinds: ["Profile"] },
+  { value: "contour", label: "3D surfaces", group: "Groups", kinds: SURFACE_KINDS },
+  { value: "wall", label: "Walls", group: "Groups", kinds: ["Wall"] },
+  { value: "face", label: "Faces", group: "Groups", kinds: ["Face", "Three"] },
+  { value: "fillet", label: "Fillets", group: "Groups", kinds: SURFACE_KINDS },
+  { value: "chamfer", label: "Chamfers", group: "Groups", kinds: ["Chamfer"] }
+];
+var TYPES = [
+  ["through_hole", "Through holes", HOLE_KINDS],
+  ["blind_hole", "Blind holes", HOLE_KINDS],
+  ["filleted_blind_hole", "Filleted blind holes", HOLE_KINDS],
+  ["tapered_through_hole", "Tapered through holes", HOLE_KINDS],
+  ["threaded_through_hole", "Threaded through holes", HOLE_KINDS],
+  ["threaded_blind_hole", "Threaded blind holes", HOLE_KINDS],
+  ["synthetic_hole", "Synthetic holes", HOLE_KINDS],
+  ["thread", "Threads", HOLE_KINDS],
+  ["sink", "Countersinks", ["Hole", "Chamfer"]],
+  ["back_sink", "Back countersinks", ["Hole", "Chamfer"]],
+  ["pocket", "Closed pockets", POCKET_KINDS],
+  ["open_pocket", "Open pockets", POCKET_KINDS],
+  ["through_pocket", "Through pockets", POCKET_KINDS],
+  ["filleted_pocket", "Filleted pockets", POCKET_KINDS],
+  ["filleted_open_pocket", "Filleted open pockets", POCKET_KINDS],
+  ["boss", "Bosses", ["Boss"]],
+  ["filleted_boss", "Filleted bosses", ["Boss"]],
+  ["wall", "Wall features", ["Wall"]],
+  ["face", "Face features", ["Face"]],
+  ["slanted_face", "Slanted faces", ["Face", "Three"]],
+  ["profile", "Profiles", ["Profile"]],
+  ["chamfer", "Chamfer features", ["Chamfer"]],
+  ["back_chamfer", "Back chamfers", ["Chamfer"]],
+  ["fillet", "Fillet features", SURFACE_KINDS],
+  ["inner_fillet", "Inner fillets", SURFACE_KINDS],
+  ["outer_fillet", "Outer fillets", SURFACE_KINDS],
+  ["contour_surface", "Contour surfaces", SURFACE_KINDS],
+  ["u_slot", "U-slots", UNDERCUT_KINDS],
+  ["undercut_wall", "Undercut walls", UNDERCUT_KINDS],
+  ["undercut_tslot", "Undercut T-slots", ["Tslot"]],
+  ["undercut_filleted_tslot", "Filleted undercut T-slots", ["Tslot"]],
+  ["undercut_dovetail", "Undercut dovetails", ["Dovetail"]],
+  ["undercut_filleted_dovetail", "Filleted undercut dovetails", ["Dovetail"]]
+];
+var TYPE_SUBJECT = "type:";
+var FEATURE_SUBJECTS = [
+  ...GROUP_SUBJECTS,
+  ...TYPES.map(([type, label, kinds]) => ({
+    value: `${TYPE_SUBJECT}${type}`,
+    label,
+    group: "Feature types",
+    kinds
+  }))
+];
+var QUICK_SUBJECTS = [
+  "any",
+  "milled",
+  "hole",
+  "threadedHole",
+  "countersink",
+  "pocket",
+  "boss",
+  "wall",
+  "face",
+  "profile",
+  "undercut",
+  "fillet",
+  "chamfer",
+  "contour"
+];
+var QUICK_METRICS = [
+  "present",
+  "ld",
+  "featureLd",
+  "depthBelowTop",
+  "featureDepth",
+  "diameter",
+  "cornerRadius",
+  "maxTool",
+  "pinchDiameter",
+  "sharpCorner",
+  "surfaceArea",
+  "floorFillet",
+  "threadPitch",
+  "chamferAngle",
+  "undercutDepth",
+  "tilted"
+];
+var subjectInfo = (value) => FEATURE_SUBJECTS.find((each) => each.value === value);
+var metricInfo = (key) => FEATURE_METRICS.find((each) => each.key === key);
+var metricsForSubject = (subject) => {
+  const kinds = subjectInfo(subject)?.kinds;
+  if (!kinds) return FEATURE_METRICS;
+  return FEATURE_METRICS.filter(
+    (each) => !each.kinds || each.kinds.some((kind) => kinds.includes(kind))
+  );
+};
+
+// src/model/dfm-rules.ts
+import { MM_PER_INCH as MM_PER_INCH3 } from "@toolpath/tool-support";
+
+// src/model/units.ts
+import { MM_PER_INCH as MM_PER_INCH2 } from "@toolpath/tool-support";
+var LENGTH_PLACES = { mm: 3, inch: 3 };
+var FIELD_LENGTH_PLACES = { mm: 3, inch: 4 };
+var UNIT_LABELS = { mm: "mm", inch: "in" };
+var inUnits = (mm, units) => units === "inch" ? mm / MM_PER_INCH2 : mm;
+var lengthValue = (mm, units) => inUnits(mm, units).toFixed(LENGTH_PLACES[units]);
+var unitLabel = (units) => UNIT_LABELS[units];
+
+// src/model/dfm-rules.ts
+var EQUAL_TOLERANCE = 5e-3;
+var OPS = ["gte", "gt", "lte", "lt", "eq", "ne", "between"];
+var OP_SYMBOLS = {
+  gte: "\u2265",
+  gt: ">",
+  lte: "\u2264",
+  lt: "<",
+  eq: "=",
+  ne: "\u2260",
+  between: "range"
+};
+var RANGE_LOWS = ["gte", "gt"];
+var RANGE_HIGHS = ["lt", "lte"];
+var opSymbol = (op) => OP_SYMBOLS[op];
+var RULE_COLORS = [
+  { name: "Red", value: "#e5484d" },
+  { name: "Orange", value: "#f76b15" },
+  { name: "Yellow", value: "#ffd60a" },
+  { name: "Purple", value: "#8e4ec6" },
+  { name: "Green", value: "#30a46c" },
+  { name: "Cyan", value: "#00a2c7" }
+];
+var compareColors = (a, b) => {
+  const rank = (color) => {
+    const at = RULE_COLORS.findIndex((each) => each.value === color);
+    return at === -1 ? RULE_COLORS.length : at;
+  };
+  return rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0);
+};
+var CRITICAL_COLOR = "#e5484d";
+var WARNING_COLOR = "#ffd60a";
+var RETIRED_COLORS = {
+  // Taken out of this palette.
+  "#e93d82": CRITICAL_COLOR,
+  "#99d52a": "#30a46c",
+  // The first palette.
+  "#dc2626": CRITICAL_COLOR,
+  "#f97316": "#f76b15",
+  "#eab308": WARNING_COLOR,
+  "#16a34a": "#30a46c",
+  "#0d9488": "#00a2c7",
+  "#2563eb": "#00a2c7",
+  "#9333ea": "#8e4ec6",
+  "#db2777": CRITICAL_COLOR,
+  // The Toolpath tokens.
+  "#ba5b4b": CRITICAL_COLOR,
+  "#843e32": CRITICAL_COLOR,
+  "#e07a48": "#f76b15",
+  "#d6632a": "#f76b15",
+  "#cd8e04": WARNING_COLOR,
+  "#ffe066": WARNING_COLOR,
+  "#68b688": "#30a46c",
+  "#6bb0b3": "#00a2c7"
+};
+var subjectLabel = (value) => subjectInfo(value)?.label ?? value;
+var trim = (value, places) => String(Number(value.toFixed(places)));
+var SQUARE_MM_PER_SQUARE_INCH = MM_PER_INCH3 ** 2;
+var quantityUnit = (quantity, units) => {
+  switch (quantity) {
+    case "length":
+      return units === "inch" ? "in" : "mm";
+    case "area":
+      return units === "inch" ? "in\xB2" : "mm\xB2";
+    case "angle":
+      return "\xB0";
+    case "percent":
+      return "%";
+    default:
+      return "";
+  }
+};
+var withUnit = (value, unit) => unit === "" ? value : unit === "\xB0" || unit === "%" ? `${value}${unit}` : `${value} ${unit}`;
+var toUnits = (quantity, value, units) => units !== "inch" ? value : quantity === "length" ? value / MM_PER_INCH3 : quantity === "area" ? value / SQUARE_MM_PER_SQUARE_INCH : value;
+var toField = (quantity, value, units) => {
+  const shown = toUnits(quantity, value, units);
+  return quantity === "length" ? trim(shown, FIELD_LENGTH_PLACES[units]) : quantity === "count" ? trim(shown, 0) : trim(shown, 3);
+};
+var fromField = (metric, text, units) => {
+  const parsed = Number(text.trim());
+  if (text.trim() === "" || !Number.isFinite(parsed) || parsed < 0 && !metric.signed) return null;
+  if (metric.quantity === "count" && !Number.isInteger(parsed)) return null;
+  if (units !== "inch") return parsed;
+  return metric.quantity === "length" ? parsed * MM_PER_INCH3 : metric.quantity === "area" ? parsed * SQUARE_MM_PER_SQUARE_INCH : parsed;
+};
+var formatMeasured = (quantity, value, units) => {
+  const shown = toUnits(quantity, value, units);
+  switch (quantity) {
+    case "length":
+      return units === "inch" ? `${trim(shown, LENGTH_PLACES.inch)}"` : `${trim(shown, LENGTH_PLACES.mm)} mm`;
+    case "area":
+      return `${Number(shown.toFixed(3)).toLocaleString(void 0, { maximumFractionDigits: 3 })} ${quantityUnit("area", units)}`;
+    case "angle":
+      return `${trim(shown, 3)}\xB0`;
+    case "percent":
+      return `${trim(shown, 3)}%`;
+    case "count":
+      return trim(shown, 0);
+    case "flag":
+    case "presence":
+      return "";
+    default:
+      return trim(shown, 3);
+  }
+};
+var describeRule = (rule, units) => {
+  const info = metricInfo(rule.metric);
+  const subject = subjectLabel(rule.subject);
+  if (!info) return subject;
+  if (info.quantity === "presence") return `${subject}, ${info.label}`;
+  if (info.quantity === "flag") return `${subject} with ${info.label}`;
+  const unit = quantityUnit(info.quantity, units);
+  const shown = (value) => withUnit(toField(info.quantity, value, units), unit);
+  return rule.op === "between" ? `${subject} with ${shown(rule.value)} ${lowOf(rule) === "gt" ? "<" : "\u2264"} ${info.label} ${opSymbol(highOf(rule))} ${shown(upperOf(rule))}` : `${subject} with ${info.label} ${opSymbol(rule.op)} ${shown(rule.value)}`;
+};
+var newRuleId = () => Math.random().toString(36).slice(2, 10);
+var makeRule = (subject, metricKey, units, color = WARNING_COLOR) => {
+  const info = metricInfo(metricKey) ?? LD_METRIC;
+  return {
+    id: newRuleId(),
+    subject,
+    metric: info.key,
+    op: info.op,
+    value: info.start[units],
+    color
+  };
+};
+var upperOf = (rule) => rule.max ?? rule.value + Math.max(Math.abs(rule.value), 1);
+var lowOf = (rule) => rule.lowOp ?? "gte";
+var highOf = (rule) => rule.highOp ?? "lt";
+var withoutRange = ({ max: _max, lowOp: _low, highOp: _high, ...rest }) => rest;
+var withMetric = (rule, metricKey, units) => {
+  const info = metricInfo(metricKey);
+  if (!info) return rule;
+  return { ...withoutRange(rule), metric: info.key, op: info.op, value: info.start[units] };
+};
+var withOp = (rule, op) => op === "between" ? { ...rule, op, max: upperOf(rule), lowOp: lowOf(rule), highOp: highOf(rule) } : { ...withoutRange(rule), op };
+var withSubject = (rule, subject, units) => {
+  const metrics = metricsForSubject(subject);
+  const moved = { ...rule, subject };
+  return metrics.some((each) => each.key === rule.metric) ? moved : withMetric(moved, (metrics[0] ?? LD_METRIC).key, units);
+};
+var breaks = (rule, quantity, value) => {
+  if (quantity === "presence") return true;
+  if (quantity === "flag") return value > 0;
+  if (rule.op === "gte") return value >= rule.value;
+  if (rule.op === "gt") return value > rule.value;
+  if (rule.op === "lte") return value <= rule.value;
+  if (rule.op === "lt") return value < rule.value;
+  if (rule.op === "between") {
+    const high = upperOf(rule);
+    const aboveLow = lowOf(rule) === "gt" ? value > rule.value : value >= rule.value;
+    const belowHigh = highOf(rule) === "lte" ? value <= high : value < high;
+    return aboveLow && belowHigh;
+  }
+  const equal = Math.abs(value - rule.value) <= Math.max(Math.abs(rule.value) * EQUAL_TOLERANCE, 1e-6);
+  return rule.op === "ne" ? !equal : equal;
+};
+var worseUpward = (rule, metric) => rule.op === "gte" || rule.op === "gt" ? true : rule.op === "lte" || rule.op === "lt" ? false : metric.op !== "lte" && metric.op !== "lt";
+var COLOR = /^#[0-9a-f]{6}$/i;
+var isValue = (value, metric) => typeof value === "number" && Number.isFinite(value) && (value >= 0 || metric?.signed === true) && (metric?.quantity !== "count" || Number.isInteger(value));
+var parseRule = (raw) => {
+  if (!raw || typeof raw !== "object") return null;
+  const {
+    id,
+    subject,
+    metric: key,
+    op,
+    value,
+    max,
+    lowOp,
+    highOp,
+    color
+  } = raw;
+  const info = typeof key === "string" ? metricInfo(key) : void 0;
+  const valid = typeof id === "string" && typeof subject === "string" && subjectInfo(subject) !== void 0 && typeof key === "string" && info !== void 0 && OPS.includes(op) && isValue(value, info) && (op !== "between" || isValue(max, info)) && typeof color === "string" && COLOR.test(color);
+  if (!valid) return null;
+  const hex = color.toLowerCase();
+  return {
+    id,
+    subject,
+    metric: key,
+    op,
+    value,
+    ...op === "between" ? {
+      max,
+      ...RANGE_LOWS.includes(lowOp) ? { lowOp } : {},
+      ...RANGE_HIGHS.includes(highOp) ? { highOp } : {}
+    } : {},
+    color: RETIRED_COLORS[hex] ?? hex
+  };
+};
+var parseRules = (raw) => Array.isArray(raw) ? raw.flatMap((each) => parseRule(each) ?? []) : null;
+
+// src/model/hole-groups.ts
+var holeSize = (sheets, tag) => {
+  const sheet = sheets[tag.toLowerCase()];
+  if (sheet?.kind !== "Hole" || sheet.diameter === void 0 || sheet.zMin === void 0 || sheet.zMax === void 0) {
+    return null;
+  }
+  return { diameter: sheet.diameter, depth: sheet.zMax - sheet.zMin };
+};
+var SAME_DEPTH = 0.05;
+var DEPTH_FLOOR = 0.01;
+var TOLERANCE = 1e-6;
+var sameDepth = (a, b) => Math.abs(a - b) <= Math.max(DEPTH_FLOOR, Math.max(Math.abs(a), Math.abs(b)) * SAME_DEPTH);
+var sameDirection = (a, b) => Math.abs(a.x - b.x) < TOLERANCE && Math.abs(a.y - b.y) < TOLERANCE && Math.abs(a.z - b.z) < TOLERANCE;
+var sameHoleSets = (features, sheets) => {
+  const sizes = features.map((feature) => holeSize(sheets, feature.tag));
+  const root = features.map((_, at) => at);
+  const find = (at) => {
+    let top = at;
+    while (root[top] !== top) top = root[top] ?? top;
+    root[at] = top;
+    return top;
+  };
+  for (let a = 0; a < features.length; a += 1) {
+    for (let b = a + 1; b < features.length; b += 1) {
+      const [first, second] = [sizes[a], sizes[b]];
+      const [one, other] = [features[a], features[b]];
+      if (first && second && one && other && sameDirection(one.machiningDirection, other.machiningDirection) && first.diameter.toFixed(3) === second.diameter.toFixed(3) && sameDepth(first.depth, second.depth)) {
+        const [low, high] = [find(a), find(b)].sort((x, y) => x - y);
+        if (high !== void 0 && low !== void 0) root[high] = low;
+      }
+    }
+  }
+  const sets = /* @__PURE__ */ new Map();
+  features.forEach((feature, at) => {
+    const top = find(at);
+    sets.set(top, [...sets.get(top) ?? [], feature]);
+  });
+  return [...sets.values()];
+};
+var featureRows = (tags, features, sheets) => {
+  const byTag = new Map(features.map((feature) => [feature.tag, feature]));
+  const listed = tags.flatMap((tag) => byTag.get(tag) ?? []);
+  const holes = listed.filter((feature) => holeSize(sheets, feature.tag));
+  const setOf = /* @__PURE__ */ new Map();
+  for (const set of sameHoleSets(holes, sheets)) {
+    if (set.length > 1) for (const feature of set) setOf.set(feature.tag, set);
+  }
+  const placed = /* @__PURE__ */ new Set();
+  return tags.flatMap((tag) => {
+    const set = setOf.get(tag);
+    if (!set) return [{ kind: "feature", tag }];
+    const [first, ...rest] = set;
+    if (!first || placed.has(first.tag)) return [];
+    placed.add(first.tag);
+    return [
+      {
+        kind: "holes",
+        key: first.tag,
+        tags: [first.tag, ...rest.map((feature) => feature.tag)],
+        diameter: holeSize(sheets, first.tag)?.diameter ?? 0
+      }
+    ];
+  });
+};
+
+// src/model/geometry.ts
+var dfmFeatures = (features) => {
+  const read = features.map(
+    ({ featureTag, featureType, machiningDirection: { x, y, z }, regionIdxs }) => ({
+      tag: featureTag,
+      featureType,
+      machiningDirection: { x, y, z },
+      regionIdxs
+    })
+  );
+  const directions = [];
+  read.forEach(({ machiningDirection }) => {
+    if (!directions.some((each) => sameDirection2(each, machiningDirection)))
+      directions.push(machiningDirection);
+  });
+  const numbered = directions.flatMap(
+    (direction) => read.filter((feature) => sameDirection2(feature.machiningDirection, direction))
+  );
+  const numberOf = new Map(numbered.map((feature, index) => [feature, index + 1]));
+  return read.map((feature) => ({ ...feature, number: numberOf.get(feature) ?? 0 }));
+};
+var TOLERANCE2 = 1e-6;
+var sameDirection2 = (a, b) => Math.abs(a.x - b.x) < TOLERANCE2 && Math.abs(a.y - b.y) < TOLERANCE2 && Math.abs(a.z - b.z) < TOLERANCE2;
+var featureTypeLabel = (featureType) => {
+  const words = featureType.replace(/_/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+var partTop = (features, sheets, direction) => {
+  let top = null;
+  for (const other of features) {
+    const zMax = sheets[other.tag.toLowerCase()]?.extendedZMax;
+    if (zMax !== void 0 && sameDirection2(other.machiningDirection, direction)) {
+      top = top === null ? zMax : Math.max(top, zMax);
+    }
+  }
+  return top;
+};
+var FLAT_TIP_DEG = 0.5;
+var isDrilled = (sheet) => sheet?.diameter !== void 0 && sheet.diameter > 0 && !(sheet.tipAngle !== void 0 && sheet.tipAngle >= 180 - FLAT_TIP_DEG);
+var featureLd = (features, feature, sheets) => {
+  const sheet = sheets[feature.tag.toLowerCase()];
+  const top = sheet ? partTop(features, sheets, feature.machiningDirection) : null;
+  const bottom = sheet?.zMin;
+  if (!sheet || top === null || bottom === void 0) return null;
+  const drilling = isDrilled(sheet);
+  const [basis, across] = sheet.diameter !== void 0 ? ["bore", sheet.diameter] : sheet.pinchDiameter !== void 0 ? ["pinch", sheet.pinchDiameter] : [
+    "radius",
+    sheet.sharpCorners || sheet.cornerRadius === void 0 ? void 0 : 2 * sheet.cornerRadius
+  ];
+  if (across === void 0 || across <= 0) return null;
+  const atLeast = basis !== "bore" && sheet.cornerRadiusUnresolved === true;
+  return {
+    ratio: (top - bottom) / across,
+    ...sheet.zMax !== void 0 ? { featureRatio: (sheet.zMax - bottom) / across } : {},
+    drilling,
+    atLeast,
+    basis,
+    across
+  };
+};
+
+// src/model/dfm-explain.ts
+var figureless = (hit) => hit.metric.quantity === "flag" || hit.metric.quantity === "presence";
+var hitFigure = (hit, units) => figureless(hit) ? "" : formatMeasured(hit.metric.quantity, hit.value, units);
+
+// src/model/rule-set-file.ts
+var FILE_KIND = "toolpath-dfm-rules";
+var serializeRuleSet = (rules, meta = {}) => JSON.stringify(
+  {
+    kind: FILE_KIND,
+    version: 1,
+    ...meta.name ? { name: meta.name } : {},
+    ...meta.description ? { description: meta.description } : {},
+    units: "mm",
+    rules: [...rules]
+  },
+  null,
+  2
+);
+var parseRuleSetFile = (text) => {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { error: "This is not JSON." };
+  }
+  const list = Array.isArray(raw) ? raw : typeof raw === "object" && raw !== null && Array.isArray(raw.rules) ? raw.rules : null;
+  if (!list) return { error: 'No rules in it: expected an object with a "rules" list.' };
+  const units = Array.isArray(raw) ? void 0 : raw.units;
+  if (units !== void 0 && units !== "mm")
+    return { error: `Its lengths are in ${JSON.stringify(units)}; only "mm" can be read.` };
+  const seen = /* @__PURE__ */ new Set();
+  const withIds = list.map((each) => {
+    if (typeof each !== "object" || each === null) return each;
+    const rule = each;
+    const id = typeof rule.id === "string" && !seen.has(rule.id) ? rule.id : newRuleId();
+    seen.add(id);
+    return { ...rule, id };
+  });
+  const rules = parseRules(withIds) ?? [];
+  if (rules.length === 0) return { error: "None of its rules could be read." };
+  const name = typeof raw === "object" && raw !== null && typeof raw.name === "string" ? raw.name : void 0;
+  return { rules, skipped: list.length - rules.length, ...name ? { name } : {} };
+};
+var OP_WORDS = {
+  gte: "at or above (\u2265)",
+  gt: "above (>)",
+  lte: "at or below (\u2264)",
+  lt: "below (<)",
+  eq: "equal, within half a percent (=)",
+  ne: "not equal (\u2260)",
+  between: "in a range: `value` \u2264 x < `max` by default; `lowOp` (gte|gt) and `highOp` (lt|lte) change the ends"
+};
+var llmRulePrompt = (current = []) => {
+  const groups = FEATURE_SUBJECTS.filter((each) => !each.value.startsWith(TYPE_SUBJECT));
+  const types = FEATURE_SUBJECTS.filter((each) => each.value.startsWith(TYPE_SUBJECT));
+  const metricLines = FEATURE_METRICS.map((metric) => {
+    const unit = quantityUnit(metric.quantity, "mm");
+    const kind = metric.quantity === "flag" ? 'yes/no \u2014 write `op: "gte"` and `value: 0`; the rule fires whenever it is so' : metric.quantity === "presence" ? 'no measurement \u2014 write `op: "gte"` and `value: 0`; flags every feature of the subject' : `${metric.quantity}${unit ? `, in ${unit}` : ""}; a new rule usually starts around ${metric.start.mm}`;
+    const kinds = metric.kinds ? ` Only features of kind ${metric.kinds.join("/")} report it.` : "";
+    return `- \`${metric.key}\` \u2014 "${metric.label}" (${kind}). ${metric.hint}.${kinds}`;
+  });
+  const example = serializeRuleSet(
+    [
+      { id: "r1", subject: "hole", metric: "ld", op: "gte", value: 8, color: "#ffd60a" },
+      {
+        id: "r2",
+        subject: "milled",
+        metric: "featureLd",
+        op: "between",
+        value: 4,
+        max: 8,
+        lowOp: "gte",
+        highOp: "lt",
+        color: "#f76b15"
+      },
+      { id: "r3", subject: "milled", metric: "sharpCorner", op: "gte", value: 0, color: "#e5484d" },
+      { id: "r4", subject: "undercut", metric: "present", op: "gte", value: 0, color: "#8e4ec6" }
+    ],
+    { name: "Example set", description: "Shows one rule of each shape" }
+  );
+  return [
+    "# Write a Toolpath DFM rule set",
+    "",
+    "You are helping a machinist or designer set up design-for-manufacturing (DFM) checks for CNC-milled parts in the Toolpath CAD viewer. Interview them, then produce ONE JSON document in the format below.",
+    "",
+    "Begin the interview in your very first reply \u2014 do not summarise this prompt, ask whether to start, or explain the format. Run it in four rounds, in a conversational tone, following up where an answer needs it: an opening round about the shop, then a milling round, then a drilling round, then a closing round. Ask only about things the metrics below can measure from the model geometry: depths, diameters, corner radii, tool sizes, areas, feature kinds. Do not ask about surface finish, tolerances, material hardness, fixturing, quantities or lead time \u2014 nothing here measures them.",
+    "",
+    'Where the user has current rules (listed at the end), do not ask whether to keep them. Weave each one into the relevant question as a suggested starting point \u2014 "your set currently warns at 4\xD7D; where does deep work start to cost you?" \u2014 so the user accepts, adjusts or drops it in their own words. The finished set should feel like theirs, not a copy of the old one.',
+    "",
+    "Each question is tied to the subject and metric it becomes. Skip one when an earlier answer has already settled it, and offer sensible defaults from their answers rather than asking about every metric. Every rule needs an `op` and a `value`, even a yes/no one.",
+    "",
+    "### Round 1 \u2014 the shop",
+    "1. What they make and in what materials. This sets the defaults, not a rule.",
+    "2. Examples of features that have challenged them before: a deep pocket that snapped a tool, a hole that needed a special drill, a corner radius that forced a re-quote, an undercut nobody saw until CAM. Ask for the feature and its rough size, then turn each into one rule: a deep pocket is `pocket` with `featureLd` or `depthBelowTop`; a small hole is `hole` with `diameter`; a deep hole is `hole` with `ld`; a tight corner is `milled` with `cornerRadius` or `maxTool`. If no metric below measures the example, say so and move on; never invent a metric.",
+    "",
+    "### Round 2 \u2014 milling (pockets, slots, walls, bosses, profiles, 3D surfaces)",
+    "3. The smallest end mill they are happy to run: `milled` with `maxTool` below it, and `milled` with `cornerRadius` below half of it.",
+    "4. The depth-to-diameter ratio where milled work starts to cost them, and where it becomes a problem: two or three bands of `milled` with `ld` (warning, caution, critical).",
+    "5. The deepest their end mills reach below the top of the part: `milled` with `depthBelowTop`. Whether they also want a feature's own depth capped: `milled` with `featureDepth`.",
+    "6. Sharp inside corners: whether every one should be flagged (`milled` with `sharpCorner`), or only on certain feature kinds.",
+    "7. Floor fillets: whether a floor fillet larger than their ball or bull-nose tooling should be flagged (`pocket` with `floorFillet` above a radius).",
+    "8. Milled features to call out on sight regardless of size: `undercut` with `present`; `contour` with `present` for 3D surfaces; `any` with `tilted` for 5-axis work; `boss` with `present` for thin standing material.",
+    "9. Large features that drive cycle time, if they quote: `pocket` with `projectedFloorArea` or `milled` with `surfaceArea` above a size.",
+    "",
+    "### Round 3 \u2014 drilling (holes, threads, countersinks)",
+    "10. The smallest drill they stock: `hole` with `diameter` below it. Whether they want holes that have no drill fit, so must be milled, called out: `hole` with `maxDrill` at 0.",
+    "11. The depth-to-diameter ratio where holes get hard, and where they need gun drilling or a second setup: two bands of `hole` with `ld`, usually looser than milled work.",
+    "12. Threads: the smallest thread they tap (`hole` with `threadDiameter` below it), and whether every threaded hole should be marked (`threadedHole` with `present`).",
+    "13. Countersinks and counterbores: whether to call out countersinks (`chamfer` with `countersink`) or counterbored holes (`hole` with `counterbore`).",
+    "",
+    "### Round 4 \u2014 closing",
+    "14. Anything they want flagged across every feature, milled or drilled \u2014 for example one overall depth below the top of the part their longest tooling cannot reach: `any` with `depthBelowTop`.",
+    "15. Which of the rules so far are critical (red), which are cautions (orange) and which are just worth a look (yellow).",
+    "",
+    `The user may stop at any point \u2014 "that's enough", "just give me the rules", "generate it" \u2014 and you then finish from what you have: rules for every answer so far, their current rules carried over for anything not yet discussed, and sensible defaults from the shop description for the rest. Never insist on completing a round first, and never leave a placeholder for an unanswered question.`,
+    "",
+    "Finishing: when the questions are answered or the user stops, list the rules you intend to write in plain words, one line each with its colour, and ask the user to confirm or change them. Once they confirm, output the JSON in a single ```json code block and nothing after it. The user will paste it into the viewer (DFM Rules \u2192 Import), so the block must be the complete file in the format below \u2014 no comments, no trailing text, no placeholder values.",
+    "",
+    "## Format",
+    "",
+    'Top level: `{"kind":"toolpath-dfm-rules","version":1,"name":"\u2026","description":"\u2026","units":"mm","rules":[\u2026]}`.',
+    "Every length is in millimetres, areas in mm\xB2, angles in degrees, ratios plain. Convert from inches yourself (1 in = 25.4 mm).",
+    "",
+    "Each rule is one sentence \u2014 *{subject} with {metric} {op} {value}* \u2014 with the fields:",
+    "- `id`: a short unique string.",
+    "- `subject`: which features (a value from the list below).",
+    "- `metric`: what is measured (a key from the list below).",
+    "- `op`: one of " + OPS.map((op) => `\`${op}\``).join(", ") + ".",
+    ...OPS.map((op) => `  - \`${op}\`: ${OP_WORDS[op]}`),
+    "- `value`: the threshold (canonical units). For `between`, the low end; add `max` for the high end.",
+    "- `color`: `#rrggbb`, from the palette: " + RULE_COLORS.map((each) => `${each.name} \`${each.value}\``).join(", ") + ". Red for critical, orange for caution, yellow for warning; purple, green and cyan for anything else. Where a feature breaks several rules the part shows the earliest palette colour.",
+    "",
+    "A rule only fires on features that have the measurement; a feature that lacks it is not flagged. Only *required* features count \u2014 ones that own a face no other feature could machine.",
+    "",
+    "## Subjects (`subject`)",
+    "",
+    "Broad groups:",
+    ...groups.map((each) => `- \`${each.value}\` \u2014 ${each.label}`),
+    "",
+    "One exact Engine feature type:",
+    ...types.map((each) => `- \`${each.value}\` \u2014 ${each.label}`),
+    "",
+    "## Metrics (`metric`)",
+    "",
+    ...metricLines,
+    "",
+    "## Example",
+    "",
+    "```json",
+    example,
+    "```",
+    ...current.length > 0 ? [
+      "",
+      "## The user's current rules",
+      "",
+      "Use these as the suggested starting points in your questions, as described above. Do not ask whether to keep them; do not copy them unchanged unless the user confirms each threshold:",
+      "",
+      "```json",
+      serializeRuleSet(current),
+      "```"
+    ] : [],
+    ""
+  ].join("\n");
+};
+
+// src/model/reach.ts
+var numbers = (value) => Array.isArray(value) && value.every((each) => typeof each === "number" && Number.isFinite(each)) ? value : null;
+var readReachCurve = (datasheet) => {
+  const curve = datasheet?.reachCurve;
+  const offsets = numbers(curve?.horizontalOffset);
+  const heights = numbers(curve?.verticalOffset);
+  if (!offsets || !heights || offsets.length === 0 || offsets.length !== heights.length) return null;
+  return { offsets, heights };
+};
+var runStart = ({ offsets }, index) => index === 0 ? 0 : offsets[index - 1] ?? 0;
+var peakHeight = ({ heights }) => Math.max(0, ...heights);
+var TAIL_MM = 12.7;
+var peakSlack = (peak) => Math.max(0.05, peak * 0.01);
+var peakStart = (curve) => {
+  const peak = peakHeight(curve);
+  const slack = peakSlack(peak);
+  const index = curve.heights.findIndex((height) => height >= peak - slack);
+  return runStart(curve, index === -1 ? 0 : index);
+};
+var trimmedCurve = (curve) => {
+  const last = curve.offsets[curve.offsets.length - 1] ?? 0;
+  const extent = peakStart(curve) + TAIL_MM;
+  if (extent >= last) return { curve, cut: false };
+  const keep = curve.offsets.findIndex((offset) => offset >= extent);
+  return {
+    curve: {
+      offsets: [...curve.offsets.slice(0, keep), extent],
+      heights: curve.heights.slice(0, keep + 1)
+    },
+    cut: true
+  };
+};
+var featureAcross = (sheet) => {
+  if (sheet?.diameter !== void 0 && sheet.diameter > 0)
+    return { width: sheet.diameter, kind: "diameter" };
+  if (sheet?.pinchDiameter !== void 0 && sheet.pinchDiameter > 0)
+    return { width: sheet.pinchDiameter, kind: "clearance" };
+  return null;
+};
+var isThroughType = (featureType) => /(^|_)through(_|$)/.test(featureType.toLowerCase());
+var featureProfile = (sheet, featureType) => {
+  const depth = sheet?.zMax !== void 0 && sheet.zMin !== void 0 ? sheet.zMax - sheet.zMin : null;
+  return {
+    across: featureAcross(sheet),
+    depth: depth !== null && depth > 0 ? depth : null,
+    through: isThroughType(featureType)
+  };
+};
+
+export {
+  PRESENCE_METRIC,
+  TYPE_SUBJECT,
+  FEATURE_SUBJECTS,
+  QUICK_SUBJECTS,
+  QUICK_METRICS,
+  metricInfo,
+  metricsForSubject,
+  LENGTH_PLACES,
+  lengthValue,
+  unitLabel,
+  OPS,
+  RANGE_LOWS,
+  RANGE_HIGHS,
+  opSymbol,
+  RULE_COLORS,
+  compareColors,
+  CRITICAL_COLOR,
+  WARNING_COLOR,
+  subjectLabel,
+  quantityUnit,
+  toField,
+  fromField,
+  formatMeasured,
+  describeRule,
+  makeRule,
+  upperOf,
+  lowOf,
+  highOf,
+  withMetric,
+  withOp,
+  withSubject,
+  breaks,
+  worseUpward,
+  parseRules,
+  sameDepth,
+  featureRows,
+  dfmFeatures,
+  featureTypeLabel,
+  partTop,
+  isDrilled,
+  featureLd,
+  hitFigure,
+  FILE_KIND,
+  serializeRuleSet,
+  parseRuleSetFile,
+  llmRulePrompt,
+  readReachCurve,
+  runStart,
+  peakHeight,
+  trimmedCurve,
+  featureProfile
+};