@toolpath/tool-scraper 0.1.0

package/dist/registry.js

@@ -0,0 +1,145 @@
+/**
+ * Which adapter serves which family — the composition root.
+ *
+ * `families/` is the config table and `vendors/` are the adapters; this is the
+ * one module that knows both, and it exists so that neither has to. Putting
+ * the binding in the config table made the table import a manufacturer, which
+ * `tests/vendor-boundary.test.ts` refuses for good reason: the table is read
+ * by every test, and none of those should drag a vendor's scraper in behind it.
+ *
+ * **This is the seam a per-vendor distribution would replace with an
+ * entry-point registry.** When a vendor package can be installed from outside
+ * the tree, the {@link ADAPTERS} table below becomes a lookup over those and
+ * nothing else here changes shape. Until then one repository holds every
+ * adapter, which is what lets one commit change the record contract and every
+ * adapter together.
+ *
+ * ## Binding is lazy, not an import side effect
+ *
+ * A mapping fault has to surface as an error naming the family, not as a
+ * missing-key fault from inside a mapper on row 1 of a scrape that already
+ * ran. Binding at import would buy that and charge for it: a consumer that
+ * imports one helper should not pay to validate a catalog it never reads.
+ *
+ * So it is memoised instead: the first call to {@link boundFamilies} validates
+ * every family and every fact, and the failure still names the family and the
+ * key. What changes is only *when* — first use rather than import — and every
+ * entry point into this package goes through here.
+ */
+import { COLLET_FAMILIES, FAMILIES, HOLDER_FAMILIES } from './families/index.js';
+import { ScraperConfigError } from './errors.js';
+import { checkFact } from './provenance.js';
+import { checkColumnMap } from './records.js';
+import { RECORD_MAPPERS as DESTINYTOOL } from './vendors/destinytool/records.js';
+import { RECORD_MAPPERS as KENNAMETAL } from './vendors/kennametal/records.js';
+/**
+ * Brand -> its row-to-record mappers, by tool kind.
+ *
+ * One entry serves two brands: Kennametal and WIDIA are the same AEM platform
+ * and the same table vocabulary, so one adapter covers both, exactly as one
+ * scraper does. A brand absent from here can still be scraped — REGO-FIX ships
+ * toolholding and no cutting tools, and only cutting tools go through a column
+ * map.
+ */
+export const ADAPTERS = {
+    kennametal: KENNAMETAL,
+    widia: KENNAMETAL,
+    destinytool: DESTINYTOOL,
+};
+/**
+ * Check every fact of one family and project its value onto the config under
+ * its own key.
+ *
+ * **This is what stops a fact being a second source of truth.** The fact is
+ * the only authored copy; the plain key is a projection with one owner.
+ * Readers keep saying `family.unit` and never learn about provenance, which is
+ * right — provenance is evidence for a person and a gate, not an input to
+ * arithmetic.
+ *
+ * `FamilyDefinition` declares no constant keys, so a family that also set the
+ * plain key is a compile error and there is nothing left to check at runtime.
+ */
+function project(table, name, cfg) {
+    const facts = cfg.facts ?? {};
+    const projected = { ...cfg };
+    for (const [key, fact] of Object.entries(facts)) {
+        checkFact(`${table} ${name}`, key, fact);
+        projected[key] = fact.value;
+    }
+    return projected;
+}
+let families = null;
+let toolholding = null;
+/**
+ * Every cutting-tool family, validated and bound to its record mapper.
+ *
+ * Memoised, so calling it twice is free and a fault is reported once.
+ */
+export function boundFamilies() {
+    if (families !== null)
+        return families;
+    const bound = new Map();
+    for (const [name, cfg] of Object.entries(FAMILIES)) {
+        const brand = cfg.brand ?? 'kennametal';
+        const mappers = ADAPTERS[brand];
+        if (mappers === undefined) {
+            throw new ScraperConfigError(name, `brand ${JSON.stringify(brand)} has no record adapter — a vendor ` +
+                `that ships cutting tools needs one ` +
+                `(known: ${Object.keys(ADAPTERS).sort().join(', ')})`);
+        }
+        const records = mappers[cfg.kind];
+        if (records === undefined) {
+            throw new ScraperConfigError(name, `brand ${JSON.stringify(brand)} has no ${cfg.kind} mapper ` +
+                `(it maps: ${Object.keys(mappers).sort().join(', ')})`);
+        }
+        const projected = project('tool', name, cfg);
+        bound.set(name, {
+            ...projected,
+            columns: checkColumnMap(name, cfg.kind, cfg.columns),
+            records,
+        });
+    }
+    families = bound;
+    return bound;
+}
+/**
+ * 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.
+ */
+export function boundToolholding() {
+    if (toolholding !== null)
+        return toolholding;
+    const bound = new Map();
+    for (const [table, families_] of [
+        ['holder', HOLDER_FAMILIES],
+        ['collet', COLLET_FAMILIES],
+    ]) {
+        for (const [name, cfg] of Object.entries(families_)) {
+            bound.set(name, project(table, name, cfg));
+        }
+    }
+    toolholding = bound;
+    return bound;
+}
+/** One bound cutting-tool family by CSV name. */
+export function boundFamily(name) {
+    const cfg = boundFamilies().get(name);
+    if (cfg === undefined) {
+        throw new ScraperConfigError(name, `unknown cutting-tool family (known: ` + `${[...boundFamilies().keys()].sort().join(', ')})`);
+    }
+    return cfg;
+}
+/**
+ * Forget what has been bound.
+ *
+ * For tests that put a family in front of the gate. Nothing in a running
+ * scrape should need it — the tables are module constants, so a second bind
+ * would produce the same answer.
+ */
+export function resetBindings() {
+    families = null;
+    toolholding = null;
+}

