@toolpath/tool-support 0.1.0

package/dist/stickout.js

@@ -0,0 +1,161 @@
+/**
+ * How far a tool stands out of whatever holds it — the one answer.
+ *
+ * **There used to be four.** The same question was worked out in four
+ * unconnected places, and they disagreed by a factor of two on an ordinary
+ * tool:
+ *
+ * | where                             | what it computed              | on a ⌀1 in end mill, `OAL` 5, `LCF` 1.25, `SFDM` 1 |
+ * | --------------------------------- | ----------------------------- | -------------------------------------------------- |
+ * | the clamping rule → `geometry.LBH` | `OAL − 3×SFDM`                | 2.000 in                                           |
+ * | the holding module's `max`         | `OAL − OAL×heldShare`         | 3.333 in                                           |
+ * | its `default` → the drawing        | flutes, floored and stepped   | 1.250 in                                           |
+ * | the hole-mode reach check          | read `geometry.LBH` as a ceiling | 2.000 in                                        |
+ *
+ * The details table printed the first and the drawing beside it drew the third,
+ * so a dimension line for `LBH` ran up past the holder nose and into the holder
+ * body. Neither of the first two consulted the other, and the two knobs behind
+ * them — a minimum clamping length (a length of **shank**) and a good hold (a
+ * share of the **overall length**) — were combined nowhere.
+ *
+ * **That bug is the single strongest argument for this package existing.** It
+ * was fixed inside one application, which left the next consumer of a tool
+ * catalog and a tool drawing to reproduce it from scratch: the quantity is a
+ * pure function of the tool, the collet and a shop's policy, and it had no home
+ * until this one.
+ *
+ * So this module owns the quantity outright and every other number is this same
+ * function with more arguments:
+ *
+ * ```
+ * geometry.LBH      ≡ stickoutRange(tool).setup                       — no holder, no feature
+ * Assembly.stickout ≡ stickoutRange(tool, { grip, required }).setup
+ * the ceiling       ≡ stickoutRange(tool, …).max
+ * ```
+ *
+ * `min ≤ setup ≤ max` holds by construction, so a drawn stickout can never
+ * exceed the length a table prints beside it. That invariant is a test rather
+ * than this sentence.
+ *
+ * **`LBH` is the setup length, not the ceiling.** The "below holder" column
+ * answers what a machinist would set the tool up at; the most it *could* stand
+ * out is {@link StickoutRange.max}, which is checked and reported but is not
+ * the column. What makes that reading workable is that the floor and the step
+ * reach it — {@link DEFAULT_STICKOUT_POLICY} carries `least` and `step`, and an
+ * earlier default carried zero for both and so produced the bare flute length.
+ */
+import { DEFAULT_CLAMPING, clampWanted } from './clamping.js';
+import { hasNeck } from './tool.js';
+/**
+ * The share of a tool's overall length a holder must always have hold of.
+ *
+ * A third. **A shop's figure, not a vendor's** — no vendor in the scraped
+ * catalog publishes a minimum engagement — which is why it is named here and
+ * every control that shows it should say whose it is. Deliberately a share of
+ * the length and not a multiple of the shank diameter: how much of a tool a
+ * collet needs is about the tool's leverage, not its shank. That other reading
+ * is {@link ClampingRule}, and both are honoured — see {@link StickoutLimit}.
+ */
+export const HELD_SHARE = 1 / 3;
+/** What a dataset is built with, and what a page starts at. */
+export const DEFAULT_STICKOUT_POLICY = {
+    heldShare: HELD_SHARE,
+    least: 12.7,
+    step: { inches: 3.175, millimeters: 3 },
+};
+const round = (value) => Math.round(value * 100) / 100;
+/** A hair, so a rounded stickout a femtometre under what is needed is not stepped up. */
+const STICKOUT_TOLERANCE = 1e-6;
+/**
+ * The least a tool can stand out: its flutes, or its neck where it has one.
+ *
+ * The collet face sits at the end of the flutes, and a stated neck — which a
+ * collet must not close on — pushes it back to the shoulder. A tool that states
+ * no flute length has no known head, so it has no known stickout at all and
+ * this answers `null`; it carries no `LBH` either, rather than one derived from
+ * `OAL` and `SFDM` alone.
+ */
+export const minStickout = (tool) => {
+    const { LCF } = tool.geometry;
+    if (LCF === undefined) {
+        return null;
+    }
+    const shoulder = tool.geometry['shoulder-length'];
+    return hasNeck(tool) && shoulder !== undefined ? shoulder : LCF;
+};
+/**
+ * The setup length before the ceiling: what is needed, no shorter than the
+ * policy's least, on the policy's step for this tool — the nearest step, or the
+ * one above it where the nearest falls short of what is needed.
+ */
+const steppedTo = (tool, needed, policy) => {
+    const step = policy.step[tool.unitSystem];
+    const preferred = Math.max(needed, policy.least);
+    if (step <= 0) {
+        return preferred;
+    }
+    const nearest = Math.round(preferred / step) * step;
+    return nearest + STICKOUT_TOLERANCE < needed ? nearest + step : nearest;
+};
+/**
+ * Every stickout this tool has, in one answer.
+ *
+ * `null` only when the tool states no flute length, because then nothing about
+ * where it stands out of a holder can be worked out at all.
+ */
+export const stickoutRange = (tool, request = {}) => {
+    const min = minStickout(tool);
+    if (min === null) {
+        return null;
+    }
+    const { grip = null, required = null, rule = DEFAULT_CLAMPING, policy = DEFAULT_STICKOUT_POLICY, } = request;
+    const { OAL } = tool.geometry;
+    /**
+     * The three ways of saying "this much stays in the holder", as three caps on
+     * one number. The tightest wins and says its name — which is the whole point
+     * of the module: a shop's sheet carries a minimum clamping length and a good
+     * hold as separate knobs, and before this they capped separate numbers in
+     * separate files and nothing ever compared them.
+     */
+    const caps = [];
+    if (OAL !== undefined) {
+        const clamp = clampWanted(tool.geometry, rule);
+        if (clamp !== null) {
+            caps.push({ by: 'clamp', at: OAL - clamp });
+        }
+        if (policy.heldShare > 0) {
+            caps.push({ by: 'hold', at: OAL * (1 - policy.heldShare) });
+        }
+        if (grip !== null) {
+            caps.push({ by: 'collet', at: OAL - grip });
+        }
+    }
+    const tightest = caps.reduce((best, cap) => (best === null || cap.at < best.at ? cap : best), null);
+    const gripShort = tightest !== null && tightest.at < min;
+    const max = tightest === null ? null : round(gripShort ? min : tightest.at);
+    const wanted = steppedTo(tool, Math.max(min, required ?? min), policy);
+    return {
+        min: round(min),
+        setup: round(max === null ? wanted : Math.min(wanted, max)),
+        max,
+        limitedBy: tightest?.by ?? null,
+        grip: OAL === undefined ? null : round(Math.max(0, OAL - min)),
+        wantedGrip: OAL === undefined || tightest === null ? null : round(OAL - tightest.at),
+        gripShort,
+    };
+};
+/**
+ * What this tool would be set up at on its own: no holder chosen and no feature
+ * to reach. This is `geometry.LBH`, and a build writes it with exactly this
+ * call.
+ */
+export const setupStickout = (tool, rule = DEFAULT_CLAMPING, policy = DEFAULT_STICKOUT_POLICY) => stickoutRange(tool, { rule, policy })?.setup ?? null;
+/**
+ * The furthest this tool can ever stand out of a holder, mm.
+ *
+ * **A reach check's number, not `LBH`.** A tap that will not reach the bottom of
+ * a hole at its setup length may reach it pulled further out, and asking `LBH` —
+ * which is the setup — would refuse it. Anything asking "could this tool get
+ * down there at all" asks this.
+ */
+export const stickoutCeiling = (tool, rule = DEFAULT_CLAMPING, policy = DEFAULT_STICKOUT_POLICY) => stickoutRange(tool, { rule, policy })?.max ?? null;

