@toolpath/tool-support 0.1.0

package/dist/provenance.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where a stated fact came from.
+ *
+ * Carried per constant by the scraper and kept all the way through, for one
+ * reason: a number a shop cannot trace is a number they have to take on faith.
+ * A derived or assumed value has to be visibly not the vendor's.
+ *
+ * The scraper calls this `FactSource` and the drawing calls it `Provenance`;
+ * they are the same three strings, and this is the one declaration. `Provenance`
+ * is the name kept because it is what the values describe — the vendor's
+ * `vendor-stated` is not a *source* in the sense the scraper's transport means
+ * one.
+ */
+/** Every {@link Provenance}, in decreasing order of how much a shop can lean on it. */
+export declare const PROVENANCE: readonly ["vendor-stated", "derived", "assumed"];
+export type Provenance = (typeof PROVENANCE)[number];
+/**
+ * Which values are the vendor's and which this pipeline decided, keyed the same
+ * way the record they describe is.
+ *
+ * A key with no entry is not a claim of `vendor-stated`: it is nobody having
+ * said. Defaulting an absent provenance to the vendor's is how a derived number
+ * ends up presented as published.
+ */
+export type ProvenanceMap = Readonly<Record<string, Provenance>>;

package/dist/provenance.js

@@ -0,0 +1,15 @@
+/**
+ * Where a stated fact came from.
+ *
+ * Carried per constant by the scraper and kept all the way through, for one
+ * reason: a number a shop cannot trace is a number they have to take on faith.
+ * A derived or assumed value has to be visibly not the vendor's.
+ *
+ * The scraper calls this `FactSource` and the drawing calls it `Provenance`;
+ * they are the same three strings, and this is the one declaration. `Provenance`
+ * is the name kept because it is what the values describe — the vendor's
+ * `vendor-stated` is not a *source* in the sense the scraper's transport means
+ * one.
+ */
+/** Every {@link Provenance}, in decreasing order of how much a shop can lean on it. */
+export const PROVENANCE = ['vendor-stated', 'derived', 'assumed'];

package/dist/reach.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The worst-case material around a feature, and what a stack has to get past.
+ *
+ * **Declared structurally, on purpose.** The shape is exactly what the Toolpath
+ * part contracts call a `ReachCurve`, and naming it here rather than importing
+ * it is what keeps this package free of the API's schema: a `ReachCurve` off a
+ * report satisfies this by structure, with no adapter, and a consumer that only
+ * draws a tool pulls in no OpenAPI contract to do it.
+ *
+ * That seam is what makes the whole package possible. Reading a curve *off a
+ * report* is an adapter and stays with whoever holds the report; reading a
+ * curve is arithmetic and belongs here.
+ */
+/**
+ * Material heights by distance out from the cut, as a staircase.
+ *
+ * Read as "material within `horizontalOffset[i]` of the cut rises to
+ * `verticalOffset[i]`". Both are in millimetres; the offsets run outward from
+ * the cutting edge and the heights up from the bottom of the feature.
+ *
+ * The rise comes at the **start** of each run, so everything out to a knot is
+ * already as tall as that knot says. Anything that reads this curve has to
+ * agree about that, or a drawn staircase and a clearance verdict describe two
+ * different pockets.
+ */
+export interface ReachCurve {
+    readonly horizontalOffset: readonly number[];
+    readonly verticalOffset: readonly number[];
+}
+/**
+ * The tallest material within `offset` mm of the cut, above the feature's
+ * bottom.
+ *
+ * **The twin that had nowhere else to go.** One copy decided the verdict — the
+ * clearance sweep, with a dozen callers that never draw anything — and the
+ * other was in the drawing package, because the gaps an overlay dimensions
+ * cannot be measured without it. Neither could depend on the other: putting the
+ * verdict behind a rendering package is the thing the whole split exists to
+ * avoid, and a drawing may not depend on a catalog's data package. So there
+ * were two, and the note beside each said they must agree exactly.
+ *
+ * The rise comes at the **start** of each run: for an offset between knots the
+ * material could be anywhere out to the next knot, so the next knot's height is
+ * the bound. Past the last knot the curve clamps.
+ */
+export declare const heightAt: (curve: ReachCurve, offset: number) => number;

package/dist/reach.js