package/dist/scrape.d.ts

@@ -0,0 +1,70 @@
+/**
+ * What a scrape hands back.
+ *
+ * Rows rather than a written file and a count: a Node backend embedding this
+ * wants the rows, and writing a CSV is one of several things it might then do
+ * with them. `@toolpath/tool-scraper/node` is what turns one into a CSV and a
+ * receipt beside it. The two pieces of provenance a receipt needs —
+ * where the rows came from, and under which vendor family code — travel with
+ * the rows rather than being reconstructed by the caller, because finding the
+ * request again is the most expensive part of adding a vendor.
+ */
+/** One scraped row: the vendor's own column labels, and its own strings. */
+export type ScrapedRow = Readonly<Record<string, string>>;
+/** One family's scrape: the rows, and enough provenance to write a receipt. */
+export interface ScrapeResult {
+    /**
+     * The CSV column order, positional.
+     *
+     * Kept beside the rows rather than derived from them: a row whose cell is
+     * empty still has to occupy its column, and deriving the header from the
+     * first row's keys would drop a column the vendor left blank on that row.
+     */
+    readonly header: readonly string[];
+    readonly rows: readonly ScrapedRow[];
+    /**
+     * The URL the rows came from. A request, not a page: this is the thing to
+     * re-issue when a column changes shape.
+     */
+    readonly source: string;
+    /**
+     * The vendor's own family code where there is one. REGO-FIX and Destiny Tool
+     * have none — their scrape target is a set of index filters — so it is null
+     * rather than an empty string, which would read as a code the vendor left
+     * blank.
+     */
+    readonly familyCode: string | null;
+}
+/**
+ * Where a scraper reports something it could not resolve but did not fail on.
+ *
+ * Injected rather than printed: a backend wants these in its own log, and a
+ * CLI wants them on stderr. Defaults to `console.warn`, so a call site that
+ * does not care passes nothing.
+ */
+export type Warn = (message: string) => void;
+/** Options every record mapper accepts. */
+export interface MapperOptions {
+    warn?: Warn;
+}
+/** The default: stderr, where a message nobody injected a sink for belongs. */
+export declare const consoleWarn: Warn;
+/**
+ * Milliseconds between requests, wherever a scrape or a mirror loops.
+ *
+ * Politeness, not rate-limit avoidance, and one number rather than a copy per
+ * loop: the Kennametal CAD annotate step, its material sweep and the
+ * vendor-neutral STEP mirror all wanted the same 400 ms, and three constants
+ * saying so drifted apart the moment one of them was tuned.
+ */
+export declare const REQUEST_DELAY_MS = 400;
+/**
+ * Wait between requests, skipped entirely at zero.
+ *
+ * Politeness, not rate-limit avoidance. It lived in the Kennametal adapter
+ * because that is the only vendor whose scrape loops — and the vendor-boundary
+ * test is what moved it: `node/cad-mirror.ts` needed it too, and a core module
+ * reaching into one manufacturer for a three-line helper is exactly the leak
+ * that rule exists to catch. Same call `conventions.CAD_COLUMN` got.
+ */
+export declare function pause(ms: number): Promise<void>;