package/dist/tool.d.ts

@@ -0,0 +1,80 @@
+/**
+ * A cutting tool, as everything downstream of a scrape needs one.
+ *
+ * ## Deliberately not a catalog's record
+ *
+ * A catalog's tool carries identity and commerce — a guid, a brand, a catalog
+ * number, a product link, which material groups a vendor rates it for. None of
+ * that is arithmetic: nothing that draws a tool, fits it to a feature or works
+ * out how far it stands out of a holder reads a single one of those fields.
+ *
+ * So this is the *domain* shape and a catalog's record **extends** it, rather
+ * than this being a projection of a record. That direction matters: a record
+ * simply _is_ a {@link Tool}, with no adapter, which is what lets one number be
+ * computed once and drawn, printed and checked against the same value.
+ *
+ * `geometry` keeps the scraper's own field names — `DC`, `SFDM`, `OAL`, `LCF`,
+ * `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`. See
+ * `geometry.ts` for why they are not renamed here.
+ *
+ * All lengths are in millimetres and all angles in degrees. `UnitSystem` is a
+ * fact about the vendor's sheet and is not carried here: it decides how a
+ * number is rounded and shown rather than what it is, and the arithmetic that
+ * needs it takes it as its own argument.
+ */
+import type { Geometry } from './geometry.js';
+import type { ProvenanceMap } from './provenance.js';
+export interface Tool {
+    /** The CAM-library name for what the tool is: `flat end mill`, `drill`, `slot mill`. */
+    readonly form: string;
+    /** What a machinist calls this one tool — a catalog number, usually. */
+    readonly label?: string;
+    readonly geometry: Geometry;
+    readonly provenance?: ProvenanceMap;
+}
+/**
+ * Whether the section between the flutes and the shank is a neck: a stated
+ * shoulder past the flutes, narrower than the shank.
+ *
+ * A collet cannot close on a neck, so the tool stands out to its shoulder at
+ * least, and a sweep meets the wall with the neck at its own radius. A shoulder
+ * as wide as the shank is still a relief worth drawing, but it is plain shank.
+ *
+ * **This had a twin, and the twin is why this package exists.** One copy drew
+ * the picture and the other decided the verdict, and the note beside the second
+ * said it outright: *"If the rule ever changes, it changes in both places or the
+ * picture and the verdict disagree about the same tool."* Nothing was watching
+ * that. Now there is one rule, and a drawing and a clearance check cannot read a
+ * different tool out of the same numbers.
+ *
+ * Takes the geometry structurally rather than a whole {@link Tool}, so a
+ * catalog record with a narrower `Record<string, number>` satisfies it with no
+ * adapter.
+ */
+export declare const hasNeck: (tool: {
+    readonly geometry: Geometry;
+}) => boolean;
+/** Whether the shank behind the flutes is reduced, or the full cutting diameter. */
+export type Shank = 'reduced' | 'full';
+/**
+ * Whether the shank behind the flutes is reduced.
+ *
+ * A **real relief**: a section immediately above the flutes that is a smaller
+ * diameter than the flute diameter *and has a length*. The distinction matters
+ * because vendors state a shoulder two different ways — 74 end mills in the
+ * scraped corpus have a genuine reduced shank, while 171 state a shoulder
+ * narrower than the cut whose shoulder length equals the flute length, which is
+ * no section to draw or to sweep. The second kind is not called reduced.
+ *
+ * `null` where no shoulder is stated at all, which is not a claim that the
+ * shank is full: it is nobody having said.
+ *
+ * Distinct from {@link hasNeck}, and both are needed. `hasNeck` asks whether
+ * there is a narrower section to draw and sweep *below the shank*; this asks
+ * whether the shank itself is reduced against the *cut*. A tool can have a
+ * relief wider than its cutting diameter — 860 end mills do, 245 of them under
+ * the cut — which is a neck to draw and not a reduced shank.
+ */
+export declare const shankOf: (tool: {
+    readonly geometry: Geometry;
+}) => Shank | null;

