@toolpath/tool-scraper 0.1.0

package/dist/node/cli.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The console entry point. Argv handling only — no scraping logic lives here.
+ *
+ * ```
+ * toolpath-scrape kennametal      family page -> CSV
+ * toolpath-scrape regofix         ProductFinder index -> toolholding CSV
+ * toolpath-scrape destinytool     Firestore products -> End Mill CSV
+ * toolpath-scrape thread-pitch    add the derived Thread Pitch column
+ * toolpath-scrape cad             add the vendor CAD model column
+ * toolpath-scrape materials       add the ISO workpiece-group column
+ * toolpath-scrape mirror-cad      download the vendor STEP models
+ * ```
+ *
+ * **One binary with subcommands.** Seven names in `node_modules/.bin` for one
+ * package is not the idiom.
+ *
+ * **Every command prints the resolved scrape root before it does anything.**
+ * The default is derived from this package's own location, which is right in a
+ * working tree and meaningless in `node_modules`, so where a scrape lands is a
+ * thing to state rather than to assume.
+ *
+ * The convert commands are not here. This package acquires; a Fusion library
+ * or an assembly catalog is a different product, and none of it is in this
+ * tree.
+ */
+import { type Fetcher } from '../fetch.js';
+/** Everything the CLI prints, injectable so a test is not stdout. */
+export interface Console_ {
+    log: (message: string) => void;
+    error: (message: string) => void;
+}
+/** Run one command. Exported so the tests drive it without a subprocess. */
+export declare function run(argv: string[], io?: Console_, fetcher?: Fetcher): Promise<number>;
+/** The process entry point: run, and turn a refusal into an exit code. */
+export declare function main(argv?: string[]): Promise<number>;

package/dist/node/cli.js

