@toolpath/tool-support 0.1.0

package/dist/geometry.d.ts

@@ -0,0 +1,191 @@
+/**
+ * The interchange dictionary: what a geometry code measures, and whether the
+ * number under it converts.
+ *
+ * Most of these are ISO 13399's own codes with the standard's meanings — the
+ * machine-tool industry's interchange vocabulary, which is also why they appear
+ * in Fusion's tool JSON. Three are Autodesk's names for measurements ISO codes
+ * differently, and {@link GeometryField.iso} records the standard's counterpart
+ * rather than quietly renaming them: a consumer recognises the name the scraper
+ * emitted, and a reader can still find the standard's.
+ *
+ * ## Why the dictionary carries a unit kind and not a label
+ *
+ * The unit kind is the part that changes behaviour: it is what decides whether
+ * a stated number converts with {@link UnitSystem} or is the same number in
+ * both systems. A flute count and a point angle do not convert, an L/D ratio
+ * does not convert, and a length does — and a consumer that converts the wrong
+ * one prints a 60-degree drill point as 2.36.
+ *
+ * Human-facing labels and descriptions are presentational: which words a detail
+ * page puts beside `SFDM` is that page's decision and changes with its
+ * audience. {@link GeometryField.definition} is not one of those — it is the
+ * phrase a diagnostic quotes back at whoever mapped a column to the wrong code,
+ * which is why the scraper already carries it.
+ *
+ * ## An unknown code is not given a meaning
+ *
+ * {@link geometryField} answers `null` rather than inventing an entry, and
+ * {@link isLengthField} answers `false`. A consumer shows an unrecognised code
+ * as the vendor's own and does not convert it — the alternative is guessing a
+ * unit for a column nobody has checked, and a guessed conversion is a wrong
+ * number that looks right.
+ */
+import { type UnitSystem } from './units.js';
+/**
+ * What kind of quantity a code states.
+ *
+ * `mm` is the only one that moves with a unit system. `deg` and `count` are the
+ * same number in both; `ratio` is dimensionless by construction, and an `LD` of
+ * 4 is 4 whichever sheet it came off.
+ */
+export type GeometryUnit = 'mm' | 'deg' | 'count' | 'ratio';
+export interface GeometryField {
+    readonly unit: GeometryUnit;
+    /**
+     * What the field measures, phrased so it can be quoted back at whoever
+     * mapped a column to the wrong one.
+     */
+    readonly definition: string;
+    /**
+     * The ISO 13399 code for this measurement, or `null` where the standard's
+     * counterpart has not been pinned. Equal to the key itself on every field
+     * that *is* the standard's code.
+     */
+    readonly iso: string | null;
+}
+/**
+ * The codes this domain knows, keyed by the name the scraper emits.
+ *
+ * **This vocabulary is the scraper's, not this package's invention.** Renaming
+ * a field here would put a translation table between two vocabularies, and a
+ * translation table is where an `SFDM` becomes a `DC` in one direction and
+ * nobody notices.
+ */
+export declare const GEOMETRY_FIELDS: {
+    readonly DC: {
+        readonly unit: "mm";
+        readonly definition: "cutting diameter";
+        readonly iso: "DC";
+    };
+    readonly SFDM: {
+        readonly unit: "mm";
+        readonly definition: "shank diameter — what the holder grips";
+        readonly iso: "DMM";
+    };
+    readonly OAL: {
+        readonly unit: "mm";
+        readonly definition: "overall length, tip to the end of the shank";
+        readonly iso: "OAL";
+    };
+    readonly LCF: {
+        readonly unit: "mm";
+        readonly definition: "flute length — the length of the cutting edge";
+        readonly iso: "LCF";
+    };
+    readonly RE: {
+        readonly unit: "mm";
+        readonly definition: "corner radius; 0 on a square-end tool";
+        readonly iso: "RE";
+    };
+    /**
+     * **`unit: 'mm'` is not the whole truth, and a caller converting a `TP` off
+     * an inch tap should know it.** A metric tap's pitch is a length; an inch
+     * tap's is conventionally threads-per-inch, which is a *reciprocal*, and
+     * converting one as a length gives a number that looks like a pitch and is
+     * wrong by a factor of its own value. No consumer in this tree converts it —
+     * the scraper reads it from a single column already in the tool's own system,
+     * and the catalog drops the code on ingest for exactly this reason — so the
+     * hazard is recorded rather than resolved. Resolving it means either
+     * confirming the inch convention against a real tap table or giving the
+     * dictionary a unit kind for "not decidable from the code alone".
+     */
+    readonly TP: {
+        readonly unit: "mm";
+        readonly definition: "thread pitch, in the tool’s own unit system";
+        readonly iso: "TP";
+    };
+    readonly NOF: {
+        readonly unit: "count";
+        readonly definition: "number of flutes";
+        readonly iso: "NOF";
+    };
+    readonly SIG: {
+        readonly unit: "deg";
+        readonly definition: "point angle, degrees included";
+        readonly iso: "SIG";
+    };
+    /**
+     * ISO 13399's clamping length minimum: the shank a manufacturer wants held.
+     *
+     * No vendor scraped so far publishes it, and the day one does this is where
+     * it lands — read in preference to any rule of thumb about how much shank a
+     * shop keeps clamped.
+     */
+    readonly LSCN: {
+        readonly unit: "mm";
+        readonly definition: "least of the shank the manufacturer wants clamped";
+        readonly iso: "LSCN";
+    };
+    /**
+     * Not a vendor's column: how far the tool is set out of the holder.
+     *
+     * The number the drawing draws and the details table prints, and the one
+     * quantity that was computed in four unconnected places and disagreed by a
+     * factor of two on an ordinary tool. It is derived, and its provenance says
+     * so.
+     */
+    readonly LBH: {
+        readonly unit: "mm";
+        readonly definition: "length below holder — how far the tool is set out of the holder nose";
+        readonly iso: null;
+    };
+    /** Length below holder over cutting diameter — the "×D" a shop reads reach in. */
+    readonly LD: {
+        readonly unit: "ratio";
+        readonly definition: "length below holder over cutting diameter — the ×D a shop reads reach in";
+        readonly iso: null;
+    };
+    readonly 'shoulder-length': {
+        readonly unit: "mm";
+        readonly definition: "usable length below the full shank";
+        readonly iso: null;
+    };
+    readonly 'shoulder-diameter': {
+        readonly unit: "mm";
+        readonly definition: "diameter at the shoulder — the neck, where necked";
+        readonly iso: null;
+    };
+};
+/** A code {@link GEOMETRY_FIELDS} knows. */
+export type GeometryCode = keyof typeof GEOMETRY_FIELDS;
+/**
+ * A tool's stated geometry: code to value, lengths in millimetres and angles in
+ * degrees whatever system the vendor published in.
+ *
+ * Keyed by `string` and not by {@link GeometryCode}, because a vendor states
+ * columns this dictionary has not pinned yet and dropping them on ingest would
+ * lose data that is still the vendor's. `undefined` is admitted so that a
+ * record with a narrower `Record<string, number>` geometry satisfies this by
+ * structure, with no adapter.
+ */
+export type Geometry = Readonly<Record<string, number | undefined>>;
+/** What a code measures, or `null` where this dictionary has not pinned it. */
+export declare const geometryField: (code: string) => GeometryField | null;
+/**
+ * Whether a value under this code is a length, and so moves with a unit system.
+ *
+ * The single question the dictionary's unit kind exists to answer. `false` for
+ * an unknown code, which is the same refusal {@link geometryField} makes: a
+ * code nobody has classified is not converted, because a guessed conversion is
+ * worse than an unconverted number a reader can still recognise.
+ */
+export declare const isLengthField: (code: string) => boolean;
+/**
+ * `value`, stated under `code`, converted between systems — or unchanged where
+ * the code does not state a length.
+ *
+ * The conversion and the decision whether to convert in one call, so a caller
+ * cannot get the second one right and the first one wrong.
+ */
+export declare const convertGeometry: (code: string, value: number, from: UnitSystem, to: UnitSystem) => number;

