@toolpath/tool-scraper 2.0.0 → 2.1.0

package/dist/columns.d.ts

@@ -20,9 +20,11 @@
  * - a column the family maps to nothing is `undefined`, not an error — a family
  *   with no neck column is a plain tool, and that is the mapper's fallback to
  *   make;
- * - a **required** field with no reading refuses the row, naming the canonical
- *   field and quoting the cell, because a tool with no cutting diameter is not
- *   a part;
+ * - a **required** field with no reading refuses the row with an
+ *   `errors.IncompletePartError`, naming the canonical field and quoting the
+ *   cell, because a tool with no cutting diameter is not a part — and that is
+ *   the one refusal `registry.toRecords` skips past rather than failing the
+ *   whole family on;
  * - an **optional** one answers null and lets the mapper decide.
  *
  * `vendors/destinytool/records.ts` keeps its own `required` and is not wired

package/dist/columns.js

@@ -20,9 +20,11 @@
  * - a column the family maps to nothing is `undefined`, not an error — a family
  *   with no neck column is a plain tool, and that is the mapper's fallback to
  *   make;
- * - a **required** field with no reading refuses the row, naming the canonical
- *   field and quoting the cell, because a tool with no cutting diameter is not
- *   a part;
+ * - a **required** field with no reading refuses the row with an
+ *   `errors.IncompletePartError`, naming the canonical field and quoting the
+ *   cell, because a tool with no cutting diameter is not a part — and that is
+ *   the one refusal `registry.toRecords` skips past rather than failing the
+ *   whole family on;
  * - an **optional** one answers null and lets the mapper decide.
  *
  * `vendors/destinytool/records.ts` keeps its own `required` and is not wired
@@ -31,7 +33,7 @@
  * has no `optional` at all. Forcing it into this shape would change how it
  * refuses, which is the one thing `measure.ts` says is a vendor's own call.
  */
-import { VendorResponseError } from './errors.js';
+import { IncompletePartError } from './errors.js';
 /**
  * The three readers, over one vendor's `read`.
  *
@@ -54,7 +56,11 @@ export function columnReaders(read) {
         const raw = cell(row, columns, canonical, unit);
         const value = raw === undefined ? null : read(raw, unit, what, options.warn);
         if (value === null) {
-            throw new VendorResponseError(what, `publishes no ${canonical} — its cell is ${JSON.stringify(raw ?? '')}`);
+            // `IncompletePartError` and not the general vendor fault: this is the
+            // one refusal `registry.toRecords` skips past, because a single part the
+            // vendor left a cell blank on must not end a family's conversion. See
+            // that type for why the others still must not be skipped.
+            throw new IncompletePartError(what, `publishes no ${canonical} — its cell is ${JSON.stringify(raw ?? '')}`);
         }
         return value;
     };

package/dist/conventions.d.ts

@@ -97,6 +97,24 @@ export declare const CAD_DXF_COLUMN = "CAD_DXF_URL";
  * `records.ToolRecord.description`, which states the same rule for the record.
  */
 export declare const DESCRIPTION_COLUMN = "Description";
+/**
+ * The CSV column holding the vendor's own full name for the family a part is
+ * in — `KenCut™ FF • HPFT • Square End • 6 Flutes • Plain Shank • Inch`.
+ *
+ * Constant down a family's whole table, and that is what makes it a *family*
+ * title rather than a {@link DESCRIPTION_COLUMN}: it names the group, not the
+ * part. Kennametal and WIDIA publish one as the `h1` of a family page and it
+ * reaches the CSV whole, while `records.ToolRecord.productLine` keeps only its
+ * leading segment — the rest is the vendor's own wording for the shape, the
+ * flute count, the shank and the unit, and a receipt that dropped it would be
+ * throwing away published text to save a column.
+ *
+ * Vendor-neutral and here rather than in the Kennametal adapter for the reason
+ * {@link CAD_COLUMN} is: a second vendor that publishes a family title writes
+ * this column rather than inventing another. Nothing forces one to — a vendor
+ * whose parts carry no family title simply has no such column.
+ */
+export declare const FAMILY_TITLE_COLUMN = "Family Title";
 /**
  * The CSV column saying how a holder seats in the spindle: `taper` or `face`.
  *

package/dist/conventions.js

@@ -98,6 +98,24 @@ export const CAD_DXF_COLUMN = 'CAD_DXF_URL';
  * `records.ToolRecord.description`, which states the same rule for the record.
  */
 export const DESCRIPTION_COLUMN = 'Description';