package/dist/tool.js

@@ -0,0 +1,89 @@
+/**
+ * A cutting tool, as everything downstream of a scrape needs one.
+ *
+ * ## Deliberately not a catalog's record
+ *
+ * A catalog's tool carries identity and commerce — a guid, a brand, a catalog
+ * number, a product link, which material groups a vendor rates it for. None of
+ * that is arithmetic: nothing that draws a tool, fits it to a feature or works
+ * out how far it stands out of a holder reads a single one of those fields.
+ *
+ * So this is the *domain* shape and a catalog's record **extends** it, rather
+ * than this being a projection of a record. That direction matters: a record
+ * simply _is_ a {@link Tool}, with no adapter, which is what lets one number be
+ * computed once and drawn, printed and checked against the same value.
+ *
+ * `geometry` keeps the scraper's own field names — `DC`, `SFDM`, `OAL`, `LCF`,
+ * `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`. See
+ * `geometry.ts` for why they are not renamed here.
+ *
+ * All lengths are in millimetres and all angles in degrees. `UnitSystem` is a
+ * fact about the vendor's sheet and is not carried here: it decides how a
+ * number is rounded and shown rather than what it is, and the arithmetic that
+ * needs it takes it as its own argument.
+ */
+/**
+ * A hair, because a shoulder and a shank that are the same nominal size are the
+ * same float only until one of them has been through a unit conversion: 3/8" is
+ * 9.525 on the collet's sheet and 9.524999999999999 on the tool's.
+ */
+const EPSILON = 1e-6;
+/**
+ * Whether the section between the flutes and the shank is a neck: a stated
+ * shoulder past the flutes, narrower than the shank.
+ *
+ * A collet cannot close on a neck, so the tool stands out to its shoulder at
+ * least, and a sweep meets the wall with the neck at its own radius. A shoulder
+ * as wide as the shank is still a relief worth drawing, but it is plain shank.
+ *
+ * **This had a twin, and the twin is why this package exists.** One copy drew
+ * the picture and the other decided the verdict, and the note beside the second
+ * said it outright: *"If the rule ever changes, it changes in both places or the
+ * picture and the verdict disagree about the same tool."* Nothing was watching
+ * that. Now there is one rule, and a drawing and a clearance check cannot read a
+ * different tool out of the same numbers.
+ *
+ * Takes the geometry structurally rather than a whole {@link Tool}, so a
+ * catalog record with a narrower `Record<string, number>` satisfies it with no
+ * adapter.
+ */
+export const hasNeck = (tool) => {
+    const { LCF, SFDM, DC } = tool.geometry;
+    const shoulder = tool.geometry['shoulder-length'];
+    const relief = tool.geometry['shoulder-diameter'];
+    if (shoulder === undefined || relief === undefined || LCF === undefined || shoulder <= LCF) {
+        return false;
+    }
+    const shank = SFDM ?? DC;
+    return shank === undefined ? true : relief < shank - EPSILON;
+};
+/**
+ * Whether the shank behind the flutes is reduced.
+ *
+ * A **real relief**: a section immediately above the flutes that is a smaller
+ * diameter than the flute diameter *and has a length*. The distinction matters
+ * because vendors state a shoulder two different ways — 74 end mills in the
+ * scraped corpus have a genuine reduced shank, while 171 state a shoulder
+ * narrower than the cut whose shoulder length equals the flute length, which is
+ * no section to draw or to sweep. The second kind is not called reduced.
+ *
+ * `null` where no shoulder is stated at all, which is not a claim that the
+ * shank is full: it is nobody having said.
+ *
+ * Distinct from {@link hasNeck}, and both are needed. `hasNeck` asks whether
+ * there is a narrower section to draw and sweep *below the shank*; this asks
+ * whether the shank itself is reduced against the *cut*. A tool can have a
+ * relief wider than its cutting diameter — 860 end mills do, 245 of them under
+ * the cut — which is a neck to draw and not a reduced shank.
+ */
+export const shankOf = (tool) => {
+    const { DC, LCF } = tool.geometry;
+    const shoulder = tool.geometry['shoulder-diameter'];
+    const length = tool.geometry['shoulder-length'];
+    if (DC === undefined || shoulder === undefined) {
+        return null;
+    }
+    const narrower = shoulder < DC - EPSILON;
+    const real = length !== undefined && LCF !== undefined && length > LCF + EPSILON;
+    return narrower && real ? 'reduced' : 'full';
+};

