@toolpath/tool-scraper 2.1.0 → 2.3.0

package/dist/records.d.ts

@@ -42,9 +42,33 @@
  * always a copy is not a second measurement. An adapter that could supply them
  * separately could supply a tool that claims a holder it does not have.
  */
-import { type UnitSystem } from './conventions.js';
+import { type UnitSystem } from '@toolpath/tool-support';
 import { type BrandName } from './identity.js';
 import type { FactSource } from './provenance.js';
+/**
+ * One canonical geometry name: what it measures, and whose name it is.
+ *
+ * **Declared here rather than re-exported from `@toolpath/tool-support`**, even
+ * though the dictionary's entries are the shared ones. The shared
+ * `GeometryField` carries a required `unit` and is `readonly` throughout, and
+ * this type has been published since 1.0: adopting it outright would stop a
+ * consumer that builds one of these — `{ definition, iso }` — from compiling,
+ * for no gain the values below do not already give. The entries *satisfy* the
+ * shared shape, so a field renamed upstream is still a compile error here.
+ */
+export interface GeometryField {
+    /**
+     * What the field measures, phrased so it can be quoted back at whoever
+     * mapped a column to the wrong one.
+     */
+    definition: string;
+    /**
+     * The ISO 13399 code for this measurement, or `null` where the standard's
+     * counterpart has not been pinned against the dictionary. Equal to the
+     * canonical name itself on every field that *is* the standard's code.
+     */
+    iso: string | null;
+}
 /** The kinds of cutting tool this package maps. */
 export type ToolKind = 'drill' | 'tap' | 'endmill';
 /**
@@ -87,20 +111,6 @@ export declare const UNSPECIFIED = "unspecified";
  * type so that the vocabularies cannot drift apart.
  */
 export type MaterialGroupsSource = FactSource | typeof UNSPECIFIED;
-/** One canonical geometry name: what it measures, and whose name it is. */
-export interface GeometryField {
-    /**
-     * What the field measures, phrased so it can be quoted back at whoever
-     * mapped a column to the wrong one.
-     */
-    definition: string;
-    /**
-     * The ISO 13399 code for this measurement, or `null` where the standard's
-     * counterpart has not been pinned against the dictionary. Equal to the
-     * canonical name itself on every field that *is* the standard's code.
-     */
-    iso: string | null;
-}
 /**
  * Canonical geometry fields an adapter may supply, and what each means.
  *
@@ -109,6 +119,26 @@ export interface GeometryField {
  * so the vocabulary's source is readable from the code rather than from a plan
  * document.
  *
+ * ## What each entry says, and what this table says
+ *
+ * The definitions and ISO codes are `@toolpath/tool-support`'s — that is the
+ * dictionary, and it is shared because a code has to mean one thing in every
+ * package that reads one. **This is not that dictionary.** It is the narrower
+ * question only a scraper asks: which of those names an *adapter may map a
+ * vendor column to*.
+ *
+ * The two are not the same list and must not become one. The dictionary knows
+ * `LBH` and `LD`, which are derived from a tool and a holder downstream and
+ * which no vendor publishes; an adapter permitted to map a column to `LBH`
+ * could supply a tool that claims a stickout nobody set. It also knows `LSCN`,
+ * ISO's clamping-length minimum, which is a real vendor column the day a vendor
+ * prints one — and which is deliberately absent below until that day, because
+ * the load-time check's job is to refuse a name no scrape can fill.
+ *
+ * So each entry is an explicit pick out of the shared table rather than a
+ * spread of it: a name dropped from the dictionary is a compile error here, and
+ * a name added to the dictionary does not silently become mappable.
+ *
  * **Seven of the ten are the standard's codes with the standard's meanings.**
  * The three that are not are Autodesk's, and each has an ISO counterpart
  * Autodesk did not use:
@@ -127,43 +157,53 @@ export interface GeometryField {
  */
 export declare const GEOMETRY_FIELDS: {
     readonly DC: {
+        readonly unit: "mm";
         readonly definition: "cutting diameter";
         readonly iso: "DC";
     };
     readonly SFDM: {
-        readonly definition: "shank diameter";
+        readonly unit: "mm";
+        readonly definition: "shank diameter \u2014 what the holder grips";
         readonly iso: "DMM";
     };
     readonly OAL: {
-        readonly definition: "overall length";
+        readonly unit: "mm";
+        readonly definition: "overall length, tip to the end of the shank";
         readonly iso: "OAL";
     };
     readonly LCF: {
-        readonly definition: "flute length — the length of the cutting edge";
+        readonly unit: "mm";
+        readonly definition: "flute length \u2014 the length of the cutting edge";
         readonly iso: "LCF";
     };
     readonly RE: {
+        readonly unit: "mm";
         readonly definition: "corner radius; 0 on a square-end tool";
         readonly iso: "RE";
     };
     readonly TP: {
-        readonly definition: "thread pitch, in the tool’s own unit system";
+        readonly unit: "mm";
+        readonly definition: "thread pitch, in the tool\u2019s own unit system";
         readonly iso: "TP";
     };
     readonly NOF: {
+        readonly unit: "count";
         readonly definition: "number of flutes";
         readonly iso: "NOF";
     };
     readonly SIG: {
+        readonly unit: "deg";
         readonly definition: "point angle, degrees included";
         readonly iso: "SIG";
     };
     readonly 'shoulder-length': {
+        readonly unit: "mm";
         readonly definition: "usable length below the full shank";
         readonly iso: null;
     };
     readonly 'shoulder-diameter': {
-        readonly definition: "diameter at the shoulder — the neck, where necked";
+        readonly unit: "mm";
+        readonly definition: "diameter at the shoulder \u2014 the neck, where necked";
         readonly iso: null;
     };
 };

