@toolpath/tool-support 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toolpath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# Toolpath Tool Support
+
+`@toolpath/tool-support` is the cutting-tool domain: what a tool, a holder, a
+collet and an assembly _are_, and the arithmetic that follows from them.
+
+**It depends on nothing.** No runtime dependencies, no peer dependencies, no
+React, no DOM, no `fs`, no Toolpath SDK. Every other package that speaks about
+cutting tools depends on it and it depends on none of them, which is what lets a
+Node ingest script, a server route and a React renderer share one answer instead
+of deriving three.
+
+```
+                    @toolpath/tool-support        depends on nothing
+                     ↑          ↑          ↑
+    @toolpath/tool-scraper   @toolpath/tool-drawing   your application
+```
+
+## Install
+
+```sh
+npm install @toolpath/tool-support
+```
+
+## Why it exists
+
+`@toolpath/tool-scraper` produces tool data and `@toolpath/tool-drawing`
+consumes it, and every application in between re-derived what a tool assembly
+is. The same fact ended up declared three times over: two names for one
+millimetres-per-inch constant, three vocabularies for one unit axis, three
+provenance types, two `PROFILES_VERSION`s — one of them imported under an alias
+specifically so it could be compared against the other — and three shapes called
+"holder" of which no two agreed on which fields exist.
+
+That is not a tidiness complaint. **How far a tool stands out of its holder was
+computed in four unconnected places and disagreed by a factor of two on an
+ordinary tool.** A details table printed one number and the drawing beside it
+drew another, so the dimension line ran past the holder nose and into the holder
+body. It was fixed inside one application, which means the next consumer of the
+same two packages reproduces it from scratch. That quantity is a pure function of
+the tool, the collet and a shop's policy, and it had no home.
+
+## What it holds
+
+### The vocabulary
+
+| Export                                                                 | What it is                                                        |
+| ---------------------------------------------------------------------- | ----------------------------------------------------------------- |
+| `UnitSystem`, `UNIT_SYSTEMS`, `MM_PER_INCH`                            | How a vendor publishes a family, and the one constant between two |
+| `convertLength`, `decimalsFor`, `UNIT_ABBREVIATION`                    | Converting, rounding and spelling it                              |
+| `Provenance`, `PROVENANCE`, `ProvenanceMap`                            | Where a stated number came from                                   |
+| `GEOMETRY_FIELDS`, `geometryField`, `isLengthField`, `convertGeometry` | The ISO 13399 dictionary, and whether a code's value converts     |
+| `TOOL_FORMS`, `ToolForm`, `MILLING_FORMS`, `isToolForm`                | What a tool is, in a CAM library's words                          |
+
+Every length is in millimetres and every angle in degrees, whatever system the
+vendor published in — that is what lets an inch tool and a metric tool compare.
+`UnitSystem` is a fact _about the tool_, never the unit a stored value is in.
+
+### The contracts
+
+| Export                                             | What it is                                   |
+| -------------------------------------------------- | -------------------------------------------- |
+| `Tool`, `Geometry`                                 | A cutting tool, as the arithmetic needs one  |
+| `Holder`, `HolderProfile`, `isHolderProfile`       | The holder union: published, or measured     |
+| `Collet`, `Assembly`                               | What grips the shank, and the stack it makes |
+| `PROFILES_VERSION`, `ProfilePoint`, `ProfileDatum` | The measured silhouette                      |
+| `ReachCurve`, `FeatureDemand`                      | What a feature demands of a tool             |
+
+### The arithmetic
+
+| Export                                                                            | What it answers                                         |
+| --------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| `stickoutRange`, `minStickout`, `setupStickout`, `stickoutCeiling`                | How far the tool stands out — **the one answer**        |
+| `DEFAULT_STICKOUT_POLICY`, `HELD_SHARE`, `StickoutPolicy`, `StickoutLimit`        | The floor, the step and the share a shop keeps held     |
+| `clampWanted`, `clampShortfall`, `heldDiameter`, `headLength`, `DEFAULT_CLAMPING` | What the clamping rule keeps in the holder              |
+| `holderTakesTool`, `colletFitsHolder`, `gripsShank`, `maxStickout`, `holdBand`    | Whether this holder takes this tool                     |
+| `gripRanges`, `gripsAnyShank`, `canHold`                                          | Whether a whole crib can hold it, as one set of spans   |
+| `stickoutLimits`, `defaultStickout`                                               | The collet-shaped way into the range above              |
+| `hasNeck`, `shankOf`, `heightAt`, `belowGageLine`                                 | The four that used to be written twice                  |
+| `fitAgainst`, `fitTools`, `DRILLING_FORMS`                                        | Whether a cutter cuts a feature                         |
+| `clearance`, `toolSilhouette`, `holderSilhouette`, `toolCollisions`               | Whether the stack clears the material around it         |
+| `assemblyAgainst`, `NOT_MODELLED`                                                 | Whether there is a way to _hold_ it that reaches        |
+| `sectionOutline`, `materialProfile`, `ASSEMBLY_PARTS`, `SILHOUETTE_PARTS`         | The feature in section, and what an assembly is made of |
+
+## Two kinds of holder
+
+A holder arrives in one of two forms, and they are **alternatives rather than a
+refinement of one by the other**:
+
+```ts
+import { isHolderProfile, type Holder, type HolderProfile } from '@toolpath/tool-support'
+
+const published: Holder = {
+  noseDiameter: 27,
+  noseLength: 12,
+  bodyDiameter: 42,
+  bodyLength: 20,
+  projection: 60,
+  flangeDiameter: 46,
+  gaugeLength: 60,
+  colletSeries: 'ER16',
+  colletProtrusion: 2.5,
+}
+
+const measured: HolderProfile = {
+  points: [
+    [-30, 8],
+    [0, 23],
+    [48, 21],
+    [60, 13.5],
+  ],
+  datum: 'gage-line',
+  colletSeries: 'ER16',
+  colletProtrusion: 2.5,
+}
+
+isHolderProfile(measured) // true — read `points`
+isHolderProfile(published) // false — read the vendor's own numbers
+```
+
+`Holder` is a handful of numbers off a DIN 4000 sheet, and a drawing built from
+them is a stylised holder. `HolderProfile` is the envelope measured off the
+vendor's STEP model — a hundred-odd vertices carrying the V-flange groove and the
+thread relief a machinist actually looks for. Reducing it to a nose and a body
+throws away the only reason to measure, so the two are a union and
+`isHolderProfile` tells them apart. A consumer with neither passes `null`.
+
+## No classes, deliberately
+
+Everything here is a readonly interface or a pure function over one. Two reasons
+beyond consistency:
+
+- **A class loses structural typing at a package boundary.** A catalog's own
+  record simply _is_ a `Tool`, with no adapter — the adapter stays a choice
+  rather than becoming a requirement.
+- **`instanceof` breaks across duplicate installs.** This tree has been bitten by
+  that once already, and `@toolpath/tool-scraper` carries a packaging test about
+  it.
+
+Where several quantities have to agree, one function answers them together
+rather than one apiece: `stickoutRange` hands back the minimum, the setup length
+and the ceiling in a single record, along with which of the three caps set it. A
+caller cannot take one of those and forget the others, which is precisely how
+the defect above happened — four callers each worked out the piece they wanted.
+
+## An unrecognised code is not given a meaning
+
+`geometryField` answers `null` and `isLengthField` answers `false` for a code the
+dictionary has not pinned. Show it as the vendor's own and do not convert it: a
+guessed unit is a wrong number that looks right, and a 118-degree drill point
+converted as a length is a plausible-looking 2.36.
+
+```ts
+import { convertGeometry, geometryField } from '@toolpath/tool-support'
+
+convertGeometry('DC', 6, 'millimeters', 'inches') // 0.2362…
+convertGeometry('SIG', 118, 'millimeters', 'inches') // 118 — an angle does not convert
+convertGeometry('WOC', 6, 'millimeters', 'inches') // 6 — unpinned, so not converted
+geometryField('WOC') // null
+```
+
+## The stickout, which is why this exists
+
+```ts
+import { stickoutRange } from '@toolpath/tool-support'
+
+const range = stickoutRange(
+  { unitSystem: 'inches', geometry: { DC: 25.4, OAL: 127, LCF: 31.75, SFDM: 25.4 } },
+  { grip: 27.5 },
+)
+// range.setup      — what a machinist sets it up at. This is `geometry.LBH`.
+// range.max        — the furthest it could ever stand out.
+// range.limitedBy  — 'clamp' | 'hold' | 'collet': which cap decided, so a
+//                    control can say why rather than showing a bare number.
+```
+
+Every other stickout is this call with more arguments, and `min ≤ setup ≤ max`
+holds by construction — so a drawn stickout can never exceed the length a table
+prints beside it. That invariant is a test, not a sentence in this file.
+
+## Status
+
+`0.x`: in use, and the surface still moves. A minor is the breaking channel
+while the major is `0` — `^0.1.0` does not accept `0.2.0` — so nothing arrives
+in a consumer's build without them asking for it.

