@toolpath/tool-scraper 0.1.0 → 2.0.0

package/dist/vendors/harvey/catalog.js

@@ -0,0 +1,120 @@
+/**
+ * The category tree -> the product pages under it.
+ *
+ * Harvey publishes no sitemap and no flat index: `robots.txt`, `sitemap.xml` and
+ * `sitemap_index.xml` all 404, and `/products/all-products` lists the seven top
+ * categories and no products. Walking the catalog grid is the only way to find
+ * out what exists — see `docs/HARVEY_PRODUCT_TABLE.md` §1.1 and §1.6.
+ *
+ * Nothing in a scrape needs this: `families/harvey.ts` names all 52 product
+ * pages, and a family scrape fetches exactly one. It is here for the maintenance
+ * question that table cannot answer — *has Harvey added a page?* — and the CLI
+ * exposes it as `harvey --catalog` for that purpose.
+ *
+ * A page carries subcategory links or product links, never both, so the
+ * recursion terminates where products appear. Both selectors were verified
+ * against all 33 category pages the four roots reach.
+ */
+import { Parser } from 'htmlparser2';
+import { compare } from '../../order.js';
+import { consoleWarn, pause, REQUEST_DELAY_MS } from '../../scrape.js';
+import { BASE } from './scrape.js';
+/**
+ * The four category trees this adapter covers.
+ *
+ * Harvey's catalog is far larger; these are the trees asked for, and adding one
+ * is a decision rather than a widening of a pattern — see the package's rule on
+ * not adding vendor scope without being asked.
+ */
+export const CATEGORY_ROOTS = [
+    '/products/miniature-end-mills/ball',
+    '/products/miniature-end-mills/corner-radius',
+    '/products/miniature-end-mills/square',
+    '/products/specialty-profiles/keyseat-cutters',
+];
+/** The class marking a link to a subcategory in the catalog grid. */
+const SUBCATEGORY_CLASS = 'img-wrapper';
+/** The classes marking the wrapper around a link to one product. */
+const PRODUCT_CLASSES = ['col-md-4', 'col-12', 'item-wrapper'];
+function classes(attribs) {
+    return (attribs['class'] ?? '').split(/\s+/).filter(Boolean);
+}
+/**
+ * The subcategory and product links on one catalog page.
+ *
+ * Product links are identified by their **wrapper** rather than by the anchor,
+ * because the anchor carries no class of its own — the grid renders
+ * `<div class="col-md-4 col-12 item-wrapper"><a href="/products/...">`. A rule
+ * that took every `/products/` anchor on the page would take the breadcrumb and
+ * the footer with it.
+ */
+export function parseCategoryPage(html) {
+    const subcategories = new Set();
+    const products = new Set();
+    // A depth counter rather than a flag, because the wrapper holds nested divs
+    // and a flag would clear on the first inner close tag.
+    let inProduct = 0;
+    const parser = new Parser({
+        onopentag: (tag, attribs) => {
+            if (inProduct > 0) {
+                inProduct++;
+                if (tag === 'a') {
+                    const href = attribs['href'] ?? '';
+                    if (href.startsWith('/products/'))
+                        products.add(href);
+                }
+                return;
+            }
+            if (tag === 'div' && PRODUCT_CLASSES.every((c) => classes(attribs).includes(c))) {
+                inProduct = 1;
+                return;
+            }
+            if (tag === 'a' && classes(attribs).includes(SUBCATEGORY_CLASS)) {
+                const href = attribs['href'] ?? '';
+                if (href.startsWith('/products/'))
+                    subcategories.add(href);
+            }
+        },
+        onclosetag: () => {
+            if (inProduct > 0)
+                inProduct--;
+        },
+    }, { decodeEntities: true });
+    parser.write(html);
+    parser.end();
+    return {
+        subcategories: [...subcategories].sort(compare),
+        products: [...products].sort(compare),
+    };
+}
+/**
+ * Every product page reachable from `roots`, sorted.
+ *
+ * Sequential and paced by the package's shared politeness delay. The whole walk
+ * is about 33 requests; nothing here needs concurrency, and Cloudflare fronts
+ * this site, so raising request volume is the only real risk.
+ */
+export async function discoverProducts(fetcher, roots = CATEGORY_ROOTS, options = {}) {
+    const { warn = consoleWarn, delayMs = REQUEST_DELAY_MS } = options;
+    const products = new Set();
+    const seen = new Set();
+    const queue = [...roots];
+    while (queue.length > 0) {
+        const path = queue.shift();
+        if (seen.has(path))
+            continue;
+        seen.add(path);
+        const { subcategories, products: found } = parseCategoryPage(await fetcher.text(BASE + path));
+        if (subcategories.length === 0 && found.length === 0) {
+            warn(`  WARNING: ${path} links to neither a subcategory nor a product`);
+        }
+        for (const product of found)
+            products.add(product);
+        for (const child of subcategories) {
+            if (child !== path)
+                queue.push(child);
+        }
+        await pause(delayMs);
+    }
+    return [...products].sort(compare);
+}

