@toolpath/tool-scraper 2.0.0 → 2.2.0

package/dist/records.js

@@ -194,22 +194,36 @@ export const DIMENSIONAL_COLUMNS = new Set([...DIMENSIONAL].filter((name) => nam
  * a key in `sometimes` may be missing and its absence is the vendor's silence;
  * a key in neither list is not part of that kind's record at all.
  *
- * Both `sometimes` entries today are a flute count nobody publishes:
- *
- * - the **end mill's**, for Harvey's two deburring families — they publish
- *   right- and left-hand tooth counts and no flute count, so there is nothing
- *   to read and 0 is not a substitute;
- * - the **tap's**, for EMUGE-FRANKEN, which states no flute count anywhere a
- *   scrape can reach — not on the grouped product, the variant listing, the
- *   per-part detail record or any facet — while its own tap families run 2, 3
- *   and 4 flutes across their size range, so no per-family constant could be
- *   true of every row. Kennametal's taps publish a `Z` column and keep filling
- *   it: `sometimes` permits the key, it does not forbid it.
+ * Every `sometimes` entry today is one vendor publishing nothing where another
+ * publishes a number. `sometimes` permits the key, it does not forbid it — the
+ * vendors that state these keep filling them.
+ *
+ * - the **end mill's `NOF`**, for Harvey's two deburring families — they
+ *   publish right- and left-hand tooth counts and no flute count, so there is
+ *   nothing to read and 0 is not a substitute;
+ * - the **tap's `NOF`**, for EMUGE-FRANKEN, which states no flute count
+ *   anywhere a scrape can reach — not on the grouped product, the variant
+ *   listing, the per-part detail record or any facet — while its own tap
+ *   families run 2, 3 and 4 flutes across their size range, so no per-family
+ *   constant could be true of every row. Kennametal's taps publish a `Z`
+ *   column and keep filling it;
+ * - the **drill's `SIG`**, for the one EMUGE-FRANKEN drill whose point-angle
+ *   cell is empty. This one is a hole in a column the vendor otherwise fills,
+ *   not a column it never had, and it is the reason the key had to move: the
+ *   EMUGE drill family reads `SIG` from a column rather than from a fact, so
+ *   a single blank cell refused the row, and `registry.toRecords` maps a
+ *   family's rows together — 2,669 drills were lost to the 2,670th. Every
+ *   Kennametal drill supplies `SIG` from a fact and none can be absent.
+ *
+ * A point angle is not a field to guess at. It sets the drill tip's length, so
+ * a CAM system that assumed 140 deg for a part ground at 118 would cut a hole
+ * to the wrong depth — an absence a consumer must check for is recoverable and
+ * a plausible wrong number is not.
  */
 export const RECORD_GEOMETRY = {
     drill: {
-        always: ['DC', 'SFDM', 'OAL', 'LCF', 'NOF', 'SIG'],
-        sometimes: [],
+        always: ['DC', 'SFDM', 'OAL', 'LCF', 'NOF'],
+        sometimes: ['SIG'],
     },
     tap: {
         always: ['DC', 'TP', 'SFDM', 'OAL', 'LCF'],
@@ -271,6 +285,15 @@ function checkGeometry(kind, what, geometry) {
 export function toolRecord(fields) {
     const groups = fields.materialGroups ?? null;
     const source = fields.materialGroupsSource ?? UNSPECIFIED;
+    // An adapter that has nothing to say about the product line says nothing;
+    // `''` would be a name and there is no nameless line. Optional here and
+    // required on the type for the reason stated above — a consumer reading a
+    // record never handles `undefined`.
+    const line = fields.productLine ?? null;
+    if (line === '') {
+        throw new ScraperConfigError(fields.materialNumber, `productLine is the empty string — a vendor that names no product line ` +
+            `is null, which is the state a consumer can tell from a name`);
+    }
     // The invariant is what keeps the three states three: groups labelled
     // `unspecified` are groups nobody stated, and an attributed source with no
     // groups attributes nothing. Either would land as a record whose material
@@ -288,6 +311,7 @@ export function toolRecord(fields) {
         materialGroups: groups === null ? null : Object.freeze([...groups]),
         materialGroupsSource: source,
         nonFerrous: fields.nonFerrous ?? null,
+        productLine: line,
     });
 }
 /**

package/dist/registry.d.ts

@@ -27,8 +27,9 @@
  * entry point into this package goes through here.
  */
 import { type BoundFamily, type BoundToolholding, type RecordMappers } from './family.js';
+import type { HoldingMappers, HoldingRecord } from './holding.js';
 import { type ToolRecord } from './records.js';
-import type { MapperOptions, ScrapeResult } from './scrape.js';
+import { type MapperOptions, type ScrapeResult } from './scrape.js';
 /**
  * Brand -> its row-to-record mappers, by tool kind.
  *
@@ -39,6 +40,26 @@ import type { MapperOptions, ScrapeResult } from './scrape.js';
  * map.
  */
 export declare const ADAPTERS: Record<string, RecordMappers>;
+/**
+ * Brand -> its toolholding mappers, by the kind of thing they build.
+ *
+ * The toolholding counterpart of {@link ADAPTERS}, and **partial in both
+ * directions on purpose**. A brand absent from here can still be scraped: its
+ * families bind, its CSVs are written, and its receipt is checked, exactly as
+ * before — what it cannot do is mint records. A brand present with a mapper for
+ * only one kind is the same statement one level down; MariTool publishes ER
+ * collets that this package does not scrape, so it maps holders and nothing
+ * else.
+ *
+ * That is what makes minting records additive rather than a break. Nothing here
+ * changes what a vendor with no entry does today, and the refusal only happens
+ * where a caller explicitly asks for records from a family whose brand maps
+ * none — {@link toHolding}, which names the brand and what it does map.
+ *
+ * One entry serves two brands for the reason {@link ADAPTERS} states: Kennametal
+ * and WIDIA are the same platform and the same table vocabulary.
+ */
+export declare const HOLDING_ADAPTERS: Record<string, HoldingMappers>;
 /**
  * Every cutting-tool family, validated and bound to its record mapper.
  *
@@ -46,13 +67,25 @@ export declare const ADAPTERS: Record<string, RecordMappers>;
  */
 export declare function boundFamilies(): Map<string, BoundFamily>;
 /**
- * Every holder and collet family, with its facts checked and projected.
+ * Every holder and collet family, with its facts checked and projected, and
+ * bound to the mapper its brand supplies for its kind.
+ *
+ * Their facts pass the same gate cutting-tool families' do: a taper or a
+ * clamping mode is a per-family constant no variant table states, exactly like
+ * a drill's flute count.
  *
- * 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.
+ * **A family whose brand maps nothing binds `undefined` rather than throwing**,
+ * which is where this differs from {@link boundFamilies}. A cutting-tool family
+ * with no mapper is a catalog fault — nothing can be done with it — but a
+ * toolholding family with no mapper is the state every one of them was in until
+ * records existed, and it still scrapes, writes a CSV and checks a receipt.
+ * Refusing at bind time would take that away from every consumer that never
+ * asked for a record. {@link toHolding} is where the absence is reported, at
+ * the one call that cannot proceed without it.
  */
 export declare function boundToolholding(): Map<string, BoundToolholding>;
+/** One bound toolholding family by CSV name. */
+export declare function boundHolding(name: string): BoundToolholding;
 /** One bound cutting-tool family by CSV name. */
 export declare function boundFamily(name: string): BoundFamily;
 /**
@@ -81,8 +114,56 @@ export declare function boundFamily(name: string): BoundFamily;
  *
  * `familyName` is the CSV filename the catalog is keyed by
  * (`'harvey_endmill_025.csv'`), which is what `boundFamily` takes.
+ *
+ * ## One incomplete part does not end the family
+ *
+ * The rows are mapped together, so until 2026-09-01 every refusal was equally
+ * fatal — and the refusals are not equal. A part the vendor left a required
+ * cell blank on is one bad row among thousands of good ones; EMUGE-FRANKEN
+ * omits `overall length l₁` on roughly 175 of its 7,021 end mill variants, and
+ * both end mill families converted to nothing at all because of them.
+ *
+ * So an {@link IncompletePartError} is warned about and the row is dropped.
+ * **Nothing else is.** A cutting material with no mapping, a column a family
+ * stopped mapping, a response that changed shape — those say the vendor's
+ * vocabulary or this package's catalog has moved, and a scraper that skipped
+ * quietly past them would publish a catalog nobody checked. `columns.required`
+ * is the only place that raises the skippable one.
+ *
+ * A dropped row is **not** a relaxed contract. `records.RECORD_GEOMETRY` still
+ * says an end mill always has an `OAL`, and every record returned here still
+ * has one: the part without it becomes no record rather than a record with a
+ * hole. Where a vendor genuinely never publishes a field, `sometimes` is still
+ * the answer — a drill's `SIG` is that, and it stays that.
+ *
+ * The count of what was dropped is not returned. A caller that needs it has
+ * the row count it passed in and the length it got back, and the warnings name
+ * every part by number.
  */
 export declare function toRecords(familyName: string, scrape: ScrapeResult, options?: MapperOptions): ToolRecord[];
+/**
+ * One toolholding family's scrape, as {@link HoldingRecord}s.
+ *
+ * {@link toRecords}'s counterpart, and deliberately the same shape: the two
+ * checks run before the first row, one incomplete part does not end the family,
+ * and the count of what was dropped is not returned because the caller has the
+ * row count it passed in and the length it got back.
+ *
+ * **It refuses only where a caller asked for something this package cannot
+ * give.** A toolholding family whose brand maps no mapper binds one anyway
+ * (see {@link boundToolholding}) and scrapes exactly as it did before; this is
+ * the one call that cannot proceed without one, so this is where the absence is
+ * named — with the brand and with what that brand does map, the way
+ * {@link boundFamilies} names a missing tool mapper.
+ *
+ * `checkColumnsExist` has no counterpart here: a holder family carries no
+ * `ColumnMap`, because the columns a holder publishes are the vendor's own and
+ * are read by that vendor's mapper rather than through a canonical name. What
+ * does still run is {@link checkIdentityColumns}, which catches the failure that
+ * matters most — a re-scrape whose part-number column was renamed still parses,
+ * still has the right row count, and mints every guid off an empty string.
+ */
+export declare function toHolding(familyName: string, scrape: ScrapeResult, options?: MapperOptions): HoldingRecord[];
 /**
  * Forget what has been bound.
  *

package/dist/registry.js

@@ -29,13 +29,17 @@
 import { checkIdentityColumns } from './conventions.js';
 import { familyBrand, } from './family.js';
 import { COLLET_FAMILIES, FAMILIES, HOLDER_FAMILIES } from './families/index.js';
-import { ScraperConfigError } from './errors.js';
+import { IncompletePartError, ScraperConfigError } from './errors.js';
 import { checkFact } from './provenance.js';
 import { checkColumnMap, checkColumnsExist } from './records.js';
+import { consoleWarn } from './scrape.js';
 import { RECORD_MAPPERS as DESTINYTOOL } from './vendors/destinytool/records.js';
 import { RECORD_MAPPERS as EMUGE } from './vendors/emuge/records.js';
 import { RECORD_MAPPERS as HARVEY } from './vendors/harvey/records.js';
+import { HOLDING_MAPPERS as KM_HOLDING } from './vendors/kennametal/holding.js';
 import { RECORD_MAPPERS as KENNAMETAL } from './vendors/kennametal/records.js';
+import { HOLDING_MAPPERS as MARITOOL_HOLDING } from './vendors/maritool/holding.js';
+import { HOLDING_MAPPERS as REGOFIX_HOLDING } from './vendors/regofix/holding.js';
 /**
  * Brand -> its row-to-record mappers, by tool kind.
  *
@@ -52,6 +56,31 @@ export const ADAPTERS = {
     harvey: HARVEY,
     emuge: EMUGE,
 };
+/**
+ * Brand -> its toolholding mappers, by the kind of thing they build.
+ *
+ * The toolholding counterpart of {@link ADAPTERS}, and **partial in both
+ * directions on purpose**. A brand absent from here can still be scraped: its
+ * families bind, its CSVs are written, and its receipt is checked, exactly as
+ * before — what it cannot do is mint records. A brand present with a mapper for
+ * only one kind is the same statement one level down; MariTool publishes ER
+ * collets that this package does not scrape, so it maps holders and nothing
+ * else.
+ *
+ * That is what makes minting records additive rather than a break. Nothing here
+ * changes what a vendor with no entry does today, and the refusal only happens
+ * where a caller explicitly asks for records from a family whose brand maps
+ * none — {@link toHolding}, which names the brand and what it does map.
+ *
+ * One entry serves two brands for the reason {@link ADAPTERS} states: Kennametal
+ * and WIDIA are the same platform and the same table vocabulary.
+ */
+export const HOLDING_ADAPTERS = {
+    kennametal: KM_HOLDING,
+    widia: KM_HOLDING,
+    regofix: REGOFIX_HOLDING,
+    maritool: MARITOOL_HOLDING,
+};
 /**
  * Check every fact of one family and project its value onto the config under
  * its own key.
@@ -109,27 +138,50 @@ export function boundFamilies() {
     return bound;
 }
 /**
- * Every holder and collet family, with its facts checked and projected.
+ * Every holder and collet family, with its facts checked and projected, and
+ * bound to the mapper its brand supplies for its kind.
  *
- * 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.
+ * Their facts pass the same gate cutting-tool families' do: a taper or a
+ * clamping mode is a per-family constant no variant table states, exactly like
+ * a drill's flute count.
+ *
+ * **A family whose brand maps nothing binds `undefined` rather than throwing**,
+ * which is where this differs from {@link boundFamilies}. A cutting-tool family
+ * with no mapper is a catalog fault — nothing can be done with it — but a
+ * toolholding family with no mapper is the state every one of them was in until
+ * records existed, and it still scrapes, writes a CSV and checks a receipt.
+ * Refusing at bind time would take that away from every consumer that never
+ * asked for a record. {@link toHolding} is where the absence is reported, at
+ * the one call that cannot proceed without it.
  */
 export function boundToolholding() {
     if (toolholding !== null)
         return toolholding;
     const bound = new Map();
-    for (const [table, families_] of [
+    for (const [kind, families_] of [
         ['holder', HOLDER_FAMILIES],
         ['collet', COLLET_FAMILIES],
     ]) {
         for (const [name, cfg] of Object.entries(families_)) {
-            bound.set(name, project(table, name, cfg));
+            const mappers = HOLDING_ADAPTERS[familyBrand(cfg)];
+            bound.set(name, {
+                ...project(kind, name, cfg),
+                kind,
+                records: mappers?.[kind],
+            });
         }
     }
     toolholding = bound;
     return bound;
 }
+/** One bound toolholding family by CSV name. */
+export function boundHolding(name) {
+    const cfg = boundToolholding().get(name);
+    if (cfg === undefined) {
+        throw new ScraperConfigError(name, `unknown toolholding family (known: ${[...boundToolholding().keys()].sort().join(', ')})`);
+    }
+    return cfg;
+}
 /** One bound cutting-tool family by CSV name. */
 export function boundFamily(name) {
     const cfg = boundFamilies().get(name);
@@ -164,12 +216,101 @@ export function boundFamily(name) {
  *
  * `familyName` is the CSV filename the catalog is keyed by
  * (`'harvey_endmill_025.csv'`), which is what `boundFamily` takes.
+ *
+ * ## One incomplete part does not end the family
+ *
+ * The rows are mapped together, so until 2026-09-01 every refusal was equally
+ * fatal — and the refusals are not equal. A part the vendor left a required
+ * cell blank on is one bad row among thousands of good ones; EMUGE-FRANKEN
+ * omits `overall length l₁` on roughly 175 of its 7,021 end mill variants, and
+ * both end mill families converted to nothing at all because of them.
+ *
+ * So an {@link IncompletePartError} is warned about and the row is dropped.
+ * **Nothing else is.** A cutting material with no mapping, a column a family
+ * stopped mapping, a response that changed shape — those say the vendor's
+ * vocabulary or this package's catalog has moved, and a scraper that skipped
+ * quietly past them would publish a catalog nobody checked. `columns.required`
+ * is the only place that raises the skippable one.
+ *
+ * A dropped row is **not** a relaxed contract. `records.RECORD_GEOMETRY` still
+ * says an end mill always has an `OAL`, and every record returned here still
+ * has one: the part without it becomes no record rather than a record with a
+ * hole. Where a vendor genuinely never publishes a field, `sometimes` is still
+ * the answer — a drill's `SIG` is that, and it stays that.
+ *
+ * The count of what was dropped is not returned. A caller that needs it has
+ * the row count it passed in and the length it got back, and the warnings name
+ * every part by number.
  */
 export function toRecords(familyName, scrape, options) {
     const cfg = boundFamily(familyName);
+    const warn = options?.warn ?? consoleWarn;
     checkIdentityColumns(familyBrand(cfg), scrape.header);
     checkColumnsExist(familyName, cfg, scrape.header);
-    return scrape.rows.map((row) => cfg.records(row, cfg, cfg.columns, options));
+    const records = [];
+    for (const row of scrape.rows) {
+        try {
+            records.push(cfg.records(row, cfg, cfg.columns, options));
+        }
+        catch (error) {
+            if (!(error instanceof IncompletePartError))
+                throw error;
+            warn(`  WARNING: ${error.message} — no record written for it`);
+        }
+    }
+    return records;
+}
+/**
+ * One toolholding family's scrape, as {@link HoldingRecord}s.
+ *
+ * {@link toRecords}'s counterpart, and deliberately the same shape: the two
+ * checks run before the first row, one incomplete part does not end the family,
+ * and the count of what was dropped is not returned because the caller has the
+ * row count it passed in and the length it got back.
+ *
+ * **It refuses only where a caller asked for something this package cannot
+ * give.** A toolholding family whose brand maps no mapper binds one anyway
+ * (see {@link boundToolholding}) and scrapes exactly as it did before; this is
+ * the one call that cannot proceed without one, so this is where the absence is
+ * named — with the brand and with what that brand does map, the way
+ * {@link boundFamilies} names a missing tool mapper.
+ *
+ * `checkColumnsExist` has no counterpart here: a holder family carries no
+ * `ColumnMap`, because the columns a holder publishes are the vendor's own and
+ * are read by that vendor's mapper rather than through a canonical name. What
+ * does still run is {@link checkIdentityColumns}, which catches the failure that
+ * matters most — a re-scrape whose part-number column was renamed still parses,
+ * still has the right row count, and mints every guid off an empty string.
+ */
+export function toHolding(familyName, scrape, options) {
+    const cfg = boundHolding(familyName);
+    const warn = options?.warn ?? consoleWarn;
+    const brand = familyBrand(cfg);
+    const mapper = cfg.records;
+    if (mapper === undefined) {
+        const mappers = HOLDING_ADAPTERS[brand];
+        throw new ScraperConfigError(familyName, `brand ${JSON.stringify(brand)} has no ${cfg.kind} mapper ` +
+            (mappers === undefined
+                ? `— it maps no toolholding at all, so this family ends at rows and ` +
+                    `a receipt (brands that map some: ` +
+                    `${Object.keys(HOLDING_ADAPTERS).sort().join(', ')})`
+                : `(it maps: ${Object.keys(mappers).sort().join(', ')})`));
+    }
+    checkIdentityColumns(brand, scrape.header);
+    const records = [];
+    for (const row of scrape.rows) {
+        try {
+            records.push(cfg.kind === 'holder'
+                ? mapper(row, cfg, options)
+                : mapper(row, cfg, options));
+        }
+        catch (error) {
+            if (!(error instanceof IncompletePartError))
+                throw error;
+            warn(`  WARNING: ${error.message} — no record written for it`);
+        }
+    }
+    return records;
 }
 /**
  * Forget what has been bound.

package/dist/vendors/destinytool/records.js

@@ -247,6 +247,14 @@ export function endmillRecord(row, family, columns, options = {}) {
         description,
         kind: 'endmill',
         unit,
+        // `series` is the vendor's own product-line name and the one column here
+        // that names one — `Viper`, `Raptor`, `DiamondBack`, and `viper-mini` and
+        // `python` in the vendor's own lower case, which stays exactly as
+        // published for the reason `records.ToolRecord.productLine` gives. It has
+        // been scraped since the adapter was written and read by nothing until
+        // now; the description cannot stand in for it, because Raptor calls itself
+        // `DVH` there and DiamondBack calls itself `DBACK RGHR`.
+        productLine: row['series']?.trim() || null,
         substrate: (row['material'] || fact(family, 'bmc', family.bmc)).toLowerCase(),
         // No carbide grade is published; the coating id is what there is.
         coating: row['coatingId'] ?? '',

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

@@ -14,7 +14,12 @@
  *   article code, per part, so there is no `conventions.IDENTITY_DEVIATIONS`
  *   entry — the first vendor since Kennametal that needs none.
  * - **A point angle, per drill.** Kennametal's drill families assume theirs; the
- *   detail record states it, so `SIG` is a mapped column here and no fact.
+ *   detail record states it, so `SIG` is a mapped column here and no fact. On
+ *   all but one part: 2,669 of 2,670 drill variants state one, and part
+ *   `000000000010727800` publishes a single classification feature and no
+ *   dimensional properties at all — so its row carries no `SIG` **key**, not
+ *   an empty one. That is why `records.RECORD_GEOMETRY.drill` lists `SIG`
+ *   under `sometimes`, and why {@link angle} reads the row rather than `cell`.
  * - **A per-part ISO 513 index.** `applicationMaterials` returns the vendor's
  *   own P/M/K/N/S/H rating for each part, which fills `materialGroups` as
  *   `vendor-stated`.
@@ -97,6 +102,79 @@ export declare const COOLANT_COLUMNS: Readonly<Record<string, Readonly<Record<st
  * facet across all three categories (2026-09-01).
  */
 export declare const SUBSTRATES: Readonly<Record<string, string>>;
+/**
+ * The column each EMUGE-FRANKEN category states its product line in, keyed by
+ * the vendor's own category code.
+ *
+ * **One column per category, and each is a facet that partitions its category
+ * exactly.** Checked against the vendor's own index on 2026-09-01, at group
+ * level rather than by summing counts:
+ *
+ * | Category | Facet                | Values | Groups it covers | Groups in two values |
+ * | -------- | -------------------- | ------ | ---------------- | -------------------- |
+ * | `FF01`   | `AMM_PROG_LINIE`     | 15     | 554 of 554       | 2                    |
+ * | `FB01`   | `HYB_BAM_SB_GT`      | 4      | 17 of 17         | 0                    |
+ * | `FG01`   | `HYB_BAM_SB_GT`      | 17     | 414 of 414       | 0                    |
+ *
+ * That is what makes a product line here a **read and not an arbitration**.
+ * EMUGE's marketing publishes 43 overlapping product-family pages — a tap is
+ * simultaneously "Rekord B-Z Taps", "Enorm Z Taps" and "Left Hand Taps" — and
+ * choosing between those would be this package inventing a rule the vendor
+ * never stated. The facets above are the vendor's own partition of the same
+ * catalog, so there is nothing to choose.
+ *
+ * **The two milling groups that fall in two values cost nothing**, because the
+ * milling column is read per part: `H300024` and `H300025` each hold both
+ * `FRANKEN TiNox-Cut` and `FRANKEN TiNox-Cut VAR` variants, and the per-part
+ * detail record states which is which. A rule that tagged a whole group would
+ * have had to pick.
+ *
+ * **No request is added for any of this.** `Geometry` is on the grouped product
+ * and `product line` on the per-part detail, so `scrape.ts` already writes both
+ * into every row — see its three-call note.
+ */
+export declare const PRODUCT_LINE_COLUMNS: Readonly<Record<string, string>>;
+/**
+ * A category's product-line codes onto the vendor's own name for each.
+ *
+ * **Both sides are EMUGE's.** The key is the value its `HYB_BAM_SB_GT` facet
+ * publishes and the name is the title of the vendor's own product-family
+ * article page for it, read on 2026-09-01 and cited per entry. Nothing here is
+ * this package's wording, which is the whole condition on a table like this —
+ * the same rule {@link SUBSTRATES} keeps, one level less strict because that
+ * one maps onto a vocabulary this package owns and this one does not.
+ *
+ * **A category whose facet already names the line has no entry.** `FF01`'s
+ * values are `FRANKEN TOP-Cut`, `FRANKEN Hard-Cut`, `FRANKEN Alu-Cut` — the
+ * vendor's marketing names already — so milling passes through verbatim and
+ * appears nowhere below. Drilling and tapping index by a geometry code
+ * (`MULTI`, `Z`, `VA`) that matches nothing EMUGE sells under that name, which
+ * is the only reason this table exists.
+ *
+ * **A code with no article page keeps the code**, and that is a gap in the
+ * vendor's marketing rather than a hole here: `SPEED`, `FK`, `GAL`, `GG` and
+ * `TILEG` are real lines with no `/a/` page on the US storefront, so the
+ * honest answer is the vendor's own code until one appears.
+ */
+export declare const PRODUCT_LINES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+/**
+ * The product line this row states, or null where the vendor states none.
+ *
+ * Three answers and they are different things. A family whose category has no
+ * entry in {@link PRODUCT_LINE_COLUMNS} is a category this adapter has not
+ * looked at, and it answers null rather than guessing at which of the row's
+ * columns is the line. A column the vendor left empty is null too — the same
+ * silence `angle` treats as an omission rather than a fault. A *value* is
+ * mapped through {@link PRODUCT_LINES} where its category has a table and
+ * passed through verbatim where it does not, which is the milling case.
+ *
+ * It does not throw on an unknown code, and that is the difference between
+ * this and `substrate`: a cutting material this package cannot map would put a
+ * wrong word in `ToolRecord.substrate`, where an unmapped product-line code is
+ * the vendor's own code and readable as one. A new EMUGE geometry showing up
+ * as `SPEED` is a name to improve, not a record to refuse.
+ */
+export declare function productLine(row: ScrapedRow, family: BoundFamily): string | null;
 /**
  * The flute count EMUGE publishes where it has none: 64 end mill variants, on
  * 2026-09-01. A sentinel and not a number, so it is refused rather than read.
@@ -123,8 +201,10 @@ export declare function endmillRecord(row: ScrapedRow, family: BoundFamily, colu
  * `SIG` is a **mapped column**, which no other drill family in this package
  * manages: the per-part detail record states the point angle outright, so
  * nothing here is derived from a point length or assumed from a product line.
- * `NOF` is the one thing that is a fact, and `nonFerrous` with it — neither has
- * a default anywhere, by design.
+ * It is also the one geometry key this record may not carry — one variant's
+ * cell is empty, and {@link angle} says what that costs. `NOF` is the one
+ * thing that is a fact, and `nonFerrous` with it — neither has a default
+ * anywhere, by design.
  */
 export declare function drillRecord(row: ScrapedRow, family: BoundFamily, columns: ColumnMap, options?: MapperOptions): ToolRecord;
 /**