package/dist/assembly-fit.d.ts

@@ -0,0 +1,54 @@
+import { type SweptAssembly } from './clearance.js';
+import type { FeatureDemand } from './demand.js';
+import { type FitFailure } from './fit.js';
+/**
+ * Whether the whole stack reaches, not just the cutter.
+ *
+ * `fit.ts` answers "could this cutter cut this feature". This answers the
+ * question a shop actually acts on: **is there a way to hold it that reaches**.
+ * The two are different often enough to matter — a 3 mm end mill with 20 mm of
+ * flute clears a 15 mm pocket on its own, and fails the moment the only collet
+ * that grips a 3 mm shank leaves 12 mm standing out of the holder.
+ *
+ * This is deliberately thin, and everything it does not model is named in
+ * {@link NOT_MODELLED} rather than left for somebody to discover.
+ */
+/**
+ * One way of holding a tool, and whether it cuts what was asked.
+ *
+ * Generic in the assembly so a catalog's own richer record — with its guid, its
+ * holder's catalog number and its published maximum stickout — comes back
+ * intact rather than as a projection of itself.
+ */
+export interface AssemblyFit<A extends SweptAssembly = SweptAssembly> {
+    readonly assembly: A;
+    readonly fits: boolean;
+    readonly failures: readonly FitFailure[];
+}
+/**
+ * What an assembly check does **not** answer yet, stated so nobody reads a
+ * pass as more than it is.
+ *
+ * - **Holder collision, on a report without a reach curve.** From Engine API
+ *   1.0.4 every datasheet carries one and `clearance.ts` sweeps the nose and
+ *   the shank over it; an older report is not checked rather than guessed. The
+ *   silhouette swept is the catalog's — nose diameter, shank, neck — not a
+ *   holder's CAD.
+ * - **Deflection.** Reach is geometry; whether a stack at that reach can take
+ *   a cut is rigidity, and this package has no force model.
+ * - **A bore holder's grip length**, which is why those assemblies use the
+ *   whole tool as their stickout and are an upper bound rather than a fact.
+ * - **Reach, on an assembly whose collet publishes no grip length.** REGO-FIX's
+ *   powRgrip collets do not, so those assemblies carry no stickout and their
+ *   reach goes unchecked rather than guessed.
+ */
+export declare const NOT_MODELLED: readonly ["holder collision without a reach curve", "deflection", "bore holder grip", "reach without a published collet grip"];
+/**
+ * Whether one assembly clears one feature.
+ *
+ * The cutter's own checks run first and unchanged — an assembly cannot rescue a
+ * tool that is too wide. What it adds is reach: the stickout has to clear the
+ * whole distance from the part top to the bottom of the feature, because the
+ * holder nose cannot go below the top of the part.
+ */
+export declare const assemblyAgainst: (assembly: SweptAssembly, demand: FeatureDemand) => FitFailure[];