@@ -0,0 +1,37 @@
+/**
+ * The worst-case material around a feature, and what a stack has to get past.
+ *
+ * **Declared structurally, on purpose.** The shape is exactly what the Toolpath
+ * part contracts call a `ReachCurve`, and naming it here rather than importing
+ * it is what keeps this package free of the API's schema: a `ReachCurve` off a
+ * report satisfies this by structure, with no adapter, and a consumer that only
+ * draws a tool pulls in no OpenAPI contract to do it.
+ *
+ * That seam is what makes the whole package possible. Reading a curve *off a
+ * report* is an adapter and stays with whoever holds the report; reading a
+ * curve is arithmetic and belongs here.
+ */
+/**
+ * The tallest material within `offset` mm of the cut, above the feature's
+ * bottom.
+ *
+ * **The twin that had nowhere else to go.** One copy decided the verdict — the
+ * clearance sweep, with a dozen callers that never draw anything — and the
+ * other was in the drawing package, because the gaps an overlay dimensions
+ * cannot be measured without it. Neither could depend on the other: putting the
+ * verdict behind a rendering package is the thing the whole split exists to
+ * avoid, and a drawing may not depend on a catalog's data package. So there
+ * were two, and the note beside each said they must agree exactly.
+ *
+ * The rise comes at the **start** of each run: for an offset between knots the
+ * material could be anywhere out to the next knot, so the next knot's height is
+ * the bound. Past the last knot the curve clamps.
+ */
+export const heightAt = (curve, offset) => {
+    for (let index = 0; index < curve.horizontalOffset.length; index += 1) {
+        if ((curve.horizontalOffset[index] ?? 0) >= offset) {
+            return curve.verticalOffset[index] ?? 0;
+        }
+    }
+    return curve.verticalOffset[curve.verticalOffset.length - 1] ?? 0;
+};

package/dist/section.d.ts

@@ -0,0 +1,67 @@
+import { type ReachCurve } from './reach.js';
+/**
+ * The feature in section, with the tool in it.
+ *
+ * A cross-section through the feature at its **worst-case place** — the
+ * tightest spot the tool has to reach — drawn the way a machinist sketches a
+ * setup: the tool's tip on the feature's bottom, its cutting edge against the
+ * wall, the wall up to the feature's top, and the part above and beyond it
+ * standing as tall as the reach curve says it can. A drill sits on the hole's
+ * axis instead, because a drill does not hug a wall.
+ *
+ * Everything is from the datasheet: the depth from `zMax − zMin`, the width
+ * from the tightest clearance (`cd.ignore.min`) or a hole's diameter, the
+ * fillet from `filletRadius`, a hole's bottom from `fullConeDeg`, the top of
+ * the part from the highest feature cut the same way, and the material
+ * beyond the wall from the reach curve — the same staircase the sweep walks,
+ * so what the drawing shows the holder clearing is what the check cleared.
+ *
+ * Coordinates are millimetres in the drawing's own frame: `x` across from the
+ * tool's axis, `z` up from the feature's bottom.
+ */
+export type SectionKind = 'pocket' | 'hole' | 'wall' | 'face';
+export interface FeatureSection {
+    readonly kind: SectionKind;
+    /** The feature's own height, `zMax − zMin`. */
+    readonly depth: number;
+    /** False for a through feature: nothing is drawn under the bottom. */
+    readonly hasFloor: boolean;
+    /** Across the tightest place, or a hole's diameter; null where the datasheet does not say. */
+    readonly width: number | null;
+    /** The floor fillet, 0 for a sharp corner. */
+    readonly filletRadius: number;
+    /** A hole's bottom cone, full angle; 180 or null is flat. */
+    readonly coneDeg: number | null;
+    /** The top of the part above the feature's bottom, which is what the holder must clear. */
+    readonly topAbove: number;
+    readonly curve: ReachCurve | null;
+}
+export interface SectionPoint {
+    readonly x: number;
+    readonly z: number;
+}
+export interface Section {
+    /** Closed polygons of material, to hatch. */
+    readonly material: ReadonlyArray<ReadonlyArray<SectionPoint>>;
+    /** The surface the tip sits on, across, or null for a through feature. */
+    readonly floor: {
+        readonly from: number;
+        readonly to: number;
+    } | null;
+    readonly leftWall: number | null;
+    readonly rightWall: number | null;
+    readonly extent: {
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly bottom: number;
+    };
+}
+/** Stock drawn under a floor, mm: enough to read as solid, not a claim about thickness. */
+export declare const FLOOR_BAND = 6;
+/** Part drawn beyond the last thing the datasheet states, mm. */
+export declare const REACH = 12;
+export declare const sectionOutline: (section: FeatureSection, tool: {
+    readonly diameter: number;
+    readonly form: string;
+}) => Section;