package/dist/vendors/harvey/header.d.ts

@@ -0,0 +1,89 @@
+/**
+ * A product table's two-row `<thead>` -> one flat column per `cols<N>` entry.
+ *
+ * Harvey publishes a table's header in the DOM and its data in a JavaScript
+ * literal, and the only thing joining them is position: `cols1` is
+ * `[{data:"a0"}, {data:"a1"}, ...]` and its Nth entry is the Nth column of the
+ * flattened header. That alignment is checked on every table — see
+ * `scrape.ts` — because a header that has drifted by one column produces a CSV
+ * where every dimension is labelled as its neighbour.
+ *
+ * ## Flattening
+ *
+ * The header is exactly two `<tr>`s. A top `<th>` with `rowspan >= 2` is its own
+ * column and has no sub-label (only "Add to Cart" is like this); otherwise it
+ * consumes `colspan` cells from the second row as its sub-labels. Verified
+ * against all 80 tables on the 52 product pages.
+ *
+ * ## Two things about the text
+ *
+ * **`<br>` is a space.** `CUTTER <br/>DIAMETER` is the same label as
+ * `CUTTER DIAMETER`, and collapsing the tag away instead yields
+ * `CUTTERDIAMETER` — a 51st header shape that exists only in the parser.
+ *
+ * **A sub-label's tolerance is excluded, not stripped afterwards.** The
+ * tolerance is rendered in its own `div.hpc-inline`, so skipping that subtree
+ * gives `D1` where reading the whole cell gives `D1+.0005"-.0005"`. It matters
+ * more than tidiness: Harvey's tolerance text carries typos — `D1+0005"-.0005"`,
+ * `R+.001"-001"`, `L2.020"-.000"` are all real — and every one of them would be
+ * another spelling for a post-hoc stripper to get right.
+ */
+/** The class of the `<div>` holding a sub-label's published tolerance. */
+export declare const TOLERANCE_CLASS = "hpc-inline";
+/** The class Harvey renders an unlabelled annotation column's header with. */
+export declare const HIDDEN_CLASS = "white-text";
+/** True where a header label says nothing about what the column holds. */
+export declare function isJunkLabel(label: string): boolean;
+/** One `<th>` as parsed: its text, its span, and its class attribute. */
+interface HeaderCell {
+    text: string;
+    colspan: number;
+    rowspan: number;
+    className: string;
+}
+/** One data column of a table, as the header describes it. */
+export interface HeaderColumn {
+    /** The top row's label, `<br>`s collapsed to spaces. */
+    top: string;
+    /** The second row's label with its tolerance removed, or null under a rowspan. */
+    sub: string | null;
+    /** The top `<th>`'s class attribute — `white-text` marks a hidden column. */
+    topClass: string;
+    /** How many columns the top `<th>` spanned. 1 unless it is a coating group. */
+    span: number;
+    /** This column's index inside that span. 0 on a column of its own. */
+    slot: number;
+}
+/**
+ * The `<th>` rows of the `<thead>` of the table with this id.
+ *
+ * Streams the whole document rather than slicing it: a `</table>` inside a cell
+ * would end a sliced segment early, and htmlparser2 is already this package's
+ * one parser dependency.
+ *
+ * `decodeEntities` is on because these headers carry `&nbsp;` and `&deg;` —
+ * the blank flute sub-label is literally `&nbsp;&nbsp;`, and it has to reach
+ * {@link isJunkLabel} as an empty string rather than as two characters.
+ */
+export declare function parseHeadRows(html: string, tableId: string): HeaderCell[][];
+/**
+ * One table's header, flattened to one entry per data column.
+ *
+ * Throws when the table is not in the document, rather than returning an empty
+ * header: a page that stopped serving a table it declares in `cols<N>` is a
+ * response that changed shape, and a zero-column table would reach the caller
+ * looking like a family the vendor discontinued.
+ */
+export declare function flatHeader(html: string, tableId: string): HeaderColumn[];
+/**
+ * The vendor's own symbol for a dimension column — `D1`, `L2`, `R`, `A1`, `#`.
+ *
+ * Null where the sub-label carries none, which is a real state rather than a
+ * fault: `NECK DIA.` publishes no symbol at all, and the ratio columns publish
+ * junk.
+ *
+ * A trailing `(h6)` is part of the shank tolerance class and not of the symbol,
+ * so `D2(h6)` and `D2` are the same column.
+ */
+export declare function symbolOf(sub: string | null): string | null;
+export {};