package/dist/assembly-fit.js

@@ -0,0 +1,55 @@
+import { clearance, describeCollision } from './clearance.js';
+import { fitAgainst } from './fit.js';
+/**
+ * What an assembly check does **not** answer yet, stated so nobody reads a
+ * pass as more than it is.
+ *
+ * - **Holder collision, on a report without a reach curve.** From Engine API
+ *   1.0.4 every datasheet carries one and `clearance.ts` sweeps the nose and
+ *   the shank over it; an older report is not checked rather than guessed. The
+ *   silhouette swept is the catalog's — nose diameter, shank, neck — not a
+ *   holder's CAD.
+ * - **Deflection.** Reach is geometry; whether a stack at that reach can take
+ *   a cut is rigidity, and this package has no force model.
+ * - **A bore holder's grip length**, which is why those assemblies use the
+ *   whole tool as their stickout and are an upper bound rather than a fact.
+ * - **Reach, on an assembly whose collet publishes no grip length.** REGO-FIX's
+ *   powRgrip collets do not, so those assemblies carry no stickout and their
+ *   reach goes unchecked rather than guessed.
+ */
+export const NOT_MODELLED = [
+    'holder collision without a reach curve',
+    'deflection',
+    'bore holder grip',
+    'reach without a published collet grip',
+];
+/**
+ * Whether one assembly clears one feature.
+ *
+ * The cutter's own checks run first and unchanged — an assembly cannot rescue a
+ * tool that is too wide. What it adds is reach: the stickout has to clear the
+ * whole distance from the part top to the bottom of the feature, because the
+ * holder nose cannot go below the top of the part.
+ */
+export const assemblyAgainst = (assembly, demand) => {
+    const failures = [...fitAgainst(assembly.tool, demand)];
+    // An unstated stickout is not checked, the same rule the cutter checks
+    // follow: what nobody has said is not a limit anybody can be held to.
+    if (assembly.stickout !== null &&
+        demand.reachBelowTop !== undefined &&
+        assembly.stickout < demand.reachBelowTop) {
+        failures.push({
+            featureTag: demand.featureTag,
+            reason: `${assembly.stickout.toFixed(1)} mm of stickout does not clear ${demand.reachBelowTop.toFixed(1)} mm below the part top`,
+        });
+    }
+    // The material around the feature, where the report states it: the holder
+    // nose and the shank are swept over the reach curve, and each thing they
+    // meet is its own reason.
+    if (demand.reachCurve) {
+        for (const collision of clearance(assembly, demand.reachCurve).collisions) {
+            failures.push({ featureTag: demand.featureTag, reason: describeCollision(collision) });
+        }
+    }
+    return failures;
+};

