@toolpath/tool-support 0.1.0

package/dist/clearance.js

@@ -0,0 +1,209 @@
+/**
+ * Whether a tool and what holds it clear the material around a feature.
+ *
+ * The Engine does the three-dimensional work and hands over a **reach curve**:
+ * for each distance out from the wall of the cut, how tall the material within
+ * that distance stands above the feature's bottom, worst case over the whole
+ * feature. An assembly is a solid of revolution, so it is a profile too —
+ * radius by height above the tip — and the check is one comparison per step of
+ * that profile: anything standing `d` past the cutting edge must sit at least
+ * `heightAt(d)` above the bottom. No sweep, no CAD, a loop over a few numbers.
+ *
+ * **The profile is what the catalog states, and says so.** A tool is flutes, an
+ * optional neck, and a shank. A holder is its nose, then the body behind it
+ * where the vendor states one, then the flange at its projection. The seated
+ * collet's protrusion below the nose is swept too. A pass here is a pass for
+ * exactly the silhouette {@link Clearance.checked} lists.
+ *
+ * **The curve is conservative.** It is the worst case over the whole feature,
+ * so an assembly that fails might clear most of the toolpath — a long slot with
+ * one tall wall at one end fails for its whole length. Pass means safe; fail
+ * means "somewhere along it".
+ *
+ * ## Why it is here and not in the drawing package
+ *
+ * This decision has a dozen callers that never draw anything, and putting it
+ * behind a rendering package is the thing the whole split exists to avoid. The
+ * *lines* an overlay draws from a verdict are `@toolpath/tool-drawing`'s; the
+ * verdict is this.
+ */
+import { NO_MARGINS } from './parts.js';
+import { heightAt } from './reach.js';
+import { hasNeck } from './tool.js';
+/**
+ * The tool's own profile above the flutes, from what the vendor states.
+ *
+ * - A neck, where a shoulder diameter *and* length are stated: that radius
+ *   from the end of the flutes to the shoulder.
+ * - The shank, from the shoulder (or the end of the flutes, where there is no
+ *   neck) upward.
+ *
+ * A neck whose diameter is unstated is taken to be no wider than the cut,
+ * which is what a neck is for, and so has nothing to check.
+ */
+export const toolSilhouette = (tool) => {
+    const { DC, LCF, SFDM } = tool.geometry;
+    const neckDiameter = tool.geometry['shoulder-diameter'];
+    const shoulder = tool.geometry['shoulder-length'];
+    if (DC === undefined || LCF === undefined) {
+        return [];
+    }
+    const steps = [];
+    if (neckDiameter !== undefined && shoulder !== undefined && shoulder > LCF) {
+        // A relief narrower than the shank is a neck; one as wide as the shank is
+        // plain shank, whatever the vendor's column calls it.
+        steps.push({
+            part: hasNeck(tool) ? 'neck' : 'shank',
+            radius: neckDiameter / 2,
+            fromHeight: LCF,
+        });
+    }
+    if (SFDM !== undefined) {
+        steps.push({ part: 'shank', radius: SFDM / 2, fromHeight: shoulder ?? LCF });
+    }
+    return steps;
+};
+/**
+ * The tool's own body against the part, whatever holds it.
+ *
+ * A shank or neck that stands past the cutting edge meets the wall above the
+ * flutes at every stickout — no holder and no pull-out changes where the
+ * tool's own steps sit above its tip. Paul's call (2026-08-30): such a tool
+ * is not compatible with the feature and is not shown; the answer is longer
+ * flutes or a reduced shank. Swept with the same margins as the holder.
+ */
+export const toolCollisions = (tool, curve, margins = NO_MARGINS) => {
+    const DC = tool.geometry.DC;
+    if (DC === undefined) {
+        return [];
+    }
+    return collisionsIn(toolSilhouette(tool), curve, DC / 2, margins);
+};
+/** Millimetres a part may be short of clearing and still clear: float noise, not geometry. */
+const CLEARANCE_TOLERANCE = 1e-6;
+const collisionsIn = (steps, curve, cuttingRadius, margins) => steps.flatMap((step) => {
+    // At the cut's own radius the step is the wall, which the flutes cut; only
+    // what stands past the edge — by more than the room wanted — can meet material.
+    const offset = step.radius + margins.radial - cuttingRadius;
+    if (offset <= 0) {
+        return [];
+    }
+    const needs = heightAt(curve, offset) + margins.axial;
+    // A hair of tolerance: a stack stood out to exactly what it needs lands a
+    // femtometre short after the arithmetic, and reported a collet colliding
+    // at the stickout this same sweep had just asked for (2026-08-30).
+    return step.fromHeight + CLEARANCE_TOLERANCE < needs
+        ? [{ part: step.part, height: step.fromHeight, needs, offset }]
+        : [];
+});
+/** The collet's own diameter is its series size: a PG 6 collet is 6 mm across. */
+const colletDiameter = (series) => {
+    const digits = /(\d+(?:\.\d+)?)/.exec(series ?? '');
+    return digits ? Number(digits[1]) : null;
+};
+/**
+ * The holder's profile above the tool, from the stickout up.
+ *
+ * - The seated collet, standing proud of the nose face by its protrusion, at
+ *   the collet's own diameter.
+ * - The nose, for its stated length — or, with no length stated, for the
+ *   gauge length as before, so an older dataset sweeps what it always did.
+ * - The body behind the nose, where stated.
+ * - The flange, at the projection. Nothing is swept between it and the body:
+ *   a `Silhouette` is a radius **from a height upward**, so the last stated
+ *   diameter carries itself up to the flange, which is the layer model of
+ *   Justin Mimbs' reach-curve note.
+ */
+export const holderSilhouette = (assembly, stickout) => {
+    const { holder } = assembly;
+    const steps = [];
+    if (holder.noseDiameter === null) {
+        return steps;
+    }
+    const collet = colletDiameter(holder.colletSeries);
+    if (holder.colletProtrusion !== null && collet !== null) {
+        steps.push({
+            part: 'collet',
+            radius: collet / 2,
+            fromHeight: stickout - holder.colletProtrusion,
+        });
+    }
+    steps.push({ part: 'nose', radius: holder.noseDiameter / 2, fromHeight: stickout });
+    // Where the nose ends. With no stated nose length the gauge length stands in,
+    // so a dataset that predates the column sweeps what it always did.
+    const behindTheNose = stickout + (holder.noseLength ?? holder.gaugeLength ?? 0);
+    if (holder.bodyDiameter !== null && holder.bodyLength !== null) {
+        steps.push({ part: 'body', radius: holder.bodyDiameter / 2, fromHeight: behindTheNose });
+    }
+    if (holder.projection !== null && holder.flangeDiameter !== null) {
+        /**
+         * **Cylinders, not cones** (Paul, 2026-08-31).
+         *
+         * The shape between the last stated diameter and the flange used to be
+         * swept as a cone in six steps — a shape no vendor publishes, and on a
+         * PG 10 × 062 a 34 mm flare from ⌀18 to ⌀46 that turned tools down for
+         * metal that is not there. Justin Mimbs' reach-curve note models a holder
+         * as layers: each swept at its widest, no credit for a taper, and the
+         * last diameter carried upward — which is what a `Silhouette` already
+         * means, so the carry needs no step of its own. The flange is its own
+         * layer, at its own height.
+         *
+         * It is the less conservative reading of an unstated shape, and
+         * deliberately so: what the vendor states is what is swept.
+         */
+        steps.push({
+            part: 'flange',
+            radius: holder.flangeDiameter / 2,
+            fromHeight: stickout + holder.projection,
+        });
+    }
+    return steps;
+};
+/**
+ * Whether one assembly clears one feature's reach curve.
+ *
+ * The holder is checked at the assembly's stickout, and `requiredStickout`
+ * says the least stickout at which every part of the holder would clear — so
+ * a stack that fails can be read as "stick it out further" rather than "no".
+ */
+export const clearance = (assembly, curve, margins = NO_MARGINS) => {
+    const { tool, holder, stickout } = assembly;
+    const DC = tool.geometry.DC;
+    if (DC === undefined) {
+        return { clears: true, collisions: [], requiredStickout: null, checked: [] };
+    }
+    const cuttingRadius = DC / 2;
+    const steps = toolSilhouette(tool);
+    let requiredStickout = null;
+    if (holder.noseDiameter !== null) {
+        // What the holder needs is the same whatever the stickout: each of its
+        // parts sits a fixed height above the nose face, and has to sit above the
+        // material at its own offset. The least stickout is the largest shortfall.
+        const atZero = holderSilhouette(assembly, 0);
+        requiredStickout = atZero.reduce((most, step) => {
+            const offset = step.radius + margins.radial - cuttingRadius;
+            if (offset <= 0) {
+                return most;
+            }
+            return Math.max(most, heightAt(curve, offset) + margins.axial - step.fromHeight);
+        }, 0);
+        if (stickout !== null) {
+            steps.push(...holderSilhouette(assembly, stickout));
+        }
+    }
+    const collisions = collisionsIn(steps, curve, cuttingRadius, margins);
+    const checked = [...new Set(steps.map((step) => step.part))];
+    return { clears: collisions.length === 0, collisions, requiredStickout, checked };
+};
+/** Why a collision rules an assembly out, in the words a machinist would use. */
+export const describeCollision = (collision) => {
+    const what = {
+        neck: 'the neck',
+        shank: 'the shank',
+        collet: 'the collet',
+        nose: 'the holder nose',
+        body: 'the holder body',
+        flange: 'the flange',
+    }[collision.part];
+    return `${what} at ${collision.height.toFixed(1)} mm collides with material ${collision.needs.toFixed(1)} mm tall, ${collision.offset.toFixed(1)} mm out from the cut`;
+};