package/dist/records.js

@@ -42,6 +42,7 @@
  * always a copy is not a second measurement. An adapter that could supply them
  * separately could supply a tool that claims a holder it does not have.
  */
+import { GEOMETRY_FIELDS as DICTIONARY } from '@toolpath/tool-support';
 import { dimensionalColumn } from './conventions.js';
 import { ScraperConfigError } from './errors.js';
 import { recordGuid } from './identity.js';
@@ -81,6 +82,26 @@ export const UNSPECIFIED = 'unspecified';
  * so the vocabulary's source is readable from the code rather than from a plan
  * document.
  *
+ * ## What each entry says, and what this table says
+ *
+ * The definitions and ISO codes are `@toolpath/tool-support`'s — that is the
+ * dictionary, and it is shared because a code has to mean one thing in every
+ * package that reads one. **This is not that dictionary.** It is the narrower
+ * question only a scraper asks: which of those names an *adapter may map a
+ * vendor column to*.
+ *
+ * The two are not the same list and must not become one. The dictionary knows
+ * `LBH` and `LD`, which are derived from a tool and a holder downstream and
+ * which no vendor publishes; an adapter permitted to map a column to `LBH`
+ * could supply a tool that claims a stickout nobody set. It also knows `LSCN`,
+ * ISO's clamping-length minimum, which is a real vendor column the day a vendor
+ * prints one — and which is deliberately absent below until that day, because
+ * the load-time check's job is to refuse a name no scrape can fill.
+ *
+ * So each entry is an explicit pick out of the shared table rather than a
+ * spread of it: a name dropped from the dictionary is a compile error here, and
+ * a name added to the dictionary does not silently become mappable.
+ *
  * **Seven of the ten are the standard's codes with the standard's meanings.**
  * The three that are not are Autodesk's, and each has an ISO counterpart
  * Autodesk did not use:
@@ -98,25 +119,16 @@ export const UNSPECIFIED = 'unspecified';
  * recognises it.
  */
 export const GEOMETRY_FIELDS = {
-    DC: { definition: 'cutting diameter', iso: 'DC' },
-    SFDM: { definition: 'shank diameter', iso: 'DMM' },
-    OAL: { definition: 'overall length', iso: 'OAL' },
-    LCF: {
-        definition: 'flute length — the length of the cutting edge',
-        iso: 'LCF',
-    },
-    RE: { definition: 'corner radius; 0 on a square-end tool', iso: 'RE' },
-    TP: { definition: 'thread pitch, in the tool’s own unit system', iso: 'TP' },
-    NOF: { definition: 'number of flutes', iso: 'NOF' },
-    SIG: { definition: 'point angle, degrees included', iso: 'SIG' },
-    'shoulder-length': {
-        definition: 'usable length below the full shank',
-        iso: null,
-    },
-    'shoulder-diameter': {
-        definition: 'diameter at the shoulder — the neck, where necked',
-        iso: null,
-    },
+    DC: DICTIONARY.DC,
+    SFDM: DICTIONARY.SFDM,
+    OAL: DICTIONARY.OAL,
+    LCF: DICTIONARY.LCF,
+    RE: DICTIONARY.RE,
+    TP: DICTIONARY.TP,
+    NOF: DICTIONARY.NOF,
+    SIG: DICTIONARY.SIG,
+    'shoulder-length': DICTIONARY['shoulder-length'],
+    'shoulder-diameter': DICTIONARY['shoulder-diameter'],
 };
 /**
  * The canonical names that are **not** ISO 13399's own codes, derived rather

package/dist/registry.d.ts

@@ -27,6 +27,7 @@
  * entry point into this package goes through here.
  */
 import { type BoundFamily, type BoundToolholding, type RecordMappers } from './family.js';