package/dist/clamping.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How much shank stays in the holder.
+ *
+ * **This is a cap, not the length below the holder.** It was written straight
+ * into `geometry.LBH` at build time until 2026-09-03, which made it one of four
+ * unreconciled answers to "how far does this tool stand out" — see the table in
+ * `stickout.ts`. `LBH` is the *setup* length and `stickout.ts` owns it; what
+ * lives here is {@link clampWanted}, the length of shank a shop keeps clamped,
+ * which `stickoutRange` takes as one of three caps on that setup.
+ *
+ * **ISO 13399 calls it `LSCN`** — clamping length minimum, stated against the
+ * shank diameter `DMM`, which is what a multiple of "D" means here: the holder
+ * grips the shank, not the cut. Manufacturers publish it per tool, and the five
+ * Seco end mills checked want between 4 and 6 diameters clamped against the 3×D
+ * rule of thumb — a difference that is most of a tool's reach. So the rule
+ * reads the vendor's own number first and falls back to a multiple of the
+ * diameter for every tool that publishes none, which is every tool in the
+ * scraped catalog today because no adapter carries the column yet.
+ *
+ *     the clamping cap = OAL − (minimum clamping length × SFDM)
+ *
+ * **The bury-the-head case is not handled here.** When the subtraction lands at
+ * or under the shoulder length, it is `stickoutRange`'s floor and `gripShort`
+ * that answer, and they answer for all three caps rather than this one: a tool
+ * the rule cannot hold is gripped as short as the grip allows and says so. As a
+ * *cap*, the exception was backwards — it raised the ceiling above what the
+ * clamping rule allowed.
+ */
+import type { Geometry } from './geometry.js';
+/** What a shop holds: the vendor's number where there is one, else a multiple of the diameter. */
+export interface ClampingRule {
+    /** Read the manufacturer's `LSCN` where the tool publishes one. On by default. */
+    readonly vendorSpec: boolean;
+    /** Diameters to clamp where it does not — the rule of thumb is 3. Zero for none. */
+    readonly perDiameter: number;
+}
+/** What a dataset is built with, and what a page starts at. */
+export declare const DEFAULT_CLAMPING: ClampingRule;
+/**
+ * The diameter a clamping length is a multiple **of**: the shank.
+ *
+ * `LSCN` is stated against `DMM`, and the shank is what the holder grips — a
+ * keyseat cutter 22 mm across on a ⌀12 shank is clamped on 12. The cut stands
+ * in only where a vendor states no shank.
+ */
+export declare const heldDiameter: (geometry: Geometry) => number | undefined;
+/**
+ * Where the shank starts, measured from the tip: past the flutes, and past the
+ * reduced section under them where a tool has one. A chuck closes on neither.
+ */
+export declare const headLength: (geometry: Geometry) => number;
+/** What this rule asks to keep in the holder, or null where it says nothing. */
+export declare const clampWanted: (geometry: Geometry, rule?: ClampingRule) => number | null;
+/** How much shank the rule asked for and the tool has not got, or null where it fits. */
+export declare const clampShortfall: (geometry: Geometry, rule?: ClampingRule) => number | null;