package/dist/vendors/harvey/header.js

@@ -0,0 +1,185 @@
+/**
+ * A product table's two-row `<thead>` -> one flat column per `cols<N>` entry.
+ *
+ * Harvey publishes a table's header in the DOM and its data in a JavaScript
+ * literal, and the only thing joining them is position: `cols1` is
+ * `[{data:"a0"}, {data:"a1"}, ...]` and its Nth entry is the Nth column of the
+ * flattened header. That alignment is checked on every table — see
+ * `scrape.ts` — because a header that has drifted by one column produces a CSV
+ * where every dimension is labelled as its neighbour.
+ *
+ * ## Flattening
+ *
+ * The header is exactly two `<tr>`s. A top `<th>` with `rowspan >= 2` is its own
+ * column and has no sub-label (only "Add to Cart" is like this); otherwise it
+ * consumes `colspan` cells from the second row as its sub-labels. Verified
+ * against all 80 tables on the 52 product pages.
+ *
+ * ## Two things about the text
+ *
+ * **`<br>` is a space.** `CUTTER <br/>DIAMETER` is the same label as
+ * `CUTTER DIAMETER`, and collapsing the tag away instead yields
+ * `CUTTERDIAMETER` — a 51st header shape that exists only in the parser.
+ *
+ * **A sub-label's tolerance is excluded, not stripped afterwards.** The
+ * tolerance is rendered in its own `div.hpc-inline`, so skipping that subtree
+ * gives `D1` where reading the whole cell gives `D1+.0005"-.0005"`. It matters
+ * more than tidiness: Harvey's tolerance text carries typos — `D1+0005"-.0005"`,
+ * `R+.001"-001"`, `L2.020"-.000"` are all real — and every one of them would be
+ * another spelling for a post-hoc stripper to get right.
+ */
+import { Parser } from 'htmlparser2';
+import { VendorResponseError } from '../../errors.js';
+/** The class of the `<div>` holding a sub-label's published tolerance. */
+export const TOLERANCE_CLASS = 'hpc-inline';
+/** The class Harvey renders an unlabelled annotation column's header with. */
+export const HIDDEN_CLASS = 'white-text';
+/** Sub-label text that carries nothing. `&nbsp;` collapses to empty here. */
+const JUNK = new Set(['', '.', '"', 'X']);
+/** True where a header label says nothing about what the column holds. */
+export function isJunkLabel(label) {
+    return JUNK.has(label);
+}
+/** `" a  b \n"` -> `"a b"`. */
+function collapse(text) {
+    return text.split(/\s+/).filter(Boolean).join(' ');
+}
+/**
+ * The `<th>` rows of the `<thead>` of the table with this id.
+ *
+ * Streams the whole document rather than slicing it: a `</table>` inside a cell
+ * would end a sliced segment early, and htmlparser2 is already this package's
+ * one parser dependency.
+ *
+ * `decodeEntities` is on because these headers carry `&nbsp;` and `&deg;` —
+ * the blank flute sub-label is literally `&nbsp;&nbsp;`, and it has to reach
+ * {@link isJunkLabel} as an empty string rather than as two characters.
+ */
+export function parseHeadRows(html, tableId) {
+    const rows = [];
+    let inTable = false;
+    let inHead = false;
+    let row = null;
+    let cell = null;
+    // A depth counter rather than a flag: the tolerance is a `div` inside a `div`,
+    // and a flag would re-enable the text on the inner close tag.
+    let tolerance = 0;
+    let depth = 0;
+    const parser = new Parser({
+        onopentag: (tag, attribs) => {
+            if (tag === 'table') {
+                inTable = attribs['id'] === tableId;
+                return;
+            }
+            if (!inTable)
+                return;
+            if (tag === 'thead') {
+                inHead = true;
+            }
+            else if (inHead && tag === 'tr') {
+                row = [];
+            }
+            else if (inHead && tag === 'th' && row !== null) {
+                cell = {
+                    text: '',
+                    colspan: Number.parseInt(attribs['colspan'] ?? '1', 10) || 1,
+                    rowspan: Number.parseInt(attribs['rowspan'] ?? '1', 10) || 1,
+                    className: attribs['class'] ?? '',
+                };
+                tolerance = 0;
+                depth = 0;
+            }
+            else if (cell !== null) {
+                depth++;
+                if (tolerance === 0 && (attribs['class'] ?? '').split(/\s+/).includes(TOLERANCE_CLASS)) {
+                    tolerance = depth;
+                }
+                if (tag === 'br')
+                    cell.text += ' ';
+            }
+        },
+        ontext: (text) => {
+            if (cell !== null && tolerance === 0)
+                cell.text += text;
+        },
+        onclosetag: (tag) => {
+            if (!inTable)
+                return;
+            if (tag === 'th' && cell !== null) {
+                row?.push({ ...cell, text: collapse(cell.text) });
+                cell = null;
+            }
+            else if (tag === 'tr' && row !== null) {
+                rows.push(row);
+                row = null;
+            }
+            else if (tag === 'thead') {
+                inHead = false;
+                // Everything after the head is data the literal already carries.
+                inTable = false;
+            }
+            else if (cell !== null) {
+                if (tolerance === depth)
+                    tolerance = 0;
+                depth--;
+            }
+        },
+    }, { decodeEntities: true });
+    parser.write(html);
+    parser.end();
+    return rows;
+}
+/**
+ * One table's header, flattened to one entry per data column.
+ *
+ * Throws when the table is not in the document, rather than returning an empty
+ * header: a page that stopped serving a table it declares in `cols<N>` is a
+ * response that changed shape, and a zero-column table would reach the caller
+ * looking like a family the vendor discontinued.
+ */
+export function flatHeader(html, tableId) {
+    const rows = parseHeadRows(html, tableId);
+    if (rows.length === 0) {
+        throw new VendorResponseError(tableId, 'has no <thead> on the page — the table changed shape');
+    }
+    const [top = [], sub = []] = rows;
+    const columns = [];
+    let next = 0;
+    for (const cell of top) {
+        if (cell.rowspan >= 2) {
+            columns.push({ top: cell.text, sub: null, topClass: cell.className, span: 1, slot: 0 });
+            continue;
+        }
+        for (let slot = 0; slot < cell.colspan; slot++) {
+            columns.push({
+                top: cell.text,
+                sub: sub[next]?.text ?? '',
+                topClass: cell.className,
+                span: cell.colspan,
+                slot,
+            });
+            next++;
+        }
+    }
+    if (next > sub.length) {
+        throw new VendorResponseError(tableId, `spans ${next} sub-labels across its top row but the second row has ` +
+            `${sub.length} — the header changed shape`);
+    }
+    return columns;
+}
+/**
+ * The vendor's own symbol for a dimension column — `D1`, `L2`, `R`, `A1`, `#`.
+ *
+ * Null where the sub-label carries none, which is a real state rather than a
+ * fault: `NECK DIA.` publishes no symbol at all, and the ratio columns publish
+ * junk.
+ *
+ * A trailing `(h6)` is part of the shank tolerance class and not of the symbol,
+ * so `D2(h6)` and `D2` are the same column.
+ */
+export function symbolOf(sub) {
+    if (sub === null)
+        return null;
+    const match = /^([A-Z]+\d*)/.exec(sub);
+    return match?.[1] ?? null;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Harvey Tool — miniature end mills and keyseat cutters, from a printed-catalog
+ * table rendered as a web page.
+ *
+ * No JSON API and no XHR: a product page inlines its entire variant table as a
+ * JavaScript literal beside a `<thead>` that names the columns, and the two are
+ * joined by position. `literal.ts`, `header.ts`, `lexicon.ts` and `value.ts` are
+ * pure and hold the parsing risk; `scrape.ts` and `catalog.ts` are the only
+ * modules that read through a `Fetcher`.
+ *
+ * The one structural thing to know before reading any of it: **one HTML row is
+ * up to nine orderable parts.** See `scrape.ts`, and
+ * `docs/HARVEY_PRODUCT_TABLE.md` for the transport.
+ */
+export * from './catalog.js';
+export * from './header.js';
+export * from './lexicon.js';
+export * from './literal.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './value.js';

package/dist/vendors/harvey/index.js

@@ -0,0 +1,21 @@
+/**
+ * Harvey Tool — miniature end mills and keyseat cutters, from a printed-catalog
+ * table rendered as a web page.
+ *
+ * No JSON API and no XHR: a product page inlines its entire variant table as a
+ * JavaScript literal beside a `<thead>` that names the columns, and the two are
+ * joined by position. `literal.ts`, `header.ts`, `lexicon.ts` and `value.ts` are
+ * pure and hold the parsing risk; `scrape.ts` and `catalog.ts` are the only
+ * modules that read through a `Fetcher`.
+ *
+ * The one structural thing to know before reading any of it: **one HTML row is
+ * up to nine orderable parts.** See `scrape.ts`, and
+ * `docs/HARVEY_PRODUCT_TABLE.md` for the transport.
+ */
+export * from './catalog.js';
+export * from './header.js';
+export * from './lexicon.js';
+export * from './literal.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './value.js';

package/dist/vendors/harvey/lexicon.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What Harvey's own column labels mean, and which of them carry a unit.
+ *
+ * 50 distinct header shapes across the 52 product pages collapse to the table
+ * below, because the variance is in *spelling* rather than in vocabulary:
+ * `CUTTER DIA.` and `CUTTER DIAMETER` are the same column, and the keyseat
+ * families call the length of cut `CUTTER WIDTH`.
+ *
+ * **This module does not map a label to a canonical ISO name.** That mapping is
+ * per family and lives in `families/harvey.ts`, where it belongs: a family
+ * declares which of *its* labels is `LCF`, and the core appends the unit suffix.
+ * What is left over — is this label one this package has seen, and does its
+ * column carry a length — is the same on every page, and is here.
+ *
+ * ## An unknown label is a hard failure
+ *
+ * A label nothing here recognises stops the scrape naming the family. The
+ * alternative is a column that reaches the CSV under whatever Harvey renamed it
+ * to, silently no longer matching the family's column map, and a family whose
+ * `DC` is quietly absent from every record. The cost of the strict rule is that
+ * a vendor's copy edit breaks a scrape; the cost of the loose one is that it
+ * does not.
+ */
+/**
+ * What a column holds, which is only ever asked so that a length gets a `_mm` /
+ * `_in` suffix and a tooth count does not.
+ *
+ * `code` is for a column whose values are not numbers at all — the keyseat
+ * `TYPE`, whose `I`/`II`/`III` nobody at Harvey has yet explained.
+ */
+export type LabelKind = 'dimension' | 'count' | 'angle' | 'code';
+/**
+ * Every geometry top label the 52 product pages publish, and what it holds.
+ *
+ * Written out rather than pattern-matched. A regex over "anything containing
+ * DIA" would have swallowed `RADIAL DOC` and `NECK DIA.` into the same rule and
+ * quietly given one of them the other's meaning, and the whole point of the
+ * strict check below is that a label this package has not seen gets looked at
+ * by a person.
+ */
+export declare const LABELS: Readonly<Record<string, LabelKind>>;
+/** The top label of the column holding the add-to-cart control. Dropped. */
+export declare const CART_LABEL = "Add to Cart";
+/** The top label of the column stating a row's flute count, where there is one. */
+export declare const FLUTES_LABEL = "FLUTES";
+/** The sub-label a coating group uses when the row states the flute count. */
+export declare const TOOL_NUMBER_LABEL = "TOOL #";
+/** The sub-label ending every coating group. */
+export declare const PRICE_LABEL = "PRICE";
+/**
+ * The eight coating names Harvey publishes across the whole catalog.
+ *
+ * A closed list, checked, because the coating is *synthesised* from a column's
+ * position rather than lifted from a cell — nothing in a row says which coating
+ * a tool number belongs to. A ninth coating is Harvey extending its catalog and
+ * is worth a person looking; a coating group whose header stopped being a
+ * coating is the grid having shifted, and that is the failure this catches.
+ */
+export declare const COATINGS: readonly string[];
+/** The flute count a group sub-label states, or null where it states none. */
+export declare function flutesInLabel(sub: string): number | null;
+/**
+ * What the column under `label` holds, refusing a label nothing here knows.
+ *
+ * `family` is in the message because that is the one thing the person reading
+ * the failure needs and cannot work out from the label: 52 pages publish these
+ * labels, and only one of them changed.
+ */
+export declare function labelKind(family: string, label: string): LabelKind;
+/** Whether the column under `label` gets a `_mm` / `_in` suffix. */
+export declare function isDimensional(family: string, label: string): boolean;
+/** Refuse a coating group header that is not one of the eight. */
+export declare function checkCoating(family: string, coating: string): string;

package/dist/vendors/harvey/lexicon.js

@@ -0,0 +1,126 @@
+/**
+ * What Harvey's own column labels mean, and which of them carry a unit.
+ *
+ * 50 distinct header shapes across the 52 product pages collapse to the table
+ * below, because the variance is in *spelling* rather than in vocabulary:
+ * `CUTTER DIA.` and `CUTTER DIAMETER` are the same column, and the keyseat
+ * families call the length of cut `CUTTER WIDTH`.
+ *
+ * **This module does not map a label to a canonical ISO name.** That mapping is
+ * per family and lives in `families/harvey.ts`, where it belongs: a family
+ * declares which of *its* labels is `LCF`, and the core appends the unit suffix.
+ * What is left over — is this label one this package has seen, and does its
+ * column carry a length — is the same on every page, and is here.
+ *
+ * ## An unknown label is a hard failure
+ *
+ * A label nothing here recognises stops the scrape naming the family. The
+ * alternative is a column that reaches the CSV under whatever Harvey renamed it
+ * to, silently no longer matching the family's column map, and a family whose
+ * `DC` is quietly absent from every record. The cost of the strict rule is that
+ * a vendor's copy edit breaks a scrape; the cost of the loose one is that it
+ * does not.
+ */
+import { ScraperConfigError } from '../../errors.js';
+/**
+ * Every geometry top label the 52 product pages publish, and what it holds.
+ *
+ * Written out rather than pattern-matched. A regex over "anything containing
+ * DIA" would have swallowed `RADIAL DOC` and `NECK DIA.` into the same rule and
+ * quietly given one of them the other's meaning, and the whole point of the
+ * strict check below is that a label this package has not seen gets looked at
+ * by a person.
+ */
+export const LABELS = {
+    // Mapped to canonical names by each family's own column map.
+    'CUTTER DIA.': 'dimension',
+    'CUTTER DIAMETER': 'dimension',
+    LOC: 'dimension',
+    'LENGTH OF CUT': 'dimension',
+    'CUTTER WIDTH': 'dimension',
+    'SHANK DIA.': 'dimension',
+    'SHANK DIAMETER': 'dimension',
+    OAL: 'dimension',
+    'OVERALL LENGTH': 'dimension',
+    'CORNER RADIUS': 'dimension',
+    RADIUS: 'dimension',
+    'NECK DIA.': 'dimension',
+    'NECK LENGTH': 'dimension',
+    'OVERALL REACH': 'dimension',
+    FLUTES: 'count',
+    // Kept verbatim and mapped to nothing. Each is either a measurement this
+    // package has no canonical name for, or one whose meaning Harvey has not
+    // stated — see `docs/HARVEY_PRODUCT_TABLE.md` §5.1 and §6.
+    'RADIAL DOC*': 'dimension',
+    'Radial DOC*': 'dimension',
+    'Radial DOC**': 'dimension',
+    'Interference Depth At Wall Angle*': 'dimension',
+    'RIGHT HAND TEETH': 'count',
+    'LEFT HAND TEETH': 'count',
+    'ANGLE PER SIDE': 'angle',
+    'EFFECTIVE WALL ANGLE*': 'angle',
+    'EFF WALL ANGLE': 'angle',
+    TYPE: 'code',
+};
+/** The top label of the column holding the add-to-cart control. Dropped. */
+export const CART_LABEL = 'Add to Cart';
+/** The top label of the column stating a row's flute count, where there is one. */
+export const FLUTES_LABEL = 'FLUTES';
+/** The sub-label a coating group uses when the row states the flute count. */
+export const TOOL_NUMBER_LABEL = 'TOOL #';
+/** The sub-label ending every coating group. */
+export const PRICE_LABEL = 'PRICE';
+/** `2 FL`, `4FL`, `5 FL` — a per-part flute count in a group's sub-label. */
+const FLUTE_LABEL = /^(\d+)\s*FL$/i;
+/**
+ * The eight coating names Harvey publishes across the whole catalog.
+ *
+ * A closed list, checked, because the coating is *synthesised* from a column's
+ * position rather than lifted from a cell — nothing in a row says which coating
+ * a tool number belongs to. A ninth coating is Harvey extending its catalog and
+ * is worth a person looking; a coating group whose header stopped being a
+ * coating is the grid having shifted, and that is the failure this catches.
+ */
+export const COATINGS = [
+    'UNCOATED',
+    'AlTiN COATED',
+    'AMORPHOUS DIAMOND COATED',
+    'AlTiN NANO COATED',
+    'Ti NANO COATED',
+    'TiB2 COATED',
+    'BALL END UNCOATED',
+    'AlTiN NANO BALL END COATED',
+];
+/** The flute count a group sub-label states, or null where it states none. */
+export function flutesInLabel(sub) {
+    const match = FLUTE_LABEL.exec(sub);
+    return match ? Number.parseInt(match[1], 10) : null;
+}
+/**
+ * What the column under `label` holds, refusing a label nothing here knows.
+ *
+ * `family` is in the message because that is the one thing the person reading
+ * the failure needs and cannot work out from the label: 52 pages publish these
+ * labels, and only one of them changed.
+ */
+export function labelKind(family, label) {
+    const kind = LABELS[label];
+    if (kind === undefined) {
+        throw new ScraperConfigError(family, `publishes a column headed ${JSON.stringify(label)}, which this adapter ` +
+            `does not know — add it to vendors/harvey/lexicon.ts with what it ` +
+            `holds, and to the family's column map if it is a canonical field`);
+    }
+    return kind;
+}
+/** Whether the column under `label` gets a `_mm` / `_in` suffix. */
+export function isDimensional(family, label) {
+    return labelKind(family, label) === 'dimension';
+}
+/** Refuse a coating group header that is not one of the eight. */
+export function checkCoating(family, coating) {
+    if (!COATINGS.includes(coating)) {
+        throw new ScraperConfigError(family, `has a tool-number group headed ${JSON.stringify(coating)}, which is not ` +
+            `one of the coatings this adapter knows (${COATINGS.join(', ')})`);
+    }
+    return coating;
+}