package/dist/geometry.js

@@ -0,0 +1,124 @@
+/**
+ * The interchange dictionary: what a geometry code measures, and whether the
+ * number under it converts.
+ *
+ * Most of these are ISO 13399's own codes with the standard's meanings — the
+ * machine-tool industry's interchange vocabulary, which is also why they appear
+ * in Fusion's tool JSON. Three are Autodesk's names for measurements ISO codes
+ * differently, and {@link GeometryField.iso} records the standard's counterpart
+ * rather than quietly renaming them: a consumer recognises the name the scraper
+ * emitted, and a reader can still find the standard's.
+ *
+ * ## Why the dictionary carries a unit kind and not a label
+ *
+ * The unit kind is the part that changes behaviour: it is what decides whether
+ * a stated number converts with {@link UnitSystem} or is the same number in
+ * both systems. A flute count and a point angle do not convert, an L/D ratio
+ * does not convert, and a length does — and a consumer that converts the wrong
+ * one prints a 60-degree drill point as 2.36.
+ *
+ * Human-facing labels and descriptions are presentational: which words a detail
+ * page puts beside `SFDM` is that page's decision and changes with its
+ * audience. {@link GeometryField.definition} is not one of those — it is the
+ * phrase a diagnostic quotes back at whoever mapped a column to the wrong code,
+ * which is why the scraper already carries it.
+ *
+ * ## An unknown code is not given a meaning
+ *
+ * {@link geometryField} answers `null` rather than inventing an entry, and
+ * {@link isLengthField} answers `false`. A consumer shows an unrecognised code
+ * as the vendor's own and does not convert it — the alternative is guessing a
+ * unit for a column nobody has checked, and a guessed conversion is a wrong
+ * number that looks right.
+ */
+import { convertLength } from './units.js';
+/**
+ * The codes this domain knows, keyed by the name the scraper emits.
+ *
+ * **This vocabulary is the scraper's, not this package's invention.** Renaming
+ * a field here would put a translation table between two vocabularies, and a
+ * translation table is where an `SFDM` becomes a `DC` in one direction and
+ * nobody notices.
+ */
+export const GEOMETRY_FIELDS = {
+    DC: { unit: 'mm', definition: 'cutting diameter', iso: 'DC' },
+    SFDM: { unit: 'mm', definition: 'shank diameter — what the holder grips', iso: 'DMM' },
+    OAL: { unit: 'mm', definition: 'overall length, tip to the end of the shank', iso: 'OAL' },
+    LCF: { unit: 'mm', definition: 'flute length — the length of the cutting edge', iso: 'LCF' },
+    RE: { unit: 'mm', definition: 'corner radius; 0 on a square-end tool', iso: 'RE' },
+    /**
+     * **`unit: 'mm'` is not the whole truth, and a caller converting a `TP` off
+     * an inch tap should know it.** A metric tap's pitch is a length; an inch
+     * tap's is conventionally threads-per-inch, which is a *reciprocal*, and
+     * converting one as a length gives a number that looks like a pitch and is
+     * wrong by a factor of its own value. No consumer in this tree converts it —
+     * the scraper reads it from a single column already in the tool's own system,
+     * and the catalog drops the code on ingest for exactly this reason — so the
+     * hazard is recorded rather than resolved. Resolving it means either
+     * confirming the inch convention against a real tap table or giving the
+     * dictionary a unit kind for "not decidable from the code alone".
+     */
+    TP: { unit: 'mm', definition: 'thread pitch, in the tool’s own unit system', iso: 'TP' },
+    NOF: { unit: 'count', definition: 'number of flutes', iso: 'NOF' },
+    SIG: { unit: 'deg', definition: 'point angle, degrees included', iso: 'SIG' },
+    /**
+     * ISO 13399's clamping length minimum: the shank a manufacturer wants held.
+     *
+     * No vendor scraped so far publishes it, and the day one does this is where
+     * it lands — read in preference to any rule of thumb about how much shank a
+     * shop keeps clamped.
+     */
+    LSCN: {
+        unit: 'mm',
+        definition: 'least of the shank the manufacturer wants clamped',
+        iso: 'LSCN',
+    },
+    /**
+     * Not a vendor's column: how far the tool is set out of the holder.
+     *
+     * The number the drawing draws and the details table prints, and the one
+     * quantity that was computed in four unconnected places and disagreed by a
+     * factor of two on an ordinary tool. It is derived, and its provenance says
+     * so.
+     */
+    LBH: {
+        unit: 'mm',
+        definition: 'length below holder — how far the tool is set out of the holder nose',
+        iso: null,
+    },
+    /** Length below holder over cutting diameter — the "×D" a shop reads reach in. */
+    LD: {
+        unit: 'ratio',
+        definition: 'length below holder over cutting diameter — the ×D a shop reads reach in',
+        iso: null,
+    },
+    'shoulder-length': {
+        unit: 'mm',
+        definition: 'usable length below the full shank',
+        iso: null,
+    },
+    'shoulder-diameter': {
+        unit: 'mm',
+        definition: 'diameter at the shoulder — the neck, where necked',
+        iso: null,
+    },
+};
+/** What a code measures, or `null` where this dictionary has not pinned it. */
+export const geometryField = (code) => Object.hasOwn(GEOMETRY_FIELDS, code) ? GEOMETRY_FIELDS[code] : null;
+/**
+ * Whether a value under this code is a length, and so moves with a unit system.
+ *
+ * The single question the dictionary's unit kind exists to answer. `false` for
+ * an unknown code, which is the same refusal {@link geometryField} makes: a
+ * code nobody has classified is not converted, because a guessed conversion is
+ * worse than an unconverted number a reader can still recognise.
+ */
+export const isLengthField = (code) => geometryField(code)?.unit === 'mm';
+/**
+ * `value`, stated under `code`, converted between systems — or unchanged where
+ * the code does not state a length.
+ *
+ * The conversion and the decision whether to convert in one call, so a caller
+ * cannot get the second one right and the first one wrong.
+ */
+export const convertGeometry = (code, value, from, to) => (isLengthField(code) ? convertLength(value, from, to) : value);