package/dist/clamping.js

@@ -0,0 +1,70 @@
+/**
+ * How much shank stays in the holder.
+ *
+ * **This is a cap, not the length below the holder.** It was written straight
+ * into `geometry.LBH` at build time until 2026-09-03, which made it one of four
+ * unreconciled answers to "how far does this tool stand out" — see the table in
+ * `stickout.ts`. `LBH` is the *setup* length and `stickout.ts` owns it; what
+ * lives here is {@link clampWanted}, the length of shank a shop keeps clamped,
+ * which `stickoutRange` takes as one of three caps on that setup.
+ *
+ * **ISO 13399 calls it `LSCN`** — clamping length minimum, stated against the
+ * shank diameter `DMM`, which is what a multiple of "D" means here: the holder
+ * grips the shank, not the cut. Manufacturers publish it per tool, and the five
+ * Seco end mills checked want between 4 and 6 diameters clamped against the 3×D
+ * rule of thumb — a difference that is most of a tool's reach. So the rule
+ * reads the vendor's own number first and falls back to a multiple of the
+ * diameter for every tool that publishes none, which is every tool in the
+ * scraped catalog today because no adapter carries the column yet.
+ *
+ *     the clamping cap = OAL − (minimum clamping length × SFDM)
+ *
+ * **The bury-the-head case is not handled here.** When the subtraction lands at
+ * or under the shoulder length, it is `stickoutRange`'s floor and `gripShort`
+ * that answer, and they answer for all three caps rather than this one: a tool
+ * the rule cannot hold is gripped as short as the grip allows and says so. As a
+ * *cap*, the exception was backwards — it raised the ceiling above what the
+ * clamping rule allowed.
+ */
+/** What a dataset is built with, and what a page starts at. */
+export const DEFAULT_CLAMPING = { vendorSpec: true, perDiameter: 3 };
+/**
+ * Two decimals, which is finer than any vendor prints and coarser than the
+ * float error of a unit conversion.
+ */
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * The diameter a clamping length is a multiple **of**: the shank.
+ *
+ * `LSCN` is stated against `DMM`, and the shank is what the holder grips — a
+ * keyseat cutter 22 mm across on a ⌀12 shank is clamped on 12. The cut stands
+ * in only where a vendor states no shank.
+ */
+export const heldDiameter = (geometry) => geometry.SFDM ?? geometry.DC;
+/**
+ * Where the shank starts, measured from the tip: past the flutes, and past the
+ * reduced section under them where a tool has one. A chuck closes on neither.
+ */
+export const headLength = (geometry) => Math.max(geometry['shoulder-length'] ?? 0, geometry.LCF ?? 0);
+/** What this rule asks to keep in the holder, or null where it says nothing. */
+export const clampWanted = (geometry, rule = DEFAULT_CLAMPING) => {
+    const stated = geometry.LSCN;
+    if (rule.vendorSpec && stated !== undefined && stated > 0) {
+        return round(stated);
+    }
+    const shank = heldDiameter(geometry);
+    if (rule.perDiameter <= 0 || shank === undefined || shank <= 0) {
+        return null;
+    }
+    return round(shank * rule.perDiameter);
+};
+/** How much shank the rule asked for and the tool has not got, or null where it fits. */
+export const clampShortfall = (geometry, rule = DEFAULT_CLAMPING) => {
+    const wanted = clampWanted(geometry, rule);
+    const { OAL } = geometry;
+    if (wanted === null || OAL === undefined) {
+        return null;
+    }
+    const shank = Math.max(0, OAL - headLength(geometry));
+    return wanted <= shank ? null : round(wanted - shank);
+};