package/dist/units.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The one constant between the two measuring systems, and how a family states
+ * which it was published in.
+ *
+ * Three names for two values stood in this tree before this module: the
+ * scraper's `'millimeters' | 'inches'`, the catalog's `'metric' | 'inch'`, and
+ * a display unit spelled `'mm' | 'in'` — reconciled by a lookup table on
+ * ingest. A lookup table between two spellings of one axis is where a metric
+ * family quietly becomes an inch one, and nothing was watching it.
+ *
+ * The scraper's spelling wins because the scraper originates the fact: a vendor
+ * publishes a family in one system or the other, and every name downstream is a
+ * rename of what it said.
+ *
+ * ## The unit a number is *stored* in is not on this axis
+ *
+ * Every length this domain states is in millimetres and every angle in
+ * degrees, whatever system the vendor published — that is what lets an inch
+ * tool and a metric tool compare at all. {@link UnitSystem} is a fact *about
+ * the tool*: which system its vendor's sheet was written in, which is what
+ * decides how a number is rounded, stepped and shown. It is never the unit a
+ * stored value is in.
+ */
+/** How a vendor publishes a family: not the unit a number is stored in. */
+export type UnitSystem = 'millimeters' | 'inches';
+/** Every {@link UnitSystem}, for a control that offers them or a message that lists them. */
+export declare const UNIT_SYSTEMS: readonly UnitSystem[];
+/** Exact by definition: the inch has been 25.4 mm since 1959. */
+export declare const MM_PER_INCH = 25.4;
+/**
+ * The short form, as a machinist writes it beside a number.
+ *
+ * **This constant is the third vocabulary, made into a map.** `'mm'` and
+ * `'in'` are not a second unit axis — they are how {@link UnitSystem} is
+ * spelled on a drawing — so they live here as a projection of it rather than
+ * as a type of their own that something has to convert onto.
+ */
+export declare const UNIT_ABBREVIATION: Readonly<Record<UnitSystem, 'mm' | 'in'>>;
+/** `value`, converted from `from` to `to`. A no-op when they agree. */
+export declare const convertLength: (value: number, from: UnitSystem, to: UnitSystem) => number;
+/**
+ * Decimals worth showing at a given size.
+ *
+ * A thousandth of an inch and a hundredth of a millimetre are about the same
+ * distance, and both are near the limit of what a mill holds — so each system
+ * gets the precision a machinist actually reads, rather than a fixed number of
+ * decimals that is either noise in one or useless in the other.
+ *
+ * The rounding is domain, not presentation: two consumers that round the same
+ * dimension differently print two different numbers for one tool.
+ */
+export declare const decimalsFor: (system: UnitSystem) => number;
+/**
+ * The same conversion, applied to an area.
+ *
+ * Areas scale with the *square* of the length conversion: 1 in² is 645.16 mm²,
+ * not 25.4. An area put through {@link convertLength} is wrong by a factor of
+ * an inch, which is large enough to read as a different pocket and small
+ * enough that nobody checks it.
+ */
+export declare const convertArea: (value: number, from: UnitSystem, to: UnitSystem) => number;
+/**
+ * A stored length, written the way a machinist reads it in `system`.
+ *
+ * The value is in millimetres, because every length this domain states is —
+ * see the note at the top of this module. What `system` decides is the unit it
+ * is *shown* in, the decimals it is rounded to, and the abbreviation beside it,
+ * which are three parts of one answer and belong together: two consumers that
+ * round the same dimension differently print two different numbers for one tool.
+ */
+export declare const formatLength: (value: number, system: UnitSystem) => string;
+/** {@link formatLength} for an area, squared units and all. */
+export declare const formatArea: (value: number, system: UnitSystem) => string;