@@ -0,0 +1,340 @@
+/**
+ * The console entry point. Argv handling only — no scraping logic lives here.
+ *
+ * ```
+ * toolpath-scrape kennametal      family page -> CSV
+ * toolpath-scrape regofix         ProductFinder index -> toolholding CSV
+ * toolpath-scrape destinytool     Firestore products -> End Mill CSV
+ * toolpath-scrape thread-pitch    add the derived Thread Pitch column
+ * toolpath-scrape cad             add the vendor CAD model column
+ * toolpath-scrape materials       add the ISO workpiece-group column
+ * toolpath-scrape mirror-cad      download the vendor STEP models
+ * ```
+ *
+ * **One binary with subcommands.** Seven names in `node_modules/.bin` for one
+ * package is not the idiom.
+ *
+ * **Every command prints the resolved scrape root before it does anything.**
+ * The default is derived from this package's own location, which is right in a
+ * working tree and meaningless in `node_modules`, so where a scrape lands is a
+ * thing to state rather than to assume.
+ *
+ * The convert commands are not here. This package acquires; a Fusion library
+ * or an assembly catalog is a different product, and none of it is in this
+ * tree.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { ScraperConfigError, VendorResponseError } from '../errors.js';
+import { familyBrand } from '../family.js';
+import { ALL_FAMILIES, FAMILIES, HOLDER_FAMILIES, familyConfig } from '../families/index.js';
+import { createFetcher } from '../fetch.js';
+import { AEM_BRANDS } from '../identity.js';
+import { boundFamily } from '../registry.js';
+import { mirrorFamilySteps } from './cad-mirror.js';
+import { parseCsv, toCsv } from './csv.js';
+import { describeRoot, familyCsv, stepDir } from './paths.js';
+import * as receipts from './receipts.js';
+import { scrapeFamily } from '../vendors/kennametal/scrape.js';
+import { annotateCadUrls } from '../vendors/kennametal/cad.js';
+import { addMaterialGroups, groupsByMaterial } from '../vendors/kennametal/materials.js';
+import { addThreadPitch } from '../vendors/kennametal/thread-column.js';
+import { scrapeEndMills, DOCUMENTS_URL } from '../vendors/destinytool/scrape.js';
+import { SEARCH_URL, scrapeCollets, scrapeHolders } from '../vendors/regofix/scrape.js';
+/**
+ * The PG series a BT 30 holder can take. PG 32 and PG 48 collets exist and no
+ * BT 30 holder in this catalog accepts one, so scraping them would add parts
+ * that fit nothing.
+ */
+const BT30_COLLET_SIZES = ['6', '10', '15', '25'];
+const USAGE = `usage: toolpath-scrape <command> [args]
+
+  kennametal [--brand kennametal|widia] FAMILY_CODE OUTPUT_CSV [Name=Value ...]
+      One AEM family page -> a CSV. Trailing Name=Value args are appended to
+      every row as constant columns, for facts the vendor table does not state
+      (e.g. "Thread System=metric").
+
+  regofix holders OUT.csv
+  regofix collets "<PRODUCT GROUP>" OUT.csv
+      The REGO-FIX ProductFinder index. \`holders\` takes every powRgrip BT/PG
+      holder whose taper is BT 30 or BT+ 30, with geometry from each part's
+      DIN 4000 document. \`collets\` takes one product group, restricted to PG
+      sizes ${BT30_COLLET_SIZES.join(', ')} — the group is the vendor's own
+      \`product_group_name\`, e.g. "Standard", "Coolant flush",
+      "Tapping collet TAP".
+
+  destinytool OUTPUT_CSV
+      Pages the whole Destiny Tool \`products\` Firestore collection and writes
+      every End Mill row.
+
+  thread-pitch TAP.csv [more.csv ...]
+      Adds a Thread Pitch column derived from D1-TDZ, in place. Safe to re-run.
+
+  cad HOLDERS.csv [more.csv ...]
+      Adds the vendor CAD model URL column, in place. One request per row
+      against product-config.net; safe to re-run.
+
+  materials FAMILY.csv [more.csv ...]
+      Adds the ISO workpiece-group column, in place. One request per material
+      group (32) per family; safe to re-run.
+
+  mirror-cad HOLDERS.csv [more.csv ...]
+      Downloads each row's STEP model into <root>/<brand>/step. Run \`cad\`
+      first — a CSV with no CAD column yields nothing and says so.
+
+An output path is used verbatim; scraped CSVs belong under the scrape root,
+in <brand>/csv/. The in-place commands take a bare CSV name and resolve it
+through the family's own brand.`;
+const STDOUT = {
+    log: (message) => process.stdout.write(`${message}\n`),
+    error: (message) => process.stderr.write(`${message}\n`),
+};
+/** Read one family's CSV off disk as a scrape result. */
+function readCsv(name, source) {
+    const path = familyCsv(name);
+    const { header, rows } = parseCsv(readFileSync(path, 'utf8'));
+    return { header, rows, source, familyCode: null };
+}
+/** Write a scrape to `path`. */
+function writeCsv(path, scrape) {
+    writeFileSync(path, toCsv(scrape.header, scrape.rows));
+}
+/**
+ * Report a scrape and record its receipt.
+ *
+ * One function because the two belong together: a scrape that reported a count
+ * and wrote no receipt would be exactly the state this package is trying to
+ * stop existing — data with nothing saying where it came from.
+ */
+function wrote(out, brand, scrape, io) {
+    writeCsv(out, scrape);
+    const receipt = receipts.write(out, {
+        brand,
+        source: scrape.source,
+        rows: scrape.rows.length,
+        familyCode: scrape.familyCode,
+    });
+    io.log(`wrote ${scrape.rows.length} rows to ${out}`);
+    io.log(`  receipt: ${basename(receipt)}`);
+    const name = basename(out);
+    // Through the merged table rather than three chained lookups, so a name two
+    // tables both claim is refused where it is built instead of resolving here
+    // to whichever happened to be checked first.
+    const declared = ALL_FAMILIES[name]?.rows;
+    const written = receipts.read(out);
+    if (declared !== undefined && written !== null) {
+        receipts.checkRows(name, declared, written);
+    }
+}
+/**
+ * Argv as family CSV names, refusing anything unknown by name.
+ *
+ * A path's directory is ignored: the family's own brand decides where its CSV
+ * lives, and honouring a typed directory would let one vendor's receipt be
+ * written into another's.
+ */
+function namesIn(argv, known, what) {
+    const names = argv.map((a) => basename(a));
+    const unknown = names.filter((n) => !Object.hasOwn(known, n));
+    if (unknown.length > 0) {
+        throw new ScraperConfigError(unknown.join(', '), `unknown ${what} CSV (known: ${Object.keys(known).sort().join(', ')})`);
+    }
+    return names;
+}
+/** Run one command. Exported so the tests drive it without a subprocess. */
+export async function run(argv, io = STDOUT, fetcher = createFetcher()) {
+    // Somebody reading the usage text is the person most likely to be about to
+    // point a scrape at the wrong place, so help gets the root too.
+    io.log(describeRoot());
+    const [command, ...rest] = argv;
+    if (command === undefined || command === '-h' || command === '--help') {
+        io.log(USAGE);
+        return 0;
+    }
+    switch (command) {
+        case 'kennametal':
+            return kennametal(rest, io, fetcher);
+        case 'regofix':
+            return regofix(rest, io, fetcher);
+        case 'destinytool':
+            return destinytool(rest, io, fetcher);
+        case 'thread-pitch':
+            return threadPitch(rest, io);
+        case 'cad':
+            return cad(rest, io, fetcher);
+        case 'materials':
+            return materials(rest, io, fetcher);
+        case 'mirror-cad':
+            return mirrorCad(rest, io, fetcher);
+        default:
+            io.error(`unknown command ${JSON.stringify(command)}\n\n${USAGE}`);
+            return 2;
+    }
+}
+async function kennametal(argv, io, fetcher) {
+    const args = [...argv];
+    let brand = 'kennametal';
+    const flag = args.indexOf('--brand');
+    if (flag !== -1) {
+        const value = args[flag + 1];
+        if (value === undefined) {
+            io.error(`--brand needs a value\n\n${USAGE}`);
+            return 2;
+        }
+        brand = value;
+        args.splice(flag, 2);
+    }
+    // Against the AEM brands rather than every brand: `scrapeFamily` reads
+    // `Brand.node`, and a brand without one built a URL with `undefined` in the
+    // path and died on the 404 instead of on this line.
+    if (!AEM_BRANDS.includes(brand)) {
+        io.error(`unknown brand: ${brand} (known: ${[...AEM_BRANDS].sort().join(', ')})`);
+        return 2;
+    }
+    if (args.length < 2) {
+        io.error(USAGE);
+        return 2;
+    }
+    const [code, out] = args;
+    // Refused rather than dropped: a quoting slip like `"Thread System" metric`
+    // used to scrape, write the CSV and exit 0 with the column missing, and the
+    // failure surfaced later in `addThreadPitch` against a file no longer being
+    // written.
+    const constants = args.slice(2);
+    const malformed = constants.find((a) => a.indexOf('=') < 1);
+    if (malformed !== undefined) {
+        io.error(`constant column ${JSON.stringify(malformed)} is not Name=Value\n\n${USAGE}`);
+        return 2;
+    }
+    const tags = constants.map((a) => {
+        const at = a.indexOf('=');
+        return [a.slice(0, at), a.slice(at + 1)];
+    });
+    const scrape = await scrapeFamily(fetcher, code, brand, tags);
+    wrote(out, brand, scrape, io);
+    return 0;
+}
+async function regofix(argv, io, fetcher) {
+    const [what, ...rest] = argv;
+    if (what === 'holders') {
+        if (rest.length !== 1) {
+            io.error(USAGE);
+            return 2;
+        }
+        const scrape = await scrapeHolders(fetcher, 'BT/PG', 'BT', {
+            warn: io.error,
+        });
+        wrote(rest[0], 'regofix', { ...scrape, source: SEARCH_URL }, io);
+        return 0;
+    }
+    if (what === 'collets') {
+        if (rest.length !== 2) {
+            io.error(USAGE);
+            return 2;
+        }
+        const [group, out] = rest;
+        const scrape = await scrapeCollets(fetcher, group, BT30_COLLET_SIZES, {
+            warn: io.error,
+        });
+        wrote(out, 'regofix', { ...scrape, source: SEARCH_URL }, io);
+        return 0;
+    }
+    io.error(`unknown subcommand ${JSON.stringify(what)}\n\n${USAGE}`);
+    return 2;
+}
+async function destinytool(argv, io, fetcher) {
+    if (argv.length !== 1) {
+        io.error(USAGE);
+        return 2;
+    }
+    const scrape = await scrapeEndMills(fetcher);
+    wrote(argv[0], 'destinytool', { ...scrape, source: DOCUMENTS_URL }, io);
+    return 0;
+}
+function threadPitch(argv, io) {
+    if (argv.length === 0) {
+        io.error(USAGE);
+        return 2;
+    }
+    for (const name of namesIn(argv, FAMILIES, 'family')) {
+        const path = familyCsv(name);
+        const updated = addThreadPitch(readCsv(name, path));
+        writeCsv(path, updated);
+        io.log(`${name}: ${updated.rows.length} rows updated`);
+    }
+    return 0;
+}
+async function cad(argv, io, fetcher) {
+    if (argv.length === 0) {
+        io.error(USAGE);
+        return 2;
+    }
+    for (const name of namesIn(argv, HOLDER_FAMILIES, 'holder')) {
+        // `annotateCadUrls` is Kennametal's CDS lookup, not a vendor-neutral one —
+        // it queries product-config.net and rewrites `CAD_COLUMN` on every row. Run
+        // against a REGO-FIX holder it would post that vendor's SKUs to Kennametal
+        // and blank the STEP URLs the REGO-FIX scrape had already filled in.
+        // `mirror-cad` reads the column and *is* neutral; this writes it and is not.
+        const brand = familyBrand(familyConfig(name));
+        if (!AEM_BRANDS.includes(brand)) {
+            io.error(`${name}: the cad step is ${[...AEM_BRANDS].sort().join('/')}-only — ` +
+                `${brand} publishes its own CAD URLs with the scrape`);
+            return 2;
+        }
+        const path = familyCsv(name);
+        const { scrape, found } = await annotateCadUrls(fetcher, readCsv(name, path));
+        writeCsv(path, scrape);
+        io.log(`${name}: ${found} CAD models`);
+    }
+    return 0;
+}
+async function materials(argv, io, fetcher) {
+    if (argv.length === 0) {
+        io.error(USAGE);
+        return 2;
+    }
+    // The family code and brand come from config, so a re-run needs neither
+    // typed again.
+    for (const name of namesIn(argv, FAMILIES, 'family')) {
+        const cfg = boundFamily(name);
+        if (cfg.familyCode === undefined) {
+            throw new ScraperConfigError(name, 'has no familyCode — the material sweep re-queries the family page ' +
+                'and cannot without one');
+        }
+        const path = familyCsv(name);
+        const found = await groupsByMaterial(fetcher, cfg.familyCode, {
+            brand: (cfg.brand ?? 'kennametal'),
+        });
+        const { scrape, matched } = addMaterialGroups(readCsv(name, path), found);
+        writeCsv(path, scrape);
+        io.log(`${name}: ${matched} rows with a material group`);
+    }
+    return 0;
+}
+async function mirrorCad(argv, io, fetcher) {
+    if (argv.length === 0) {
+        io.error(USAGE);
+        return 2;
+    }
+    for (const name of namesIn(argv, HOLDER_FAMILIES, 'holder')) {
+        const path = familyCsv(name);
+        const brand = familyBrand(familyConfig(name));
+        const written = await mirrorFamilySteps(fetcher, readCsv(name, path).rows, stepDir(brand), undefined, io.error);
+        const total = written.reduce((sum, f) => sum + f.bytes, 0);
+        io.log(`${name}: ${written.length} STEP files, ${Math.floor(total / 1024)} KB`);
+    }
+    return 0;
+}
+/** The process entry point: run, and turn a refusal into an exit code. */
+export async function main(argv = process.argv.slice(2)) {
+    try {
+        return await run(argv);
+    }
+    catch (error) {
+        if (error instanceof ScraperConfigError || error instanceof VendorResponseError) {
+            STDOUT.error(error.message);
+            return 2;
+        }
+        throw error;
+    }
+}