package/dist/demand.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What a feature demands of a tool, in millimetres.
+ *
+ * ## The seam that keeps the part schema out of this package
+ *
+ * Reading these numbers off a Toolpath datasheet needs the Engine's part
+ * schema; *checking a tool against them* needs only tool vocabulary. Those two
+ * halves used to sit in one file, and splitting them at exactly this type is
+ * what lets the checking travel: every field below is tool language, and no
+ * part feature, machining direction or datasheet appears in it.
+ *
+ * So the adapter — feature to demand — stays with whoever holds the report, and
+ * fitting comes here. A consumer with no Toolpath report at all can still state
+ * a demand by hand and ask whether a tool meets it.
+ *
+ * ## Every field is optional, and that is the contract
+ *
+ * The kernel states different measurements for different feature kinds, and **a
+ * demand nobody stated must not silently become a demand of zero**. What is not
+ * stated is not checked, and not claimed: that is the difference between a shop
+ * trusting a tool list and a shop checking every row of it by hand.
+ */
+import type { ReachCurve } from './reach.js';
+export interface FeatureDemand {
+    /** The feature this came from, so a result can say which selection excluded a tool. */
+    readonly featureTag: string;
+    /** The widest cutter that still reaches the tightest corner. */
+    readonly maxToolDiameter?: number;
+    /** Stated separately for a hole: the widest drill, and the widest endmill. */
+    readonly maxDrillDiameter?: number;
+    readonly maxEndmillDiameter?: number;
+    /** A hole's bore. Nothing wider than this goes in it. */
+    readonly holeDiameter?: number;
+    /** How deep the cut reaches, which the flutes have to cover. */
+    readonly depth?: number;
+    /**
+     * How far below the top of the part the feature bottoms out, in millimetres.
+     *
+     * Depth is the feature; this is the *reach* — what the whole stack has to
+     * clear before it cuts anything.
+     */
+    readonly reachBelowTop?: number;
+    /** The floor fillet: a corner radius larger than this cannot finish the floor. */
+    readonly floorRadius?: number;
+    /**
+     * How tall the material stands, by distance out from the cut — what a holder
+     * and a shank are swept against. A demand without it is simply not checked
+     * for collisions.
+     */
+    readonly reachCurve?: ReachCurve;
+}

