@toolpath/tool-scraper 0.1.0

package/dist/vendors/kennametal/records.js

@@ -0,0 +1,241 @@
+/**
+ * Kennametal rows -> {@link ToolRecord}. The adapter half of the record seam.
+ *
+ * Everything here knows Kennametal's column vocabulary and nothing here knows
+ * what a record becomes. The reverse is true of whatever consumes one: it
+ * knows no vendor at all.
+ *
+ * What stayed on this side of the line, and why each is a *vendor* fact rather
+ * than a domain one:
+ *
+ * - **Which column holds a canonical field.** Declared per family as
+ *   `columns: { DC: 'D1', … }` and resolved through `ColumnMap`, which appends
+ *   the unit suffix. A vendor with different labels declares different labels.
+ * - **Where the identity strings live.** `Material Number` and `ISO Catalog
+ *   Number` are Kennametal's header text — the labels
+ *   `conventions.IDENTITY_COLUMNS` took as the convention because this vendor
+ *   was first, and which Destiny Tool then did not follow.
+ * - **Which column is the grade.** A drill and an end mill carry a carbide
+ *   `Grade`; a tap has no carbide grade and carries `Coating`, the surface
+ *   treatment, in the record's `grade` field. That is Kennametal's table
+ *   shape, not a rule about taps everywhere.
+ * - **That a tap's unit system is per row.** `Thread System` is a constant tag
+ *   column this package appends at scrape time, and a metric and an inch tap
+ *   can sit in one family — so a tap's `unit` is read per row where a drill's
+ *   and an end mill's come from config.
+ * - **The optional columns.** `Re`, `L3` and `D3` are present on some families
+ *   and absent on others, and the *absence* means something specific: no
+ *   corner radius is a square end (RE 0); no `L3` on a plain-shank tool means
+ *   AP1MAX is the shoulder length too; no `D3` means the shoulder is the
+ *   cutting diameter. Those three fallbacks are Kennametal-table facts and
+ *   they stay here.
+ *
+ * What deliberately stays out: whether a corner radius makes a tool a bull
+ * nose, `LB` and `assemblyGaugeLength` being `OAL` on a bare tool, and every
+ * cutting preset. Those are true of a tool, not of a table.
+ */
+import { ScraperConfigError, VendorResponseError } from '../../errors.js';
+import { familyBrand } from '../../family.js';
+import { BRANDS } from '../../identity.js';
+import { toolRecord } from '../../records.js';
+import { threadMajorDiameter } from '../../thread.js';
+import { MATERIALS_COLUMN, materialClasses } from './materials.js';
+/**
+ * Kennametal's identity columns. Named here rather than inline so a table that
+ * renames one fails in a single place.
+ */
+export const MATERIAL_NUMBER = 'Material Number';
+export const CATALOG_NUMBER = 'ISO Catalog Number';
+/**
+ * One canonical dimension, or null when this family maps or publishes none.
+ *
+ * Null is a real state and the callers distinguish it: an absent `Re` is a
+ * square-end tool, an absent `L3` is a plain shank. It is never a silent zero,
+ * because a zero corner radius and an unpublished one are the same number and
+ * different facts.
+ */
+function dim(row, columns, canonical, unit) {
+    const column = columns.column(canonical, unit);
+    if (column === null)
+        return null;
+    const raw = row[column];
+    if (raw === undefined || raw.trim() === '')
+        return null;
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw new VendorResponseError(column, `${JSON.stringify(raw)} is not a number`);
+    }
+    return value;
+}
+/**
+ * A dimension the kind requires. `checkColumnMap` has already refused a family
+ * that maps none, so what this catches is a *row* the vendor left empty —
+ * which is a scrape problem, not a config one, and says so.
+ */
+function require_(row, columns, canonical, unit, what) {
+    const value = dim(row, columns, canonical, unit);
+    if (value === null) {
+        throw new VendorResponseError(what, `no value for ${canonical} in column ` + `${JSON.stringify(columns.column(canonical, unit))}`);
+    }
+    return value;
+}
+/** A per-family constant a mapper cannot proceed without. */
+function fact(family, key, value) {
+    if (value === undefined) {
+        throw new ScraperConfigError(family.id, `a ${family.kind} family must state ${key} as a fact`);
+    }
+    return value;
+}
+/**
+ * The `Thread System` tag, refusing anything that is not one of the two.
+ *
+ * Read here and nowhere else, because the two readers of a cast tag defaulted
+ * in *opposite* directions: this module took anything that was not `'inch'` as
+ * metric, and `thread.threadMajorDiameter` took anything that was not
+ * `'metric'` as inch. A missing, empty or capitalised tag then produced a
+ * record whose `DC` was parsed in inches and whose `TP`/`SFDM`/`OAL`/`LCF`
+ * came from the `_mm` columns — the silent unit mix `conventions` exists to
+ * make impossible.
+ */
+function threadSystem(row, what) {
+    const value = row['Thread System'] ?? '';
+    if (value !== 'metric' && value !== 'inch') {
+        throw new VendorResponseError(what, `Thread System is ${JSON.stringify(value)}, not "metric" or "inch" — ` +
+            `a tap family states it as a constant column on the scrape`);
+    }
+    return value;
+}
+/** An integer column the vendor always publishes — the flute count. */
+function count(row, column, what) {
+    const value = Number.parseInt(row[column] ?? '', 10);
+    if (!Number.isInteger(value)) {
+        throw new VendorResponseError(what, `no integer in column ${JSON.stringify(column)}`);
+    }
+    return value;
+}
+/**
+ * A drill, in the family's native unit system per its `unit` fact.
+ *
+ * Every drill table publishes both unit columns, so `unit` is config and never
+ * inferred: it decides which column is read and what a machinist is shown.
+ * Getting it wrong converts cleanly and prints 5.9531 mm where the part
+ * ordered is a 15/64 in KenDrill TXD.
+ *
+ * L4 (max drilling depth) and L5 (point length) are mapped by no family and
+ * reach no record — but L5 is not inert, because it is what pins `pointAngle`
+ * on a family whose table states none. See `families/kennametal.ts`.
+ */
+export function drillRecord(row, family, columns) {
+    const unit = fact(family, 'unit', family.unit);
+    const what = row[MATERIAL_NUMBER] ?? '';
+    return toolRecord({
+        vendor: BRANDS[familyBrand(family)].vendor,
+        materialNumber: what,
+        catalogNumber: row[CATALOG_NUMBER] ?? '',
+        description: row[CATALOG_NUMBER] ?? '',
+        kind: 'drill',
+        unit,
+        substrate: fact(family, 'bmc', family.bmc),
+        grade: row['Grade'] ?? '',
+        materialGroups: materialClasses(row[MATERIALS_COLUMN]),
+        coolantThrough: fact(family, 'coolantThrough', family.coolantThrough),
+        nonFerrous: fact(family, 'nonFerrous', family.nonFerrous),
+        geometry: {
+            DC: require_(row, columns, 'DC', unit, what),
+            SFDM: require_(row, columns, 'SFDM', unit, what),
+            OAL: require_(row, columns, 'OAL', unit, what),
+            LCF: require_(row, columns, 'LCF', unit, what),
+            NOF: fact(family, 'flutes', family.flutes),
+            SIG: fact(family, 'pointAngle', family.pointAngle),
+        },
+    });
+}
+/**
+ * A tap, in **its own** native unit system rather than the family's.
+ *
+ * `Thread System` is a constant column the scraper tags on, because the table
+ * does not state it; metric taps read the mm columns and inch taps the inch
+ * ones. `Thread Pitch` is already native-unit — derived from `D1-TDZ` by
+ * `thread-column.addThreadPitch` — which is why `TP` is dimensional but
+ * unsuffixed.
+ *
+ * `DC` is **derived, not read**: a tap table publishes a thread designation
+ * (`#2-56`, `M6 X 1`) and no major-diameter column, so the major diameter is
+ * parsed out of the designation. That is arithmetic over a standard, which is
+ * why `threadMajorDiameter` sits in the core.
+ */
+export function tapRecord(row, family, columns) {
+    const system = threadSystem(row, row[MATERIAL_NUMBER] ?? '');
+    const unit = system === 'inch' ? 'inches' : 'millimeters';
+    const tdz = row['D1-TDZ'] ?? '';
+    const what = row[MATERIAL_NUMBER] ?? '';
+    return toolRecord({
+        vendor: BRANDS[familyBrand(family)].vendor,
+        materialNumber: what,
+        catalogNumber: row[CATALOG_NUMBER] ?? '',
+        // The designation is part of what a tap *is*, and the catalog number alone
+        // does not carry the size.
+        description: `${row[CATALOG_NUMBER] ?? ''} ${tdz}`,
+        kind: 'tap',
+        unit,
+        substrate: fact(family, 'bmc', family.bmc),
+        // A tap has no carbide grade; the record's grade carries the coating.
+        grade: row['Coating'] ?? '',
+        materialGroups: materialClasses(row[MATERIALS_COLUMN]),
+        coolantThrough: false,
+        geometry: {
+            DC: threadMajorDiameter(tdz, system),
+            TP: require_(row, columns, 'TP', unit, what),
+            SFDM: require_(row, columns, 'SFDM', unit, what),
+            OAL: require_(row, columns, 'OAL', unit, what),
+            LCF: require_(row, columns, 'LCF', unit, what),
+            NOF: count(row, 'Z', what),
+        },
+    });
+}
+/**
+ * A solid end mill, native unit per the family's `unit` fact.
+ *
+ * Three optional columns, and each absence carries a meaning this table
+ * assigns rather than one the domain does:
+ *
+ * - **no `Re`** → a square-end family, corner radius 0;
+ * - **no `L3`** → nothing below the flutes to reach past, so the maximum flute
+ *   length is the shoulder length too (the WIDIA VariMill tables);
+ * - **no `D3`** → a plain shank, so the shoulder is the cutting diameter.
+ *
+ * Whether a radius makes it a bull nose is a consumer's call, not this one.
+ */
+export function endmillRecord(row, family, columns) {
+    const unit = fact(family, 'unit', family.unit);
+    const what = row[MATERIAL_NUMBER] ?? '';
+    const dc = require_(row, columns, 'DC', unit, what);
+    const fluteLength = require_(row, columns, 'LCF', unit, what);
+    return toolRecord({
+        vendor: BRANDS[familyBrand(family)].vendor,
+        materialNumber: what,
+        catalogNumber: row[CATALOG_NUMBER] ?? '',
+        description: row[CATALOG_NUMBER] ?? '',
+        kind: 'endmill',
+        unit,
+        substrate: fact(family, 'bmc', family.bmc),
+        grade: row['Grade'] ?? '',
+        materialGroups: materialClasses(row[MATERIALS_COLUMN]),
+        coolantThrough: fact(family, 'coolantThrough', family.coolantThrough),
+        geometry: {
+            DC: dc,
+            RE: dim(row, columns, 'RE', unit) ?? 0,
+            SFDM: require_(row, columns, 'SFDM', unit, what),
+            OAL: require_(row, columns, 'OAL', unit, what),
+            LCF: fluteLength,
+            'shoulder-length': dim(row, columns, 'shoulder-length', unit) ?? fluteLength,
+            'shoulder-diameter': dim(row, columns, 'shoulder-diameter', unit) ?? dc,
+            NOF: count(row, 'Z', what),
+        },
+    });
+}
+export const RECORD_MAPPERS = {
+    drill: drillRecord,
+    tap: tapRecord,
+    endmill: endmillRecord,
+};

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