package/dist/units.js

@@ -0,0 +1,82 @@
+/**
+ * The one constant between the two measuring systems, and how a family states
+ * which it was published in.
+ *
+ * Three names for two values stood in this tree before this module: the
+ * scraper's `'millimeters' | 'inches'`, the catalog's `'metric' | 'inch'`, and
+ * a display unit spelled `'mm' | 'in'` — reconciled by a lookup table on
+ * ingest. A lookup table between two spellings of one axis is where a metric
+ * family quietly becomes an inch one, and nothing was watching it.
+ *
+ * The scraper's spelling wins because the scraper originates the fact: a vendor
+ * publishes a family in one system or the other, and every name downstream is a
+ * rename of what it said.
+ *
+ * ## The unit a number is *stored* in is not on this axis
+ *
+ * Every length this domain states is in millimetres and every angle in
+ * degrees, whatever system the vendor published — that is what lets an inch
+ * tool and a metric tool compare at all. {@link UnitSystem} is a fact *about
+ * the tool*: which system its vendor's sheet was written in, which is what
+ * decides how a number is rounded, stepped and shown. It is never the unit a
+ * stored value is in.
+ */
+/** Every {@link UnitSystem}, for a control that offers them or a message that lists them. */
+export const UNIT_SYSTEMS = ['millimeters', 'inches'];
+/** Exact by definition: the inch has been 25.4 mm since 1959. */
+export const MM_PER_INCH = 25.4;
+/**
+ * The short form, as a machinist writes it beside a number.
+ *
+ * **This constant is the third vocabulary, made into a map.** `'mm'` and
+ * `'in'` are not a second unit axis — they are how {@link UnitSystem} is
+ * spelled on a drawing — so they live here as a projection of it rather than
+ * as a type of their own that something has to convert onto.
+ */
+export const UNIT_ABBREVIATION = {
+    millimeters: 'mm',
+    inches: 'in',
+};
+/** `value`, converted from `from` to `to`. A no-op when they agree. */
+export const convertLength = (value, from, to) => {
+    if (from === to)
+        return value;
+    return to === 'inches' ? value / MM_PER_INCH : value * MM_PER_INCH;
+};
+/**
+ * Decimals worth showing at a given size.
+ *
+ * A thousandth of an inch and a hundredth of a millimetre are about the same
+ * distance, and both are near the limit of what a mill holds — so each system
+ * gets the precision a machinist actually reads, rather than a fixed number of
+ * decimals that is either noise in one or useless in the other.
+ *
+ * The rounding is domain, not presentation: two consumers that round the same
+ * dimension differently print two different numbers for one tool.
+ */
+export const decimalsFor = (system) => (system === 'inches' ? 3 : 2);
+/**
+ * The same conversion, applied to an area.
+ *
+ * Areas scale with the *square* of the length conversion: 1 in² is 645.16 mm²,
+ * not 25.4. An area put through {@link convertLength} is wrong by a factor of
+ * an inch, which is large enough to read as a different pocket and small
+ * enough that nobody checks it.
+ */
+export const convertArea = (value, from, to) => {
+    if (from === to)
+        return value;
+    return to === 'inches' ? value / MM_PER_INCH ** 2 : value * MM_PER_INCH ** 2;
+};
+/**
+ * A stored length, written the way a machinist reads it in `system`.
+ *
+ * The value is in millimetres, because every length this domain states is —
+ * see the note at the top of this module. What `system` decides is the unit it
+ * is *shown* in, the decimals it is rounded to, and the abbreviation beside it,
+ * which are three parts of one answer and belong together: two consumers that
+ * round the same dimension differently print two different numbers for one tool.
+ */
+export const formatLength = (value, system) => `${convertLength(value, 'millimeters', system).toFixed(decimalsFor(system))} ${UNIT_ABBREVIATION[system]}`;
+/** {@link formatLength} for an area, squared units and all. */
+export const formatArea = (value, system) => `${convertArea(value, 'millimeters', system).toFixed(decimalsFor(system))} ${UNIT_ABBREVIATION[system]}²`;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@toolpath/tool-support",
+  "version": "0.1.0",
+  "description": "The cutting-tool domain: what a tool, holder, collet and assembly are",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/toolpath/ui-packages.git",
+    "directory": "packages/tool-support"
+  },
+  "homepage": "https://developers.toolpath.com",
+  "bugs": {
+    "url": "https://github.com/toolpath/ui-packages/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3",
+    "vitest": "4.1.10"
+  }
+}