package/dist/demand.js

@@ -0,0 +1,23 @@
+/**
+ * What a feature demands of a tool, in millimetres.
+ *
+ * ## The seam that keeps the part schema out of this package
+ *
+ * Reading these numbers off a Toolpath datasheet needs the Engine's part
+ * schema; *checking a tool against them* needs only tool vocabulary. Those two
+ * halves used to sit in one file, and splitting them at exactly this type is
+ * what lets the checking travel: every field below is tool language, and no
+ * part feature, machining direction or datasheet appears in it.
+ *
+ * So the adapter — feature to demand — stays with whoever holds the report, and
+ * fitting comes here. A consumer with no Toolpath report at all can still state
+ * a demand by hand and ask whether a tool meets it.
+ *
+ * ## Every field is optional, and that is the contract
+ *
+ * The kernel states different measurements for different feature kinds, and **a
+ * demand nobody stated must not silently become a demand of zero**. What is not
+ * stated is not checked, and not claimed: that is the difference between a shop
+ * trusting a tool list and a shop checking every row of it by hand.
+ */
+export {};

package/dist/fit.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Whether a tool can cut a feature.
+ *
+ * ## The seam that lets this travel at all
+ *
+ * Reading a feature's demands off a Toolpath datasheet needs the Engine's part
+ * schema. *Checking a tool against those demands* needs only tool vocabulary.
+ * Those two halves sat in one file, and splitting them at {@link FeatureDemand}
+ * is what lets the checking live here: every field of a demand is tool
+ * language, and no part feature, machining direction or datasheet appears in
+ * it.
+ *
+ * So the adapter — feature to demand — stays with whoever holds the report, and
+ * this package inherits no OpenAPI contract for it. A consumer with no Toolpath
+ * report at all can state a demand by hand and ask the same question.
+ *
+ * ## What is not stated is not claimed
+ *
+ * **A demand the datasheet does not state is not checked.** The alternative —
+ * treating an absent measurement as zero, or as no limit — is the difference
+ * between a shop trusting a tool list and a shop checking every row of it by
+ * hand.
+ *
+ * This is the opposite of the rule `holderTakesTool` follows, and deliberately:
+ * there, an unchecked case is a cutter falling out of a spindle, so silence
+ * refuses. Here an unchecked case is a tool offered that a machinist will look
+ * at anyway, so silence passes.
+ */
+import type { FeatureDemand } from './demand.js';
+import type { ToolForm } from './forms.js';
+import type { Tool } from './tool.js';
+/**
+ * The forms that go into a hole bore-first, and so are bounded by the bore
+ * rather than by what can helix down it.
+ *
+ * Stated over {@link ToolForm} rather than over a coarser tool type, which is a
+ * refinement: the coarse vocabulary this replaced had one word, `drill`, for
+ * what a CAM library calls a drill, a centre drill and a spot drill, so a
+ * stated spot drill could not be recognised as going in bore-first. All three
+ * do.
+ */
+export declare const DRILLING_FORMS: ReadonlySet<ToolForm>;
+/** Why a tool cannot cut a feature, in the words a machinist would use. */
+export interface FitFailure {
+    readonly featureTag: string;
+    readonly reason: string;
+}
+export interface ToolFit<T> {
+    readonly tool: T;
+    readonly fits: boolean;
+    /** Empty when the tool fits. One entry per feature that ruled it out. */
+    readonly failures: readonly FitFailure[];
+}
+/** Whether one tool can cut one feature, and why not where it cannot. */
+export declare const fitAgainst: (tool: Pick<Tool, "geometry" | "form">, demand: FeatureDemand) => FitFailure[];
+/**
+ * Which tools cut **every** demand given.
+ *
+ * The intersection is the point of the exercise: one setup wants one tool for
+ * as much of the part as possible, and a tool that clears four of five features
+ * is not an answer — but knowing which feature ruled it out is, which is why a
+ * near miss keeps its failures instead of vanishing.
+ *
+ * With no demands every tool fits, because nothing has been asked of them yet.
+ *
+ * Generic in the tool, so a caller gets its own records back rather than a
+ * projection of them.
+ */
+export declare const fitTools: <T extends Pick<Tool, "geometry" | "form">>(tools: readonly T[], demands: readonly FeatureDemand[]) => ToolFit<T>[];