@@ -0,0 +1,111 @@
+/**
+ * Family page -> rows, for every brand on Kennametal's AEM platform.
+ *
+ * Family pages render their variant table client-side, but the table comes
+ * from a plain AEM GET that returns ALL variants as one HTML table — no
+ * pagination, no JS, no bot-blocking. The package runbook records how the
+ * endpoint was found and how to read a new brand's component node off a family
+ * page.
+ *
+ * Column identity comes from the `<th>` class attribute (e.g.
+ * `"DRL_CUT_D1_MIN metric"`), NOT the visible label — labels like `D1` repeat
+ * across unit pairs and non-dimensional columns like wire size.
+ *
+ * ## The one dependency in this package, and why it is here
+ *
+ * Node ships no HTML parser, so this module declares `htmlparser2` — and
+ * declares it rather than putting it in the core, on the rule that *a
+ * transport that needs a parser declares it; nothing shared may pretend to
+ * know how a vendor serves a table.* This module is the only importer:
+ * REGO-FIX's XML is read by regex and Destiny Tool's Firestore is JSON.
+ *
+ * `decodeEntities` is on — these tables carry `&deg;` and `&Oslash;` in cell
+ * text, and a raw `&#248;` in a description would reach the CSV as five
+ * characters.
+ */
+import type { Fetcher } from '../../fetch.js';
+import { type AemBrandName } from '../../identity.js';
+import type { ScrapeResult } from '../../scrape.js';
+export declare const BASE: string;
+/**
+ * The Hybris/Solr facet string that scopes a request to a family's active
+ * variants. The family code in the URL path already scopes to the family, so
+ * this only drops the discontinued ones. `materials` appends a second facet to
+ * it; nothing else should need to.
+ */
+export declare const ACTIVE_ONLY = ":relevance:obsoleteFacet:false";
+/**
+ * The class the vendor renders instead of a table when a query matches
+ * nothing. Distinguishing that from a response we failed to parse is the whole
+ * reason {@link parseVariantTable} looks for it.
+ */
+export declare const NO_RESULTS = "class=\"no-results\"";
+/**
+ * One parsed cell: its collapsed text, and the tag's attributes. Column
+ * identity lives in those attributes, never in the text — see the note above.
+ */
+export type Cell = readonly [text: string, attrs: Record<string, string>];
+export type Row = Cell[];
+/** A constant column appended to every row — `['Thread System', 'metric']`. */
+export type Tag = readonly [name: string, value: string];
+/** Collects rows of `[cellText, attributes]` pairs. */
+export declare class TableParser {
+    readonly rows: Row[];
+    private row;
+    private cell;
+    private attrs;
+    /** Feed a whole document. */
+    feed(html: string): void;
+}
+/** One family's variants URL. */
+export declare function variantsUrl(code: string, brand?: AemBrandName, query?: string): string;
+/**
+ * One family's variants response, as HTML.
+ *
+ * The one network call in this module, and the seam every test replaces —
+ * everything below it parses a string.
+ */
+export declare function fetchVariants(fetcher: Fetcher, code: string, brand?: AemBrandName, query?: string): Promise<string>;
+/** What {@link parseVariantTable} answers with. */
+export interface VariantTable {
+    /** Null when the vendor's own no-results notice came back instead. */
+    header: Row | null;
+    rows: Row[];
+}
+/**
+ * The header row and the data rows of a variants response.
+ *
+ * Both callers need the same two subtleties and neither is obvious, which is
+ * why this is one function rather than two copies: the header is found by its
+ * "Material Number" cell rather than by position (the response opens with
+ * filter rows that are also `<tr>`s), and a data row is one exactly as long as
+ * the header whose second cell is all digits. Header, filter and footer rows
+ * all fail one of those two tests.
+ *
+ * A **matched-nothing** response has no table in it at all, only the vendor's
+ * own no-results notice, and comes back with a null header. That is the
+ * ordinary answer to a facet query for a group a family isn't rated for
+ * (`materials`), and a hard error for a family scrape — so it is returned as a
+ * state rather than thrown, and {@link scrapeFamily} is what decides it's fatal.
+ *
+ * A response with neither the notice nor a header is a *third* thing: the
+ * endpoint changed shape. That throws, because silently reporting zero rows
+ * would look exactly like the vendor discontinuing a family.
+ */
+export declare function parseVariantTable(html: string): VariantTable;
+/**
+ * Build unique column names from header label + `th` class unit hints.
+ *
+ * A `null` entry is a column the CSV drops — the checkbox, the sticky CTA, and
+ * the marketing flag. The list stays positional so it can be zipped against a
+ * data row.
+ */
+export declare function columnNames(header: readonly Cell[]): (string | null)[];
+/**
+ * Scrape one family into rows.
+ *
+ * `tags` is a sequence of `[name, value]` pairs appended to every row as
+ * constant columns — used to tag facts the table doesn't state, e.g. the
+ * thread system on a tap family.
+ */
+export declare function scrapeFamily(fetcher: Fetcher, code: string, brand?: AemBrandName, tags?: readonly Tag[]): Promise<ScrapeResult>;

