@toolpath/tool-scraper 2.0.0 → 2.2.0

package/dist/vendors/emuge/records.js

@@ -14,7 +14,12 @@
  *   article code, per part, so there is no `conventions.IDENTITY_DEVIATIONS`
  *   entry — the first vendor since Kennametal that needs none.
  * - **A point angle, per drill.** Kennametal's drill families assume theirs; the
- *   detail record states it, so `SIG` is a mapped column here and no fact.
+ *   detail record states it, so `SIG` is a mapped column here and no fact. On
+ *   all but one part: 2,669 of 2,670 drill variants state one, and part
+ *   `000000000010727800` publishes a single classification feature and no
+ *   dimensional properties at all — so its row carries no `SIG` **key**, not
+ *   an empty one. That is why `records.RECORD_GEOMETRY.drill` lists `SIG`
+ *   under `sometimes`, and why {@link angle} reads the row rather than `cell`.
  * - **A per-part ISO 513 index.** `applicationMaterials` returns the vendor's
  *   own P/M/K/N/S/H rating for each part, which fills `materialGroups` as
  *   `vendor-stated`.
@@ -132,6 +137,125 @@ export const SUBSTRATES = {
     CBN: 'cbn',
     ceramic: 'ceramic',
 };
+/**
+ * The column each EMUGE-FRANKEN category states its product line in, keyed by
+ * the vendor's own category code.
+ *
+ * **One column per category, and each is a facet that partitions its category
+ * exactly.** Checked against the vendor's own index on 2026-09-01, at group
+ * level rather than by summing counts:
+ *
+ * | Category | Facet                | Values | Groups it covers | Groups in two values |
+ * | -------- | -------------------- | ------ | ---------------- | -------------------- |
+ * | `FF01`   | `AMM_PROG_LINIE`     | 15     | 554 of 554       | 2                    |
+ * | `FB01`   | `HYB_BAM_SB_GT`      | 4      | 17 of 17         | 0                    |
+ * | `FG01`   | `HYB_BAM_SB_GT`      | 17     | 414 of 414       | 0                    |
+ *
+ * That is what makes a product line here a **read and not an arbitration**.
+ * EMUGE's marketing publishes 43 overlapping product-family pages — a tap is
+ * simultaneously "Rekord B-Z Taps", "Enorm Z Taps" and "Left Hand Taps" — and
+ * choosing between those would be this package inventing a rule the vendor
+ * never stated. The facets above are the vendor's own partition of the same
+ * catalog, so there is nothing to choose.
+ *
+ * **The two milling groups that fall in two values cost nothing**, because the
+ * milling column is read per part: `H300024` and `H300025` each hold both
+ * `FRANKEN TiNox-Cut` and `FRANKEN TiNox-Cut VAR` variants, and the per-part
+ * detail record states which is which. A rule that tagged a whole group would
+ * have had to pick.
+ *
+ * **No request is added for any of this.** `Geometry` is on the grouped product
+ * and `product line` on the per-part detail, so `scrape.ts` already writes both
+ * into every row — see its three-call note.
+ */
+export const PRODUCT_LINE_COLUMNS = {
+    FF01: 'product line',
+    FB01: 'Geometry',
+    FG01: 'Geometry',
+};
+/**
+ * A category's product-line codes onto the vendor's own name for each.
+ *
+ * **Both sides are EMUGE's.** The key is the value its `HYB_BAM_SB_GT` facet
+ * publishes and the name is the title of the vendor's own product-family
+ * article page for it, read on 2026-09-01 and cited per entry. Nothing here is
+ * this package's wording, which is the whole condition on a table like this —
+ * the same rule {@link SUBSTRATES} keeps, one level less strict because that
+ * one maps onto a vocabulary this package owns and this one does not.
+ *
+ * **A category whose facet already names the line has no entry.** `FF01`'s
+ * values are `FRANKEN TOP-Cut`, `FRANKEN Hard-Cut`, `FRANKEN Alu-Cut` — the
+ * vendor's marketing names already — so milling passes through verbatim and
+ * appears nowhere below. Drilling and tapping index by a geometry code
+ * (`MULTI`, `Z`, `VA`) that matches nothing EMUGE sells under that name, which
+ * is the only reason this table exists.
+ *
+ * **A code with no article page keeps the code**, and that is a gap in the
+ * vendor's marketing rather than a hole here: `SPEED`, `FK`, `GAL`, `GG` and
+ * `TILEG` are real lines with no `/a/` page on the US storefront, so the
+ * honest answer is the vendor's own code until one appears.
+ */
+export const PRODUCT_LINES = {
+    // `/us/en/multi-drill/a/MultiDRILL`, `/us/en/steeldrill/a/SteelDrill`,
+    // `/us/en/inox/a/Inox`, and
+    // `/us/en/ef-va---carbide-drills---stainless-steel-titanium-alloys`.
+    //
+    // `STEEL` has two article pages — "SteelDrill" and "EF / CARBIDE DRILLS" —
+    // that resolve to the identical 8 groups. `SteelDrill` is the one the
+    // vendor's own part names use (`SteelDrill SD102-5xD-HA`), which is the
+    // tiebreak: a part that calls itself one of the two is evidence and a
+    // preference between two pages is not.
+    FB01: {
+        MULTI: 'MultiDRILL',
+        STEEL: 'SteelDrill',
+        INOX: 'Inox',
+        VA: 'EF-VA / CARBIDE DRILLS',
+    },
+    // One article page each, all under `/us/en/<slug>/a/<name>`: multitap,
+    // va-taps, ti-taps, ni-taps, aero-taps, rekord-b-z-taps, a-h-taps, al-taps,
+    // a-gjv-taps, a-hcut-taps, steel-taps.
+    //
+    // `FK`, `GAL`, `GG`, `SPEED` and `TILEG` are absent on purpose — see above.
+    FG01: {
+        MULTI: 'MultiTAP™',
+        VA: 'VA Taps',
+        TI: 'TI-Taps',
+        NI: 'Ni Taps',
+        AERO: 'AERO Taps',
+        Z: 'Rekord B-Z Taps',
+        H: 'A-H Taps',
+        AL: 'Al Taps',
+        GJV: 'A-GJV Taps',
+        HCUT: 'A-HCUT Taps',
+        STEEL: 'Steel Taps',
+    },
+};
+/**
+ * The product line this row states, or null where the vendor states none.
+ *
+ * Three answers and they are different things. A family whose category has no
+ * entry in {@link PRODUCT_LINE_COLUMNS} is a category this adapter has not
+ * looked at, and it answers null rather than guessing at which of the row's
+ * columns is the line. A column the vendor left empty is null too — the same
+ * silence `angle` treats as an omission rather than a fault. A *value* is
+ * mapped through {@link PRODUCT_LINES} where its category has a table and
+ * passed through verbatim where it does not, which is the milling case.
+ *
+ * It does not throw on an unknown code, and that is the difference between
+ * this and `substrate`: a cutting material this package cannot map would put a
+ * wrong word in `ToolRecord.substrate`, where an unmapped product-line code is
+ * the vendor's own code and readable as one. A new EMUGE geometry showing up
+ * as `SPEED` is a name to improve, not a record to refuse.
+ */
+export function productLine(row, family) {
+    const column = PRODUCT_LINE_COLUMNS[family.familyCode ?? ''];
+    if (column === undefined)
+        return null;
+    const stated = (row[column] ?? '').trim();
+    if (stated === '')
+        return null;
+    return PRODUCT_LINES[family.familyCode ?? '']?.[stated] ?? stated;
+}
 /**
  * The flute count EMUGE publishes where it has none: 64 end mill variants, on
  * 2026-09-01. A sentinel and not a number, so it is refused rather than read.
@@ -146,17 +270,55 @@ export const NO_FLUTE_COUNT = 999;
  */
 const { cell, required, optional } = columnReaders(measureIn);
 /**
- * An angle in degrees — the drill's point angle.
+ * An angle in degrees — the drill's point angle — or null where the vendor
+ * left the cell empty.
  *
  * Read through {@link parseMeasure} rather than {@link measureIn}, which
  * refuses degrees on purpose: a length column stating an angle is a property
  * that has moved. Here degrees are what the column is for.
+ *
+ * **An empty cell and an unreadable one are different answers**, the same
+ * split {@link coolantThrough} makes one level down. EMUGE fills this column
+ * on 2,669 of its 2,670 drill variants and leaves it blank on one, so a blank
+ * is the vendor publishing nothing and the row is still a part somebody can
+ * order — `records.RECORD_GEOMETRY.drill` lists `SIG` under `sometimes` for
+ * it. A cell holding a *value* this cannot read is the other case: a length
+ * where an angle belongs is the property having moved, a range has no single
+ * reading, and either one is refused rather than dropped quietly.
+ *
+ * A column the family maps to nothing refuses too, and is a third thing again
+ * — this adapter's drill family maps `point angle`, so its absence is that map
+ * having changed rather than anything the vendor did. **That is a fact about
+ * the map and not about a row**, which is why it is asked of `columns` and not
+ * inferred from a missing cell: a part publishing no dimensional properties
+ * has no such key either, and reading the two as one refused every drill in
+ * the family over one incomplete part.
+ * `records.REQUIRED_GEOMETRY` cannot catch it: `SIG` is not listed under its
+ * `drill` entry, because Kennametal's drills supply theirs as a fact and map
+ * no column at all.
  */
