@toolpath/tool-scraper 2.4.0 → 2.5.0

package/README.md

@@ -69,6 +69,7 @@ version.
 export TOOLPATH_SCRAPE_ROOT=~/toolpath-scrapes      # default: ./scrape-out, gitignored
 
 toolpath-scrape kennametal 100003658 "$TOOLPATH_SCRAPE_ROOT/kennametal/csv/godrill_3xd_metric.csv"
+toolpath-scrape kennametal --collets                 # every ER collet family, and which CSV claims it
 toolpath-scrape materials godrill_3xd_metric.csv
 toolpath-scrape regofix holders "$TOOLPATH_SCRAPE_ROOT/regofix/csv/regofix_bt30_pg_holders.csv"
 toolpath-scrape destinytool "$TOOLPATH_SCRAPE_ROOT/destinytool/csv/destinytool_end_mills_inch.csv"

package/dist/families/kennametal.d.ts

@@ -757,15 +757,169 @@ export declare 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 declare const COLLET_FAMILIES: {
     readonly 'er_standard_collets_metric.csv': {
         readonly catalogName: "Kennametal ER Standard Collets Metric";
         readonly rows: 110;
+        readonly familyCode: "100000478";
         readonly facts: {
             readonly style: {
                 readonly value: "er-standard";
                 readonly source: "vendor-stated";
-                readonly cite: "the family is Kennametal's plain ER collet line";
+                readonly cite: "the vendor's category is 'ER Collets / ER Standard Collets'; the family publishes a CCCN-CCCX capacity band and no square";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er_standard_collets_inch.csv': {
+        readonly catalogName: "Kennametal ER Standard Collets Inch";
+        readonly rows: 98;
+        readonly familyCode: "100000479";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-standard";
+                readonly source: "vendor-stated";
+                readonly cite: "the vendor's category is 'ER Collets / ER Standard Collets'; the family publishes a CCCN-CCCX capacity band and no square";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er11_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER11 Collets Coolant-Through Metric";
+        readonly rows: 5;
+        readonly familyCode: "109333979";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er16_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER16 Collets Coolant-Through Metric";
+        readonly rows: 8;
+        readonly familyCode: "109333976";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er20_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER20 Collets Coolant-Through Metric";
+        readonly rows: 11;
+        readonly familyCode: "109333973";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er25_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER25 Collets Coolant-Through Metric";
+        readonly rows: 11;
+        readonly familyCode: "109333627";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er32_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER32 Collets Coolant-Through Metric";
+        readonly rows: 15;
+        readonly familyCode: "109333626";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er40_collets_coolant_through_metric.csv': {
+        readonly catalogName: "Kennametal ER40 Collets Coolant-Through Metric";
+        readonly rows: 19;
+        readonly familyCode: "109321468";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
             };
             readonly unit: {
                 readonly value: "millimeters";
@@ -774,14 +928,32 @@ export declare const COLLET_FAMILIES: {
             };
         };
     };
+    readonly 'er11_collets_coolant_through_inch.csv': {
+        readonly catalogName: "Kennametal ER11 Collets Coolant-Through Inch";
+        readonly rows: 4;
+        readonly familyCode: "109333978";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
     readonly 'er16_collets_coolant_through_inch.csv': {
         readonly catalogName: "Kennametal ER16 Collets Coolant-Through Inch";
         readonly rows: 10;
+        readonly familyCode: "109333975";
         readonly facts: {
             readonly style: {
                 readonly value: "er-sealed";
                 readonly source: "vendor-stated";
-                readonly cite: "CCCX == CCCN == D1 on every row; Kennametal specs an H6 shank, so it clamps one exact size";
+                readonly 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";
             };
             readonly unit: {
                 readonly value: "inches";
@@ -790,4 +962,106 @@ export declare const COLLET_FAMILIES: {
             };
         };
     };
+    readonly 'er20_collets_coolant_through_inch.csv': {
+        readonly catalogName: "Kennametal ER20 Collets Coolant-Through Inch";
+        readonly rows: 13;
+        readonly familyCode: "109333974";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er25_collets_coolant_through_inch.csv': {
+        readonly catalogName: "Kennametal ER25 Collets Coolant-Through Inch";
+        readonly rows: 14;
+        readonly familyCode: "109333628";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er32_collets_coolant_through_inch.csv': {
+        readonly catalogName: "Kennametal ER32 Collets Coolant-Through Inch";
+        readonly rows: 17;
+        readonly familyCode: "109333625";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er40_collets_coolant_through_inch.csv': {
+        readonly catalogName: "Kennametal ER40 Collets Coolant-Through Inch";
+        readonly rows: 12;
+        readonly familyCode: "109321469";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-sealed";
+                readonly source: "vendor-stated";
+                readonly 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";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er_tap_collets_ansi.csv': {
+        readonly catalogName: "Kennametal ER Standard Tap Collets ANSI";
+        readonly rows: 47;
+        readonly familyCode: "100000434";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-tap";
+                readonly source: "vendor-stated";
+                readonly cite: "the vendor's category is 'ER Collets / ER Tap Collets'; every row publishes an S10 square size and no capacity band";
+            };
+            readonly unit: {
+                readonly value: "inches";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
+    readonly 'er_tap_collets_din_iso.csv': {
+        readonly catalogName: "Kennametal ER Standard Tap Collets DIN and ISO";
+        readonly rows: 49;
+        readonly familyCode: "100000435";
+        readonly facts: {
+            readonly style: {
+                readonly value: "er-tap";
+                readonly source: "vendor-stated";
+                readonly cite: "the vendor's category is 'ER Collets / ER Tap Collets'; every row publishes an S10 square size and no capacity band";
+            };
+            readonly unit: {
+                readonly value: "millimeters";
+                readonly source: "vendor-stated";
+                readonly cite: "the family is titled and catalogued in this system; both unit columns are usually published, so this decides which is displayed";
+            };
+        };
+    };
 };

package/dist/families/kennametal.js

@@ -139,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',
@@ -673,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/family.d.ts

@@ -128,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 {};