package/dist/fit.js

@@ -0,0 +1,90 @@
+/**
+ * Whether a tool can cut a feature.
+ *
+ * ## The seam that lets this travel at all
+ *
+ * Reading a feature's demands off a Toolpath datasheet needs the Engine's part
+ * schema. *Checking a tool against those demands* needs only tool vocabulary.
+ * Those two halves sat in one file, and splitting them at {@link FeatureDemand}
+ * is what lets the checking live here: every field of a demand is tool
+ * language, and no part feature, machining direction or datasheet appears in
+ * it.
+ *
+ * So the adapter — feature to demand — stays with whoever holds the report, and
+ * this package inherits no OpenAPI contract for it. A consumer with no Toolpath
+ * report at all can state a demand by hand and ask the same question.
+ *
+ * ## What is not stated is not claimed
+ *
+ * **A demand the datasheet does not state is not checked.** The alternative —
+ * treating an absent measurement as zero, or as no limit — is the difference
+ * between a shop trusting a tool list and a shop checking every row of it by
+ * hand.
+ *
+ * This is the opposite of the rule `holderTakesTool` follows, and deliberately:
+ * there, an unchecked case is a cutter falling out of a spindle, so silence
+ * refuses. Here an unchecked case is a tool offered that a machinist will look
+ * at anyway, so silence passes.
+ */
+/**
+ * The forms that go into a hole bore-first, and so are bounded by the bore
+ * rather than by what can helix down it.
+ *
+ * Stated over {@link ToolForm} rather than over a coarser tool type, which is a
+ * refinement: the coarse vocabulary this replaced had one word, `drill`, for
+ * what a CAM library calls a drill, a centre drill and a spot drill, so a
+ * stated spot drill could not be recognised as going in bore-first. All three
+ * do.
+ */
+export const DRILLING_FORMS = new Set([
+    'drill',
+    'center drill',
+    'spot drill',
+    'reamer',
+]);
+/** Whether one tool can cut one feature, and why not where it cannot. */
+export const fitAgainst = (tool, demand) => {
+    const failures = [];
+    const say = (reason) => failures.push({ featureTag: demand.featureTag, reason });
+    const diameter = tool.geometry.DC;
+    const fluteLength = tool.geometry.LCF;
+    const cornerRadius = tool.geometry.RE;
+    const drilling = DRILLING_FORMS.has(tool.form);
+    // A hole states its own limits, and which one applies depends on how the tool
+    // goes in: a drill is bounded by the bore, an endmill by what can helix in it.
+    const widest = drilling
+        ? (demand.maxDrillDiameter ?? demand.holeDiameter ?? demand.maxToolDiameter)
+        : (demand.maxEndmillDiameter ?? demand.maxToolDiameter);
+    if (diameter !== undefined && widest !== undefined && diameter > widest) {
+        say(`⌀${diameter} mm is wider than the ${widest} mm this feature admits`);
+    }
+    if (fluteLength !== undefined && demand.depth !== undefined && fluteLength < demand.depth) {
+        say(`${fluteLength} mm of flute does not reach ${demand.depth} mm deep`);
+    }
+    // A corner radius larger than the floor fillet leaves material the floor does
+    // not have room for. A sharp tool in a filleted corner is fine — it just
+    // leaves the fillet to something else.
+    if (cornerRadius !== undefined &&
+        demand.floorRadius !== undefined &&
+        cornerRadius > demand.floorRadius) {
+        say(`a ${cornerRadius} mm corner does not fit a ${demand.floorRadius} mm floor fillet`);
+    }
+    return failures;
+};
+/**
+ * Which tools cut **every** demand given.
+ *
+ * The intersection is the point of the exercise: one setup wants one tool for
+ * as much of the part as possible, and a tool that clears four of five features
+ * is not an answer — but knowing which feature ruled it out is, which is why a
+ * near miss keeps its failures instead of vanishing.
+ *
+ * With no demands every tool fits, because nothing has been asked of them yet.
+ *
+ * Generic in the tool, so a caller gets its own records back rather than a
+ * projection of them.
+ */
+export const fitTools = (tools, demands) => tools.map((tool) => {
+    const failures = demands.flatMap((demand) => fitAgainst(tool, demand));
+    return { tool, fits: failures.length === 0, failures };
+});