-function angle(row, columns, unit, what) {
-    const raw = cell(row, columns, 'SIG', unit);
-    const { value, stated } = parseMeasure(raw ?? '');
+function angle(row, columns, unit, what, warn) {
+    // `cell` cannot be used here. It answers `undefined` for two different
+    // things — the family mapping no `SIG` column, and *this row* carrying no
+    // such key — and those are the regression and the vendor's silence
+    // respectively. Asking the map directly separates them: `column` is null
+    // only when the map has nothing, so an absent key is left to be read off the
+    // row like any other blank.
+    const column = columns.column('SIG', unit);
+    if (column === null) {
+        throw new VendorResponseError(what, `is a drill whose family maps no point angle column — EMUGE states one ` +
+            `per part and this adapter reads it, so a map without it is a regression`);
+    }
+    const raw = row[column];
+    if (raw === undefined || raw.trim() === '') {
+        warn(`  WARNING: ${what}: the vendor publishes no point angle — omitted`);
+        return null;
+    }
+    const { value, stated } = parseMeasure(raw);
     if (value === null || stated === 'inches' || stated === 'millimeters') {
-        throw new VendorResponseError(what, `publishes no point angle — its cell is ${JSON.stringify(raw ?? '')}`);
+        throw new VendorResponseError(what, `states a point angle of ${JSON.stringify(raw)}, which is not an angle — ` +
+            `an empty cell is the vendor's silence and is omitted, but a value ` +
+            `this cannot read is a property that has moved`);
     }
     return value;
 }
@@ -248,6 +410,7 @@ function common(row, family, what, warn) {
         materialNumber: what,
         catalogNumber: row[CATALOG_NUMBER_COLUMN] ?? '',
         description: row[DESCRIPTION_COLUMN] ?? '',
+        productLine: productLine(row, family),
         substrate: substrate(row, what),
         coating: coating(row),
         coolantThrough: coolantThrough(row, what, warn),
@@ -308,27 +471,32 @@ export function endmillRecord(row, family, columns, options = {}) {
  * `SIG` is a **mapped column**, which no other drill family in this package
  * manages: the per-part detail record states the point angle outright, so
  * nothing here is derived from a point length or assumed from a product line.
- * `NOF` is the one thing that is a fact, and `nonFerrous` with it — neither has
- * a default anywhere, by design.
+ * It is also the one geometry key this record may not carry — one variant's
+ * cell is empty, and {@link angle} says what that costs. `NOF` is the one
+ * thing that is a fact, and `nonFerrous` with it — neither has a default
+ * anywhere, by design.
  */
 export function drillRecord(row, family, columns, options = {}) {
     const warn = options.warn ?? consoleWarn;
     const opts = { warn };
     const unit = fact(family, 'unit', family.unit);
     const what = partNumber(row, family);
+    const geometry = {
+        DC: required(row, columns, 'DC', unit, what, opts),
+        SFDM: required(row, columns, 'SFDM', unit, what, opts),
+        OAL: required(row, columns, 'OAL', unit, what, opts),
+        LCF: required(row, columns, 'LCF', unit, what, opts),
+        NOF: fact(family, 'flutes', family.flutes),
+    };
+    const pointAngle = angle(row, columns, unit, what, warn);
+    if (pointAngle !== null)
+        geometry.SIG = pointAngle;
     return toolRecord({
         ...common(row, family, what, warn),
         kind: 'drill',
         unit,
         nonFerrous: fact(family, 'nonFerrous', family.nonFerrous),
-        geometry: {
-            DC: required(row, columns, 'DC', unit, what, opts),
-            SFDM: required(row, columns, 'SFDM', unit, what, opts),
-            OAL: required(row, columns, 'OAL', unit, what, opts),
-            LCF: required(row, columns, 'LCF', unit, what, opts),
-            NOF: fact(family, 'flutes', family.flutes),
-            SIG: angle(row, columns, unit, what),
-        },
+        geometry,
     });
 }
 /**

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

@@ -0,0 +1,119 @@
+/**
+ * A family page's own title, for every brand on Kennametal's AEM platform.
+ *
+ * `scrape.ts` reads the variant *table* that a family page renders; this reads
+ * the heading above it. They are two requests against the same family because
+ * they are two different AEM resources — the table is a component node's
+ * `.variants.<code>.html` selector and the title is the page — and the second
+ * is what nothing else in this package publishes:
+ *
+ * ```html
+ * <h1>KenCut™ FF • HPFT • Square End • 6 Flutes • Plain Shank • Inch</h1>
+ * ```
+ *
+ * ## The slug does not matter
+ *
+ * The vendor's own links are `fam.<slug>.<code>.html`, and AEM resolves the
+ * page off the numeric code alone — `fam.x.100003783.html` answers 200 with
+ * exactly the page above. That is what makes this reachable from a
+ * `familyCode` and nothing else: `families/kennametal.ts` records the code
+ * because the variants endpoint needs it, and no family in it carries a slug.
+ *
+ * **`fam.<code>.html` — the code with no slug segment at all — 301s**, so the
+ * placeholder is load-bearing rather than decoration. {@link FAMILY_SLUG} is
+ * what fills it.
+ *
+ * ## Why the page is trusted to be the right one
+ *
+ * A URL built from a code that no longer names a family would answer *some*
+ * page, and a title read off it would be silently wrong for a whole table. So
+ * the page's own `data-product-code` is checked against the code that was
+ * asked for, and a mismatch throws. It is the same argument
+ * `scrape.parseVariantTable` makes for telling the vendor's no-results notice
+ * apart from a response that changed shape: a scrape that reports the wrong
+ * answer confidently is worse than one that stops.
+ *
+ * ## What the title is, and what only part of it is
+ *
+ * The whole `h1` is the family's name and reaches the CSV whole, under
+ * `conventions.FAMILY_TITLE_COLUMN`. Its **leading `•` segment** is the
+ * product line — `KenCut™ FF`, `HARVI™ I TE`, `VariMill™ Chip Splitters` —
+ * and that is the part `records.ToolRecord.productLine` keeps. Everything
+ * after it describes the shape, the flute count, the shank and the unit, which
+ * are already canonical geometry on the record.
+ *
+ * The split is the vendor's own punctuation and not a guess at where a name
+ * ends: every family title on both hosts is `•`-separated, and a title with no
+ * separator is its own product line.
+ */
+import type { Fetcher } from '../../fetch.js';
+import { type AemBrandName } from '../../identity.js';
+/**
+ * The URL shape of a family page.
+ *
+ * `{host}` and `{code}` are filled; `{slug}` is {@link FAMILY_SLUG}. Stated as
+ * one template beside `scrape.BASE` so that the two URLs this adapter builds
+ * are readable together.
+ */
+export declare const FAMILY_PAGE = "https://www.{host}/us/en/products/fam.{slug}.{code}.html";
+/**
+ * What goes where the vendor writes a human-readable slug.
+ *
+ * AEM ignores it — see the module note — and this package has no slug to put
+ * there, because a `familyCode` is the only handle `families/kennametal.ts`
+ * records. A word rather than a single letter so that a request showing up in
+ * somebody's log says what it is.
+ */
+export declare const FAMILY_SLUG = "family";
+/** The vendor's own separator between the parts of a family title. */
+export declare const TITLE_SEPARATOR = "\u2022";
+/** One family page's URL. */
+export declare function familyPageUrl(code: string, brand?: AemBrandName): string;
+/** What {@link parseFamilyPage} reads off a family page. */
+export interface FamilyPage {
+    /** The `h1`, collapsed. */
+    readonly title: string;
+    /** The code the page states for itself, or null where it states none. */
+    readonly code: string | null;
+}
+/**
+ * The family title and the page's own code.
+ *
+ * `htmlparser2` rather than a regex for the same reason `scrape.TableParser`
+ * uses it: these pages carry `&deg;`, `&Oslash;` and `&trade;` in their text,
+ * and a `KenCut&trade; FF` reaching the CSV as eleven characters is the bug
+ * `decodeEntities` exists to prevent. The `™` in every title above is exactly
+ * that entity.
+ *
+ * The **first** `h1` is taken. The pages carry one, and reading the first is
+ * what makes a second one added below the fold somebody else's problem rather
+ * than a title that changes under a re-scrape.
+ */
+export declare function parseFamilyPage(html: string): FamilyPage;
+/**
+ * A family title's leading segment — the product line.
+ *
+ * `''` in and `''` out, which is the one case the caller has to keep: a page
+ * with no `h1` states no line, and {@link fetchFamily} answers null for it
+ * rather than an empty name. See `records.ToolRecord.productLine`.
+ */
+export declare function productLineOf(title: string): string;
+/** A family's title and product line, or nulls where the page states none. */
+export interface Family {
+    readonly title: string;
+    readonly productLine: string | null;
+}
+/**
+ * One family page, read.
+ *
+ * The one network call in this module — the seam a test replaces, exactly as
+ * `scrape.fetchVariants` is.
+ *
+ * A page that answers with no `h1` is **not** an error: it is a family the
+ * vendor publishes without a heading, and the table below it is still a table
+ * of real parts. It comes back with an empty title and a null line, and the
+ * rows are written without either column rather than the scrape stopping. A
+ * page whose `data-product-code` names a *different* family is the other case
+ * and throws — see the module note.
+ */
+export declare function fetchFamily(fetcher: Fetcher, code: string, brand?: AemBrandName): Promise<Family>;

package/dist/vendors/kennametal/family.js

@@ -0,0 +1,155 @@
+/**
+ * A family page's own title, for every brand on Kennametal's AEM platform.
+ *
+ * `scrape.ts` reads the variant *table* that a family page renders; this reads
+ * the heading above it. They are two requests against the same family because
+ * they are two different AEM resources — the table is a component node's
+ * `.variants.<code>.html` selector and the title is the page — and the second
+ * is what nothing else in this package publishes:
+ *
+ * ```html
+ * <h1>KenCut™ FF • HPFT • Square End • 6 Flutes • Plain Shank • Inch</h1>
+ * ```
+ *
+ * ## The slug does not matter
+ *
+ * The vendor's own links are `fam.<slug>.<code>.html`, and AEM resolves the
+ * page off the numeric code alone — `fam.x.100003783.html` answers 200 with
+ * exactly the page above. That is what makes this reachable from a
+ * `familyCode` and nothing else: `families/kennametal.ts` records the code
+ * because the variants endpoint needs it, and no family in it carries a slug.
+ *
+ * **`fam.<code>.html` — the code with no slug segment at all — 301s**, so the
+ * placeholder is load-bearing rather than decoration. {@link FAMILY_SLUG} is
+ * what fills it.
+ *
+ * ## Why the page is trusted to be the right one
+ *
+ * A URL built from a code that no longer names a family would answer *some*
+ * page, and a title read off it would be silently wrong for a whole table. So
+ * the page's own `data-product-code` is checked against the code that was
+ * asked for, and a mismatch throws. It is the same argument
+ * `scrape.parseVariantTable` makes for telling the vendor's no-results notice
+ * apart from a response that changed shape: a scrape that reports the wrong
+ * answer confidently is worse than one that stops.
+ *
+ * ## What the title is, and what only part of it is
+ *
+ * The whole `h1` is the family's name and reaches the CSV whole, under
+ * `conventions.FAMILY_TITLE_COLUMN`. Its **leading `•` segment** is the
+ * product line — `KenCut™ FF`, `HARVI™ I TE`, `VariMill™ Chip Splitters` —
+ * and that is the part `records.ToolRecord.productLine` keeps. Everything
+ * after it describes the shape, the flute count, the shank and the unit, which
+ * are already canonical geometry on the record.
+ *
+ * The split is the vendor's own punctuation and not a guess at where a name
+ * ends: every family title on both hosts is `•`-separated, and a title with no
+ * separator is its own product line.
+ */
+import { Parser } from 'htmlparser2';
+import { VendorResponseError } from '../../errors.js';
+import { BRANDS } from '../../identity.js';
+/**
+ * The URL shape of a family page.
+ *
+ * `{host}` and `{code}` are filled; `{slug}` is {@link FAMILY_SLUG}. Stated as
+ * one template beside `scrape.BASE` so that the two URLs this adapter builds
+ * are readable together.
+ */
+export const FAMILY_PAGE = 'https://www.{host}/us/en/products/fam.{slug}.{code}.html';
+/**
+ * What goes where the vendor writes a human-readable slug.
+ *
+ * AEM ignores it — see the module note — and this package has no slug to put
+ * there, because a `familyCode` is the only handle `families/kennametal.ts`
+ * records. A word rather than a single letter so that a request showing up in
+ * somebody's log says what it is.
+ */
+export const FAMILY_SLUG = 'family';
+/** The vendor's own separator between the parts of a family title. */
+export const TITLE_SEPARATOR = '•';
+/** The attribute a family page states its own code in. */
+const PRODUCT_CODE_ATTR = 'data-product-code';
+/** One family page's URL. */
+export function familyPageUrl(code, brand = 'kennametal') {
+    const { host } = BRANDS[brand];
+    return FAMILY_PAGE.replace('{host}', host).replace('{slug}', FAMILY_SLUG).replace('{code}', code);
+}
+/**
+ * The family title and the page's own code.
+ *
+ * `htmlparser2` rather than a regex for the same reason `scrape.TableParser`
+ * uses it: these pages carry `&deg;`, `&Oslash;` and `&trade;` in their text,
+ * and a `KenCut&trade; FF` reaching the CSV as eleven characters is the bug
+ * `decodeEntities` exists to prevent. The `™` in every title above is exactly
+ * that entity.
+ *
+ * The **first** `h1` is taken. The pages carry one, and reading the first is
+ * what makes a second one added below the fold somebody else's problem rather
+ * than a title that changes under a re-scrape.
+ */
+export function parseFamilyPage(html) {
+    let title = null;
+    let depth = 0;
+    let text = '';
+    let code = null;
+    const parser = new Parser({
+        onopentag: (tag, attribs) => {
+            if (tag === 'h1' && title === null)
+                depth += 1;
+            const stated = attribs[PRODUCT_CODE_ATTR];
+            if (code === null && stated !== undefined && stated !== '')
+                code = stated;
+        },
+        ontext: (chunk) => {
+            if (depth > 0)
+                text += chunk;
+        },
+        onclosetag: (tag) => {
+            if (tag === 'h1' && depth > 0) {
+                depth -= 1;
+                if (depth === 0) {
+                    title = text.split(/\s+/).filter(Boolean).join(' ');
+                    text = '';
+                }
+            }
+        },
+    }, { decodeEntities: true });
+    parser.write(html);
+    parser.end();
+    return { title: title ?? '', code };
+}
+/**
+ * A family title's leading segment — the product line.
+ *
+ * `''` in and `''` out, which is the one case the caller has to keep: a page
+ * with no `h1` states no line, and {@link fetchFamily} answers null for it
+ * rather than an empty name. See `records.ToolRecord.productLine`.
+ */
+export function productLineOf(title) {
+    return (title.split(TITLE_SEPARATOR)[0] ?? '').trim();
+}
+/**
+ * One family page, read.
+ *
+ * The one network call in this module — the seam a test replaces, exactly as
+ * `scrape.fetchVariants` is.
+ *
+ * A page that answers with no `h1` is **not** an error: it is a family the
+ * vendor publishes without a heading, and the table below it is still a table
+ * of real parts. It comes back with an empty title and a null line, and the
+ * rows are written without either column rather than the scrape stopping. A
+ * page whose `data-product-code` names a *different* family is the other case
+ * and throws — see the module note.
+ */
+export async function fetchFamily(fetcher, code, brand = 'kennametal') {
+    const url = familyPageUrl(code, brand);
+    const { title, code: stated } = parseFamilyPage(await fetcher.text(url));
+    if (stated !== null && stated !== code) {
+        throw new VendorResponseError(url, `is the page for ${JSON.stringify(stated)} and not ${JSON.stringify(code)} — ` +
+            `the family code was retired or redirected, and its title would name the ` +
+            `wrong product line for every row of the table`);
+    }
+    const line = productLineOf(title);
+    return { title, productLine: line === '' ? null : line };
+}

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;