package/dist/holding.d.ts

@@ -0,0 +1,266 @@
+/**
+ * What holds a tool, and the stack the two make together.
+ *
+ * ## The holder is a union, not one shape with optional extras
+ *
+ * A holder arrives in one of two forms and they are alternatives rather than a
+ * refinement of one by the other: {@link Holder} is what a vendor *publishes*
+ * about it, and {@link HolderProfile} is what its own CAD model *measures*.
+ * {@link isHolderProfile} tells them apart. A consumer that has both picks one;
+ * a consumer that has neither passes `null` and the tool stands alone.
+ *
+ * ## What is here and what is not
+ *
+ * Three shapes in this tree called themselves a holder and no two agreed on
+ * which fields exist — sixteen, nine and nineteen. What they *did* agree on is
+ * the geometry below, which is also exactly what a drawing and a clearance
+ * sweep read. Identity and commerce — a guid, a brand, a catalog number, the
+ * vendor's own CAD download — belong to a catalog's record, which extends this.
+ *
+ * ## How a holder grips is optional, and the absence is load bearing
+ *
+ * {@link Holder.clamping}, {@link Holder.boreDiameter} and {@link Holder.taper}
+ * arrived with the functions that read them, and they are optional because a
+ * drawing has never needed them: a consumer that hands over nine numbers to get
+ * a picture must not have to invent a clamping mode to do it.
+ *
+ * **Absent means nobody has said, and nobody-has-said refuses.** A holder that
+ * does not state how it clamps takes no tool, offers no grip range and matches
+ * no taper. That is the same rule {@link holderTakesTool} applies to a tool
+ * with no stated shank, and for the same reason: the unchecked case here is a
+ * cutter falling out of a spindle.
+ */
+import type { HolderProfile } from './profile.js';
+import type { ProvenanceMap } from './provenance.js';
+import type { Tool } from './tool.js';
+import { type StickoutPolicy, type StickoutRange, type StickoutTool } from './stickout.js';
+import { type ClampingRule } from './clamping.js';
+/**
+ * How a holder grips what it holds.
+ *
+ * `hydraulic` is here rather than folded into `bore` because vendors classify
+ * parts as hydraulic outright, and folding it in would be this package
+ * reclassifying a family its vendor already named.
+ */
+export type Clamping = 'bore' | 'collet' | 'shrink' | 'hydraulic';
+/**
+ * What goes in the spindle, as its vendor publishes it.
+ *
+ * Every field is nullable because a DIN 4000 sheet is not a promise: each is
+ * `null` where the vendor states nothing, and nothing is drawn or swept for it
+ * then. An absent number is not a zero — a holder with no stated body diameter
+ * is not a holder with no body.
+ */
+export interface Holder {
+    /** The nose, where a holder fouls the part before the tool runs out of reach. */
+    readonly noseDiameter: number | null;
+    readonly noseLength: number | null;
+    /** The body behind the nose, where the vendor states it step by step. */
+    readonly bodyDiameter: number | null;
+    readonly bodyLength: number | null;
+    /** Nose face to flange face, in millimetres. */
+    readonly projection: number | null;
+    readonly flangeDiameter: number | null;
+    /**
+     * Spindle face to holder nose, in millimetres.
+     *
+     * Not the same as reach: what sticks out past the nose is the tool's, and
+     * that is the number a feature depth is measured against.
+     */
+    readonly gaugeLength: number | null;
+    /** For a collet holder: which collet series it takes — `ER16`, `PG10`. */
+    readonly colletSeries: string | null;
+    /**
+     * How the holder grips: through a collet, a bore, a shrink fit or hydraulic
+     * pressure.
+     *
+     * A shrink-fit holder and a hydraulic chuck grip the shank directly, the same
+     * way a bore does, and they stay apart because the distinction is one a buyer
+     * makes — a shrink fit needs an induction heater on the bench and a hydraulic
+     * chuck an actuation screw — and because a vendor states which it published.
+     */
+    readonly clamping?: Clamping;
+    /**
+     * For a bore, shrink or hydraulic holder: the one shank diameter it takes, in
+     * millimetres.
+     *
+     * **One diameter, not an upper bound.** A shrink-fit holder bored for 12 mm
+     * does not hold a 10 mm shank at all, and treating it as a maximum would put
+     * a tool in a holder that drops it.
+     */
+    readonly boreDiameter?: number | null;
+    /** The spindle interface — `BT30`. A holder only fits the machine that takes it. */
+    readonly taper?: string | null;
+    /**
+     * How far the seated collet stands proud of the nose face, in millimetres.
+     *
+     * A powRgrip collet is pressed in and its front protrudes; the tool sees the
+     * collet's own diameter for that much before the nose.
+     */
+    readonly colletProtrusion: number | null;
+    readonly provenance?: ProvenanceMap;
+}
+/**
+ * Which of the two holder forms this is.
+ *
+ * On the presence of `points` rather than on a `kind` tag, because a tag would
+ * have to be added to {@link Holder} as well and every existing adapter would
+ * stop compiling to gain nothing a structural check does not already give.
+ */
+export declare const isHolderProfile: (holder: Holder | HolderProfile) => holder is HolderProfile;
+/**
+ * What grips the shank inside a collet holder.
+ *
+ * As with {@link Holder}, this is the gripping and nothing else. `series` has to
+ * equal the holder's exactly — a series is a mechanical interface, not a size
+ * class, and an `ER16` collet does not go in an `ER20` nose.
+ */
+export interface Collet {
+    /** `ER16`, `PG10` — must equal the holder's series exactly. */
+    readonly series: string;
+    /** The shank diameters it grips, in millimetres. */
+    readonly clampMin: number;
+    readonly clampMax: number;
+    /**
+     * How much shank the collet actually holds, in millimetres.
+     *
+     * `null` where the vendor does not publish it, and that absence is load
+     * bearing: without it there is no honest maximum stickout, and the answer has
+     * to be "nobody has said" rather than an invented grip rule.
+     */
+    readonly clampLength: number | null;
+    readonly provenance?: ProvenanceMap;
+}
+/**
+ * A tool, what holds it, and how far it stands out.
+ *
+ * **The whole reason this package exists is that `stickout` cannot be a bare
+ * number a caller worked out on its own.** How far a tool stands out of its
+ * holder is a pure function of the tool, the collet and a shop's policy, and
+ * before this it had no home: it was computed in four unconnected places, they
+ * disagreed by a factor of two on an ordinary tool, and the details table
+ * printed one number while the drawing beside it drew another.
+ *
+ * The arithmetic that resolves it — the clamping rule, the hold share, the
+ * collet's cap — is {@link stickoutRange}, and {@link stickoutLimits} is the
+ * collet-shaped way into it. A consumer that has already chosen a stickout
+ * passes the one it holds; a consumer that has not asks for it here rather than
+ * working out a fifth answer of its own.
+ */
+export interface Assembly {
+    readonly tool: Tool;
+    readonly holder: Holder | HolderProfile | null;
+    /** Null for a bore or shrink holder, which grips the shank directly, and for no holder at all. */
+    readonly collet: Collet | null;
+    /**
+     * Tool tip to holder nose, in millimetres — the reach of the stack, as set.
+     *
+     * `null` draws the tool alone and checks nothing against a part: it is "nobody
+     * has decided", not zero.
+     */
+    readonly stickout: number | null;
+}
+/**
+ * A collet fits a holder when the holder takes collets of exactly its series.
+ *
+ * A series is a mechanical interface and not a size class: an `ER16` collet
+ * does not go in an `ER20` nose.
+ */
+export declare const colletFitsHolder: (collet: Pick<Collet, "series">, holder: Pick<Holder, "clamping" | "colletSeries">) => boolean;
+/** Whether a collet grips a given shank diameter, in millimetres. */
+export declare const gripsShank: (collet: Pick<Collet, "clampMin" | "clampMax">, shank: number) => boolean;
+/**
+ * Whether a holder takes this tool's shank, with the collet if it needs one.
+ *
+ * **A tool whose shank the vendor does not state is refused, not assumed to
+ * fit.** This is the one place the domain differs from "what is not stated is
+ * not checked", because here the unchecked case is a cutter falling out of a
+ * spindle.
+ */
+export declare const holderTakesTool: (holder: Pick<Holder, "clamping" | "colletSeries" | "boreDiameter">, collet: Collet | null, tool: Pick<Tool, "geometry">) => boolean;
+/**
+ * The furthest a tool can stand out of its holder, in millimetres: overall
+ * length less the length that has to stay gripped.
+ *
+ * `null` when either is unstated. A maximum stickout is exactly the number
+ * somebody would use to decide a deep pocket is reachable, and a guessed one is
+ * worse than an absent one. A bore or shrink holder's grip length is the
+ * holder's rather than a collet's, and this package does not carry it — so
+ * those answer `null` too, honestly, until the contract gains it.
+ */
+export declare const maxStickout: (tool: Pick<Tool, "geometry">, collet: Pick<Collet, "clampLength"> | null) => number | null;
+export type HoldBand = 'good' | 'medium' | 'bad';
+/**
+ * How well the holder has hold of the tool at this stickout, by the share of
+ * the overall length left in the holder.
+ *
+ * At or above `good` is good; between `least` and that is possible but bad;
+ * below `least` is not compatible. The thresholds are a shop's, handed in as
+ * fractions rather than named here, because they are the same knob
+ * {@link StickoutPolicy.heldShare} is and a package must not carry two.
+ */
+export declare const holdBand: (tool: Pick<Tool, "geometry">, stickout: number, thresholds: {
+    readonly good: number;
+    readonly least: number;
+}) => HoldBand | null;
+/**
+ * How far this tool may stand out of this holder — the collet-shaped way into
+ * {@link stickoutRange}.
+ *
+ * **The arithmetic is not here.** This was one of the four places that worked
+ * out a stickout, and the one that capped at a share of the overall length
+ * while the clamping rule capped at a length of shank and neither knew about
+ * the other. `stickout.ts` owns the quantity and combines the two knobs in one
+ * place; this maps a collet onto the grip length that module asks for, which is
+ * all a collet was ever contributing.
+ */
+export declare const stickoutLimits: (tool: StickoutTool, collet: Pick<Collet, "clampLength"> | null, 
+/** What the holder needs to clear the part, from the sweep: the setup stands out at least this far. */
+required?: number | null, policy?: StickoutPolicy, rule?: ClampingRule) => StickoutRange | null;
+/**
+ * The stickout an assembly starts at: the setup length for this tool, held
+ * within what the grip allows.
+ *
+ * A tool whose setup outruns its grip is gripped as short as the grip lets it
+ * and no shorter — rather than refused, because the shop is the one who knows
+ * whether that is a problem.
+ */
+export declare const defaultStickout: (tool: StickoutTool & Pick<Tool, "geometry">, collet: Pick<Collet, "clampLength"> | null) => number | null;
+/**
+ * The shank diameters a crib can grip, given what it is asked to hold with.
+ *
+ * Every rule above reduces to one number — the shank — so "can anything here
+ * hold this tool" is a question about a set of diameters. Working that set out
+ * once and asking it per tool is what makes holding usable as a filter: asked
+ * tool by tool it is holders × collets × tools, which on a real catalog is tens
+ * of millions of comparisons per keystroke.
+ */
+export interface GripRanges {
+    /** Closed intervals a collet grips, in millimetres. */
+    readonly spans: ReadonlyArray<readonly [number, number]>;
+    /** Exact diameters a bore or shrink holder takes. */
+    readonly bores: ReadonlyArray<number>;
+}
+/** `taper` narrows to one spindle interface, `colletSeries` to one collet family; either left out means "any". */
+export declare const gripRanges: (holders: readonly Pick<Holder, "clamping" | "colletSeries" | "boreDiameter" | "taper">[], collets: readonly Collet[], want?: {
+    readonly taper?: string | null;
+    readonly colletSeries?: string | null;
+}) => GripRanges;
+/**
+ * Whether anything in {@link gripRanges} holds this shank, in millimetres.
+ *
+ * **Through {@link gripsShank} and {@link boreTakesShank}, not a second
+ * comparison.** This is the fast filter and `holderTakesTool` is the exact
+ * check, and the two must agree: asked strictly, a ⅜" shank that converts to
+ * 9.524999999999999 misses a collet whose sheet says 9.525, so the crib reports
+ * no holder for a tool the holder plainly takes. That is the failure the
+ * tolerance above was introduced for, and it belongs on both paths.
+ */
+export declare const gripsAnyShank: (ranges: GripRanges, shank: number) => boolean;
+/**
+ * Whether the crib can hold this tool at all.
+ *
+ * A tool whose shank the vendor does not state is refused, for the same reason
+ * {@link holderTakesTool} refuses it.
+ */
+export declare const canHold: (ranges: GripRanges, tool: Pick<Tool, "geometry">) => boolean;