+import type { HoldingMappers, HoldingRecord } from './holding.js';
 import { type ToolRecord } from './records.js';
 import { type MapperOptions, type ScrapeResult } from './scrape.js';
 /**
@@ -39,6 +40,26 @@ import { type MapperOptions, type ScrapeResult } from './scrape.js';
  * map.
  */
 export declare const ADAPTERS: Record<string, RecordMappers>;
+/**
+ * Brand -> its toolholding mappers, by the kind of thing they build.
+ *
+ * The toolholding counterpart of {@link ADAPTERS}, and **partial in both
+ * directions on purpose**. A brand absent from here can still be scraped: its
+ * families bind, its CSVs are written, and its receipt is checked, exactly as
+ * before — what it cannot do is mint records. A brand present with a mapper for
+ * only one kind is the same statement one level down; MariTool publishes ER
+ * collets that this package does not scrape, so it maps holders and nothing
+ * else.
+ *
+ * That is what makes minting records additive rather than a break. Nothing here
+ * changes what a vendor with no entry does today, and the refusal only happens
+ * where a caller explicitly asks for records from a family whose brand maps
+ * none — {@link toHolding}, which names the brand and what it does map.
+ *
+ * One entry serves two brands for the reason {@link ADAPTERS} states: Kennametal
+ * and WIDIA are the same platform and the same table vocabulary.
+ */
+export declare const HOLDING_ADAPTERS: Record<string, HoldingMappers>;
 /**
  * Every cutting-tool family, validated and bound to its record mapper.
  *
@@ -46,13 +67,25 @@ export declare const ADAPTERS: Record<string, RecordMappers>;
  */
 export declare function boundFamilies(): Map<string, BoundFamily>;
 /**
- * Every holder and collet family, with its facts checked and projected.
- *
- * They bind no adapter — only cutting tools go through a column map — but
- * their facts pass the same gate: a taper or a clamping mode is a per-family
- * constant no variant table states, exactly like a drill's flute count.
+ * Every holder and collet family, with its facts checked and projected, and
+ * bound to the mapper its brand supplies for its kind.
+ *
+ * Their facts pass the same gate cutting-tool families' do: a taper or a
+ * clamping mode is a per-family constant no variant table states, exactly like
+ * a drill's flute count.
+ *
+ * **A family whose brand maps nothing binds `undefined` rather than throwing**,
+ * which is where this differs from {@link boundFamilies}. A cutting-tool family
+ * with no mapper is a catalog fault — nothing can be done with it — but a
+ * toolholding family with no mapper is the state every one of them was in until
+ * records existed, and it still scrapes, writes a CSV and checks a receipt.
+ * Refusing at bind time would take that away from every consumer that never
+ * asked for a record. {@link toHolding} is where the absence is reported, at
+ * the one call that cannot proceed without it.
  */
 export declare function boundToolholding(): Map<string, BoundToolholding>;
+/** One bound toolholding family by CSV name. */
+export declare function boundHolding(name: string): BoundToolholding;
 /** One bound cutting-tool family by CSV name. */
 export declare function boundFamily(name: string): BoundFamily;
 /**
@@ -108,6 +141,29 @@ export declare function boundFamily(name: string): BoundFamily;
  * every part by number.
  */
 export declare function toRecords(familyName: string, scrape: ScrapeResult, options?: MapperOptions): ToolRecord[];