package/dist/node/csv.d.ts

@@ -0,0 +1,47 @@
+/**
+ * CSV, to the letter of what Python's `csv` module writes.
+ *
+ * Node has no CSV in its standard library and this package needs about sixty
+ * lines of one, so it is here rather than a dependency — the same call
+ * `uuid5.ts` makes, and for the same reason: a dependency whose whole surface
+ * is two functions is a supply chain for no gain.
+ *
+ * **Byte-compatible with the Python this replaces, deliberately.** Scraped
+ * CSVs already exist on the machines that keep a corpus, and a re-scrape has
+ * to produce the same file or every diff is noise. That means three details
+ * that are not the obvious defaults:
+ *
+ * 1. **`\r\n` line endings.** Python's `csv.writer` uses them regardless of
+ *    platform; `open(path, 'w', newline='')` is what stops the runtime
+ *    translating them, not a choice to emit `\n`.
+ * 2. **Minimal quoting.** A field is quoted only when it contains a comma, a
+ *    quote or a newline — `QUOTE_MINIMAL`, Python's default.
+ * 3. **Doubled quotes**, not backslash escapes.
+ *
+ * The reader accepts either line ending, because a CSV that has been through
+ * an editor is still a CSV.
+ */
+import type { ScrapedRow } from '../scrape.js';
+/**
+ * Rows to CSV text, in `header` order.
+ *
+ * A row missing one of the header's columns writes an empty cell rather than
+ * failing: a mixed-unit collet family has `D1_mm` on its metric rows and
+ * `D1_in` on its inch ones, and both columns are in the union header.
+ */
+export declare function toCsv(header: readonly string[], rows: readonly ScrapedRow[]): string;
+/** What {@link parseCsv} answers with. */
+export interface ParsedCsv {
+    header: string[];
+    rows: ScrapedRow[];
+}
+/**
+ * CSV text back into a header and rows.
+ *
+ * A row longer than the header keeps its extra cells under no name, and a
+ * shorter one leaves the missing columns empty — the same shape Python's
+ * `DictReader` produces, and the reason neither is an error is that these
+ * files are re-read by the annotate steps, which have to be able to say what
+ * changed rather than refuse the file.
+ */
+export declare function parseCsv(text: string): ParsedCsv;

