@toolpath/tool-scraper 0.1.0

package/dist/vendors/kennametal/cad.js

@@ -0,0 +1,119 @@
+/**
+ * Vendor CAD model URLs: material number in, a static STEP link out.
+ *
+ * Kennametal's product pages don't host their CAD models — a third party does
+ * (CDS Visual, on `product-config.net`), and the page reaches it in one of two
+ * ways. For an *assembly* it POSTs a job, polls a batch, and gets back a
+ * transient generated ZIP. For a **single part with no child components** —
+ * every holder in this catalog — it takes a different branch entirely and asks
+ * for a pre-built static file:
+ *
+ * ```
+ * GET https://www.product-config.net/catalog3/cad?d=kennametal&id=<material>
+ * ```
+ *
+ * That returns `staticURLs`, a map of format key -> permanent CloudFront URL,
+ * and the files behind it are ordinary objects with a `Last-Modified` in 2024.
+ * The response also states `authenticatedDownload: false`, which is what makes
+ * a direct link viable: no login, no session, no token.
+ *
+ * `docs/KENNAMETAL_CAD_API.md` documents the endpoint and the format keys.
+ * This module scrapes one of them — `stp-lwm`, the lightweight STEP, which is
+ * the collision model to give a CAM package as holder geometry.
+ *
+ * ## Why the download half is not in this module
+ *
+ * Mirroring every STEP file onto disk is a maintainer's batch job — it takes
+ * an output directory, writes ~54 KB per part with a rate-limit pause between,
+ * and has no return value a caller wants. It lives in `node/cad-mirror.ts` and
+ * is reachable only from the CLI.
+ *
+ * What a backend consuming this package wants is the permanent URL, which is
+ * what {@link lightweightStepUrl} and {@link annotateCadUrls} give it — to
+ * link to, or to fetch on demand, rather than to bulk-mirror. The seam was
+ * already here: the annotate step writes a URL precisely so that downloading
+ * is a separate, later, optional step.
+ */
+import { CAD_COLUMN } from '../../conventions.js';
+import { statusOf } from '../../fetch.js';
+import { REQUEST_DELAY_MS, pause } from '../../scrape.js';
+export const CAD_API = 'https://www.product-config.net/catalog3/cad?d=kennametal&id={material}';
+/**
+ * The `staticURLs` key for the lightweight STEP — CDS calls it LWM, the vendor
+ * UI calls it "3D Anti Collision Model", and it is the simplified solid rather
+ * than the full graphical model (`stp-gtm`).
+ *
+ * The column it is written to is `conventions.CAD_COLUMN`, shared with every
+ * other vendor's scraper because a consumer reads exactly one. What is
+ * Kennametal-specific is *which* of CDS Visual's formats fills it — that is
+ * this constant, and it stays here.
+ */
+export const LIGHTWEIGHT_STEP = 'stp-lwm';
+/** The CAD metadata for one material number. */
+export async function fetchCad(fetcher, material) {
+    return fetcher.json(CAD_API.replace('{material}', material));
+}
+/**
+ * The lightweight STEP URL from a CAD payload, or null when there is none.
+ *
+ * Null is a real state and not an error: the vendor's own UI carries a "we do
+ * not have any CAD models available for download" case, and a holder without a
+ * published model is a holder this package should say nothing about rather
+ * than offer a dead link for. All twenty holders scraped so far do have one,
+ * which is exactly why the absent case needs a test rather than a reassuring
+ * assumption.
+ */
+export function lightweightStepUrl(payload) {
+    if (!payload.cadAvailable)
+        return null;
+    const url = (payload.staticURLs ?? {})[LIGHTWEIGHT_STEP];
+    return typeof url === 'string' && url ? url : null;
+}
+/**
+ * {@link fetchCad}, with a 404 read as "the vendor publishes none".
+ *
+ * The docstring below promises a row whose lookup finds no model keeps an
+ * empty cell and is never dropped. That held only for the `cadAvailable:
+ * false` payload — a 404 threw out of the loop and abandoned the whole file
+ * part-annotated, past `main()`'s catch and onto a stack trace. Any other
+ * status is still a failed request and still stops the run.
+ *
+ * Duck-typed through `statusOf` rather than `instanceof`, so a caller's own
+ * {@link Fetcher} gets the same handling — the same call `vendors/regofix`
+ * makes for the holders whose DIN 4000 document does not exist.
+ */
+async function cadFor(fetcher, material) {
+    try {
+        return await fetchCad(fetcher, material);
+    }
+    catch (error) {
+        if (statusOf(error) === 404)
+            return { cadAvailable: false };
+        throw error;
+    }
+}
+/**
+ * Add (or refresh) the CAD model column on a toolholding scrape.
+ *
+ * Safe to re-run, like the thread-pitch and material-group steps: an existing
+ * column is rebuilt rather than duplicated. A row whose lookup finds no model
+ * keeps an empty cell; the row is never dropped, because the holder still
+ * exists.
+ */
+export async function annotateCadUrls(fetcher, scrape, delayMs = REQUEST_DELAY_MS) {
+    if (scrape.rows.length === 0)
+        return { scrape, found: 0 };
+    const column = CAD_COLUMN;
+    const header = scrape.header.includes(column) ? [...scrape.header] : [...scrape.header, column];
+    let found = 0;
+    const rows = [];
+    for (const [index, row] of scrape.rows.entries()) {
+        if (index)
+            await pause(delayMs);
+        const url = lightweightStepUrl(await cadFor(fetcher, row['Material Number'] ?? ''));
+        if (url)
+            found += 1;
+        rows.push({ ...row, [column]: url ?? '' });
+    }
+    return { scrape: { ...scrape, header, rows }, found };
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Kennametal and WIDIA — one adapter, because they are one platform.
+ *
+ * Both run the same AEM/Hybris component on the same URL shape; only the host,
+ * the component node name and the vendor string differ, and `identity.BRANDS`
+ * is where that is recorded. Treating them as two adapters would duplicate
+ * every module here to encode one differing node name.
+ *
+ * **Their data directories are still separate**, and the distinction is worth
+ * holding on to: an adapter is a fact about *code*, a receipt is a fact about
+ * *who published it*. So WIDIA's scraped tables live under WIDIA's own brand
+ * even though this module is what scraped them, and a CSV is resolved through
+ * its family's `brand` rather than through the adapter that wrote it. A future
+ * brand on this same platform is a `BRANDS` entry and a data directory, and no
+ * code here at all.
+ */
+export * from './cad.js';
+export * from './materials.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './thread-column.js';

package/dist/vendors/kennametal/index.js

@@ -0,0 +1,21 @@
+/**
+ * Kennametal and WIDIA — one adapter, because they are one platform.
+ *
+ * Both run the same AEM/Hybris component on the same URL shape; only the host,
+ * the component node name and the vendor string differ, and `identity.BRANDS`
+ * is where that is recorded. Treating them as two adapters would duplicate
+ * every module here to encode one differing node name.
+ *
+ * **Their data directories are still separate**, and the distinction is worth
+ * holding on to: an adapter is a fact about *code*, a receipt is a fact about
+ * *who published it*. So WIDIA's scraped tables live under WIDIA's own brand
+ * even though this module is what scraped them, and a CSV is resolved through
+ * its family's `brand` rather than through the adapter that wrote it. A future
+ * brand on this same platform is a `BRANDS` entry and a data directory, and no
+ * code here at all.
+ */
+export * from './cad.js';
+export * from './materials.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './thread-column.js';

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

@@ -0,0 +1,143 @@
+/**
+ * Which ISO workpiece materials a tool is indexed for, from the search facet.
+ *
+ * The variant table this package scrapes carries no material column: it states
+ * geometry and the carbide *grade* (KCU20, KCPM15), and a grade is what the
+ * tool is made of, not what it is meant to cut. The applicability lives in two
+ * other places on the same pages, and this module reads the machine-readable
+ * one.
+ *
+ * **The source is the `workpieceMaterialDetail` search facet**, the panel of
+ * P/M/K/N/S/H/C checkboxes on a category listing. It is a Solr facet over the
+ * same index the variants endpoint queries, so appending it to that endpoint's
+ * `query` parameter filters the family's table down to the variants indexed
+ * for one group — no second endpoint, no second parser. Sweeping the 32 groups
+ * and collecting which variants come back gives every tool its own list.
+ *
+ * **It is enforced, which is what makes an empty answer meaningful.** An
+ * unknown group value returns zero rows rather than being ignored, so "this
+ * family matched nothing under N1" is a statement about the vendor's index and
+ * not about a typo. (An unknown *facet name* is ignored, which is why the name
+ * here is a constant and not a caller's argument.) Verified JG 2026-08-05.
+ *
+ * **What this is not.** The family pages also publish an Application Data
+ * table: per ISO subgroup, with ap/ae limits, a cutting-speed range and feed
+ * per tooth by diameter. That is the engineering data and it is richer, and on
+ * two of the six endmill families it *disagrees* with this facet — MaxiMet's
+ * table lists N5 (plastics) where the facet stops at N4, and both GOmill
+ * families' facets claim all 28 groups including H3/H4 where the metric
+ * family's own table stops at H2. The facet is the marketing-side index and is
+ * the broader of the two. It is what this module scrapes because it is
+ * per-variant and structured; the application table is a separate scrape that
+ * has not been written. Don't read a group here as a vendor speed-and-feed
+ * recommendation.
+ *
+ * Taps carry no material indexing at all — all three tap families return zero
+ * rows for all 32 groups. That is a vendor gap, not a scrape failure, and it
+ * is pinned in the tests so that a vendor who starts publishing them fails a
+ * test rather than going unnoticed.
+ */
+import type { Fetcher } from '../../fetch.js';
+import type { AemBrandName } from '../../identity.js';
+import { type ScrapeResult } from '../../scrape.js';
+/**
+ * The facet this module queries. A constant rather than a parameter because a
+ * misspelled facet *name* is silently ignored by the endpoint and would report
+ * every group as matching every tool.
+ */
+export declare const FACET = "workpieceMaterialDetail";
+/**
+ * The column {@link addMaterialGroups} writes, holding one row's groups
+ * space-separated in {@link MATERIAL_GROUPS} order.
+ */
+export declare const MATERIALS_COLUMN = "Material Groups";
+/**
+ * The vendor's ISO 513 workpiece groups, in the order the facet panel lists
+ * them — letter by machining class, then subgroup by increasing difficulty.
+ * Read off the facet panel of a Kennametal category listing (JG 2026-08-05);
+ * the titles and hardness bands that go with each code are a *display* concern
+ * and belong with whatever displays them, not here.
+ *
+ * This list is the sweep vocabulary, so a group the vendor adds later is
+ * invisible until it is added here. That is the safe direction to fail: a
+ * missing group under-reports a tool rather than inventing an application for
+ * it.
+ */
+export declare const MATERIAL_GROUPS: readonly ["P0", "P1", "P2", "P3", "P4", "P5", "P6", "M1", "M2", "M3", "K1", "K2", "K3", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "S1", "S2", "S3", "S4", "H1", "H2", "H3", "H4", "C1", "C2", "C3", "C4"];
+/**
+ * ISO 513's main groups — the letters, in the vendor's own panel order, which
+ * happens to be the standard's own order too. Re-exported from
+ * `records.ISO_MATERIAL_GROUPS` rather than redefined here — see that
+ * constant's docstring for why the ordering is a domain fact and not a
+ * Kennametal one.
+ */
+export declare const ISO_CLASSES: readonly ["P", "M", "K", "N", "S", "H", "C"];
+/**
+ * The Material Numbers in one family that are indexed for one group.
+ *
+ * The only network call here. An empty set is the ordinary answer for a group
+ * the family isn't rated for.
+ */
+export declare function materialsInGroup(fetcher: Fetcher, code: string, group: string, brand?: AemBrandName): Promise<Set<string>>;
+/** Options for a material sweep. */
+export interface SweepOptions {
+    brand?: AemBrandName;
+    groups?: readonly string[];
+    delayMs?: number;
+}
+/**
+ * Sweep every group and invert the result: material number -> its groups.
+ *
+ * Values keep {@link MATERIAL_GROUPS} order rather than being sorted, so the
+ * written column reads P before M before K the way the vendor's own panel
+ * does, and so re-running produces a byte-identical result.
+ *
+ * **Per material number, not per family**, even though all eleven families
+ * scraped so far answer uniformly — every group either matched every variant
+ * or none of them. A single family-wide list would be a claim this sweep
+ * cannot actually support, and it would go from true to false silently the
+ * first time a vendor splits a family by size.
+ */
+export declare function groupsByMaterial(fetcher: Fetcher, code: string, options?: SweepOptions): Promise<Map<string, string[]>>;
+/** What {@link addMaterialGroups} answers with. */
+export interface MaterialSweep {
+    scrape: ScrapeResult;
+    /**
+     * How many rows got at least one group — deliberately not the row count, so
+     * a sweep that found nothing reads as `0 of 259` at the call site rather
+     * than as success. Zero is nonetheless a legitimate result for a tap family;
+     * the caller reports the number and does not judge it.
+     */
+    matched: number;
+}
+/**
+ * Add (or refresh) the material-groups column on a family scrape.
+ *
+ * Safe to re-run, like {@link addThreadPitch} and the CAD annotation: an
+ * existing column is rebuilt rather than duplicated.
+ */
+export declare function addMaterialGroups(scrape: ScrapeResult, found: Map<string, string[]>): MaterialSweep;
+/**
+ * The column back into a list.
+ *
+ * Unknown codes are dropped rather than passed through: this column is
+ * generated, so anything not in {@link MATERIAL_GROUPS} came from a hand-edit,
+ * and a made-up group would reach a catalog's filter panel as a value no
+ * control could ever offer.
+ */
+export declare function parseMaterialGroups(cell: string | undefined): string[];
+/**
+ * The column collapsed to ISO 513 main groups — `P`, `M`, `K`, …
+ *
+ * **The subgroup is scraped and then deliberately dropped here.** The facet
+ * publishes 32 subgroups and the CSV keeps all of them, because the CSV is the
+ * record of what the vendor said; but P0 through P6 is a hardness band within
+ * steel, and the question a catalog answers is "does this end mill cut steel".
+ * Keeping the band would mean labelling 28 codes whose distinctions (`S3`
+ * nickel alloys versus `S4` titanium) matter enormously to a cut and not at
+ * all to picking a tool off a shelf.
+ *
+ * Collapsing here rather than at the scrape is what keeps that reversible:
+ * re-deriving subgroups is an edit here, not a re-scrape.
+ */
+export declare function materialClasses(cell: string | undefined): string[];

package/dist/vendors/kennametal/materials.js

@@ -0,0 +1,200 @@
+/**
+ * Which ISO workpiece materials a tool is indexed for, from the search facet.
+ *
+ * The variant table this package scrapes carries no material column: it states
+ * geometry and the carbide *grade* (KCU20, KCPM15), and a grade is what the
+ * tool is made of, not what it is meant to cut. The applicability lives in two
+ * other places on the same pages, and this module reads the machine-readable
+ * one.
+ *
+ * **The source is the `workpieceMaterialDetail` search facet**, the panel of
+ * P/M/K/N/S/H/C checkboxes on a category listing. It is a Solr facet over the
+ * same index the variants endpoint queries, so appending it to that endpoint's
+ * `query` parameter filters the family's table down to the variants indexed
+ * for one group — no second endpoint, no second parser. Sweeping the 32 groups
+ * and collecting which variants come back gives every tool its own list.
+ *
+ * **It is enforced, which is what makes an empty answer meaningful.** An
+ * unknown group value returns zero rows rather than being ignored, so "this
+ * family matched nothing under N1" is a statement about the vendor's index and
+ * not about a typo. (An unknown *facet name* is ignored, which is why the name
+ * here is a constant and not a caller's argument.) Verified JG 2026-08-05.
+ *
+ * **What this is not.** The family pages also publish an Application Data
+ * table: per ISO subgroup, with ap/ae limits, a cutting-speed range and feed
+ * per tooth by diameter. That is the engineering data and it is richer, and on
+ * two of the six endmill families it *disagrees* with this facet — MaxiMet's
+ * table lists N5 (plastics) where the facet stops at N4, and both GOmill
+ * families' facets claim all 28 groups including H3/H4 where the metric
+ * family's own table stops at H2. The facet is the marketing-side index and is
+ * the broader of the two. It is what this module scrapes because it is
+ * per-variant and structured; the application table is a separate scrape that
+ * has not been written. Don't read a group here as a vendor speed-and-feed
+ * recommendation.
+ *
+ * Taps carry no material indexing at all — all three tap families return zero
+ * rows for all 32 groups. That is a vendor gap, not a scrape failure, and it
+ * is pinned in the tests so that a vendor who starts publishing them fails a
+ * test rather than going unnoticed.
+ */
+import { ISO_MATERIAL_GROUPS } from '../../records.js';
+import { REQUEST_DELAY_MS, pause } from '../../scrape.js';
+import { ACTIVE_ONLY, fetchVariants, parseVariantTable } from './scrape.js';
+/**
+ * The facet this module queries. A constant rather than a parameter because a
+ * misspelled facet *name* is silently ignored by the endpoint and would report
+ * every group as matching every tool.
+ */
+export const FACET = 'workpieceMaterialDetail';
+/**
+ * The column {@link addMaterialGroups} writes, holding one row's groups
+ * space-separated in {@link MATERIAL_GROUPS} order.
+ */
+export const MATERIALS_COLUMN = 'Material Groups';
+/**
+ * The vendor's ISO 513 workpiece groups, in the order the facet panel lists
+ * them — letter by machining class, then subgroup by increasing difficulty.
+ * Read off the facet panel of a Kennametal category listing (JG 2026-08-05);
+ * the titles and hardness bands that go with each code are a *display* concern
+ * and belong with whatever displays them, not here.
+ *
+ * This list is the sweep vocabulary, so a group the vendor adds later is
+ * invisible until it is added here. That is the safe direction to fail: a
+ * missing group under-reports a tool rather than inventing an application for
+ * it.
+ */
+export const MATERIAL_GROUPS = [
+    'P0',
+    'P1',
+    'P2',
+    'P3',
+    'P4',
+    'P5',
+    'P6',
+    'M1',
+    'M2',
+    'M3',
+    'K1',
+    'K2',
+    'K3',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'S1',
+    'S2',
+    'S3',
+    'S4',
+    'H1',
+    'H2',
+    'H3',
+    'H4',
+    'C1',
+    'C2',
+    'C3',
+    'C4',
+];
+/**
+ * ISO 513's main groups — the letters, in the vendor's own panel order, which
+ * happens to be the standard's own order too. Re-exported from
+ * `records.ISO_MATERIAL_GROUPS` rather than redefined here — see that
+ * constant's docstring for why the ordering is a domain fact and not a
+ * Kennametal one.
+ */
+export const ISO_CLASSES = ISO_MATERIAL_GROUPS;
+/**
+ * The Material Numbers in one family that are indexed for one group.
+ *
+ * The only network call here. An empty set is the ordinary answer for a group
+ * the family isn't rated for.
+ */
+export async function materialsInGroup(fetcher, code, group, brand = 'kennametal') {
+    const html = await fetchVariants(fetcher, code, brand, `${ACTIVE_ONLY}:${FACET}:${group}`);
+    const { rows } = parseVariantTable(html);
+    return new Set(rows.map((row) => row[1]?.[0] ?? ''));
+}
+/**
+ * Sweep every group and invert the result: material number -> its groups.
+ *
+ * Values keep {@link MATERIAL_GROUPS} order rather than being sorted, so the
+ * written column reads P before M before K the way the vendor's own panel
+ * does, and so re-running produces a byte-identical result.
+ *
+ * **Per material number, not per family**, even though all eleven families
+ * scraped so far answer uniformly — every group either matched every variant
+ * or none of them. A single family-wide list would be a claim this sweep
+ * cannot actually support, and it would go from true to false silently the
+ * first time a vendor splits a family by size.
+ */
+export async function groupsByMaterial(fetcher, code, options = {}) {
+    const { brand = 'kennametal', groups = MATERIAL_GROUPS, delayMs = REQUEST_DELAY_MS } = options;
+    const found = new Map();
+    for (const [index, group] of groups.entries()) {
+        if (index)
+            await pause(delayMs);
+        for (const material of await materialsInGroup(fetcher, code, group, brand)) {
+            const existing = found.get(material);
+            if (existing)
+                existing.push(group);
+            else
+                found.set(material, [group]);
+        }
+    }
+    return found;
+}
+/**
+ * Add (or refresh) the material-groups column on a family scrape.
+ *
+ * Safe to re-run, like {@link addThreadPitch} and the CAD annotation: an
+ * existing column is rebuilt rather than duplicated.
+ */
+export function addMaterialGroups(scrape, found) {
+    if (scrape.rows.length === 0)
+        return { scrape, matched: 0 };
+    const header = scrape.header.includes(MATERIALS_COLUMN)
+        ? [...scrape.header]
+        : [...scrape.header, MATERIALS_COLUMN];
+    let matched = 0;
+    const rows = scrape.rows.map((row) => {
+        const groups = found.get(row['Material Number'] ?? '') ?? [];
+        if (groups.length > 0)
+            matched += 1;
+        return { ...row, [MATERIALS_COLUMN]: groups.join(' ') };
+    });
+    return { scrape: { ...scrape, header, rows }, matched };
+}
+/**
+ * The column back into a list.
+ *
+ * Unknown codes are dropped rather than passed through: this column is
+ * generated, so anything not in {@link MATERIAL_GROUPS} came from a hand-edit,
+ * and a made-up group would reach a catalog's filter panel as a value no
+ * control could ever offer.
+ */
+export function parseMaterialGroups(cell) {
+    if (!cell)
+        return [];
+    const present = new Set(cell.split(/\s+/).filter(Boolean));
+    return MATERIAL_GROUPS.filter((group) => present.has(group));
+}
+/**
+ * The column collapsed to ISO 513 main groups — `P`, `M`, `K`, …
+ *
+ * **The subgroup is scraped and then deliberately dropped here.** The facet
+ * publishes 32 subgroups and the CSV keeps all of them, because the CSV is the
+ * record of what the vendor said; but P0 through P6 is a hardness band within
+ * steel, and the question a catalog answers is "does this end mill cut steel".
+ * Keeping the band would mean labelling 28 codes whose distinctions (`S3`
+ * nickel alloys versus `S4` titanium) matter enormously to a cut and not at
+ * all to picking a tool off a shelf.
+ *
+ * Collapsing here rather than at the scrape is what keeps that reversible:
+ * re-deriving subgroups is an edit here, not a re-scrape.
+ */
+export function materialClasses(cell) {
+    const present = new Set(parseMaterialGroups(cell).map((g) => g[0]));
+    return ISO_CLASSES.filter((iso) => present.has(iso));
+}

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

@@ -0,0 +1,88 @@
+/**
+ * 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 { type BoundFamily, type RecordMappers } from '../../family.js';
+import { type ColumnMap, type ToolRecord } from '../../records.js';
+import type { ScrapedRow } from '../../scrape.js';
+/**
+ * Kennametal's identity columns. Named here rather than inline so a table that
+ * renames one fails in a single place.
+ */
+export declare const MATERIAL_NUMBER = "Material Number";
+export declare const CATALOG_NUMBER = "ISO Catalog Number";
+/**
+ * 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 declare function drillRecord(row: ScrapedRow, family: BoundFamily, columns: ColumnMap): ToolRecord;
+/**
+ * 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 declare function tapRecord(row: ScrapedRow, family: BoundFamily, columns: ColumnMap): ToolRecord;
+/**
+ * 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 declare function endmillRecord(row: ScrapedRow, family: BoundFamily, columns: ColumnMap): ToolRecord;
+export declare const RECORD_MAPPERS: RecordMappers;