package/dist/section.js

@@ -0,0 +1,185 @@
+import { heightAt } from './reach.js';
+/** Forms that sit on a hole's axis rather than against its wall. */
+const ON_AXIS = new Set([
+    'drill',
+    'spot drill',
+    'center drill',
+    'reamer',
+    'counter sink',
+    'counter bore',
+    'boring bar',
+    'tap right hand',
+    'tap left hand',
+    'thread mill',
+]);
+/** Stock drawn under a floor, mm: enough to read as solid, not a claim about thickness. */
+export const FLOOR_BAND = 6;
+/** Part drawn beyond the last thing the datasheet states, mm. */
+export const REACH = 12;
+const exact = (value) => Math.round(value * 1e6) / 1e6;
+/** A quarter arc of a floor fillet, from the floor tangent up to the wall tangent. */
+const filletArc = (corner, radius, side, steps = 6) => Array.from({ length: steps + 1 }, (_, index) => {
+    // From straight down (on the floor, one radius in from the wall) round to
+    // straight across (on the wall, one radius up).
+    const angle = (-90 + (90 * index) / steps) * (Math.PI / 180);
+    const centre = { x: corner.x + side * radius, z: corner.z + radius };
+    return {
+        x: exact(centre.x - side * radius * Math.cos(angle)),
+        z: exact(centre.z + radius * Math.sin(angle)),
+    };
+});
+/**
+ * The material beyond one wall, as a staircase from the tool's edge outward.
+ *
+ * `fromEdge` is how far the wall stands from the tool's cutting edge; the
+ * curve's offsets are from that edge. Heights are the sweep's own reading —
+ * every offset up to a knot is as tall as the knot says — so the staircase
+ * rises at the start of each run, exactly as `materialProfile` draws it.
+ * Returns (distance beyond the wall, height) pairs, ending `reach` past the
+ * last knot.
+ */
+const staircase = (curve, fromEdge, floorAt, topAbove, reach) => {
+    if (!curve || curve.horizontalOffset.length === 0) {
+        return [
+            { s: 0, z: Math.max(floorAt, topAbove) },
+            { s: reach, z: Math.max(floorAt, topAbove) },
+        ];
+    }
+    const out = [];
+    let from = fromEdge;
+    curve.horizontalOffset.forEach((offset, index) => {
+        if (offset < fromEdge) {
+            return;
+        }
+        const height = Math.max(floorAt, curve.verticalOffset[index] ?? 0);
+        out.push({ s: from - fromEdge, z: height }, { s: offset - fromEdge, z: height });
+        from = offset;
+    });
+    const last = out[out.length - 1];
+    const height = last ? last.z : Math.max(floorAt, heightAt(curve, fromEdge));
+    if (!last) {
+        out.push({ s: 0, z: height });
+    }
+    out.push({ s: (last?.s ?? 0) + reach, z: height });
+    return out;
+};
+/**
+ * One wall and the material behind it, as a closed polygon.
+ *
+ * `side` is −1 for the wall on the tool's left, +1 on its right. From the
+ * floor tangent of the fillet, round the fillet, up the wall to the feature's
+ * top, then outward along the staircase, then down to the bottom of the
+ * drawing and back under the fillet.
+ */
+const wallPolygon = (wallX, side, section, toolEdge, bottom, floorAt) => {
+    const r = Math.max(0, Math.min(section.filletRadius, section.depth));
+    const corner = { x: wallX, z: floorAt };
+    const points = [];
+    if (r > 0) {
+        points.push(...filletArc(corner, r, side === -1 ? 1 : -1, 6));
+    }
+    else {
+        points.push(corner);
+    }
+    points.push({ x: wallX, z: floorAt + section.depth });
+    const fromEdge = Math.abs(wallX - toolEdge);
+    for (const step of staircase(section.curve, fromEdge, floorAt + section.depth, section.topAbove, REACH)) {
+        points.push({ x: exact(wallX + side * step.s), z: exact(step.z) });
+    }
+    const far = points[points.length - 1].x;
+    points.push({ x: far, z: bottom });
+    points.push({ x: exact(wallX + side * -1 * r), z: bottom });
+    return points;
+};
+export const sectionOutline = (section, tool) => {
+    const R = tool.diameter / 2;
+    const bottom = section.hasFloor ? -FLOOR_BAND : 0;
+    const material = [];
+    if (section.kind === 'face') {
+        // The feature is the floor: stock under it across the whole drawing, and
+        // whatever stands around it either side, from the reach curve.
+        const walls = [-1, 1].map((side) => {
+            const rise = staircase(section.curve, 0, 0, section.topAbove, REACH);
+            const points = rise.map((step) => ({ x: exact(side * (R + step.s)), z: exact(step.z) }));
+            return { side, points, far: points[points.length - 1].x };
+        });
+        const left = walls[0].far;
+        const right = walls[1].far;
+        material.push([
+            { x: left, z: 0 },
+            { x: right, z: 0 },
+            { x: right, z: bottom },
+            { x: left, z: bottom },
+        ]);
+        for (const wall of walls) {
+            if (wall.points.some((point) => point.z > 0)) {
+                material.push([{ x: exact(wall.side * R), z: 0 }, ...wall.points, { x: wall.far, z: 0 }]);
+            }
+        }
+        return {
+            material,
+            floor: { from: left, to: right },
+            leftWall: null,
+            rightWall: null,
+            extent: {
+                left,
+                right,
+                top: Math.max(0, ...walls.flatMap((w) => w.points.map((p) => p.z))),
+                bottom,
+            },
+        };
+    }
+    const onAxis = section.kind === 'hole' && ON_AXIS.has(tool.form) && section.width !== null;
+    const leftWall = onAxis ? -(section.width ?? tool.diameter) / 2 : -R;
+    const width = section.width === null ? null : Math.max(section.width, tool.diameter);
+    const rightWall = section.kind === 'wall' || width === null ? null : onAxis ? width / 2 : leftWall + width;
+    // A drilled bottom: the walls stand on the cone's rim, the tip in its apex.
+    const coneRise = section.kind === 'hole' &&
+        section.hasFloor &&
+        section.coneDeg !== null &&
+        section.coneDeg < 180 &&
+        section.filletRadius <= 0
+        ? Math.abs(leftWall) / Math.tan(((section.coneDeg / 2) * Math.PI) / 180)
+        : 0;
+    const left = wallPolygon(leftWall, -1, section, -R, bottom, coneRise);
+    material.push(left);
+    const leftFar = left.find((p) => p.z === bottom).x;
+    let rightFar = leftWall + Math.max(width ?? 0, tool.diameter) + REACH * 2;
+    if (rightWall !== null) {
+        const right = wallPolygon(rightWall, 1, section, R, bottom, coneRise);
+        material.push(right);
+        rightFar = right.find((p) => p.z === bottom).x;
+    }
+    let floor = null;
+    if (section.hasFloor) {
+        const r = Math.max(0, Math.min(section.filletRadius, section.depth));
+        const from = leftWall + r;
+        const to = rightWall === null ? rightFar : rightWall - r;
+        if (coneRise > 0 && rightWall !== null) {
+            material.push([
+                { x: leftWall, z: exact(coneRise) },
+                { x: 0, z: 0 },
+                { x: rightWall, z: exact(coneRise) },
+                { x: rightWall, z: bottom },
+                { x: leftWall, z: bottom },
+            ]);
+        }
+        else {
+            material.push([
+                { x: from, z: 0 },
+                { x: to, z: 0 },
+                { x: to, z: bottom },
+                { x: from, z: bottom },
+            ]);
+        }
+        floor = { from, to };
+    }
+    const top = Math.max(...material.flatMap((polygon) => polygon.map((p) => p.z)));
+    return {
+        material,
+        floor,
+        leftWall,
+        rightWall,
+        extent: { left: leftFar, right: rightFar, top, bottom },
+    };
+};