package/dist/node/csv.js

@@ -0,0 +1,123 @@
+/**
+ * CSV, to the letter of what Python's `csv` module writes.
+ *
+ * Node has no CSV in its standard library and this package needs about sixty
+ * lines of one, so it is here rather than a dependency — the same call
+ * `uuid5.ts` makes, and for the same reason: a dependency whose whole surface
+ * is two functions is a supply chain for no gain.
+ *
+ * **Byte-compatible with the Python this replaces, deliberately.** Scraped
+ * CSVs already exist on the machines that keep a corpus, and a re-scrape has
+ * to produce the same file or every diff is noise. That means three details
+ * that are not the obvious defaults:
+ *
+ * 1. **`\r\n` line endings.** Python's `csv.writer` uses them regardless of
+ *    platform; `open(path, 'w', newline='')` is what stops the runtime
+ *    translating them, not a choice to emit `\n`.
+ * 2. **Minimal quoting.** A field is quoted only when it contains a comma, a
+ *    quote or a newline — `QUOTE_MINIMAL`, Python's default.
+ * 3. **Doubled quotes**, not backslash escapes.
+ *
+ * The reader accepts either line ending, because a CSV that has been through
+ * an editor is still a CSV.
+ */
+const NEEDS_QUOTING = /[",\r\n]/;
+/** One field, quoted only if it has to be. */
+function field(value) {
+    return NEEDS_QUOTING.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+/**
+ * Rows to CSV text, in `header` order.
+ *
+ * A row missing one of the header's columns writes an empty cell rather than
+ * failing: a mixed-unit collet family has `D1_mm` on its metric rows and
+ * `D1_in` on its inch ones, and both columns are in the union header.
+ */
+export function toCsv(header, rows) {
+    const lines = [header.map(field).join(',')];
+    for (const row of rows) {
+        lines.push(header.map((column) => field(row[column] ?? '')).join(','));
+    }
+    return `${lines.join('\r\n')}\r\n`;
+}
+/**
+ * CSV text back into a header and rows.
+ *
+ * A row longer than the header keeps its extra cells under no name, and a
+ * shorter one leaves the missing columns empty — the same shape Python's
+ * `DictReader` produces, and the reason neither is an error is that these
+ * files are re-read by the annotate steps, which have to be able to say what
+ * changed rather than refuse the file.
+ */
+export function parseCsv(text) {
+    const records = parseRecords(text);
+    const header = records.shift() ?? [];
+    const rows = records.map((cells) => {
+        const row = {};
+        header.forEach((column, index) => {
+            row[column] = cells[index] ?? '';
+        });
+        return row;
+    });
+    return { header, rows };
+}
+/** The raw grid, before a header is applied. */
+function parseRecords(text) {
+    const records = [];
+    let record = [];
+    let cell = '';
+    let quoted = false;
+    let started = false;
+    const endCell = () => {
+        record.push(cell);
+        cell = '';
+    };
+    const endRecord = () => {
+        endCell();
+        records.push(record);
+        record = [];
+        started = false;
+    };
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (quoted) {
+            if (char === '"') {
+                if (text[i + 1] === '"') {
+                    cell += '"';
+                    i += 1;
+                }
+                else {
+                    quoted = false;
+                }
+            }
+            else {
+                cell += char;
+            }
+            continue;
+        }
+        if (char === '"' && cell === '') {
+            quoted = true;
+            started = true;
+        }
+        else if (char === ',') {
+            endCell();
+            started = true;
+        }
+        else if (char === '\r' || char === '\n') {
+            if (char === '\r' && text[i + 1] === '\n')
+                i += 1;
+            // A blank line between records is not a record. Python's reader skips
+            // it, and a trailing newline would otherwise add a row of one empty cell
+            // to every file this package writes.
+            if (started || cell !== '' || record.length > 0)
+                endRecord();
+        }
+        else {
+            cell += char;
+            started = true;
+        }
+    }
+    if (started || cell !== '' || record.length > 0)
+        endRecord();
+    return records;
+}

package/dist/node/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The half of this package that touches the filesystem.
+ *
+ * A scrape returns rows; turning them into a CSV, writing the provenance
+ * sidecar that goes beside one, resolving where a vendor's files live and
+ * mirroring the vendor's CAD binaries all need `fs`, and a backend that only
+ * wants records should not have to import any of it.
+ *
+ * So they are a separate entry point — `@toolpath/tool-scraper/node` — and the
+ * main one stays what a library ought to be: functions in, values out.
+ */
+export * from './cad-mirror.js';
+export * from './cli.js';
+export * from './csv.js';
+export * from './paths.js';
+export * from './receipts.js';

package/dist/node/index.js

@@ -0,0 +1,16 @@
+/**
+ * The half of this package that touches the filesystem.
+ *
+ * A scrape returns rows; turning them into a CSV, writing the provenance
+ * sidecar that goes beside one, resolving where a vendor's files live and
+ * mirroring the vendor's CAD binaries all need `fs`, and a backend that only
+ * wants records should not have to import any of it.
+ *
+ * So they are a separate entry point — `@toolpath/tool-scraper/node` — and the
+ * main one stays what a library ought to be: functions in, values out.
+ */
+export * from './cad-mirror.js';
+export * from './cli.js';
+export * from './csv.js';
+export * from './paths.js';
+export * from './receipts.js';

package/dist/node/main.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * The executable. Nothing but the shebang and the call.
+ *
+ * Separate from `cli.ts` because that module is also imported —
+ * `@toolpath/tool-scraper/node` re-exports `run` so a consumer can drive a
+ * command without a subprocess, and a top-level "if this is the entry point"
+ * guard in an imported module is both fragile and a side effect. It was fragile
+ * here in exactly the way that matters: run through the `bin` symlink,
+ * `process.argv[1]` is the symlink's name and the guard never matched, so the
+ * installed command printed nothing and exited 0.
+ */
+export {};

package/dist/node/main.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * The executable. Nothing but the shebang and the call.
+ *
+ * Separate from `cli.ts` because that module is also imported —
+ * `@toolpath/tool-scraper/node` re-exports `run` so a consumer can drive a
+ * command without a subprocess, and a top-level "if this is the entry point"
+ * guard in an imported module is both fragile and a side effect. It was fragile
+ * here in exactly the way that matters: run through the `bin` symlink,
+ * `process.argv[1]` is the symlink's name and the guard never matched, so the
+ * installed command printed nothing and exited 0.
+ */
+import { main } from './cli.js';
+process.exitCode = await main();

package/dist/node/paths.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Where a scrape lands.
+ *
+ * **Scraped output is never committed.** A CSV is a vendor's data and a
+ * working file, not source, and this repository is public — which is a second
+ * reason, independent of size, to keep it out. Git was carrying the provenance
+ * of those CSVs for free; now that it is not, every scrape writes a
+ * {@link receipts} sidecar beside its file.
+ *
+ * This module is in `node/` rather than beside the config tables: resolving a
+ * root needs `process.env` and a path relative to this file's own location,
+ * and a family table that needed either would be unimportable in anything that
+ * only wants to read records.
+ */
+import type { BrandName } from '../identity.js';
+/**
+ * Where scraped CSVs are read from and written to.
+ *
+ * Set it when the package is installed rather than run from a checkout: the
+ * default below is derived from this file's own location, which is right in a
+ * working tree and meaningless inside `node_modules`. Every command prints the
+ * resolved root for exactly that reason — a scrape that wrote somewhere
+ * surprising should say so on the way, not be discovered later.
+ */
+export declare const SCRAPE_ROOT_ENV = "TOOLPATH_SCRAPE_ROOT";
+/** `packages/tool-scraper/scrape-out`, which `.gitignore` already covers. */
+export declare const DEFAULT_SCRAPE_ROOT: string;
+/** The directory holding every vendor's scraped CSVs. */
+export declare function scrapeRoot(): string;
+/**
+ * One line naming the resolved root and how it was resolved.
+ *
+ * Printed by every command. The distinction it carries is the one that matters
+ * when a scrape goes somewhere unexpected: whether the path came from the
+ * environment or from this package's own location.
+ */
+export declare function describeRoot(): string;
+/**
+ * Where one vendor's scraped CSVs live — the receipts.
+ *
+ * Per brand rather than per adapter, and the distinction is worth holding on
+ * to: an adapter is a fact about *code*, a scraped table is a fact about who
+ * published it. WIDIA's tables are WIDIA's even though Kennametal's adapter is
+ * what fetched them.
+ */
+export declare function csvDir(brand: BrandName): string;
+/**
+ * One vendor's mirrored STEP models.
+ *
+ * Nothing is redistributed from here: these are a local working copy for
+ * measuring a holder, and only a derived profile is ever meant to leave.
+ */
+export declare function stepDir(brand: BrandName): string;
+/**
+ * Where one family's CSV lives, resolved through its own brand.
+ *
+ * Takes a bare CSV name rather than a path, so a caller cannot pass a file
+ * from somewhere else and have it silently treated as this family's receipt.
+ */
+export declare function familyCsv(name: string): string;