+/**
+ * The CSV column holding the vendor's own full name for the family a part is
+ * in — `KenCut™ FF • HPFT • Square End • 6 Flutes • Plain Shank • Inch`.
+ *
+ * Constant down a family's whole table, and that is what makes it a *family*
+ * title rather than a {@link DESCRIPTION_COLUMN}: it names the group, not the
+ * part. Kennametal and WIDIA publish one as the `h1` of a family page and it
+ * reaches the CSV whole, while `records.ToolRecord.productLine` keeps only its
+ * leading segment — the rest is the vendor's own wording for the shape, the
+ * flute count, the shank and the unit, and a receipt that dropped it would be
+ * throwing away published text to save a column.
+ *
+ * Vendor-neutral and here rather than in the Kennametal adapter for the reason
+ * {@link CAD_COLUMN} is: a second vendor that publishes a family title writes
+ * this column rather than inventing another. Nothing forces one to — a vendor
+ * whose parts carry no family title simply has no such column.
+ */
+export const FAMILY_TITLE_COLUMN = 'Family Title';
 /**
  * The CSV column saying how a holder seats in the spindle: `taper` or `face`.
  *

package/dist/errors.d.ts

@@ -10,6 +10,9 @@
  *   cannot read.** The variants endpoint changed shape, a scrape's row count
  *   disagrees with the declared one, a DIN 4000 code that should be pinned is
  *   absent. The catalog is fine; the world moved.
+ * - {@link IncompletePartError} — **one part is missing a measurement it
+ *   cannot be a part without.** A narrower case of the second, and the only
+ *   one `registry.toRecords` may skip past: see below.
  *
  * They throw rather than exiting the process: a Node backend imports this, and
  * a mapped column that moved must not take down somebody's request handler.
@@ -43,4 +46,31 @@ export declare class ScraperConfigError extends ScraperError {
  */
 export declare class VendorResponseError extends ScraperError {
 }
+/**
+ * One part does not publish a dimension its kind requires.
+ *
+ * **The only failure a whole family survives.** `registry.toRecords` maps a
+ * family's rows together, so before this type existed every refusal was
+ * equally fatal: one part with an unpublished cell ended the conversion and
+ * took every other row with it. EMUGE-FRANKEN omits `overall length l₁` on
+ * roughly 175 of its 7,021 end mill variants, and both end mill families
+ * produced nothing at all because of them.
+ *
+ * It is a distinct type rather than a flag on {@link VendorResponseError}
+ * because the two must not be skipped alike. A cutting material this package
+ * has no word for, a point-angle column a family stopped mapping, a variants
+ * table that changed shape — those are the vendor's vocabulary or this
+ * package's map having moved, and skipping past them quietly is how a scraper
+ * starts publishing a catalog nobody checked. Only `columns.required` raises
+ * this one, and only for a cell the vendor left unpublished.
+ *
+ * **It is not a licence to relax a kind's contract.** `records.RECORD_GEOMETRY`
+ * still says an end mill always has an `OAL`, and that stays true of every
+ * record this package emits: a part without one does not become a record with
+ * a hole in it, it becomes no record and a warning. Where a *vendor* genuinely
+ * never publishes a field, the answer is still `sometimes` — that is what a
+ * drill's `SIG` is, and why one is a contract decision and the other is not.
+ */
+export declare class IncompletePartError extends VendorResponseError {
+}
 export {};

package/dist/errors.js

@@ -10,6 +10,9 @@
  *   cannot read.** The variants endpoint changed shape, a scrape's row count
  *   disagrees with the declared one, a DIN 4000 code that should be pinned is
  *   absent. The catalog is fine; the world moved.