package/dist/stickout.d.ts

@@ -0,0 +1,187 @@
+/**
+ * How far a tool stands out of whatever holds it — the one answer.
+ *
+ * **There used to be four.** The same question was worked out in four
+ * unconnected places, and they disagreed by a factor of two on an ordinary
+ * tool:
+ *
+ * | where                             | what it computed              | on a ⌀1 in end mill, `OAL` 5, `LCF` 1.25, `SFDM` 1 |
+ * | --------------------------------- | ----------------------------- | -------------------------------------------------- |
+ * | the clamping rule → `geometry.LBH` | `OAL − 3×SFDM`                | 2.000 in                                           |
+ * | the holding module's `max`         | `OAL − OAL×heldShare`         | 3.333 in                                           |
+ * | its `default` → the drawing        | flutes, floored and stepped   | 1.250 in                                           |
+ * | the hole-mode reach check          | read `geometry.LBH` as a ceiling | 2.000 in                                        |
+ *
+ * The details table printed the first and the drawing beside it drew the third,
+ * so a dimension line for `LBH` ran up past the holder nose and into the holder
+ * body. Neither of the first two consulted the other, and the two knobs behind
+ * them — a minimum clamping length (a length of **shank**) and a good hold (a
+ * share of the **overall length**) — were combined nowhere.
+ *
+ * **That bug is the single strongest argument for this package existing.** It
+ * was fixed inside one application, which left the next consumer of a tool
+ * catalog and a tool drawing to reproduce it from scratch: the quantity is a
+ * pure function of the tool, the collet and a shop's policy, and it had no home
+ * until this one.
+ *
+ * So this module owns the quantity outright and every other number is this same
+ * function with more arguments:
+ *
+ * ```
+ * geometry.LBH      ≡ stickoutRange(tool).setup                       — no holder, no feature
+ * Assembly.stickout ≡ stickoutRange(tool, { grip, required }).setup
+ * the ceiling       ≡ stickoutRange(tool, …).max
+ * ```
+ *
+ * `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 rather
+ * than this sentence.
+ *
+ * **`LBH` is the setup length, not the ceiling.** The "below holder" column
+ * answers what a machinist would set the tool up at; the most it *could* stand
+ * out is {@link StickoutRange.max}, which is checked and reported but is not
+ * the column. What makes that reading workable is that the floor and the step
+ * reach it — {@link DEFAULT_STICKOUT_POLICY} carries `least` and `step`, and an
+ * earlier default carried zero for both and so produced the bare flute length.
+ */
+import { type ClampingRule } from './clamping.js';
+import type { Geometry } from './geometry.js';
+import type { UnitSystem } from './units.js';
+/**
+ * What this module needs of a tool: its geometry, and which unit system its
+ * step is counted in.
+ *
+ * Deliberately narrower than a whole {@link Tool} so a build can ask before a
+ * tool is finished being built, and so nothing here can reach for a catalog
+ * number or a vendor.
+ */
+export interface StickoutTool {
+    readonly geometry: Geometry;
+    readonly unitSystem: UnitSystem;
+}
+/**
+ * The share of a tool's overall length a holder must always have hold of.
+ *
+ * A third. **A shop's figure, not a vendor's** — no vendor in the scraped
+ * catalog publishes a minimum engagement — which is why it is named here and
+ * every control that shows it should say whose it is. Deliberately a share of
+ * the length and not a multiple of the shank diameter: how much of a tool a
+ * collet needs is about the tool's leverage, not its shank. That other reading
+ * is {@link ClampingRule}, and both are honoured — see {@link StickoutLimit}.
+ */
+export declare const HELD_SHARE: number;
+/**
+ * How the setup stickout is set.
+ *
+ * Nobody sets a tool up 6 mm out, so the stickout stands out at least `least`
+ * (half an inch) where the tool's length allows, and lands on a round number —
+ * the `step` for the tool's unit system (an eighth of an inch, or 3 mm) nearest
+ * what the holder needs, never under it.
+ */
+export interface StickoutPolicy {
+    /** Share of the overall length that must stay in the holder. */
+    readonly heldShare: number;
+    /** The shortest stickout worth setting up, mm; zero for none. */
+    readonly least: number;
+    /**
+     * The increment the setup lands on, mm, by the tool's unit system; zero for
+     * none.
+     *
+     * Keyed by {@link UnitSystem} rather than by a pair of its own, so a policy
+     * cannot name a system this package does not have.
+     */
+    readonly step: Readonly<Record<UnitSystem, number>>;
+}
+/** What a dataset is built with, and what a page starts at. */
+export declare const DEFAULT_STICKOUT_POLICY: StickoutPolicy;
+/**
+ * Which rule set the ceiling, so a control can say why rather than showing a
+ * number nobody can trace.
+ *
+ * `clamp` is the shop's clamping length, or the vendor's own `LSCN`; `hold` is
+ * {@link HELD_SHARE}; `collet` is the collet's published grip. They used to be
+ * a ceiling each in a different file; here they are three caps and the tightest
+ * wins.
+ */
+export type StickoutLimit = 'clamp' | 'hold' | 'collet';
+export interface StickoutRange {
+    /** Shortest, mm: the flutes out of the collet, or the neck where there is one. */
+    readonly min: number;
+    /**
+     * The length to set the tool up at, mm: the least that works for this
+     * feature, floored and stepped by the policy, held under {@link max}.
+     *
+     * This is `geometry.LBH` when asked with no holder and no feature, and an
+     * assembly's stickout when asked with both.
+     */
+    readonly setup: number;
+    /**
+     * Longest, mm: the tightest of the three caps, and never under {@link min} —
+     * a tool that cannot meet the rule at any depth is gripped as short as the
+     * grip allows and {@link gripShort} says so. Null where the tool states no
+     * overall length, which is an unbounded range rather than a bound of nothing.
+     */
+    readonly max: number | null;
+    /** Which cap {@link max} came from, or null where nothing capped it. */
+    readonly limitedBy: StickoutLimit | null;
+    /** The parallel shank behind {@link min}, mm: all a holder can ever grip. */
+    readonly grip: number | null;
+    /** How much of the tool the tightest cap asks to keep in the holder, mm. */
+    readonly wantedGrip: number | null;
+    /**
+     * True when the rule cannot be met at any depth: the range collapses onto
+     * {@link min}, and a control should say why rather than refuse.
+     */
+    readonly gripShort: boolean;
+}
+export interface StickoutRequest {
+    /**
+     * How much shank the holder actually grips, mm — a collet's published grip
+     * length. Null where the vendor does not publish one, which REGO-FIX's
+     * powRgrip line does not, and null for a bore or shrink holder, whose grip
+     * this package does not carry.
+     *
+     * **A length rather than a {@link Collet}**, so this module depends on
+     * nothing in `holding.ts` and the two cannot form a cycle. `stickoutLimits`
+     * there is the collet-shaped way in.
+     */
+    readonly grip?: number | null;
+    /** What the holder needs to clear the part, mm, from the sweep. */
+    readonly required?: number | null;
+    /** What the shop keeps clamped. */
+    readonly rule?: ClampingRule;
+    /** The floor, step and hold share. */
+    readonly policy?: StickoutPolicy;
+}
+/**
+ * The least a tool can stand out: its flutes, or its neck where it has one.
+ *
+ * The collet face sits at the end of the flutes, and a stated neck — which a
+ * collet must not close on — pushes it back to the shoulder. A tool that states
+ * no flute length has no known head, so it has no known stickout at all and
+ * this answers `null`; it carries no `LBH` either, rather than one derived from
+ * `OAL` and `SFDM` alone.
+ */
+export declare const minStickout: (tool: StickoutTool) => number | null;
+/**
+ * Every stickout this tool has, in one answer.
+ *
+ * `null` only when the tool states no flute length, because then nothing about
+ * where it stands out of a holder can be worked out at all.
+ */
+export declare const stickoutRange: (tool: StickoutTool, request?: StickoutRequest) => StickoutRange | null;
+/**
+ * What this tool would be set up at on its own: no holder chosen and no feature
+ * to reach. This is `geometry.LBH`, and a build writes it with exactly this
+ * call.
+ */
+export declare const setupStickout: (tool: StickoutTool, rule?: ClampingRule, policy?: StickoutPolicy) => number | null;
+/**
+ * The furthest this tool can ever stand out of a holder, mm.
+ *
+ * **A reach check's number, not `LBH`.** A tap that will not reach the bottom of
+ * a hole at its setup length may reach it pulled further out, and asking `LBH` —
+ * which is the setup — would refuse it. Anything asking "could this tool get
+ * down there at all" asks this.
+ */
+export declare const stickoutCeiling: (tool: StickoutTool, rule?: ClampingRule, policy?: StickoutPolicy) => number | null;