package/dist/forms.d.ts

@@ -0,0 +1,130 @@
+/**
+ * What a tool *is*, in the words a CAM library uses.
+ *
+ * A scrape hands over a coarse kind — `endmill`, `drill`, `tap` — and that is
+ * the right seam for it: it is what a vendor's family table says. But a shop
+ * choosing a tool for a filleted pocket is not choosing "an endmill", it is
+ * choosing a bull nose, and the difference is one number the vendor did state:
+ * the corner radius. So the finer name is derived where a dataset is built, and
+ * carried on every tool as its `form`.
+ *
+ * The vocabulary is Fusion's own library, so a tool exported there lands on the
+ * type it already has. This list is the single source: icons draw from it,
+ * filter panels offer it, and a drawing decides from it whether it has an
+ * honest picture to draw.
+ */
+/** One form, and the group a control offers it under. */
+export interface ToolFormEntry {
+    readonly value: string;
+    readonly label: string;
+    readonly group: 'Milling' | 'Hole making';
+}
+export declare const TOOL_FORMS: readonly [{
+    readonly value: "ball end mill";
+    readonly label: "Ball end mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "bull nose end mill";
+    readonly label: "Bull nose end mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "flat end mill";
+    readonly label: "Flat end mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "face mill";
+    readonly label: "Face mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "tapered mill";
+    readonly label: "Tapered mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "radius mill";
+    readonly label: "Radius mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "chamfer mill";
+    readonly label: "Engrave/chamfer mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "dovetail mill";
+    readonly label: "Dovetail mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "lollipop mill";
+    readonly label: "Lollipop mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "slot mill";
+    readonly label: "Slot mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "thread mill";
+    readonly label: "Thread mill";
+    readonly group: "Milling";
+}, {
+    readonly value: "circle segment barrel";
+    readonly label: "Circle segment barrel";
+    readonly group: "Milling";
+}, {
+    readonly value: "circle segment lens";
+    readonly label: "Circle segment lens";
+    readonly group: "Milling";
+}, {
+    readonly value: "circle segment oval";
+    readonly label: "Circle segment oval";
+    readonly group: "Milling";
+}, {
+    readonly value: "circle segment taper";
+    readonly label: "Circle segment taper";
+    readonly group: "Milling";
+}, {
+    readonly value: "boring bar";
+    readonly label: "Boring bar";
+    readonly group: "Hole making";
+}, {
+    readonly value: "counter bore";
+    readonly label: "Counter bore";
+    readonly group: "Hole making";
+}, {
+    readonly value: "drill";
+    readonly label: "Drill";
+    readonly group: "Hole making";
+}, {
+    readonly value: "center drill";
+    readonly label: "Center drill";
+    readonly group: "Hole making";
+}, {
+    readonly value: "spot drill";
+    readonly label: "Spot drill";
+    readonly group: "Hole making";
+}, {
+    readonly value: "reamer";
+    readonly label: "Reamer";
+    readonly group: "Hole making";
+}, {
+    readonly value: "counter sink";
+    readonly label: "Counter sink";
+    readonly group: "Hole making";
+}, {
+    readonly value: "tap left hand";
+    readonly label: "Tap left hand";
+    readonly group: "Hole making";
+}, {
+    readonly value: "tap right hand";
+    readonly label: "Tap right hand";
+    readonly group: "Hole making";
+}];
+/**
+ * A form, or `other`.
+ *
+ * `other` is in the union rather than beside it because it is a real answer: a
+ * vendor publishes tools this vocabulary has no word for, and a dataset that
+ * had to pick the nearest wrong form would be worse than one that says it does
+ * not know. What draws or suggests from a form has to handle it.
+ */
+export type ToolForm = (typeof TOOL_FORMS)[number]['value'] | 'other';
+/** The forms that mill — the ones a flute-count suggestion makes sense for. */
+export declare const MILLING_FORMS: ReadonlySet<ToolForm>;
+export declare const isToolForm: (value: string) => value is ToolForm;

