@toolpath/tool-scraper 2.3.0 → 2.5.0

package/dist/families/kennametal.js

@@ -73,6 +73,40 @@ const NO_COOLANT_THROUGH_TAP = {
     checked: '2026-08-29',
     by: 'JG',
 };
+/**
+ * The tap-type facet, and what it settles.
+ *
+ * **The variant table does not carry it.** All three tap families publish
+ * `D1-TDZ`, `Thread Tolerance Class ANSI`, `Tap Pitch Diameter Limit` and
+ * `Type of Thread` — the thread's *class*, never how it is produced. What does
+ * carry it is the vendor's own `newTapType` Solr facet, and it narrows the same
+ * `.variants.<code>.html` endpoint `vendors/kennametal/scrape.ts` already
+ * calls: `scrape.ACTIVE_ONLY` is one facet on that query and this is a second,
+ * exactly as `vendors/kennametal/materials.ts` appends one.
+ *
+ * Its vocabulary, read off the threading category listing on 2026-09-07, is
+ * `2-Hand Tap`, `3-Forming Tap`, `8-Spiral Flute Tap`, `10-Pipe Tap`,
+ * `11-Spiral Point Tap` and `13-Straight Flute Tap`. Exactly one of the six is
+ * a forming tap; the other five cut. So a family that answers any value but
+ * `3-Forming Tap` is a cutting family, and each of the three below was probed
+ * for its own value **and** for `3-Forming Tap`, which returned the vendor's
+ * no-results notice every time.
+ *
+ * That is why these are `vendor-stated` and not `assumed`: the cite is a query
+ * anybody can re-run, and the *negative* half of it is the part that matters.
+ * A `cite` naming only the CSV's own filename would be this table reading its
+ * own name back to itself.
+ */
+const SPIRAL_POINT_TAP = {
+    value: 'cutting',
+    source: 'vendor-stated',
+    cite: "the vendor's own `newTapType` facet on the variants endpoint: every row of this family answers `:relevance:obsoleteFacet:false:newTapType:11-Spiral Point Tap`, and `3-Forming Tap` — the one forming value of the six — returns the no-results notice (JG 2026-09-07)",
+};
+const HAND_TAP = {
+    value: 'cutting',
+    source: 'vendor-stated',
+    cite: 'the same `newTapType` facet: every row of this family answers `2-Hand Tap`, and `3-Forming Tap`, `8-Spiral Flute Tap`, `10-Pipe Tap` and `11-Spiral Point Tap` each return the no-results notice (JG 2026-09-07)',
+};
 const HSS_ASSUMED = {
     value: 'hss',
     source: 'assumed',
@@ -105,6 +139,51 @@ const ER_COLLET_CHUCK = {
     source: 'vendor-stated',
     cite: 'breadcrumb ".../ER Collet Chucks/ER(tm) Collet Adapter -BT30"',
 };
+/**
+ * The three ER collet styles, each stated once for the families that share it.
+ *
+ * `style` is the finer axis beside a holder's `clamping`, and here it is what
+ * tells a consumer which kind of collet it is holding. All three are
+ * Kennametal's own product lines, read off the collet category tree — see
+ * `vendors/kennametal/catalog.ts`, which is what enumerates them.
+ */
+const ER_STANDARD = {
+    value: 'er-standard',
+    source: 'vendor-stated',
+    cite: "the vendor's category is 'ER Collets / ER Standard Collets'; the family publishes a CCCN-CCCX capacity band and no square",
+};
+/**
+ * Sealed coolant-through collets. `style` separates them from the standard ones
+ * because they behave differently in a way the numbers show but a label should
+ * not hide: `CCCX == CCCN` on every row, so each clamps one exact size rather
+ * than a 1 mm band.
+ *
+ * No special case is needed anywhere — a zero-width range is still a range —
+ * but a user choosing one deserves to be told which kind it is.
+ *
+ * **The ER40 inch line is designated larger than it clamps**, and that is the
+ * vendor's own statement rather than a rounding: `40ERSS1000` is named for one
+ * inch and publishes a capacity of 0.9938 in / 25.243 mm against a `D1` of
+ * 1.0 in / 25.4 mm — both figures agree across both unit columns. Ten of its
+ * twelve rows do this, up to 0.193 mm on `40ERSS0812`. `holding.NOMINAL_SLACK`
+ * is the gate that lets a designation sit outside the size it measures, and
+ * those rows are where its bound comes from.
+ */
+const ER_SEALED = {
+    value: 'er-sealed',
+    source: 'vendor-stated',
+    cite: "the vendor's category is 'ER Collets / ER Coolant Through Collets'; CCCX == CCCN == D1 on all 139 rows of the twelve families, and Kennametal specs an H6 shank, so each clamps one exact size",
+};
+/**
+ * Tap collets. The square drive is the fact that matters and it is scraped
+ * rather than declared — `holding.ColletRecord.squareSize` — so this is the
+ * label and not the discriminant.
+ */
+const ER_TAP = {
+    value: 'er-tap',
+    source: 'vendor-stated',
+    cite: "the vendor's category is 'ER Collets / ER Tap Collets'; every row publishes an S10 square size and no capacity band",
+};
 const METRIC_CATALOG = {
     value: 'millimeters',
     source: 'vendor-stated',
@@ -307,6 +386,7 @@ export const FAMILIES = {
         facts: {
             bmc: HSS_ASSUMED,
             coolantThrough: NO_COOLANT_THROUGH_TAP,
+            threadMethod: SPIRAL_POINT_TAP,
         },
     },
     'khsst_hand_metric_plug.csv': {
@@ -318,6 +398,7 @@ export const FAMILIES = {
         facts: {
             bmc: HSS_ASSUMED,
             coolantThrough: NO_COOLANT_THROUGH_TAP,
+            threadMethod: HAND_TAP,
         },
     },
     'spiral_point_metric_plug.csv': {
@@ -329,6 +410,7 @@ export const FAMILIES = {
         facts: {
             bmc: HSS_ASSUMED,
             coolantThrough: NO_COOLANT_THROUGH_TAP,
+            threadMethod: SPIRAL_POINT_TAP,
         },
     },
     'gomill_pro_radiused_4fl_necked_metric.csv': {
@@ -636,35 +718,152 @@ export const HOLDER_FAMILIES = {
         },
     },
 };
+/**
+ * ER collets, one entry per vendor family.
+ *
+ * **One entry per vendor family and not one per style.** Kennametal codes the
+ * coolant-through line as twelve families — one per series per unit — and their
+ * column shapes genuinely differ: the inch half publishes `LF` and `L`, the
+ * metric half publishes `L9` instead, and only `109321468` publishes both.
+ * Merging them into two CSVs would also destroy `ToolholdingDefinition.rows`,
+ * which is a per-family restatement and the only independent check that a
+ * re-scrape did not lose parts.
+ *
+ * Every `familyCode` here came out of `kennametal --collets`, which is what
+ * `vendors/kennametal/catalog.ts` exists for. The row counts are that walk's
+ * own per-family totals, and each category's parts sum to them exactly —
+ * 117 + 107 = 224 standard, 75 + 74 = 149 coolant-through, 47 + 49 = 96 tap.
+ *
+ * ## The four kit families are deliberately absent
+ *
+ * `100000428`, `100000425`, `109433662` and `109433658` — 26 parts — publish
+ * `Kit Series`, `Number-Kit Items`, `Dimension Range-Kit Items` and
+ * `Incremental Division-Kit Items`, and no `D1`, no capacity and no length. A
+ * kit is a purchasing unit whose contents are already the per-part families
+ * below, and minting one into a `holding.ColletRecord` would mean deriving a
+ * capacity band from a range string — authoring tool data, which this package
+ * does not do. `kennametal --collets` lists them every run, so they stay
+ * visible rather than forgotten.
+ *
+ * ## ER8 fits nothing in this catalog
+ *
+ * Nine of the 110 standard metric collets are ER8, and no BT30 ER8 adapter is
+ * configured. They are scraped anyway: `holding.HolderRecord.colletSeries`
+ * states the direction — a collet nothing takes costs an option, and a collet
+ * offered for a holder it does not fit costs a machinist a purchase.
+ */
 export const COLLET_FAMILIES = {
+    // ── ER standard collets (JG 2026-09-08) ──────────────────────────────────
     'er_standard_collets_metric.csv': {
         catalogName: 'Kennametal ER Standard Collets Metric',
         rows: 110,
-        facts: {
-            style: {
-                value: 'er-standard',
-                source: 'vendor-stated',
-                cite: "the family is Kennametal's plain ER collet line",
-            },
-            unit: METRIC_CATALOG,
-        },
+        familyCode: '100000478',
+        facts: { style: ER_STANDARD, unit: METRIC_CATALOG },
+    },
+    'er_standard_collets_inch.csv': {
+        catalogName: 'Kennametal ER Standard Collets Inch',
+        rows: 98,
+        familyCode: '100000479',
+        facts: { style: ER_STANDARD, unit: INCH_CATALOG },
+    },
+    // ── ER coolant-through collets (JG 2026-09-08) ───────────────────────────
+    // Twelve families, one per series per unit. `ER8` has no coolant-through
+    // line; `ER11` upward do.
+    'er11_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER11 Collets Coolant-Through Metric',
+        rows: 5,
+        familyCode: '109333979',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er16_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER16 Collets Coolant-Through Metric',
+        rows: 8,
+        familyCode: '109333976',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er20_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER20 Collets Coolant-Through Metric',
+        rows: 11,
+        familyCode: '109333973',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er25_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER25 Collets Coolant-Through Metric',
+        rows: 11,
+        familyCode: '109333627',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er32_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER32 Collets Coolant-Through Metric',
+        rows: 15,
+        familyCode: '109333626',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er40_collets_coolant_through_metric.csv': {
+        catalogName: 'Kennametal ER40 Collets Coolant-Through Metric',
+        rows: 19,
+        familyCode: '109321468',
+        facts: { style: ER_SEALED, unit: METRIC_CATALOG },
+    },
+    'er11_collets_coolant_through_inch.csv': {
+        catalogName: 'Kennametal ER11 Collets Coolant-Through Inch',
+        rows: 4,
+        familyCode: '109333978',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
     },
-    // Sealed coolant-through collets. `style` separates them from the standard
-    // ones because they behave differently in a way the numbers alone show but
-    // a label should not hide: CCCX == CCCN on every row, so each clamps one
-    // exact size (Kennametal specs H6 shank tolerance) rather than a 1 mm band.
-    // No special case is needed anywhere — a zero-width range is still a range
-    // — but a user choosing one deserves to be told which kind it is.
     'er16_collets_coolant_through_inch.csv': {
         catalogName: 'Kennametal ER16 Collets Coolant-Through Inch',
         rows: 10,
-        facts: {
-            style: {
-                value: 'er-sealed',
-                source: 'vendor-stated',
-                cite: 'CCCX == CCCN == D1 on every row; Kennametal specs an H6 shank, so it clamps one exact size',
-            },
-            unit: INCH_CATALOG,
-        },
+        familyCode: '109333975',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
+    },
+    'er20_collets_coolant_through_inch.csv': {
+        catalogName: 'Kennametal ER20 Collets Coolant-Through Inch',
+        rows: 13,
+        familyCode: '109333974',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
+    },
+    'er25_collets_coolant_through_inch.csv': {
+        catalogName: 'Kennametal ER25 Collets Coolant-Through Inch',
+        rows: 14,
+        familyCode: '109333628',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
+    },
+    'er32_collets_coolant_through_inch.csv': {
+        catalogName: 'Kennametal ER32 Collets Coolant-Through Inch',
+        rows: 17,
+        familyCode: '109333625',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
+    },
+    'er40_collets_coolant_through_inch.csv': {
+        catalogName: 'Kennametal ER40 Collets Coolant-Through Inch',
+        rows: 12,
+        familyCode: '109321469',
+        facts: { style: ER_SEALED, unit: INCH_CATALOG },
+    },
+    // ── ER tap collets (JG 2026-09-08) ───────────────────────────────────────
+    // Two families, split by thread system rather than by series: each holds
+    // ER16 through ER40. Neither publishes `CCCN`/`CCCX` at all — see
+    // `vendors/kennametal/holding.ts`'s `colletCapacity` for why that is a
+    // zero-width band at `D1` rather than an incomplete row.
+    //
+    // **`unit` is decided by which column carries the exact value**, the same
+    // test the TT HPV split above uses. `100000434` publishes `16ERTC10`'s `D1`
+    // as 0.194 in and 4.928 mm — 0.194 in is the ANSI shank of a #10 tap, and
+    // 4.928 is it rounded — while `100000435` publishes `16ERTC045034M`'s as
+    // 4.5 mm and 0.1772 in. So the ANSI family is inch-native and the DIN/ISO
+    // one metric-native, which also decides which of the two `Tap Range` columns
+    // a record carries: `#14 & 1/4` on one, `M6 & M6.3` on the other.
+    'er_tap_collets_ansi.csv': {
+        catalogName: 'Kennametal ER Standard Tap Collets ANSI',
+        rows: 47,
+        familyCode: '100000434',
+        facts: { style: ER_TAP, unit: INCH_CATALOG },
+    },
+    'er_tap_collets_din_iso.csv': {
+        catalogName: 'Kennametal ER Standard Tap Collets DIN and ISO',
+        rows: 49,
+        familyCode: '100000435',
+        facts: { style: ER_TAP, unit: METRIC_CATALOG },
     },
 };

package/dist/families/maritool.d.ts

@@ -46,6 +46,37 @@
  *
  * ## What is not scraped
  *
+ * **The taps are not scraped, and the evidence for when they are is here.**
+ * MariTool sells taps under `c78_148`, and its tree already answers the one
+ * question a tap record needs that no vendor of ours states in a column —
+ * whether the tap cuts its thread or forms it. Only the forming branch carries
+ * the word, so the leaf name settles it (JG 2026-09-07):
+ *
+ * | Leaf                    | cPath              | Method    |
+ * | ----------------------- | ------------------ | --------- |
+ * | Thread Forming Taps     | `78_148_274`       | `forming` |
+ * | — Plug Form Tap         | `78_148_274_275`   | `forming` |
+ * | — Bottoming Form Tap    | `78_148_274_276`   | `forming` |
+ * | Spiral Flute Taps       | `78_148_149`       | `cutting` |
+ * | Spiral Point Taps       | `78_148_224`       | `cutting` |
+ * | Taps for Aluminum       | `78_148_271`       | `cutting` |
+ * | Taper Pipe Taps         | `78_148_283`       | `cutting` |
+ * | DIN Length HPT Taps     | `78_148_284`       | `cutting` |
+ *
+ * **Checked into a table when it is built, not run as a filter**, for the
+ * reason the ER leaves above already give: a rule matching a name drops
+ * silently when the vendor renames a category, and three leaves here are
+ * already named something other than what they hold. `maritool --catalog` walks
+ * the tree, which is how the rule gets re-checked rather than trusted.
+ *
+ * **What still has to be decided before a tap family lands.** A MariTool tap
+ * page publishes `Shank Size`, `Total Length`, `Thread Length` and `Size` —
+ * enough for `SFDM`, `OAL`, `LCF` and a designation `thread.ts` can already
+ * parse — but a metric tap states `Size: M3` and `Pitch Diameter: 0.5` against
+ * a body in inches (`Shank Size: 0.141`, `Total Length: 1 15/16`). No family in
+ * this package is mixed that way and `ToolRecord.unit` is one value, so that is
+ * a decision on its own merits and not a widening of this table.
+ *
  * **BT50 and ISO30 produce no CSV.** MariTool's only BT50 category is end mill
  * holders, which is out of scope; ISO30 has three ER parts and none of them
  * publishes a spec table, so the family would be a receipt of nothing.

package/dist/families/maritool.js

@@ -46,6 +46,37 @@
  *
  * ## What is not scraped
  *
+ * **The taps are not scraped, and the evidence for when they are is here.**
+ * MariTool sells taps under `c78_148`, and its tree already answers the one
+ * question a tap record needs that no vendor of ours states in a column —
+ * whether the tap cuts its thread or forms it. Only the forming branch carries
+ * the word, so the leaf name settles it (JG 2026-09-07):
+ *
+ * | Leaf                    | cPath              | Method    |
+ * | ----------------------- | ------------------ | --------- |
+ * | Thread Forming Taps     | `78_148_274`       | `forming` |
+ * | — Plug Form Tap         | `78_148_274_275`   | `forming` |
+ * | — Bottoming Form Tap    | `78_148_274_276`   | `forming` |
+ * | Spiral Flute Taps       | `78_148_149`       | `cutting` |
+ * | Spiral Point Taps       | `78_148_224`       | `cutting` |
+ * | Taps for Aluminum       | `78_148_271`       | `cutting` |
+ * | Taper Pipe Taps         | `78_148_283`       | `cutting` |
+ * | DIN Length HPT Taps     | `78_148_284`       | `cutting` |
+ *
+ * **Checked into a table when it is built, not run as a filter**, for the
+ * reason the ER leaves above already give: a rule matching a name drops
+ * silently when the vendor renames a category, and three leaves here are
+ * already named something other than what they hold. `maritool --catalog` walks
+ * the tree, which is how the rule gets re-checked rather than trusted.
+ *
+ * **What still has to be decided before a tap family lands.** A MariTool tap
+ * page publishes `Shank Size`, `Total Length`, `Thread Length` and `Size` —
+ * enough for `SFDM`, `OAL`, `LCF` and a designation `thread.ts` can already
+ * parse — but a metric tap states `Size: M3` and `Pitch Diameter: 0.5` against
+ * a body in inches (`Shank Size: 0.141`, `Total Length: 1 15/16`). No family in
+ * this package is mixed that way and `ToolRecord.unit` is one value, so that is
+ * a decision on its own merits and not a widening of this table.
+ *
  * **BT50 and ISO30 produce no CSV.** MariTool's only BT50 category is end mill
  * holders, which is out of scope; ISO30 has three ER parts and none of them
  * publishes a spec table, so the family would be a receipt of nothing.

package/dist/family.d.ts

@@ -20,12 +20,12 @@ import type { UnitSystem } from './conventions.js';
 import type { BrandName } from './identity.js';
 import type { HoldingMapper, ToolholdingKind } from './holding.js';
 import type { Fact } from './provenance.js';
-import type { ColumnMap, ToolKind, ToolRecord } from './records.js';
+import type { ColumnMap, ThreadMethod, ToolKind, ToolRecord } from './records.js';
 import type { MapperOptions, ScrapedRow } from './scrape.js';
 /**
  * The per-family constants a fact can carry, and their types.
  *
- * Eleven keys, which is the whole vocabulary the catalog uses. Naming them rather
+ * Twelve keys, which is the whole vocabulary the catalog uses. Naming them rather
  * than accepting any string is what lets a mapper read `family.coolantThrough`
  * as a `boolean` instead of casting an `unknown` out of a bag — and what makes
  * a fact whose value is the wrong type a compile error where the family is
@@ -49,6 +49,20 @@ export interface FamilyFacts {
      */
     profile?: string;
     coolantThrough?: boolean;
+    /**
+     * How a tap makes its thread — `cutting` or `forming`.
+     *
+     * A fact and not a column because neither vendor publishes it per part: it is
+     * Kennametal's `newTapType` facet, which the variant table does not carry,
+     * and EMUGE's category, which partitions its taps into two. Every declaration
+     * in `families/` cites the index it was read off, and each is one value for a
+     * whole family — checked against the vendor rather than assumed, which is why
+     * they are `vendor-stated`.
+     *
+     * Every `kind: 'tap'` family must state it: `tapRecord` reads it through
+     * {@link fact}, and `records.toolRecord` refuses a tap record without one.
+     */
+    threadMethod?: ThreadMethod;
     flutes?: number;
     /** Degrees included. */
     pointAngle?: number;
@@ -114,6 +128,18 @@ export interface FamilyDefinition extends CommonDefinition {
 export interface ToolholdingDefinition extends CommonDefinition {
     /** What a human calls this family. Holders and collets have no `id`. */
     readonly catalogName: string;
+    /**
+     * The vendor's own code for the family, where the scrape target is a family
+     * page — {@link FamilyDefinition.familyCode}'s counterpart.
+     *
+     * Absent where the vendor has no such page: REGO-FIX and MariTool families
+     * are a set of index filters and name none. It was absent on Kennametal's
+     * toolholding too until 2026-09-08, because those families were scraped by
+     * hand from a code read off the page at the time — which made a re-scrape a
+     * trip back to the browser. Recording it is what makes one re-runnable, and
+     * it is what `kennametal --collets` reconciles its walk against.
+     */
+    readonly familyCode?: string;
 }
 /** A cutting-tool family after {@link FamilyDefinition} has been validated. */
 export type BoundFamily = Omit<FamilyDefinition, 'columns'> & FamilyFacts & {

package/dist/holding.d.ts

@@ -211,6 +211,41 @@ export interface ColletRecord extends HoldingIdentity {
     readonly functionalLength: number | null;
     /** `L` — overall length. */
     readonly overallLength: number | null;
+    /**
+     * `L9` — how deep the clamping bore is, and therefore how much shank the
+     * collet actually holds.
+     *
+     * Twinned in millimetres because it is **compared and not only displayed**:
+     * it is `@toolpath/tool-support`'s `Collet.clampLength`, the one input to
+     * `maxStickout`, which answers `null` for every collet without it. That is
+     * the rule this module states for `bore`, `gaugeLength` and the capacity
+     * pair, and this is the fourth dimension to earn it.
+     *
+     * Not a second overall length. Kennametal's `109321468` publishes both: `L`
+     * is 46 mm down all nineteen ER40 rows while `L9` runs 22 / 28 / 46 by size.
+     */
+    readonly clampingLength: number | null;
+    readonly clampingLengthMm: number | null;
+    /**
+     * The vendor's own designation of the taps this collet is for, verbatim —
+     * `"M6 & M6.3"`, `"#14 & 1/4"`.
+     *
+     * **Text, and deliberately not parsed.** It names two thread designations in
+     * the vendor's own words and this package does not author tool data; what a
+     * fit rule compares is {@link ColletRecord.clampMin}/{@link ColletRecord.clampMax},
+     * which are numbers. `null` on every collet whose vendor publishes none.
+     */
+    readonly tapRange: string | null;
+    /**
+     * `S10` — the square drive the bore carries, across flats.
+     *
+     * The fact that makes a tap collet a tap collet: its bore is not round, so
+     * the part it takes is a tap and nothing else. A shank test alone would say
+     * yes to an end mill of the same diameter, held by nothing —
+     * `@toolpath/tool-support`'s `holderTakesTool` reads this to refuse that.
+     * `null` where the vendor publishes no square, which is every round collet.
+     */
+    readonly squareSize: number | null;
 }
 /** Either toolholding record. Narrow on {@link HoldingIdentity.kind}. */
 export type HoldingRecord = HolderRecord | ColletRecord;
@@ -295,6 +330,29 @@ export declare function millimeters(value: number | null, unit: UnitSystem): num
  * for a machinist's number and refuses a range rather than summing it.
  */
 export declare function dim(row: ScrapedRow, label: string, unit: UnitSystem): number | null;
+/**
+ * How far a collet's *designation* may sit from its measured capacity, as a
+ * fraction of that capacity.
+ *
+ * {@link ColletRecord.nominal} is the size the vendor **designates** the collet
+ * by; {@link ColletRecord.clampMin}/{@link ColletRecord.clampMax} is what it
+ * measures. They are not two readings of one number, and on a sealed collet
+ * they are routinely different: Kennametal's `40ERSS1000` is designated 1 inch
+ * and clamps 0.9938, `40ERSS0500` is designated 1/2 and clamps 0.4943. Both
+ * unit columns agree on both figures — 25.4 against 25.243 mm, 12.7 against
+ * 12.556 — so this is the vendor stating an undersized capacity for a collet it
+ * names by the fraction, not a cell in the wrong column.
+ *
+ * **Relative rather than absolute, because the gap scales with the collet.**
+ * Across the 443-part collet corpus fourteen rows sit outside their own band.
+ * The widest is `40ERSS0812` at 0.193 mm, which is 0.94 % of its 20.4 mm
+ * capacity; the widest by fraction is `40ERSS0500` at 1.14 %. The error this
+ * must still refuse is a cell in the wrong unit system, which is 96 % out — the
+ * shape `16ERSS0312` has, where `D1`'s metric cell holds the inch value. This
+ * sits 4.4x above the first and 19x below the second. A row that lands in
+ * between is a finding to investigate rather than a number to widen.
+ */
+export declare const NOMINAL_SLACK = 0.05;
 /**
  * Report where a vendor's own millimetre and inch cells disagree.
  *
@@ -387,10 +445,10 @@ type HolderFields = Omit<HolderRecord, 'kind' | 'guid' | 'vendor' | 'productLink
  * mutated one would be reaching back across the seam this type exists to draw.
  */
 export declare function holderRecord(fields: HolderFields): HolderRecord;
-/** The same, for a collet. REGO-FIX publishes none of these four. */
-type OptionalColletFields = 'nominal' | 'bodyDiameter' | 'functionalLength' | 'overallLength';
+/** The same, for a collet. REGO-FIX publishes none of these seven. */
+type OptionalColletFields = 'nominal' | 'bodyDiameter' | 'functionalLength' | 'overallLength' | 'clampingLength' | 'tapRange' | 'squareSize';
 /** What a mapper supplies to build a collet. */
-type ColletFields = Omit<ColletRecord, 'kind' | 'guid' | 'vendor' | 'productLink' | 'clampMinMm' | 'clampMaxMm' | OptionalColletFields> & Partial<Pick<ColletRecord, OptionalColletFields>>;
+type ColletFields = Omit<ColletRecord, 'kind' | 'guid' | 'vendor' | 'productLink' | 'clampMinMm' | 'clampMaxMm' | 'clampingLengthMm' | OptionalColletFields> & Partial<Pick<ColletRecord, OptionalColletFields>>;
 /** Build a {@link ColletRecord}, on the same terms as {@link holderRecord}. */
 export declare function colletRecord(fields: ColletFields): ColletRecord;
 export {};

package/dist/holding.js

@@ -163,6 +163,29 @@ function halfUlp(raw) {
     const fraction = raw.includes('.') ? raw.slice(raw.indexOf('.') + 1) : '';
     return 0.5 * 10 ** -fraction.length;
 }
+/**
+ * How far a collet's *designation* may sit from its measured capacity, as a
+ * fraction of that capacity.
+ *
+ * {@link ColletRecord.nominal} is the size the vendor **designates** the collet
+ * by; {@link ColletRecord.clampMin}/{@link ColletRecord.clampMax} is what it
+ * measures. They are not two readings of one number, and on a sealed collet
+ * they are routinely different: Kennametal's `40ERSS1000` is designated 1 inch
+ * and clamps 0.9938, `40ERSS0500` is designated 1/2 and clamps 0.4943. Both
+ * unit columns agree on both figures — 25.4 against 25.243 mm, 12.7 against
+ * 12.556 — so this is the vendor stating an undersized capacity for a collet it
+ * names by the fraction, not a cell in the wrong column.
+ *
+ * **Relative rather than absolute, because the gap scales with the collet.**
+ * Across the 443-part collet corpus fourteen rows sit outside their own band.
+ * The widest is `40ERSS0812` at 0.193 mm, which is 0.94 % of its 20.4 mm
+ * capacity; the widest by fraction is `40ERSS0500` at 1.14 %. The error this
+ * must still refuse is a cell in the wrong unit system, which is 96 % out — the
+ * shape `16ERSS0312` has, where `D1`'s metric cell holds the inch value. This
+ * sits 4.4x above the first and 19x below the second. A row that lands in
+ * between is a finding to investigate rather than a number to widen.
+ */
+export const NOMINAL_SLACK = 0.05;
 /**
  * Report where a vendor's own millimetre and inch cells disagree.
  *
@@ -298,11 +321,25 @@ export function checkCollet(record) {
     // In the native unit, which is the gate with teeth: these are the values a
     // consumer compares, and the contradictory cells this catalog knows about all
     // sit in the column `dim` ignores.
+    //
+    // The slack is {@link NOMINAL_SLACK}, because a designation is not a
+    // measurement — see that constant for the fourteen rows it exists for and the
+    // margin either side of it. Unit-free, so it needs no conversion.
     if (record.nominal !== null &&
-        (record.nominal < record.clampMin || record.nominal > record.clampMax)) {
+        (record.nominal < record.clampMin * (1 - NOMINAL_SLACK) ||
+            record.nominal > record.clampMax * (1 + NOMINAL_SLACK))) {
         throw new VendorResponseError(what, `nominal ${record.nominal} is outside its own capacity ` +
             `${record.clampMin}-${record.clampMax}`);
     }
+    // A tap's square across flats is inscribed in its shank, so it is smaller
+    // than the bore that takes it — true on all 96 rows of both Kennametal tap
+    // families. A square at or past the clamping diameter is the inch cell in the
+    // metric column or two labels swapped, which is the failure `dim`'s native
+    // read cannot see and `checkUnitAgreement` only reports.
+    if (record.squareSize !== null && record.squareSize >= record.clampMax) {
+        throw new VendorResponseError(what, `square size ${record.squareSize} is not smaller than the ` +
+            `${record.clampMax} it clamps — a square is inscribed in the shank`);
+    }
 }
 /**
  * Build a {@link HolderRecord}: mint its guid, derive its millimetre twins, and
@@ -354,6 +391,10 @@ export function colletRecord(fields) {
         bodyDiameter: fields.bodyDiameter ?? null,
         functionalLength: fields.functionalLength ?? null,
         overallLength: fields.overallLength ?? null,
+        clampingLength: fields.clampingLength ?? null,
+        clampingLengthMm: millimeters(fields.clampingLength ?? null, fields.unit),
+        tapRange: fields.tapRange ?? null,
+        squareSize: fields.squareSize ?? null,
     });
     checkCollet(record);
     return record;

package/dist/identity.d.ts

@@ -75,7 +75,7 @@ export declare const BRANDS: {
         readonly host: "destinytool.com";
         readonly home: "https://destinytool.com";
         readonly vendor: "Destiny Tool";
-        readonly productLink: "https://destinytool.com/products?search={material}";
+        readonly productLink: "https://destinytool.com/products/{material}";
     };
     readonly harvey: {
         readonly host: "harveytool.com";

package/dist/identity.js

@@ -54,16 +54,13 @@ export const BRANDS = {
         productLink: 'https://us.rego-fix.com/en/productfinder?q={material}',
     },
     // Destiny Tool is a Next.js SPA with no product data in the HTML at all — it
-    // reads live from a Firestore database. Like REGO-FIX there is no per-part
-    // page to link to, only a client-rendered products list; unlike REGO-FIX's
-    // ProductFinder, nothing here has confirmed a search query parameter the SPA
-    // actually reads, so this is a best-effort link to the listing page rather
-    // than a verified deep link (JG 2026-08-19).
+    // reads live from a Firestore database. Its client-rendered product page is
+    // addressable by the vendor's item number in the path.
     destinytool: {
         host: 'destinytool.com',
         home: 'https://destinytool.com',
         vendor: 'Destiny Tool',
-        productLink: 'https://destinytool.com/products?search={material}',
+        productLink: 'https://destinytool.com/products/{material}',
     },
     // Harvey Tool is the first brand here whose per-part link is a real page the
     // vendor already publishes: every tool number in a product table is rendered