package/dist/scrape.js

@@ -0,0 +1,37 @@
+/**
+ * What a scrape hands back.
+ *
+ * Rows rather than a written file and a count: a Node backend embedding this
+ * wants the rows, and writing a CSV is one of several things it might then do
+ * with them. `@toolpath/tool-scraper/node` is what turns one into a CSV and a
+ * receipt beside it. The two pieces of provenance a receipt needs —
+ * where the rows came from, and under which vendor family code — travel with
+ * the rows rather than being reconstructed by the caller, because finding the
+ * request again is the most expensive part of adding a vendor.
+ */
+/** The default: stderr, where a message nobody injected a sink for belongs. */
+export const consoleWarn = (message) => {
+    console.warn(message);
+};
+/**
+ * Milliseconds between requests, wherever a scrape or a mirror loops.
+ *
+ * Politeness, not rate-limit avoidance, and one number rather than a copy per
+ * loop: the Kennametal CAD annotate step, its material sweep and the
+ * vendor-neutral STEP mirror all wanted the same 400 ms, and three constants
+ * saying so drifted apart the moment one of them was tuned.
+ */
+export const REQUEST_DELAY_MS = 400;
+/**
+ * Wait between requests, skipped entirely at zero.
+ *
+ * Politeness, not rate-limit avoidance. It lived in the Kennametal adapter
+ * because that is the only vendor whose scrape loops — and the vendor-boundary
+ * test is what moved it: `node/cad-mirror.ts` needed it too, and a core module
+ * reaching into one manufacturer for a three-line helper is exactly the leak
+ * that rule exists to catch. Same call `conventions.CAD_COLUMN` got.
+ */
+export async function pause(ms) {
+    if (ms > 0)
+        await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/thread.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Thread designations in, native-unit numbers out.
+ *
+ * **Core, not an adapter**, and the distinction is the one this package draws
+ * everywhere: a thread designation is a *standard* — `#2-56` is a UTS thread
+ * and `M6 X 1` an ISO metric one whoever prints it — so parsing one is domain
+ * arithmetic that every vendor's taps need and none of them owns. What is
+ * Kennametal's is that its tables publish the designation in a column called
+ * `D1-TDZ` and publish no pitch at all, and that fact lives in
+ * `vendors/kennametal/thread-column.ts` with the CSV step that fixes it.
+ *
+ * Native units throughout — millimetres for metric threads, inches for inch
+ * threads. A tap's system is a per-row fact, so the caller passes it in rather
+ * than this module assuming a family's.
+ *
+ * ## Rounding is pinned, not incidental
+ *
+ * Python's `round` is half-to-even over a float; JavaScript has no direct
+ * equivalent. Both functions below round the way the Python did, and
+ * `tests/thread.test.ts` checks all 2,232 designations this package can
+ * plausibly meet against output generated by it. Within the ranges that occur
+ * — machine screw numbers 0–14, 4 to 80 threads per inch — no value lands on
+ * an exact half, so `Math.round` and half-to-even cannot disagree; the vectors
+ * are what makes that a checked fact rather than an argument.
+ */
+/** Which standard a designation is written in, and therefore its unit. */
+export type ThreadSystem = 'metric' | 'inch';
+/**
+ * Major diameter from a thread designation string, in the thread system's
+ * native unit (mm for metric, inches for inch).
+ *
+ * Formats seen in the scraped tables: `M10X1.5`, `#2-56`, `#0 - 80`,
+ * `1/4 - 20`, `5/16-18`.
+ */
+export declare function threadMajorDiameter(tdz: string, threadSystem: ThreadSystem): number;
+/**
+ * Pitch from a thread designation, in the thread system's native unit.
+ *
+ * ```
+ * metric: 'M6X1'     -> '1'        (mm, the value after the X)
+ * inch:   '#4-40'    -> '0.025'    (in, 1 / threads-per-inch)
+ *         '1/4 - 20' -> '0.05'
+ * ```
+ *
+ * Returned as the string that goes into the CSV, so re-running the step is a
+ * no-op rather than a float round-trip that rewrites `1` as `1.0` in every row.
+ */
+export declare function threadPitch(designation: string, threadSystem: ThreadSystem): string;

package/dist/thread.js

@@ -0,0 +1,98 @@
+/**
+ * Thread designations in, native-unit numbers out.
+ *
+ * **Core, not an adapter**, and the distinction is the one this package draws
+ * everywhere: a thread designation is a *standard* — `#2-56` is a UTS thread
+ * and `M6 X 1` an ISO metric one whoever prints it — so parsing one is domain
+ * arithmetic that every vendor's taps need and none of them owns. What is
+ * Kennametal's is that its tables publish the designation in a column called
+ * `D1-TDZ` and publish no pitch at all, and that fact lives in
+ * `vendors/kennametal/thread-column.ts` with the CSV step that fixes it.
+ *
+ * Native units throughout — millimetres for metric threads, inches for inch
+ * threads. A tap's system is a per-row fact, so the caller passes it in rather
+ * than this module assuming a family's.
+ *
+ * ## Rounding is pinned, not incidental
+ *
+ * Python's `round` is half-to-even over a float; JavaScript has no direct
+ * equivalent. Both functions below round the way the Python did, and
+ * `tests/thread.test.ts` checks all 2,232 designations this package can
+ * plausibly meet against output generated by it. Within the ranges that occur
+ * — machine screw numbers 0–14, 4 to 80 threads per inch — no value lands on
+ * an exact half, so `Math.round` and half-to-even cannot disagree; the vectors
+ * are what makes that a checked fact rather than an argument.
+ */
+/** `M10X1.5` — the capital `X` is required, as the Python's pattern was. */
+const METRIC_MAJOR = /^M([0-9]+(?:\.[0-9]+)?)X[0-9.]+$/;
+/** `M6 x 1`, `M6X1` — pitch parsing accepts either case, major diameter does not. */
+const METRIC_PITCH = /[xX]\s*([\d.]+)\s*$/;
+/** `#4-40`, `1/4 - 20` — the trailing number is threads per inch. */
+const INCH_PITCH = /-\s*([\d.]+)\s*$/;
+/** Round to `places` decimals the way Python's `round(x, places)` does here. */
+function round(value, places) {
+    const scale = 10 ** places;
+    return Math.round(value * scale) / scale;
+}
+/**
+ * Major diameter from a thread designation string, in the thread system's
+ * native unit (mm for metric, inches for inch).
+ *
+ * Formats seen in the scraped tables: `M10X1.5`, `#2-56`, `#0 - 80`,
+ * `1/4 - 20`, `5/16-18`.
+ */
+export function threadMajorDiameter(tdz, threadSystem) {
+    const s = tdz.replaceAll(' ', '');
+    if (threadSystem === 'metric') {
+        const match = METRIC_MAJOR.exec(s);
+        if (!match?.[1]) {
+            throw new RangeError(`unrecognized metric thread designation: ${tdz}`);
+        }
+        return Number(match[1]);
+    }
+    const size = s.split('-', 1)[0] ?? '';
+    if (size.startsWith('#')) {
+        // ANSI machine-screw numbers: major dia = 0.060 + 0.013 * N inches
+        const n = Number.parseInt(size.slice(1), 10);
+        if (!Number.isInteger(n)) {
+            throw new RangeError(`unrecognized inch thread designation: ${tdz}`);
+        }
+        return round(0.06 + 0.013 * n, 4);
+    }
+    if (size.includes('/')) {
+        const [num, den] = size.split('/');
+        const value = Number(num) / Number(den);
+        // A designation like `1/` parses to NaN, which would otherwise travel into
+        // a record as a diameter. Every other unreadable shape here throws.
+        if (!Number.isFinite(value)) {
+            throw new RangeError(`unrecognized inch thread designation: ${tdz}`);
+        }
+        return value;
+    }
+    throw new RangeError(`unrecognized inch thread designation: ${tdz}`);
+}
+/**
+ * Pitch from a thread designation, in the thread system's native unit.
+ *
+ * ```
+ * metric: 'M6X1'     -> '1'        (mm, the value after the X)
+ * inch:   '#4-40'    -> '0.025'    (in, 1 / threads-per-inch)
+ *         '1/4 - 20' -> '0.05'
+ * ```
+ *
+ * Returned as the string that goes into the CSV, so re-running the step is a
+ * no-op rather than a float round-trip that rewrites `1` as `1.0` in every row.
+ */
+export function threadPitch(designation, threadSystem) {
+    if (threadSystem === 'metric') {
+        const match = METRIC_PITCH.exec(designation);
+        if (match?.[1])
+            return match[1];
+    }
+    else {
+        const match = INCH_PITCH.exec(designation);
+        if (match?.[1])
+            return String(round(1 / Number(match[1]), 6));
+    }
+    throw new RangeError(`cannot parse pitch from ${designation} (${threadSystem})`);
+}

package/dist/uuid5.d.ts

@@ -0,0 +1,31 @@
+/**
+ * RFC 4122 name-based UUIDs, version 5.
+ *
+ * Python's `uuid` module ships this; Node's does not — `node:crypto` offers
+ * `randomUUID` and nothing else — so the eleven lines are here rather than as
+ * a dependency. It is SHA-1 over the namespace's 16 bytes followed by the
+ * name's UTF-8 bytes, truncated to 16, with the version and variant bits
+ * overwritten.
+ *
+ * **This has to agree with Python's `uuid.uuid5` byte for byte.** Tool guids
+ * are the join key every downstream consumer of a scrape uses, so a value that
+ * differs by one bit is not a formatting difference, it is a catalog that no
+ * longer matches the one scraped last month. `tests/identity.test.ts` pins the
+ * output against values generated by the Python this was ported from, for the
+ * ordinary case and for the two that would catch an encoding slip — a name
+ * with non-ASCII in it, and the empty name.
+ */
+/**
+ * RFC 4122's namespace for URLs.
+ *
+ * The only namespace this package seeds from: every brand's namespace is
+ * itself a v5 UUID of that brand's home page under this one.
+ */
+export declare const NAMESPACE_URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+/**
+ * The version 5 UUID of `name` within `namespace`.
+ *
+ * Deterministic across machines and runs, which is the whole point — see the
+ * module docstring.
+ */
+export declare function uuid5(namespace: string, name: string): string;

package/dist/uuid5.js

@@ -0,0 +1,64 @@
+/**
+ * RFC 4122 name-based UUIDs, version 5.
+ *
+ * Python's `uuid` module ships this; Node's does not — `node:crypto` offers
+ * `randomUUID` and nothing else — so the eleven lines are here rather than as
+ * a dependency. It is SHA-1 over the namespace's 16 bytes followed by the
+ * name's UTF-8 bytes, truncated to 16, with the version and variant bits
+ * overwritten.
+ *
+ * **This has to agree with Python's `uuid.uuid5` byte for byte.** Tool guids
+ * are the join key every downstream consumer of a scrape uses, so a value that
+ * differs by one bit is not a formatting difference, it is a catalog that no
+ * longer matches the one scraped last month. `tests/identity.test.ts` pins the
+ * output against values generated by the Python this was ported from, for the
+ * ordinary case and for the two that would catch an encoding slip — a name
+ * with non-ASCII in it, and the empty name.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * RFC 4122's namespace for URLs.
+ *
+ * The only namespace this package seeds from: every brand's namespace is
+ * itself a v5 UUID of that brand's home page under this one.
+ */
+export const NAMESPACE_URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+/** The 16 bytes a hyphenated UUID string denotes. */
+function bytesOf(uuid) {
+    const hex = uuid.replaceAll('-', '');
+    if (hex.length !== 32 || !/^[0-9a-fA-F]{32}$/.test(hex)) {
+        throw new TypeError(`not a UUID: ${uuid}`);
+    }
+    return Buffer.from(hex, 'hex');
+}
+/** The canonical 8-4-4-4-12 rendering of 16 bytes. */
+function format(bytes) {
+    const hex = bytes.toString('hex');
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        hex.slice(12, 16),
+        hex.slice(16, 20),
+        hex.slice(20, 32),
+    ].join('-');
+}
+/**
+ * The version 5 UUID of `name` within `namespace`.
+ *
+ * Deterministic across machines and runs, which is the whole point — see the
+ * module docstring.
+ */
+export function uuid5(namespace, name) {
+    const digest = createHash('sha1')
+        .update(bytesOf(namespace))
+        .update(Buffer.from(name, 'utf8'))
+        .digest();
+    const bytes = digest.subarray(0, 16);
+    // Version 5 in the high nibble of octet 6, and the RFC 4122 variant in the
+    // top two bits of octet 8. `writeUInt8`/`readUInt8` rather than index
+    // assignment so the arithmetic is on `number` and not on `number |
+    // undefined` under `noUncheckedIndexedAccess`.
+    bytes.writeUInt8((bytes.readUInt8(6) & 0x0f) | 0x50, 6);
+    bytes.writeUInt8((bytes.readUInt8(8) & 0x3f) | 0x80, 8);
+    return format(bytes);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Destiny Tool — solid end mills, sold direct from a live Firestore database.
+ *
+ * Not a server-rendered vendor catalog: the storefront is a Next.js SPA built
+ * on Firebase Studio with no product data in the HTML, so the "scrape" is a
+ * paginated Firestore REST client rather than an HTML table parser. See
+ * `scrape.ts` for the endpoint and `records.ts` for what the adapter derives
+ * from free-text descriptions that the vendor's structured fields leave blank.
+ */
+export * from './records.js';
+export * from './scrape.js';

package/dist/vendors/destinytool/index.js

@@ -0,0 +1,11 @@
+/**
+ * Destiny Tool — solid end mills, sold direct from a live Firestore database.
+ *
+ * Not a server-rendered vendor catalog: the storefront is a Next.js SPA built
+ * on Firebase Studio with no product data in the HTML, so the "scrape" is a
+ * paginated Firestore REST client rather than an HTML table parser. See
+ * `scrape.ts` for the endpoint and `records.ts` for what the adapter derives
+ * from free-text descriptions that the vendor's structured fields leave blank.
+ */
+export * from './records.js';
+export * from './scrape.js';

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

@@ -0,0 +1,118 @@
+/**
+ * Destiny Tool rows -> {@link ToolRecord}.
+ *
+ * Destiny Tool publishes exactly one identifier (`itemNumber`), no carbide
+ * grade, no structured shank column, and dimensions as fractional-inch
+ * **strings** rather than decimal columns — the closest precedent in this
+ * package is `thread.threadMajorDiameter`'s designation parsing, not any other
+ * vendor's dimension reader, all of which already publish decimals.
+ *
+ * **Three geometry fields are derived from the free-text `description` rather
+ * than a column, because no column exists for them**: a shank diameter from a
+ * "SHK" annotation, a corner radius from a "RAD" annotation when the vendor's
+ * own `rad` cell is blank, and a neck diameter from a "NECK" annotation. The
+ * latter two were found scraping the real collection 2026-08-19. All three
+ * follow the same shape: real vendor data (a populated column) wins when
+ * present, and the description is read only when the column is not — absence
+ * is a stated fact, not a gap to fill.
+ *
+ * **A per-record derivation is not a `Fact`.** These three are arithmetic over
+ * a row, so they belong in code with their evidence beside them; a fact is a
+ * per-family constant nothing in the table states, and putting one of these
+ * there would claim a whole family's provenance for a value that varies row by
+ * row.
+ */
+import { type BoundFamily, type RecordMappers } from '../../family.js';
+import { type ColumnMap, type ToolRecord } from '../../records.js';
+import { type MapperOptions, type ScrapedRow } from '../../scrape.js';
+/**
+ * Destiny Tool's one identifier. There is no second catalog number the way
+ * Kennametal publishes an ISO number alongside a material number — the item
+ * number fills both roles on a record.
+ */
+export declare const ITEM_NUMBER = "itemNumber";
+/**
+ * Flute counts at or below this route to the non-ferrous material-group
+ * fallback — see {@link materialGroups}.
+ */
+export declare const NON_FERROUS_MAX_FLUTES = 3;
+/**
+ * A Destiny Tool dimension string, in inches.
+ *
+ * Every form seen across the real scrape (2026-08-19): a decimal (`.093`), a
+ * bare or quoted whole number (`1`, `1"`), a simple fraction (`3/4`), or a
+ * mixed number, quoted or not (`1-1/2`, `1-1/2"`).
+ */
+export declare function parseFractionInches(text: string): number;
+/**
+ * The shank diameter: parsed off a "SHK" annotation when the tool is necked or
+ * reduced-shank, or the cutting diameter otherwise.
+ *
+ * Destiny Tool has no structured shank column at all — unlike Kennametal,
+ * where an absent `D` column would be a scrape bug, here a shank equal to the
+ * cut diameter is simply never stated in the vendor's own text either (checked
+ * over the full scrape, 2026-08-19).
+ */
+export declare function shankDiameter(description: string, dc: number): number;
+/**
+ * The corner radius, in priority order.
+ *
+ * 1. The vendor's own `rad` cell, when populated — real data wins, and this is
+ *    trusted outright the way every scraped column in this package is.
+ * 2. `DC / 2` on a `Ball` end mill, which Destiny Tool publishes with no
+ *    radius column at all for that style (checked 2026-08-19).
+ * 3. The description's own "RAD" annotation, for the 123 of 3,898 rows found
+ *    2026-08-19 where `endStyle` is `"Corner Radius"` but the `rad` cell is
+ *    blank and the text states one anyway. A range like `".035-.040 RAD"`
+ *    resolves to its **upper** bound: across the 370 rows that state a range
+ *    and also publish a populated `rad` cell, the cell equals the upper bound
+ *    352 times (95%) and the lower bound 18 times, so the upper bound is the
+ *    better-corroborated guess for the rows where only the range is available.
+ *
+ *    **Recovered from text, so it is checked rather than trusted outright.**
+ *    `V33220R093` states `"0.93 RAD"` where its two siblings (identical
+ *    geometry, different coating) both say `".093 RAD"` and the item number's
+ *    own `093` suffix agrees with them — a vendor typo missing a leading zero,
+ *    found running this against the real scrape. A value that would make the
+ *    tool geometrically impossible (2×RE > DC) is not used; the row falls
+ *    through to 4 instead, with a warning.
+ * 4. `0` — a real square end — when nothing states one (2 of 3,898 rows), or
+ *    when 3 recovered a value this package will not ship.
+ */
+export declare function cornerRadius(description: string, endStyle: string, what: string, dc: number, radCell: number | null, warn?: import("../../scrape.js").Warn): number;
+/**
+ * The neck (shoulder) diameter: parsed off a "NECK" annotation when the tool
+ * is necked, or the cutting diameter otherwise — a plain-shank tool below the
+ * flutes, the same convention a family with no neck column at all uses.
+ * Destiny Tool never publishes a structured neck column; the description
+ * states one on 171 of 3,898 rows (2026-08-19) and this reads it rather than
+ * defaulting every row to plain-shank.
+ */
+export declare function shoulderDiameter(description: string, dc: number): number;
+/**
+ * The ISO workpiece-material groups: the vendor's own `isoMaterialGroups`
+ * column when populated, or a fallback keyed on flute count when it is not
+ * (blank on 423 of 3,898 rows, 2026-08-19).
+ *
+ * The fallback is not a new rule invented for this vendor — it is the split
+ * cutting-data presets are routed by downstream (≤3 flutes non-ferrous, >3
+ * ferrous), applied here to the material-groups facet instead. Real vendor
+ * data wins when present: the full scrape shows 92 ≤3-flute rows whose stated
+ * groups are not exactly `['N']` and 168 >3-flute rows whose stated groups
+ * include `N`, so this is deliberately a fallback for the blank cells and not
+ * a correction of the populated ones.
+ *
+ * **The populated cell is reordered onto `ISO_MATERIAL_GROUPS`, not passed
+ * through in Destiny Tool's own order.** Its `isoMaterialGroups` array comes
+ * back as e.g. `['M', 'P', 'S']` — alphabetical-ish, not the ISO 513 sequence
+ * every other list agrees on — and a consumer that renders a facet from one
+ * array and a tool's own list from another has no way to notice the two
+ * disagree.
+ */
+export declare function materialGroups(row: ScrapedRow, flutes: number): string[];
+/**
+ * A solid end mill, always in inches — Destiny Tool publishes no metric line
+ * (the `unit` fact on the family).
+ */
+export declare function endmillRecord(row: ScrapedRow, family: BoundFamily, columns: ColumnMap, options?: MapperOptions): ToolRecord;
+export declare const RECORD_MAPPERS: RecordMappers;