package/dist/vendors/kennametal/scrape.js

@@ -0,0 +1,226 @@
+/**
+ * Family page -> rows, for every brand on Kennametal's AEM platform.
+ *
+ * Family pages render their variant table client-side, but the table comes
+ * from a plain AEM GET that returns ALL variants as one HTML table — no
+ * pagination, no JS, no bot-blocking. The package runbook records how the
+ * endpoint was found and how to read a new brand's component node off a family
+ * page.
+ *
+ * Column identity comes from the `<th>` class attribute (e.g.
+ * `"DRL_CUT_D1_MIN metric"`), NOT the visible label — labels like `D1` repeat
+ * across unit pairs and non-dimensional columns like wire size.
+ *
+ * ## The one dependency in this package, and why it is here
+ *
+ * Node ships no HTML parser, so this module declares `htmlparser2` — and
+ * declares it rather than putting it in the core, on the rule that *a
+ * transport that needs a parser declares it; nothing shared may pretend to
+ * know how a vendor serves a table.* This module is the only importer:
+ * REGO-FIX's XML is read by regex and Destiny Tool's Firestore is JSON.
+ *
+ * `decodeEntities` is on — these tables carry `&deg;` and `&Oslash;` in cell
+ * text, and a raw `&#248;` in a description would reach the CSV as five
+ * characters.
+ */
+import { Parser } from 'htmlparser2';
+import { VendorResponseError } from '../../errors.js';
+import { BRANDS } from '../../identity.js';
+export const BASE = 'https://www.{host}/us/en/products/fam/_jcr_content/root/' +
+    'responsivegrid/{node}.variants.{code}.html' +
+    '?query={query}&uom=metric';
+/**
+ * The Hybris/Solr facet string that scopes a request to a family's active
+ * variants. The family code in the URL path already scopes to the family, so
+ * this only drops the discontinued ones. `materials` appends a second facet to
+ * it; nothing else should need to.
+ */
+export const ACTIVE_ONLY = ':relevance:obsoleteFacet:false';
+/**
+ * The class the vendor renders instead of a table when a query matches
+ * nothing. Distinguishing that from a response we failed to parse is the whole
+ * reason {@link parseVariantTable} looks for it.
+ */
+export const NO_RESULTS = 'class="no-results"';
+const SKIP_CLASSES = ['collab-checkbox-header', 'sticky-column', 'marketingFirstChoice'];
+/** Collects rows of `[cellText, attributes]` pairs. */
+export class TableParser {
+    rows = [];
+    row = null;
+    cell = null;
+    attrs = {};
+    /** Feed a whole document. */
+    feed(html) {
+        const parser = new Parser({
+            onopentag: (tag, attribs) => {
+                if (tag === 'tr') {
+                    this.row = [];
+                }
+                else if ((tag === 'td' || tag === 'th') && this.row !== null) {
+                    this.cell = '';
+                    this.attrs = { ...attribs };
+                }
+            },
+            ontext: (text) => {
+                if (this.cell !== null)
+                    this.cell += text;
+            },
+            onclosetag: (tag) => {
+                if (tag === 'tr' && this.row !== null) {
+                    this.rows.push(this.row);
+                    this.row = null;
+                }
+                else if ((tag === 'td' || tag === 'th') && this.cell !== null) {
+                    this.row?.push([collapse(this.cell), this.attrs]);
+                    this.cell = null;
+                }
+            },
+        }, { decodeEntities: true });
+        parser.write(html);
+        parser.end();
+    }
+}
+/** `" a  b \n"` -> `"a b"`, as Python's `' '.join(s.split())` does. */
+function collapse(text) {
+    return text.split(/\s+/).filter(Boolean).join(' ');
+}
+/** One family's variants URL. */
+export function variantsUrl(code, brand = 'kennametal', query = ACTIVE_ONLY) {
+    const { host, node } = BRANDS[brand];
+    return BASE.replace('{host}', host)
+        .replace('{node}', node)
+        .replace('{code}', code)
+        .replace('{query}', encodeURIComponent(query));
+}
+/**
+ * One family's variants response, as HTML.
+ *
+ * The one network call in this module, and the seam every test replaces —
+ * everything below it parses a string.
+ */
+export async function fetchVariants(fetcher, code, brand = 'kennametal', query = ACTIVE_ONLY) {
+    return fetcher.text(variantsUrl(code, brand, query));
+}
+/**
+ * The header row and the data rows of a variants response.
+ *
+ * Both callers need the same two subtleties and neither is obvious, which is
+ * why this is one function rather than two copies: the header is found by its
+ * "Material Number" cell rather than by position (the response opens with
+ * filter rows that are also `<tr>`s), and a data row is one exactly as long as
+ * the header whose second cell is all digits. Header, filter and footer rows
+ * all fail one of those two tests.
+ *
+ * A **matched-nothing** response has no table in it at all, only the vendor's
+ * own no-results notice, and comes back with a null header. That is the
+ * ordinary answer to a facet query for a group a family isn't rated for
+ * (`materials`), and a hard error for a family scrape — so it is returned as a
+ * state rather than thrown, and {@link scrapeFamily} is what decides it's fatal.
+ *
+ * A response with neither the notice nor a header is a *third* thing: the
+ * endpoint changed shape. That throws, because silently reporting zero rows
+ * would look exactly like the vendor discontinuing a family.
+ */
+export function parseVariantTable(html) {
+    const parser = new TableParser();
+    parser.feed(html);
+    const header = parser.rows.find((row) => row.some(([text]) => text === 'Material Number')) ?? null;
+    if (header === null) {
+        if (html.includes(NO_RESULTS))
+            return { header: null, rows: [] };
+        throw new VendorResponseError('variants response', `has neither a Material Number header nor the vendor's ` +
+            `${JSON.stringify(NO_RESULTS)} marker — the endpoint changed shape`);
+    }
+    const rows = parser.rows.filter((row) => row.length === header.length && /^\d+$/.test(row[1]?.[0] ?? ''));
+    return { header, rows };
+}
+/**
+ * Build unique column names from header label + `th` class unit hints.
+ *
+ * A `null` entry is a column the CSV drops — the checkbox, the sticky CTA, and
+ * the marketing flag. The list stays positional so it can be zipped against a
+ * data row.
+ */
+export function columnNames(header) {
+    const labelCounts = new Map();
+    for (const [text] of header) {
+        labelCounts.set(text, (labelCounts.get(text) ?? 0) + 1);
+    }
+    const names = header.map(([text, attrs]) => {
+        const cls = attrs['class'] ?? '';
+        if (!text || SKIP_CLASSES.some((skip) => cls.includes(skip)))
+            return null;
+        if (cls.includes('CatNo')) {
+            // Catalog number columns carry unit classes but are not dimensions.
+            return text;
+        }
+        if (cls.includes('metric'))
+            return `${text}_mm`;
+        if (cls.includes('inch'))
+            return `${text}_in`;
+        if ((labelCounts.get(text) ?? 0) > 1) {
+            // A unitless column sharing a label with a unit pair, e.g. a third `D1`
+            // with data-value `[D1] Wire Size` -> `D1_wire_size`.
+            const title = (attrs['data-value'] ?? '').replace(/^\[[^\]]*\]\s*/, '').trim();
+            if (title && title.toLowerCase() !== text.toLowerCase()) {
+                const slug = title
+                    .replace(/[^A-Za-z0-9]+/g, '_')
+                    .replace(/^_+|_+$/g, '')
+                    .toLowerCase();
+                return `${text}_${slug}`;
+            }
+        }
+        return text;
+    });
+    // Refused rather than allowed to collide: `scrapeFamily` writes `out[name]`,
+    // so a repeated name kept the last column's data under a header the CSV
+    // still printed twice — the loss the class-based identity above exists to
+    // prevent.
+    const seen = new Set();
+    for (const name of names) {
+        if (name === null)
+            continue;
+        if (seen.has(name)) {
+            throw new VendorResponseError('variants response', `two columns are both named ${JSON.stringify(name)} — neither a unit ` +
+                `class nor a data-value title tells them apart`);
+        }
+        seen.add(name);
+    }
+    return names;
+}
+/**
+ * Scrape one family into rows.
+ *
+ * `tags` is a sequence of `[name, value]` pairs appended to every row as
+ * constant columns — used to tag facts the table doesn't state, e.g. the
+ * thread system on a tap family.
+ */
+export async function scrapeFamily(fetcher, code, brand = 'kennametal', tags = []) {
+    const url = variantsUrl(code, brand);
+    const { header, rows: dataRows } = parseVariantTable(await fetcher.text(url));
+    if (header === null) {
+        throw new VendorResponseError(`family ${code}`, 'the vendor returned no variants');
+    }
+    const names = columnNames(header);
+    const kept = names.filter((name) => name !== null);
+    const csvHeader = [...kept, ...tags.map(([name]) => name)];
+    const rows = dataRows.map((row) => {
+        // `dataRows` is filtered to rows exactly as long as the header, and
+        // `names` has one entry per header cell, so a length mismatch here means
+        // the table changed shape mid-parse. Truncating silently would shift every
+        // column after the gap by one.
+        if (row.length !== names.length) {
+            throw new VendorResponseError(`family ${code}`, `a data row has ${row.length} cells where the header has ` +
+                `${names.length} — the table changed shape mid-parse`);
+        }
+        const out = {};
+        names.forEach((name, index) => {
+            if (name !== null)
+                out[name] = row[index]?.[0] ?? '';
+        });
+        for (const [name, value] of tags)
+            out[name] = value;
+        return out;
+    });
+    return { header: csvHeader, rows, source: url, familyCode: code };
+}