package/dist/forms.js

@@ -0,0 +1,44 @@
+/**
+ * What a tool *is*, in the words a CAM library uses.
+ *
+ * A scrape hands over a coarse kind — `endmill`, `drill`, `tap` — and that is
+ * the right seam for it: it is what a vendor's family table says. But a shop
+ * choosing a tool for a filleted pocket is not choosing "an endmill", it is
+ * choosing a bull nose, and the difference is one number the vendor did state:
+ * the corner radius. So the finer name is derived where a dataset is built, and
+ * carried on every tool as its `form`.
+ *
+ * The vocabulary is Fusion's own library, so a tool exported there lands on the
+ * type it already has. This list is the single source: icons draw from it,
+ * filter panels offer it, and a drawing decides from it whether it has an
+ * honest picture to draw.
+ */
+export const TOOL_FORMS = [
+    { value: 'ball end mill', label: 'Ball end mill', group: 'Milling' },
+    { value: 'bull nose end mill', label: 'Bull nose end mill', group: 'Milling' },
+    { value: 'flat end mill', label: 'Flat end mill', group: 'Milling' },
+    { value: 'face mill', label: 'Face mill', group: 'Milling' },
+    { value: 'tapered mill', label: 'Tapered mill', group: 'Milling' },
+    { value: 'radius mill', label: 'Radius mill', group: 'Milling' },
+    { value: 'chamfer mill', label: 'Engrave/chamfer mill', group: 'Milling' },
+    { value: 'dovetail mill', label: 'Dovetail mill', group: 'Milling' },
+    { value: 'lollipop mill', label: 'Lollipop mill', group: 'Milling' },
+    { value: 'slot mill', label: 'Slot mill', group: 'Milling' },
+    { value: 'thread mill', label: 'Thread mill', group: 'Milling' },
+    { value: 'circle segment barrel', label: 'Circle segment barrel', group: 'Milling' },
+    { value: 'circle segment lens', label: 'Circle segment lens', group: 'Milling' },
+    { value: 'circle segment oval', label: 'Circle segment oval', group: 'Milling' },
+    { value: 'circle segment taper', label: 'Circle segment taper', group: 'Milling' },
+    { value: 'boring bar', label: 'Boring bar', group: 'Hole making' },
+    { value: 'counter bore', label: 'Counter bore', group: 'Hole making' },
+    { value: 'drill', label: 'Drill', group: 'Hole making' },
+    { value: 'center drill', label: 'Center drill', group: 'Hole making' },
+    { value: 'spot drill', label: 'Spot drill', group: 'Hole making' },
+    { value: 'reamer', label: 'Reamer', group: 'Hole making' },
+    { value: 'counter sink', label: 'Counter sink', group: 'Hole making' },
+    { value: 'tap left hand', label: 'Tap left hand', group: 'Hole making' },
+    { value: 'tap right hand', label: 'Tap right hand', group: 'Hole making' },
+];
+/** The forms that mill — the ones a flute-count suggestion makes sense for. */
+export const MILLING_FORMS = new Set(TOOL_FORMS.filter((form) => form.group === 'Milling').map((form) => form.value));
+export const isToolForm = (value) => value === 'other' || TOOL_FORMS.some((form) => form.value === value);