+ * - {@link IncompletePartError} — **one part is missing a measurement it
+ *   cannot be a part without.** A narrower case of the second, and the only
+ *   one `registry.toRecords` may skip past: see below.
  *
  * They throw rather than exiting the process: a Node backend imports this, and
  * a mapped column that moved must not take down somebody's request handler.
@@ -51,3 +54,30 @@ export class ScraperConfigError extends ScraperError {
  */
 export class VendorResponseError extends ScraperError {
 }
+/**
+ * One part does not publish a dimension its kind requires.
+ *
+ * **The only failure a whole family survives.** `registry.toRecords` maps a
+ * family's rows together, so before this type existed every refusal was
+ * equally fatal: one part with an unpublished cell ended the conversion and
+ * took every other row with it. EMUGE-FRANKEN omits `overall length l₁` on
+ * roughly 175 of its 7,021 end mill variants, and both end mill families
+ * produced nothing at all because of them.
+ *
+ * It is a distinct type rather than a flag on {@link VendorResponseError}
+ * because the two must not be skipped alike. A cutting material this package
+ * has no word for, a point-angle column a family stopped mapping, a variants
+ * table that changed shape — those are the vendor's vocabulary or this
+ * package's map having moved, and skipping past them quietly is how a scraper
+ * starts publishing a catalog nobody checked. Only `columns.required` raises
+ * this one, and only for a cell the vendor left unpublished.
+ *
+ * **It is not a licence to relax a kind's contract.** `records.RECORD_GEOMETRY`
+ * still says an end mill always has an `OAL`, and that stays true of every
+ * record this package emits: a part without one does not become a record with
+ * a hole in it, it becomes no record and a warning. Where a *vendor* genuinely
+ * never publishes a field, the answer is still `sometimes` — that is what a
+ * drill's `SIG` is, and why one is a contract decision and the other is not.
+ */
+export class IncompletePartError extends VendorResponseError {
+}

package/dist/families/emuge.d.ts

@@ -8,7 +8,9 @@
  * coating and the coolant supply **per part**, in columns, and a scraped column
  * beats a family constant. Splitting by product line would turn four counted
  * row totals into thirty and buy nothing a `product line` column does not
- * already carry.
+ * already carry — and it is carried: `vendors/emuge/records.ts`'s
+ * `PRODUCT_LINE_COLUMNS` reads one per part onto `ToolRecord.productLine`, from
+ * a column every scrape already writes.
  *
  * So the only fact three of these four state is `unit`, and the fourth adds the
  * two a drill record cannot be built without.

package/dist/families/emuge.js

@@ -8,7 +8,9 @@
  * coating and the coolant supply **per part**, in columns, and a scraped column
  * beats a family constant. Splitting by product line would turn four counted
  * row totals into thirty and buy nothing a `product line` column does not
- * already carry.
+ * already carry — and it is carried: `vendors/emuge/records.ts`'s
+ * `PRODUCT_LINE_COLUMNS` reads one per part onto `ToolRecord.productLine`, from
+ * a column every scrape already writes.
  *
  * So the only fact three of these four state is `unit`, and the fourth adds the
  * two a drill record cannot be built without.
@@ -100,9 +102,11 @@ export const FAMILIES = {
         kind: 'drill',
         familyCode: 'FB01',
         // `SIG` is a mapped column and not a fact, which no other drill family in
-        // this package manages: EMUGE states a point angle on every part's detail
-        // record. Kennametal's two drill lines assume theirs or derive them from a
-        // point length, and both say so at length in `families/kennametal.ts`.
+        // this package manages: EMUGE states a point angle on the detail record of
+        // 2,669 of these 2,670 parts, and leaves the cell empty on the last, so the
+        // record may carry no `SIG` — see `vendors/emuge/records.ts`'s `angle`.
+        // Kennametal's two drill lines assume theirs or derive them from a point
+        // length, and both say so at length in `families/kennametal.ts`.
         columns: {
             DC: 'nominal diameter d₁',
             SFDM: 'Shank diameter d₂',

package/dist/node/cli.js

@@ -257,7 +257,12 @@ async function kennametal(argv, io, fetcher) {
         const at = a.indexOf('=');
         return [a.slice(0, at), a.slice(at + 1)];
     });
-    const scrape = await scrapeFamily(fetcher, code, brand, tags);
+    // The family page carries the product line, which the variants table does
+    // not state anywhere. One extra request per family — see
+    // `vendors/kennametal/family.ts`.
+    const scrape = await scrapeFamily(fetcher, code, brand, tags, {
+        familyTitle: true,
+    });
     wrote(out, brand, scrape, io);
     return 0;
 }

package/dist/records.d.ts

@@ -236,17 +236,31 @@ export declare const DIMENSIONAL_COLUMNS: ReadonlySet<GeometryName>;
  * 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 declare const RECORD_GEOMETRY: Record<ToolKind, {
     readonly always: readonly GeometryName[];
@@ -325,6 +339,37 @@ export interface ToolRecord {
      * consumer that needs a per-part string has `catalogNumber`.
      */
     readonly description: string;
+    /**
+     * The vendor's own name for the product line this part belongs to —
+     * `FRANKEN TOP-Cut`, `MultiDRILL`, `KenCut™ FF`, `Viper` — or `null` where
+     * the vendor names none.
+     *
+     * **Null is the vendor's silence, not an empty name**, the same three-state
+     * reasoning {@link ToolRecord.materialGroups} makes with {@link UNSPECIFIED}
+     * and for the same reason: a consumer faceting a catalog by product line has
+     * to be able to tell "EMUGE calls this Alu-Cut" from "nobody has decided what
+     * Harvey's line is called", and `''` collapses the two.
+     *
+     * **Verbatim, and never inferred** — the {@link ToolRecord.coating} rule.
+     * EMUGE's own index says `FRANKEN Expert` for the eight end mills its
+     * marketing calls "Cut & Form", and Destiny Tool ships `viper-mini` and
+     * `python` beside `Viper` and `Raptor`; case-folding either here would be
+     * this package authoring a vendor's catalog. The one thing an adapter may do
+     * is map a vendor's *code* onto that same vendor's *own* published name for
+     * it — see `vendors/emuge/records.ts`'s `PRODUCT_LINES`, where both sides of
+     * every entry are EMUGE's and the article page each name came from is cited.
+     *
+     * **Where it comes from is a fact about the vendor's data, not a convention.**
+     * Three sources are in use and each is the only one its vendor offers: a
+     * scraped column read per part (EMUGE, Destiny Tool), a page title fetched
+     * per family (Kennametal, WIDIA), and nothing at all (Harvey Tool, whose
+     * product-line title is already this record's `description` — a second copy
+     * of one string is the thing that field's own docstring refuses).
+     *
+     * **Never a copy of another field on this record**, for the reason
+     * {@link ToolRecord.description} states it.
+     */
+    readonly productLine: string | null;
     readonly kind: ToolKind;
     readonly unit: UnitSystem;
     readonly substrate: string;
@@ -388,7 +433,7 @@ export interface ToolRecord {
  * interchange value, and a mapper that mutated one would be reaching back
  * across the seam this type exists to draw.
  */
-export declare function toolRecord(fields: Omit<ToolRecord, 'guid' | 'materialGroups' | 'materialGroupsSource' | 'nonFerrous'> & Partial<Pick<ToolRecord, 'materialGroups' | 'materialGroupsSource' | 'nonFerrous'>>): ToolRecord;
+export declare function toolRecord(fields: Omit<ToolRecord, 'guid' | 'materialGroups' | 'materialGroupsSource' | 'nonFerrous' | 'productLine'> & Partial<Pick<ToolRecord, 'materialGroups' | 'materialGroupsSource' | 'nonFerrous' | 'productLine'>>): ToolRecord;
 /**
  * A family's canonical-field → CSV-column-label mapping, validated.
  *

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

@@ -28,7 +28,7 @@
  */
 import { type BoundFamily, type BoundToolholding, type RecordMappers } from './family.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.
  *
@@ -81,6 +81,31 @@ 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[];
 /**

package/dist/registry.js

@@ -29,9 +29,10 @@
 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';
@@ -164,12 +165,49 @@ 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;
 }
 /**
  * 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;
 /**