+/**
+ * One toolholding family's scrape, as {@link HoldingRecord}s.
+ *
+ * {@link toRecords}'s counterpart, and deliberately the same shape: the two
+ * checks run before the first row, one incomplete part does not end the family,
+ * and the count of what was dropped is not returned because the caller has the
+ * row count it passed in and the length it got back.
+ *
+ * **It refuses only where a caller asked for something this package cannot
+ * give.** A toolholding family whose brand maps no mapper binds one anyway
+ * (see {@link boundToolholding}) and scrapes exactly as it did before; this is
+ * the one call that cannot proceed without one, so this is where the absence is
+ * named — with the brand and with what that brand does map, the way
+ * {@link boundFamilies} names a missing tool mapper.
+ *
+ * `checkColumnsExist` has no counterpart here: a holder family carries no
+ * `ColumnMap`, because the columns a holder publishes are the vendor's own and
+ * are read by that vendor's mapper rather than through a canonical name. What
+ * does still run is {@link checkIdentityColumns}, which catches the failure that
+ * matters most — a re-scrape whose part-number column was renamed still parses,
+ * still has the right row count, and mints every guid off an empty string.
+ */
+export declare function toHolding(familyName: string, scrape: ScrapeResult, options?: MapperOptions): HoldingRecord[];
 /**
  * Forget what has been bound.
  *

package/dist/registry.js

@@ -36,7 +36,10 @@ import { consoleWarn } from './scrape.js';
 import { RECORD_MAPPERS as DESTINYTOOL } from './vendors/destinytool/records.js';
 import { RECORD_MAPPERS as EMUGE } from './vendors/emuge/records.js';
 import { RECORD_MAPPERS as HARVEY } from './vendors/harvey/records.js';
+import { HOLDING_MAPPERS as KM_HOLDING } from './vendors/kennametal/holding.js';
 import { RECORD_MAPPERS as KENNAMETAL } from './vendors/kennametal/records.js';
+import { HOLDING_MAPPERS as MARITOOL_HOLDING } from './vendors/maritool/holding.js';
+import { HOLDING_MAPPERS as REGOFIX_HOLDING } from './vendors/regofix/holding.js';
 /**
  * Brand -> its row-to-record mappers, by tool kind.
  *
@@ -53,6 +56,31 @@ export const ADAPTERS = {
     harvey: HARVEY,
     emuge: EMUGE,
 };
+/**
+ * Brand -> its toolholding mappers, by the kind of thing they build.
+ *
+ * The toolholding counterpart of {@link ADAPTERS}, and **partial in both
+ * directions on purpose**. A brand absent from here can still be scraped: its
+ * families bind, its CSVs are written, and its receipt is checked, exactly as
+ * before — what it cannot do is mint records. A brand present with a mapper for
+ * only one kind is the same statement one level down; MariTool publishes ER
+ * collets that this package does not scrape, so it maps holders and nothing
+ * else.
+ *
+ * That is what makes minting records additive rather than a break. Nothing here
+ * changes what a vendor with no entry does today, and the refusal only happens
+ * where a caller explicitly asks for records from a family whose brand maps
+ * none — {@link toHolding}, which names the brand and what it does map.
+ *
+ * One entry serves two brands for the reason {@link ADAPTERS} states: Kennametal
+ * and WIDIA are the same platform and the same table vocabulary.
+ */
+export const HOLDING_ADAPTERS = {
+    kennametal: KM_HOLDING,
+    widia: KM_HOLDING,
+    regofix: REGOFIX_HOLDING,
+    maritool: MARITOOL_HOLDING,
+};
 /**
  * Check every fact of one family and project its value onto the config under
  * its own key.
@@ -110,27 +138,50 @@ export function boundFamilies() {
     return bound;
 }
 /**
- * Every holder and collet family, with its facts checked and projected.
+ * Every holder and collet family, with its facts checked and projected, and
+ * bound to the mapper its brand supplies for its kind.
  *
- * They bind no adapter — only cutting tools go through a column map — but
- * their facts pass the same gate: a taper or a clamping mode is a per-family
- * constant no variant table states, exactly like a drill's flute count.
+ * Their facts pass the same gate cutting-tool families' do: a taper or a
+ * clamping mode is a per-family constant no variant table states, exactly like
+ * a drill's flute count.
+ *
+ * **A family whose brand maps nothing binds `undefined` rather than throwing**,
+ * which is where this differs from {@link boundFamilies}. A cutting-tool family
+ * with no mapper is a catalog fault — nothing can be done with it — but a
+ * toolholding family with no mapper is the state every one of them was in until
+ * records existed, and it still scrapes, writes a CSV and checks a receipt.
+ * Refusing at bind time would take that away from every consumer that never
+ * asked for a record. {@link toHolding} is where the absence is reported, at
+ * the one call that cannot proceed without it.
  */
 export function boundToolholding() {
     if (toolholding !== null)
         return toolholding;
     const bound = new Map();
-    for (const [table, families_] of [
+    for (const [kind, families_] of [
         ['holder', HOLDER_FAMILIES],
         ['collet', COLLET_FAMILIES],
     ]) {
         for (const [name, cfg] of Object.entries(families_)) {
-            bound.set(name, project(table, name, cfg));
+            const mappers = HOLDING_ADAPTERS[familyBrand(cfg)];
+            bound.set(name, {
+                ...project(kind, name, cfg),
+                kind,
+                records: mappers?.[kind],
+            });
         }
     }
     toolholding = bound;
     return bound;
 }
+/** One bound toolholding family by CSV name. */
+export function boundHolding(name) {
+    const cfg = boundToolholding().get(name);
+    if (cfg === undefined) {
+        throw new ScraperConfigError(name, `unknown toolholding family (known: ${[...boundToolholding().keys()].sort().join(', ')})`);
+    }
+    return cfg;
+}
 /** One bound cutting-tool family by CSV name. */
 export function boundFamily(name) {
     const cfg = boundFamilies().get(name);
@@ -209,6 +260,58 @@ export function toRecords(familyName, scrape, options) {
     }
     return records;
 }
+/**
+ * One toolholding family's scrape, as {@link HoldingRecord}s.
+ *
+ * {@link toRecords}'s counterpart, and deliberately the same shape: the two
+ * checks run before the first row, one incomplete part does not end the family,
+ * and the count of what was dropped is not returned because the caller has the
+ * row count it passed in and the length it got back.
+ *
+ * **It refuses only where a caller asked for something this package cannot
+ * give.** A toolholding family whose brand maps no mapper binds one anyway
+ * (see {@link boundToolholding}) and scrapes exactly as it did before; this is
+ * the one call that cannot proceed without one, so this is where the absence is
+ * named — with the brand and with what that brand does map, the way
+ * {@link boundFamilies} names a missing tool mapper.
+ *
+ * `checkColumnsExist` has no counterpart here: a holder family carries no
+ * `ColumnMap`, because the columns a holder publishes are the vendor's own and
+ * are read by that vendor's mapper rather than through a canonical name. What
+ * does still run is {@link checkIdentityColumns}, which catches the failure that
+ * matters most — a re-scrape whose part-number column was renamed still parses,
+ * still has the right row count, and mints every guid off an empty string.
+ */
+export function toHolding(familyName, scrape, options) {
+    const cfg = boundHolding(familyName);
+    const warn = options?.warn ?? consoleWarn;
+    const brand = familyBrand(cfg);
+    const mapper = cfg.records;
+    if (mapper === undefined) {
+        const mappers = HOLDING_ADAPTERS[brand];
+        throw new ScraperConfigError(familyName, `brand ${JSON.stringify(brand)} has no ${cfg.kind} mapper ` +
+            (mappers === undefined
+                ? `— it maps no toolholding at all, so this family ends at rows and ` +
+                    `a receipt (brands that map some: ` +
+                    `${Object.keys(HOLDING_ADAPTERS).sort().join(', ')})`
+                : `(it maps: ${Object.keys(mappers).sort().join(', ')})`));
+    }
+    checkIdentityColumns(brand, scrape.header);
+    const records = [];
+    for (const row of scrape.rows) {
+        try {
+            records.push(cfg.kind === 'holder'
+                ? mapper(row, cfg, options)
+                : mapper(row, cfg, options));
+        }
+        catch (error) {
+            if (!(error instanceof IncompletePartError))
+                throw error;
+            warn(`  WARNING: ${error.message} — no record written for it`);
+        }
+    }
+    return records;
+}
 /**
  * Forget what has been bound.
  *

package/dist/vendors/kennametal/holding.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Kennametal's and WIDIA's toolholding column vocabulary, and nothing else.
+ *
+ * The counterpart of `records.ts` for a holder and a collet: every decision
+ * about *what a record is* lives in `holding.ts`, and what lives here is which
+ * of this vendor's columns answers each question. That is the same line
+ * `vendors/kennametal/records.ts` draws for cutting tools.
+ *
+ * ## What this platform states as a fact rather than a column
+ *
+ * Almost everything. `taper`, `contact`, `clamping`, `style` and `unit` are all
+ * per-family constants here, declared in `families/kennametal.ts` with a
+ * citation each, because Kennametal sells one interface and one clamping mode
+ * per family — its dual-contact BT30 is a separate line (BTKV\*) with its own
+ * family code. The two vendors whose holders vary row by row are the ones whose
+ * mappers read a column instead.
+ *
+ * ## Two published columns this deliberately does not carry
+ *
+ * - **`L1FC`**, the BTKV30 line's "Gage Length Face Contact", 0.998 mm shorter
+ *   than `L1` on every row. It is not a second measurement of one thing: it is
+ *   the gage length *in a face-contact spindle*, so which of the two is true is
+ *   a fact about the machine rather than about the holder. Carrying both would
+ *   put two numbers named "gage" on one record with nothing to say which one
+ *   stickout arithmetic should use. `contact` records that the holder has the
+ *   geometry; `gaugeLength` stays `L1`. Promote it the day something reads a
+ *   spindle's contact mode, and change `gaugeLength` with it rather than
+ *   showing both.
+ * - **Torque figures, actuation-screw drive size, weight and `D21`.** Published,
+ *   and dropped under `records.ToolRecord`'s standing rule: add a field when
+ *   something displays it, not before.
+ */
+import { type HoldingMappers } from '../../holding.js';
+/** The toolholding half of the adapter contract `registry` looks up by brand. */
+export declare const HOLDING_MAPPERS: HoldingMappers;

package/dist/vendors/kennametal/holding.js

@@ -0,0 +1,112 @@
+/**
+ * Kennametal's and WIDIA's toolholding column vocabulary, and nothing else.
+ *
+ * The counterpart of `records.ts` for a holder and a collet: every decision
+ * about *what a record is* lives in `holding.ts`, and what lives here is which
+ * of this vendor's columns answers each question. That is the same line
+ * `vendors/kennametal/records.ts` draws for cutting tools.
+ *
+ * ## What this platform states as a fact rather than a column
+ *
+ * Almost everything. `taper`, `contact`, `clamping`, `style` and `unit` are all
+ * per-family constants here, declared in `families/kennametal.ts` with a
+ * citation each, because Kennametal sells one interface and one clamping mode
+ * per family — its dual-contact BT30 is a separate line (BTKV\*) with its own
+ * family code. The two vendors whose holders vary row by row are the ones whose
+ * mappers read a column instead.
+ *
+ * ## Two published columns this deliberately does not carry
+ *
+ * - **`L1FC`**, the BTKV30 line's "Gage Length Face Contact", 0.998 mm shorter
+ *   than `L1` on every row. It is not a second measurement of one thing: it is
+ *   the gage length *in a face-contact spindle*, so which of the two is true is
+ *   a fact about the machine rather than about the holder. Carrying both would
+ *   put two numbers named "gage" on one record with nothing to say which one
+ *   stickout arithmetic should use. `contact` records that the holder has the
+ *   geometry; `gaugeLength` stays `L1`. Promote it the day something reads a
+ *   spindle's contact mode, and change `gaugeLength` with it rather than
+ *   showing both.
+ * - **Torque figures, actuation-screw drive size, weight and `D21`.** Published,
+ *   and dropped under `records.ToolRecord`'s standing rule: add a field when
+ *   something displays it, not before.
+ */
+import { CAD_COLUMN, COLLET_DESIGNATION_COLUMN, COLLET_SERIES_COLUMN } from '../../conventions.js';
+import { familyBrand } from '../../family.js';
+import { checkUnitAgreement, clampingMode, colletRecord, contactMode, dim, holderRecord, holdingFact, published, } from '../../holding.js';
+import { consoleWarn } from '../../scrape.js';
+import { CATALOG_NUMBER, MATERIAL_NUMBER } from './records.js';
+/**
+ * The dimensional labels whose two unit columns are worth cross-checking.
+ *
+ * Every dimension either record carries, and no more: a label nothing reads
+ * cannot produce a wrong number, so warning about it is noise. `holding.dim`
+ * reads the native column and never the other one, which is what makes this a
+ * report rather than a gate.
+ */
+const HOLDER_LABELS = ['D1', 'L1', 'L2', 'L9', 'V', 'D2', 'D11'];
+const COLLET_LABELS = ['CCCN', 'CCCX', 'D1', 'BDX', 'LF', 'L'];
+/** How a part names itself in a warning or a refusal. */
+function subject(row) {
+    return `${row[CATALOG_NUMBER] ?? ''} (${row[MATERIAL_NUMBER] ?? ''})`;
+}
+/** One Kennametal or WIDIA holder row -> one {@link HolderRecord}. */
+function holder(row, family, options = {}) {
+    const warn = options.warn ?? consoleWarn;
+    const what = subject(row);
+    const unit = holdingFact(family, 'unit', family.unit);
+    for (const label of HOLDER_LABELS)
+        checkUnitAgreement(row, label, what, warn);
+    // Kennametal publishes no description column for toolholding, and `''` is the
+    // honest answer where a vendor publishes none — `records.ToolRecord.description`
+    // states the rule and the reason: a description that restates the catalog
+    // number puts one string in two fields.
+    return holderRecord({
+        brand: familyBrand(family),
+        materialNumber: published(row[MATERIAL_NUMBER], what, 'material number'),
+        catalogNumber: published(row[CATALOG_NUMBER], what, 'catalog number'),
+        description: '',
+        unit,
+        taper: holdingFact(family, 'taper', family.taper),
+        contact: contactMode(holdingFact(family, 'contact', family.contact), what),
+        clamping: clampingMode(holdingFact(family, 'clamping', family.clamping), what),
+        style: holdingFact(family, 'style', family.style),
+        colletSeries: row[COLLET_SERIES_COLUMN] || null,
+        bore: dim(row, 'D1', unit),
+        gaugeLength: published(dim(row, 'L1', unit), what, 'L1 gage length'),
+        usableLength: dim(row, 'L2', unit),
+        clampingLength: dim(row, 'L9', unit),
+        adjustmentRange: dim(row, 'V', unit),
+        bodyDiameter: dim(row, 'D2', unit),
+        lockNutDiameter: dim(row, 'D11', unit),
+        cadModelUrl: row[CAD_COLUMN] || null,
+        // This platform publishes a STEP model and no 2D profile. A DXF column would
+        // be a claim about the data, and false — the call `conventions.CAD_DXF_COLUMN`
+        // records.
+        cadDxfUrl: null,
+    });
+}
+/** One Kennametal or WIDIA collet row -> one {@link ColletRecord}. */
+function collet(row, family, options = {}) {
+    const warn = options.warn ?? consoleWarn;
+    const what = subject(row);
+    const unit = holdingFact(family, 'unit', family.unit);
+    for (const label of COLLET_LABELS)
+        checkUnitAgreement(row, label, what, warn);
+    return colletRecord({
+        brand: familyBrand(family),
+        materialNumber: published(row[MATERIAL_NUMBER], what, 'material number'),
+        catalogNumber: published(row[CATALOG_NUMBER], what, 'catalog number'),
+        description: '',
+        unit,
+        series: published(row[COLLET_DESIGNATION_COLUMN], what, 'collet series'),
+        style: holdingFact(family, 'style', family.style),
+        nominal: dim(row, 'D1', unit),
+        clampMin: published(dim(row, 'CCCN', unit), what, 'CCCN clamping minimum'),
+        clampMax: published(dim(row, 'CCCX', unit), what, 'CCCX clamping maximum'),
+        bodyDiameter: dim(row, 'BDX', unit),
+        functionalLength: dim(row, 'LF', unit),
+        overallLength: dim(row, 'L', unit),
+    });
+}
+/** The toolholding half of the adapter contract `registry` looks up by brand. */
+export const HOLDING_MAPPERS = { holder, collet };

package/dist/vendors/kennametal/index.d.ts

@@ -16,6 +16,7 @@
  */
 export * from './cad.js';
 export * from './family.js';
+export * from './holding.js';
 export * from './materials.js';
 export * from './records.js';
 export * from './scrape.js';

package/dist/vendors/kennametal/index.js

@@ -16,6 +16,7 @@
  */
 export * from './cad.js';
 export * from './family.js';
+export * from './holding.js';
 export * from './materials.js';
 export * from './records.js';
 export * from './scrape.js';