@toolpath/tool-drawing 0.2.0 → 0.3.0

package/README.md

@@ -14,6 +14,12 @@ in 3D; this one draws a catalog tool in 2D.
 npm install @toolpath/tool-drawing react react-dom
 ```
 
+Its one runtime dependency is [`@toolpath/tool-support`](../tool-support), the
+shared cutting-tool domain, which itself depends on nothing. `Provenance`,
+`ViewerTool`, `ViewerHolder` and `ViewerHolderProfile` are aliases of its types
+and are re-exported here, so a consumer that also uses `@toolpath/tool-support`
+gets the same types and needs no adapter between them.
+
 ## Exports
 
 | Entry point                        | What it is                                              |
@@ -24,6 +30,7 @@ npm install @toolpath/tool-drawing react react-dom
 
 `/geometry` is pure and server-safe: it touches no DOM and imports no React, so
 a Node server can measure an assembly without paying for a renderer.
+`tests/subpaths.test.ts` asserts that from the import graph.
 
 ## Geometry
 
@@ -92,13 +99,47 @@ as a plausible cylinder.
 ## Dimensions
 
 ```tsx
-<ToolDrawing assembly={assembly} dimensions dimensionSides="both" formatLength={inches} />
+<ToolDrawing
+  assembly={assembly}
+  dimensions
+  dimensionSides="both"
+  highlight={hovered}
+  onDimensionHover={setHovered}
+/>
 ```
 
 Every stated length and width, each in its own lane, nested shortest-innermost
-so no two lines cross, with each figure in the band just outboard of its own
-lane. Only stated numbers are dimensioned. `formatLength` is yours, because the
-unit a shop reads in is the application's.
+so no two lines cross. Only stated numbers are dimensioned.
+
+**The drawing letters none of them.** The numbers belong in your own table,
+where they can be read; six two-line figures fighting for the margin said the
+same numbers a second time and worse. Which line is which is answered by
+pointing at it instead:
+
+- `highlight` names the dimension or dimensions to draw in the sheet's accent,
+  by ISO 13399 code — `DC`, `LCF`, `OAL`, `SFDM`, `LBH`, `stickout`, `SIG`, and
+  the two `shoulder-` codes. A code the tool does not dimension highlights
+  nothing.
+- `onDimensionHover` is told the code under the pointer and `null` when it
+  leaves, so your table can be lit from the drawing as well as the other way
+  about. Passing it puts hit targets on the lines; leaving it off draws none.
+
+Where two codes are one span the drawing carries one line, not two. A shop that
+clamps to its own rule states the stickout and the below-holder length as the
+same number, and a tool stood out to its flutes states it again as the flute
+length; with nothing lettered, identical lines in two lanes cannot be told
+apart. The first code named keeps the line — the tool's own number ahead of the
+shop's — and the others light it too. Hover reports the code the line is drawn
+under.
+
+**The stickout is yours.** `assembly.stickout` is where the holder nose goes,
+and nothing here derives it — pass `LBH` as the stickout if standing the tool
+out to its below-holder length is the rule you want drawn. Where the two
+disagree and `LBH` ends up inside the holder, it is not dimensioned: the
+drawing will not run a line to a face it has drawn a holder over.
+
+A highlighted line is drawn in the accent **and heavier**, so the highlight
+survives a reader who cannot tell the two colours apart.
 
 ## Clearance overlay
 

package/dist/{chunk-UBENO6GN.js → chunk-WYHJGR7P.js}

@@ -1,7 +1,8 @@
 // src/model/types.ts
-var isHolderProfile = (holder) => "points" in holder;
+import { isHolderProfile } from "@toolpath/tool-support";
 
 // src/model/outline.ts
+import { hasNeck } from "@toolpath/tool-support";
 var EPSILON = 1e-6;
 var stated = (tool, code) => tool.provenance?.[code] ?? "vendor-stated";
 var arc = (centre, radius, fromDeg, toDeg, steps = 6) => Array.from({ length: steps + 1 }, (_, index) => {
@@ -12,16 +13,6 @@ var arc = (centre, radius, fromDeg, toDeg, steps = 6) => Array.from({ length: st
     z: exact(centre.z + radius * Math.sin(angle))
   };
 });
-var hasNeck = (tool) => {
-  const { LCF, SFDM, DC } = tool.geometry;
-  const shoulder = tool.geometry["shoulder-length"];
-  const relief = tool.geometry["shoulder-diameter"];
-  if (shoulder === void 0 || relief === void 0 || LCF === void 0 || shoulder <= LCF) {
-    return false;
-  }
-  const shank = SFDM ?? DC;
-  return shank === void 0 ? true : relief < shank - EPSILON;
-};
 var cone = (tool, r, whenUnstated) => {
   const angle = tool.geometry.SIG;
   const half = (angle ?? whenUnstated) / 2 * (Math.PI / 180);
@@ -261,9 +252,26 @@ var assemblyOutline = (assembly) => {
   const radius = Math.max(...segments.flatMap((segment) => segment.points.map((point2) => point2.r)));
   return { segments, height: top, radius };
 };
+var edgeRadius = (from, to, z) => {
+  const low = Math.min(from.z, to.z);
+  const high = Math.max(from.z, to.z);
+  if (z < low - EPSILON || z > high + EPSILON) {
+    return null;
+  }
+  if (high - low <= EPSILON) {
+    return Math.max(from.r, to.r);
+  }
+  return from.r + (z - from.z) / (to.z - from.z) * (to.r - from.r);
+};
+var radiusAt = (outline, z) => Math.max(
+  0,
+  ...outline.segments.flatMap(
+    (segment) => segment.points.slice(1).map((point, index) => edgeRadius(segment.points[index], point, z)).filter((radius) => radius !== null)
+  )
+);
 
 export {
   isHolderProfile,
-  hasNeck,
-  assemblyOutline
+  assemblyOutline,
+  radiusAt
 };

package/dist/clearance/index.d.ts

@@ -1,47 +1,25 @@
+import { ReachCurve } from '@toolpath/tool-support';
+export { ReachCurve, heightAt } from '@toolpath/tool-support';
 import { OutlinePart, OutlineSegment, OutlinePoint } from '../geometry/index.js';
 import * as react from 'react';
-import { F as Frame, E as Extent, S as Sheet } from '../sheet-D0LSO7qP.js';
+import { F as Frame, E as Extent, S as Sheet } from '../sheet-DicKQYfF.js';
 
 /**
  * The feature's reach curve, and how the drawing reads it.
  *
- * **Declared structurally, on purpose.** The shape is exactly what
- * `@toolpath/part-contracts` calls a `ReachCurve`, and naming it here rather
- * than importing it is one of the three senses in which this overlay stays
- * optional: a consumer that draws a tool alone pulls in no Toolpath schema.
- * A `ReachCurve` from the API satisfies this by structure, with no adapter.
+ * **Still declared structurally, one package up.** `@toolpath/tool-support`
+ * names the shape and imports no Toolpath schema to do it, which is one of the
+ * three senses in which this overlay stays optional: a consumer that draws a
+ * tool alone pulls in no OpenAPI contract. A `ReachCurve` off a report
+ * satisfies it by structure, with no adapter, exactly as before.
  */
-/**
- * The worst-case material around a feature, as a staircase.
- *
- * Read as "material within `horizontalOffset[i]` of the cut rises to
- * `verticalOffset[i]`". Both are in millimetres; the offsets run outward from
- * the cutting edge and the heights up from the bottom of the feature.
- */
-interface ReachCurve {
-    readonly horizontalOffset: ReadonlyArray<number>;
-    readonly verticalOffset: ReadonlyArray<number>;
-}
+
 /** Room the shop wants kept between the stack and the part, in millimetres. */
 interface Margins {
     readonly radial: number;
     readonly axial: number;
 }
 declare const NO_MARGINS: Margins;
-/**
- * The tallest material within `offset` mm of the cut, above the feature's bottom.
- *
- * **The one piece of the verdict's own arithmetic that had to travel.** The
- * decision — whether an assembly clears — stays with the catalog's
- * tool-selection engine, which has a dozen callers that never draw anything.
- * This is not that decision: it is the reading of the curve that the drawn
- * staircase is drawn from, and the gaps this overlay dimensions are measured
- * against. It is here because {@link tightestGaps} cannot be written without
- * it, and it must keep agreeing with whatever draws the material profile — the
- * rise comes at the *start* of each run, so everything out to a knot is
- * already as tall as that knot says.
- */
-declare const heightAt: (curve: ReachCurve, offset: number) => number;
 /**
  * Where the wall face stands at a given height, as an offset from the cut:
  * the start of the first run of the staircase that rises above that height.
@@ -202,4 +180,4 @@ declare const ClearanceOverlay: ({ profile, frame: framed, outline: extent, cutt
  */
 declare const describeGaps: (gaps: Gaps, margins: Margins, formatLength: (millimetres: number) => string) => string | null;
 
-export { type AxialGap, ClearanceOverlay, type ClearanceOverlayProps, type Gap, type Gaps, type Margins, NO_MARGINS, type ReachCurve, clipped, describeGaps, heightAt, lastRise, tightestGaps, wallCorners, wallFaceAt, wallPath, zigzag };
+export { type AxialGap, ClearanceOverlay, type ClearanceOverlayProps, type Gap, type Gaps, type Margins, NO_MARGINS, clipped, describeGaps, lastRise, tightestGaps, wallCorners, wallFaceAt, wallPath, zigzag };

package/dist/clearance/index.js

@@ -8,16 +8,9 @@ import {
 } from "../chunk-7ZID4QRO.js";
 
 // src/clearance/model/curve.ts
+import { heightAt } from "@toolpath/tool-support";
 var NO_MARGINS = { radial: 0, axial: 0 };
 var GAP_TOLERANCE = 1e-6;
-var heightAt = (curve, offset) => {
-  for (let index = 0; index < curve.horizontalOffset.length; index += 1) {
-    if ((curve.horizontalOffset[index] ?? 0) >= offset) {
-      return curve.verticalOffset[index] ?? 0;
-    }
-  }
-  return curve.verticalOffset[curve.verticalOffset.length - 1] ?? 0;
-};
 var wallFaceAt = (curve, z) => {
   let from = 0;
   for (let index = 0; index < curve.horizontalOffset.length; index += 1) {

package/dist/geometry/index.d.ts

@@ -1,97 +1,63 @@
+import { Tool, Holder, HolderProfile, Provenance } from '@toolpath/tool-support';
+export { Provenance, isHolderProfile } from '@toolpath/tool-support';
+
 /**
- * What this package needs to draw an assembly, and nothing more.
+ * What this package needs to draw an assembly — which is the shared cutting-tool
+ * domain, under the names this package has always published.
+ *
+ * These four were declared here until `@toolpath/tool-support` existed, and the
+ * declarations were three-way duplicates: the same provenance strings, the same
+ * geometry codes and three shapes called "holder" of which no two agreed on
+ * which fields exist. A drawing and the number printed beside it were free to
+ * disagree about one tool, and once did — the stickout the details table showed
+ * was not the stickout the dimension line drew.
+ *
+ * So the shapes now come from the one declaration and these are **aliases**,
+ * exported from `.` and from `/geometry` exactly as before. A consumer's adapter
+ * does not move: `ViewerTool` is `Tool`, and a catalog record that satisfied one
+ * satisfies the other by structure.
+ *
+ * ## Why the alias and not a rename
  *
- * The contract is the package's own, so nothing here depends on a particular
- * catalog's record types. A consumer writes one adapter that projects its own
- * tool onto {@link ViewerTool}; the adapter is the single file that fails
- * loudly when either side moves.
+ * A consumer's adapter is the single file that fails loudly when either side
+ * moves, and renaming the type it targets would be that failure for no gain. The
+ * `Viewer*` names are also what the two entry points publish, so dropping them
+ * is a major bump this change has no reason to spend. `@toolpath/tool-support`
+ * is where the domain is documented; this file is the seam.
  *
- * `geometry` keeps the scraper's own field names — `DC`, `SFDM`, `OAL`, `LCF`,
- * `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`. Renaming one here
- * would put a translation table between two vocabularies, which is where an
- * `SFDM` silently becomes a `DC`.
+ * `geometry` still keeps the scraper's own field names — `DC`, `SFDM`, `OAL`,
+ * `LCF`, `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length` — and
+ * `@toolpath/tool-support`'s `GEOMETRY_FIELDS` is now the dictionary behind
+ * them.
  *
  * All lengths are in millimetres and all angles in degrees, and every generator
  * works in whatever unit system it is handed: an inch tool yields an inch
  * outline. Converting is the caller's, at the seam where a tool meets a holder.
  */
-/** Where a stated number came from. */
-type Provenance = 'vendor-stated' | 'derived' | 'assumed';
-interface ViewerTool {
-    /** The CAM-library name for what the tool is: `flat end mill`, `drill`, `slot mill`. */
-    readonly form: string;
-    readonly label?: string;
-    readonly geometry: Readonly<Record<string, number | undefined>>;
-    readonly provenance?: Readonly<Record<string, Provenance>>;
-}
-interface ViewerHolder {
-    readonly noseDiameter: number | null;
-    readonly noseLength: number | null;
-    readonly bodyDiameter: number | null;
-    readonly bodyLength: number | null;
-    readonly projection: number | null;
-    readonly flangeDiameter: number | null;
-    readonly gaugeLength: number | null;
-    readonly colletSeries: string | null;
-    readonly colletProtrusion: number | null;
-    readonly provenance?: Readonly<Record<string, Provenance>>;
-}
+
+/** A cutting tool, as the drawing needs one. */
+type ViewerTool = Tool;
+/** A holder as its vendor publishes it: a nose, a body, a projection. */
+type ViewerHolder = Holder;
 /**
  * A holder as its own CAD model measures it: the silhouette, and nothing
  * parametric.
  *
- * A {@link ViewerHolder} is a handful of numbers a vendor publishes in a table,
- * and a drawing built from them is a stylised holder. This is the other thing a
- * catalog can have — the envelope measured off the vendor's STEP model, a
- * hundred-odd vertices carrying the V-flange groove and the thread relief that
- * a machinist actually looks for. **It is not a refinement of the parametric
- * form and does not project onto it**: reducing it to a nose and a body throws
- * away the only reason to measure.
- *
- * So the two are a union rather than one shape with optional extras, and
- * {@link isHolderProfile} tells them apart. A consumer that has both picks one;
+ * Not a refinement of {@link ViewerHolder} and it does not project onto one —
+ * reducing a measured envelope to a nose and a body throws away the only reason
+ * to measure. The two are a union and {@link isHolderProfile} tells them apart;
  * a consumer that has neither passes `null` and the tool is drawn alone.
  */
-interface ViewerHolderProfile {
-    /**
-     * The silhouette as `[z, r]` in millimetres, `z` ascending.
-     *
-     * Two vertices share a `z` where the solid steps, so this is a polyline and
-     * not a function of `z`. Fewer than two vertices is no holder and draws none.
-     */
-    readonly points: ReadonlyArray<readonly [z: number, r: number]>;
-    /**
-     * What `z = 0` means.
-     *
-     * `gage-line` is the spindle face, with `z` increasing toward the cutting end
-     * — so the taper is negative, the nose positive, and the holder's gauge
-     * length is the last vertex's `z`. `nose` is the frame a holder with no taper
-     * to solve a gauge plane on is measured in, and it is stated rather than
-     * silently referenced to an arbitrary end: there is no gauge length to read
-     * off it, and the drawing says so instead of printing one.
-     */
-    readonly datum: 'gage-line' | 'nose';
-    /** The series the holder takes, as {@link ViewerHolder} means it. */
-    readonly colletSeries: string | null;
-    /** How far the seated collet stands proud of the nose, in millimetres. */
-    readonly colletProtrusion: number | null;
-    /**
-     * Keyed as {@link ViewerHolder}'s is, plus `points` for the measurement
-     * itself — which is `vendor-stated` unless a caller says otherwise, because
-     * the shape measured is the vendor's own model rather than a derivation from
-     * its table.
-     */
-    readonly provenance?: Readonly<Record<string, Provenance>>;
-}
+type ViewerHolderProfile = HolderProfile;
+
 /**
- * Which of the two holder forms this is.
+ * A tool, the holder it is clamped in, and how far it stands out.
  *
- * On the presence of `points` rather than on a `kind` tag, because a tag would
- * have to be added to {@link ViewerHolder} as well and every existing adapter
- * would stop compiling to gain nothing a structural check does not already
- * give.
+ * Deliberately **not** `@toolpath/tool-support`'s `Assembly`, which also carries
+ * the collet: a drawing reads a collet only through the holder's own series and
+ * protrusion, and taking one it never reads would be a field every adapter has
+ * to fill for nothing.
  */
-declare const isHolderProfile: (holder: ViewerHolder | ViewerHolderProfile) => holder is ViewerHolderProfile;
 interface ViewerAssembly {
     readonly tool: ViewerTool;
     readonly holder: ViewerHolder | ViewerHolderProfile | null;
@@ -155,4 +121,4 @@ interface Outline {
  */
 declare const assemblyOutline: (assembly: ViewerAssembly) => Outline | null;
 
-export { type Outline, type OutlinePart, type OutlinePoint, type OutlineSegment, type Provenance, type ViewerAssembly, type ViewerHolder, type ViewerHolderProfile, type ViewerTool, assemblyOutline, isHolderProfile };
+export { type Outline, type OutlinePart, type OutlinePoint, type OutlineSegment, type ViewerAssembly, type ViewerHolder, type ViewerHolderProfile, type ViewerTool, assemblyOutline };

package/dist/geometry/index.js

@@ -1,7 +1,7 @@
 import {
   assemblyOutline,
   isHolderProfile
-} from "../chunk-UBENO6GN.js";
+} from "../chunk-WYHJGR7P.js";
 export {
   assemblyOutline,
   isHolderProfile