package/dist/vendors/kennametal/thread-column.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The `Thread Pitch` column Kennametal's tap tables do not publish.
+ *
+ * The arithmetic is in `thread.ts` — parsing a thread designation is a
+ * standard, not a vendor's. What is Kennametal's, and therefore here, is that
+ * the designation arrives in a column named `D1-TDZ`, that the thread system
+ * arrives in a `Thread System` tag column this package appends at scrape time,
+ * and that a pitch column has to be derived at all because the vendor's table
+ * carries none.
+ */
+import type { ScrapeResult } from '../../scrape.js';
+/** The vendor's column holding the thread designation — `#2-56`, `M6 X 1`. */
+export declare const DESIGNATION_COLUMN = "D1-TDZ";
+/** The constant column the scraper tags on, because the table states none. */
+export declare const SYSTEM_COLUMN = "Thread System";
+/** The column this module derives. */
+export declare const PITCH_COLUMN = "Thread Pitch";
+/**
+ * Add (or replace) the `Thread Pitch` column on a tap scrape.
+ *
+ * Safe to re-run: an existing pitch column is dropped and rebuilt, and the
+ * column is always reinserted directly after `D1-TDZ`, so re-running produces
+ * a byte-identical result rather than appending a second copy.
+ *
+ * Returns a new result rather than rewriting a file in place, so this step
+ * composes with the others instead of needing a CSV between them.
+ */
+export declare function addThreadPitch(scrape: ScrapeResult): ScrapeResult;