package/dist/clearance.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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 { type Margins, type Silhouette, type SilhouettePart } from './parts.js';
+import { type ReachCurve } from './reach.js';
+import { type Tool } from './tool.js';
+import type { Collet, Holder } from './holding.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 declare const toolSilhouette: (tool: Pick<Tool, "geometry">) => Silhouette[];
+/**
+ * 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 declare const toolCollisions: (tool: Pick<Tool, "geometry">, curve: ReachCurve, margins?: Margins) => Collision[];
+/**
+ * What the sweep needs of an assembly.
+ *
+ * **The parametric holder, not the union.** A measured `HolderProfile` is a
+ * hundred-odd vertices and sweeping one is a different function that does not
+ * exist yet; taking the union here would let a caller hand over a profile and
+ * get a verdict computed from nothing. Declared structurally, so a catalog's
+ * own richer assembly satisfies it with no adapter.
+ */
+export interface SweptAssembly {
+    readonly tool: Pick<Tool, 'geometry' | 'form'>;
+    readonly holder: Holder;
+    readonly collet?: Collet | null;
+    readonly stickout: number | null;
+}
+export interface Collision {
+    readonly part: SilhouettePart;
+    /** Where that part of the assembly begins, above the tip, in mm. */
+    readonly height: number;
+    /** How high the material stands at that part's offset from the cut, in mm. */
+    readonly needs: number;
+    /** That offset, in mm past the cutting edge. */
+    readonly offset: number;
+}
+export interface Clearance {
+    /** Every checked part of the silhouette clears. */
+    readonly clears: boolean;
+    readonly collisions: readonly Collision[];
+    /**
+     * The least the holder nose has to stand off the tip to clear, in mm — or
+     * null where the holder's nose is unstated and so unchecked.
+     */
+    readonly requiredStickout: number | null;
+    /** What was actually swept, so a pass is read as exactly that much. */
+    readonly checked: readonly SilhouettePart[];
+}
+/**
+ * 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 declare const holderSilhouette: (assembly: SweptAssembly, stickout: number) => Silhouette[];
+/**
+ * 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 declare const clearance: (assembly: SweptAssembly, curve: ReachCurve, margins?: Margins) => Clearance;
+/** Why a collision rules an assembly out, in the words a machinist would use. */
+export declare const describeCollision: (collision: Collision) => string;