package/dist/vendors/kennametal/thread-column.js

@@ -0,0 +1,41 @@
+/**
+ * The `Thread Pitch` column Kennametal's tap tables do not publish.
+ *
+ * The arithmetic is in `thread.ts` — parsing a thread designation is a
+ * standard, not a vendor's. What is Kennametal's, and therefore here, is that
+ * the designation arrives in a column named `D1-TDZ`, that the thread system
+ * arrives in a `Thread System` tag column this package appends at scrape time,
+ * and that a pitch column has to be derived at all because the vendor's table
+ * carries none.
+ */
+import { VendorResponseError } from '../../errors.js';
+import { threadPitch } from '../../thread.js';
+/** The vendor's column holding the thread designation — `#2-56`, `M6 X 1`. */
+export const DESIGNATION_COLUMN = 'D1-TDZ';
+/** The constant column the scraper tags on, because the table states none. */
+export const SYSTEM_COLUMN = 'Thread System';
+/** The column this module derives. */
+export const PITCH_COLUMN = 'Thread Pitch';
+/**
+ * Add (or replace) the `Thread Pitch` column on a tap scrape.
+ *
+ * Safe to re-run: an existing pitch column is dropped and rebuilt, and the
+ * column is always reinserted directly after `D1-TDZ`, so re-running produces
+ * a byte-identical result rather than appending a second copy.
+ *
+ * Returns a new result rather than rewriting a file in place, so this step
+ * composes with the others instead of needing a CSV between them.
+ */
+export function addThreadPitch(scrape) {
+    const header = scrape.header.filter((name) => name !== PITCH_COLUMN);
+    const at = header.indexOf(DESIGNATION_COLUMN);
+    if (at === -1) {
+        throw new VendorResponseError(PITCH_COLUMN, `the scrape has no ${DESIGNATION_COLUMN} column to derive a pitch from`);
+    }
+    header.splice(at + 1, 0, PITCH_COLUMN);
+    const rows = scrape.rows.map((row) => ({
+        ...row,
+        [PITCH_COLUMN]: threadPitch(row[DESIGNATION_COLUMN] ?? '', (row[SYSTEM_COLUMN] ?? '')),
+    }));
+    return { ...scrape, header, rows };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * REGO-FIX — toolholding only, and nothing here is shared with Kennametal.
+ *
+ * Different CMS, different transport, and — the part that surprises — the
+ * roster and the geometry are two different fetches. See
+ * `docs/REGOFIX_PRODUCTFINDER_API.md`.
+ */
+export * from './scrape.js';

package/dist/vendors/regofix/index.js

@@ -0,0 +1,8 @@
+/**
+ * REGO-FIX — toolholding only, and nothing here is shared with Kennametal.
+ *
+ * Different CMS, different transport, and — the part that surprises — the
+ * roster and the geometry are two different fetches. See
+ * `docs/REGOFIX_PRODUCTFINDER_API.md`.
+ */
+export * from './scrape.js';