@toolpath/tool-drawing 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toolpath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+# Toolpath Tool Drawing
+
+`@toolpath/tool-drawing` draws a cutting tool, and the holder it is clamped in,
+as a 2D elevation: one silhouette turned about the tool axis, dimensioned, on
+its own sheet. It is SVG and arithmetic — no runtime dependencies, React only as
+a peer.
+
+It is deliberately not `@toolpath/viewer`. That package shows a customer's part
+in 3D; this one draws a catalog tool in 2D.
+
+## Install
+
+```sh
+npm install @toolpath/tool-drawing react react-dom
+```
+
+## Exports
+
+| Entry point                        | What it is                                              |
+| ---------------------------------- | ------------------------------------------------------- |
+| `@toolpath/tool-drawing`           | The component, the input contract, the framing options  |
+| `@toolpath/tool-drawing/geometry`  | `assemblyOutline` and the profile generators — no React |
+| `@toolpath/tool-drawing/clearance` | The optional clearance overlay                          |
+
+`/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.
+
+## Geometry
+
+```ts
+import { assemblyOutline } from '@toolpath/tool-drawing/geometry'
+
+const outline = assemblyOutline({
+  tool: { form: 'flat end mill', geometry: { DC: 6, LCF: 13, SFDM: 6, OAL: 57 } },
+  holder: null,
+  stickout: null,
+})
+```
+
+`assemblyOutline` returns `null` rather than a picture when it cannot draw the
+tool honestly — an unrecognised form, or a tool with no stated cutting diameter
+or flute length. **Every number in a generated profile comes off a vendor
+field.** There is no default taper angle, no assumed neck, no invented lead
+chamfer. Where a number has to be assumed to draw at all — a drill point angle
+the vendor never published — the segment says so in its `provenance`, and a
+renderer is expected to show it.
+
+`geometry` keys are the scraper's own field names (`DC`, `SFDM`, `OAL`, `LCF`,
+`RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`). They are not
+renamed here: a translation table between two vocabularies is where an `SFDM`
+silently becomes a `DC`.
+
+## Drawing
+
+```tsx
+import { ToolDrawing } from '@toolpath/tool-drawing'
+;<ToolDrawing assembly={assembly} theme="dark" />
+```
+
+The component measures its own panel, frames the assembly to fill it, and draws
+along the panel's long axis — no orientation prop, no pan, no zoom. `theme` is a
+prop rather than a hook because a package cannot reach the application's theme;
+it defaults to `'dark'`.
+
+A form the geometry has no shape for is **stated in words and named**, not drawn
+as a plausible cylinder.
+
+## Dimensions
+
+```tsx
+<ToolDrawing assembly={assembly} dimensions dimensionSides="both" formatLength={inches} />
+```
+
+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.
+
+## Clearance overlay
+
+```tsx
+import { ClearanceOverlay, tightestGaps, describeGaps } from '@toolpath/tool-drawing/clearance'
+
+;<ToolDrawing assembly={assembly} collisions={collisions} verdict={{ clears, note }}>
+  <ClearanceOverlay
+    profile={profile}
+    gaps={gaps}
+    cuttingRadius={cuttingRadius}
+    formatLength={formatLength}
+  />
+</ToolDrawing>
+```
+
+The overlay draws in the drawing's own coordinates and is given them: the
+frame, the outline and the sheet reach it from the `<ToolDrawing>` around it.
+It could not work them out for itself — the panel is measured by a
+`ResizeObserver` inside that component, on an `<svg>` you never hold — so
+passing them is only for overriding the frame, as a test framing a fixture
+does. Drawn outside a `<ToolDrawing>` with none supplied, it throws rather than
+inventing one.
+
+**The overlay draws a verdict; it does not reach one.** Whether an assembly
+clears a feature is a tool-selection question with callers that never draw
+anything, so it stays with them: this takes the material profile, the
+collisions and the two tightest gaps as data and owns every line drawn from
+them — the wall, the hatch, the interrupted-view breaks, the clearance
+dimensions and their readouts, and the paint on a section that is in the metal.
+
+It is optional in three senses: a subpath of its own, so a consumer that never
+imports it never pays for it; no Toolpath schema dependency, because the
+reach-curve shape is declared structurally here; and omitting the props draws
+the tool alone.
+
+## Status
+
+Geometry, layout, the renderer, the dimensions and the clearance overlay are
+all in.

package/dist/chunk-7ZID4QRO.js

@@ -0,0 +1,34 @@
+// src/render/drawing-context.tsx
+import { createContext, useContext } from "react";
+var Drawing = createContext(null);
+var DrawingProvider = Drawing.Provider;
+var useDrawingContext = () => useContext(Drawing);
+
+// src/render/arrows.ts
+var TOWARD_TIP = { dr: 0, dz: -1 };
+var AWAY_FROM_TIP = { dr: 0, dz: 1 };
+var TOWARD_PLUS = { dr: 1, dz: 0 };
+var TOWARD_MINUS = { dr: -1, dz: 0 };
+var at = (point, frame) => `${frame.toX(point.r, point.z).toFixed(2)},${frame.toY(point.r, point.z).toFixed(2)}`;
+var arrowhead = (r, z, towards, size, frame) => {
+  const wing = size * 0.3;
+  const baseR = r - towards.dr * size;
+  const baseZ = z - towards.dz * size;
+  const acrossR = -towards.dz * wing;
+  const acrossZ = towards.dr * wing;
+  return [
+    at({ r, z }, frame),
+    at({ r: baseR + acrossR, z: baseZ + acrossZ }, frame),
+    at({ r: baseR - acrossR, z: baseZ - acrossZ }, frame)
+  ].join(" ");
+};
+
+export {
+  DrawingProvider,
+  useDrawingContext,
+  TOWARD_TIP,
+  AWAY_FROM_TIP,
+  TOWARD_PLUS,
+  TOWARD_MINUS,
+  arrowhead
+};

package/dist/chunk-OUMNS4RI.js

@@ -0,0 +1,225 @@
+// src/model/outline.ts
+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) => {
+  const angle = (fromDeg + (toDeg - fromDeg) * index / steps) * Math.PI / 180;
+  const exact = (value) => Math.round(value * 1e9) / 1e9;
+  return {
+    r: exact(centre.r + radius * Math.cos(angle)),
+    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);
+  const top = r / Math.tan(half);
+  if (!Number.isFinite(top) || top < 0) {
+    return null;
+  }
+  return {
+    points: [
+      { r: 0, z: 0 },
+      { r, z: top }
+    ],
+    provenance: angle === void 0 ? "assumed" : stated(tool, "SIG"),
+    top
+  };
+};
+var tip = (tool, LCF) => {
+  const DC = tool.geometry.DC ?? 0;
+  const r = DC / 2;
+  const RE = tool.geometry.RE ?? 0;
+  const square = {
+    points: [
+      { r: 0, z: 0 },
+      { r, z: 0 }
+    ],
+    provenance: stated(tool, "DC"),
+    top: 0
+  };
+  switch (tool.form) {
+    case "flat end mill":
+    case "tap left hand":
+    case "tap right hand":
+      return square;
+    case "ball end mill":
+      return { points: arc({ r: 0, z: r }, r, -90, 0), provenance: stated(tool, "DC"), top: r };
+    case "bull nose end mill": {
+      const corner = Math.min(RE, r, LCF / 2);
+      if (corner <= EPSILON) {
+        return square;
+      }
+      return {
+        points: [
+          { r: 0, z: 0 },
+          { r: r - corner, z: 0 },
+          ...arc({ r: r - corner, z: corner }, corner, -90, 0)
+        ],
+        provenance: stated(tool, "RE"),
+        top: corner
+      };
+    }
+    case "slot mill": {
+      const corner = Math.min(RE, r, LCF / 2);
+      if (corner <= EPSILON) {
+        return square;
+      }
+      return {
+        points: [
+          { r: 0, z: 0 },
+          { r: r - corner, z: 0 },
+          ...arc({ r: r - corner, z: corner }, corner, -90, 0)
+        ],
+        provenance: stated(tool, "RE"),
+        top: corner,
+        crown: arc({ r: r - corner, z: LCF - corner }, corner, 0, 90)
+      };
+    }
+    case "drill":
+    case "spot drill":
+    case "center drill":
+      return cone(tool, r, 118);
+    case "chamfer mill":
+    case "counter sink":
+      return cone(tool, r, 90);
+    default:
+      return null;
+  }
+};
+var assemblyOutline = (assembly) => {
+  const { tool, holder, stickout } = assembly;
+  const { DC, LCF, SFDM } = tool.geometry;
+  if (DC === void 0 || LCF === void 0) {
+    return null;
+  }
+  const r = DC / 2;
+  const segments = [];
+  const point = tip(tool, LCF);
+  if (point === null) {
+    return null;
+  }
+  segments.push({ part: "tip", points: point.points, provenance: point.provenance });
+  const crown = point.crown ?? [];
+  const straightTop = crown[0]?.z ?? LCF;
+  segments.push({
+    part: "flutes",
+    points: [
+      { r, z: point.top },
+      { r, z: straightTop }
+    ],
+    provenance: stated(tool, "LCF")
+  });
+  if (crown.length > 0) {
+    segments.push({ part: "flutes", points: crown, provenance: point.provenance });
+  }
+  const neckDiameter = tool.geometry["shoulder-diameter"];
+  const shoulder = tool.geometry["shoulder-length"];
+  let top = LCF;
+  if (neckDiameter !== void 0 && shoulder !== void 0 && shoulder > LCF) {
+    const rn = neckDiameter / 2;
+    segments.push({
+      // A shoulder as wide as the cut is plain shank; only a narrower one is a neck.
+      part: hasNeck(tool) ? "neck" : "shank",
+      points: [
+        { r: rn, z: LCF },
+        { r: rn, z: shoulder }
+      ],
+      provenance: stated(tool, "shoulder-length")
+    });
+    top = shoulder;
+  }
+  const shankTop = stickout ?? tool.geometry.OAL ?? top;
+  if (SFDM !== void 0 && shankTop > top) {
+    const rs = SFDM / 2;
+    segments.push({
+      part: "shank",
+      points: [
+        { r: rs, z: top },
+        { r: rs, z: shankTop }
+      ],
+      provenance: stickout === null ? stated(tool, "SFDM") : "chosen"
+    });
+    top = shankTop;
+  }
+  if (stickout !== null && holder !== null && holder.noseDiameter !== null) {
+    const rh = holder.noseDiameter / 2;
+    const holderStated = (code) => holder.provenance?.[code] ?? "vendor-stated";
+    const series = /(\d+(?:\.\d+)?)/.exec(holder.colletSeries ?? "");
+    if (holder.colletProtrusion !== null && series) {
+      const rc = Number(series[1]) / 2;
+      segments.push({
+        part: "collet",
+        points: [
+          { r: rc, z: stickout - holder.colletProtrusion },
+          { r: rc, z: stickout }
+        ],
+        provenance: holderStated("colletProtrusion")
+      });
+    }
+    const noseLength = holder.noseLength ?? holder.gaugeLength ?? Math.max(20, DC * 3);
+    segments.push({
+      part: "nose",
+      points: [
+        { r: rh, z: stickout },
+        { r: rh, z: stickout + noseLength }
+      ],
+      provenance: holder.noseLength !== null ? holderStated("noseLength") : holder.gaugeLength === null ? "assumed" : holderStated("noseDiameter")
+    });
+    top = stickout + noseLength;
+    let radius2 = rh;
+    if (holder.bodyDiameter !== null && holder.bodyLength !== null) {
+      const rb = holder.bodyDiameter / 2;
+      segments.push({
+        part: "body",
+        points: [
+          { r: rb, z: top },
+          { r: rb, z: top + holder.bodyLength }
+        ],
+        provenance: holderStated("bodyDiameter")
+      });
+      top += holder.bodyLength;
+      radius2 = rb;
+    }
+    if (holder.projection !== null && holder.flangeDiameter !== null) {
+      const flangeAt = stickout + holder.projection;
+      const rf = holder.flangeDiameter / 2;
+      if (flangeAt > top) {
+        segments.push({
+          part: "body",
+          points: [
+            { r: radius2, z: top },
+            { r: radius2, z: flangeAt }
+          ],
+          provenance: "assumed"
+        });
+      }
+      const flangeTop = holder.gaugeLength !== null && holder.gaugeLength > holder.projection ? stickout + holder.gaugeLength : flangeAt + 20;
+      segments.push({
+        part: "flange",
+        points: [
+          { r: rf, z: flangeAt },
+          { r: rf, z: flangeTop }
+        ],
+        provenance: holder.gaugeLength === null ? "assumed" : holderStated("flangeDiameter")
+      });
+      top = flangeTop;
+    }
+  }
+  const radius = Math.max(...segments.flatMap((segment) => segment.points.map((point2) => point2.r)));
+  return { segments, height: top, radius };
+};
+
+export {
+  hasNeck,
+  assemblyOutline
+};

package/dist/clearance/index.d.ts

@@ -0,0 +1,205 @@
+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';
+
+/**
+ * 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.
+ */
+/**
+ * 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.
+ * Null where nothing stands that tall — no wall to measure to.
+ */
+declare const wallFaceAt: (curve: ReachCurve, z: number) => number | null;
+
+interface Gap {
+    readonly part: OutlinePart;
+    /** Where on the stack it was measured: radius from the axis, height above the tip, mm. */
+    readonly r: number;
+    readonly z: number;
+    /** The room measured, mm — negative is into the material. */
+    readonly gap: number;
+    /** Whether that much meets the room the shop asked for. */
+    readonly clears: boolean;
+}
+/** The axial gap also carries the wall it was measured from. */
+interface AxialGap extends Gap {
+    /** How high the material stands at this part's offset, mm. */
+    readonly wall: number;
+}
+interface Gaps {
+    /** Up from the material to the part above it. Null with nothing swept. */
+    readonly axial: AxialGap | null;
+    /** Sideways to a wall taller than the part. Null where nothing stands taller. */
+    readonly radial: Gap | null;
+}
+/**
+ * Both gaps, each at its own tightest point.
+ *
+ * Takes the outline's segments rather than an assembly, because by the time
+ * anything is drawn the outline already exists — and because an outline is
+ * this package's own vocabulary, where an assembly record is the consumer's.
+ */
+declare const tightestGaps: (segments: ReadonlyArray<OutlineSegment>, curve: ReachCurve, cuttingRadius: number, margins: Margins) => Gaps;
+
+/**
+ * The material beside the tool, as lines.
+ *
+ * All of it in the drawing's own space — radius from the axis, height above
+ * the tip — so the overlay maps through `toX`/`toY` like everything else and
+ * reads the same either way the tool is laid.
+ */
+/**
+ * The wall's corners: **both ends of every run**, so a step draws as a step.
+ *
+ * A rise smaller than `noise` is float noise and makes no corner. Everything
+ * else is kept, including the far end of the run the rise interrupts — and
+ * that far end is the correction of 2026-08-30. Keeping only the point where
+ * a new height begins left consecutive corners that spanned a whole run *and*
+ * the rise after it, so the line drew a diagonal ramp across both: a square
+ * step read as a chamfer, and the material over the run looked taller than
+ * the sweep says it is. Paul's section view is the reference — a wall is
+ * vertical, a ledge is horizontal, and only a fillet is round.
+ *
+ * A sampled fillet still keeps every corner, which is what lets `wallPath`
+ * draw it as the arc it is (Paul, 2026-08-30: thinning to chords had turned a
+ * fillet into a chamfer).
+ */
+declare const wallCorners: (profile: ReadonlyArray<OutlinePoint>, noise: number) => Array<OutlinePoint>;
+/**
+ * Where the wall stops changing: the radius of the outermost rise. Beyond it
+ * the material is flat and drawing more of it says nothing.
+ */
+declare const lastRise: (corners: ReadonlyArray<OutlinePoint>) => number;
+/** The staircase as a polygon, clipped at the drawing's outer edge and its top. */
+declare const clipped: (profile: ReadonlyArray<OutlinePoint>, edge: number, ceiling: number) => Array<OutlinePoint>;
+/** The frame's two coordinate mappings: the only things that know the axis sense. */
+interface Mapping {
+    readonly toX: (r: number, z: number) => number;
+    readonly toY: (r: number, z: number) => number;
+}
+/**
+ * The wall as an SVG path that looks like the geometry it came from.
+ *
+ * The reach curve samples a curved surface — a fillet, a draft — as a run of
+ * closely spaced rises; a vertical wall or a step is one big rise. A corner
+ * whose neighbours on both sides are within `smooth.run` across and
+ * `smooth.rise` up belongs to a curve and is passed through with a
+ * Catmull-Rom spline; any other corner stays a sharp line join. So a fillet
+ * reads as the arc it is and a wall as the wall it is (Paul, 2026-08-30:
+ * "more closely resemble the actual geometry", after chords made a fillet
+ * read as a chamfer).
+ */
+declare const wallPath: (points: ReadonlyArray<OutlinePoint>, smooth: {
+    readonly run: number;
+    readonly rise: number;
+}, frame: Mapping) => string;
+/**
+ * A break, as the ragged edge of an interrupted view: the saw-tooth along an
+ * edge that says the material carries on past where the drawing stops. It is
+ * what lets the part be cut short at all.
+ *
+ * Runs at a constant radius, from one height to another, wandering across the
+ * axis by `amplitude` — so it is the same saw-tooth whichever way the tool is
+ * laid.
+ */
+declare const zigzag: (atR: number, fromZ: number, toZ: number, amplitude: number, steps?: number) => Array<OutlinePoint>;
+
+/**
+ * The material the sweep read, drawn beside the tool, with the two clearances
+ * that decided the verdict.
+ *
+ * **The verdict does not live here — only its drawing does.** Whether an
+ * assembly clears a feature is the catalog's tool-selection question, answered
+ * for a dozen callers that never draw anything; putting it behind a rendering
+ * package would put that engine behind a dependency on React. So this takes
+ * the answer as data — the material profile, the collisions, the two tightest
+ * gaps — and owns every line drawn from it.
+ *
+ * **The part is always secondary to the assembly** (Paul, 2026-08-30). The
+ * stack sets the frame and the scale; the material is drawn in the room left
+ * beside it and cut off at a **break** — the saw-tooth of an interrupted view
+ * — rather than pushing the stack smaller to fit a wall in. A dimension whose
+ * far face falls past the break is broken too, and carries the true number.
+ * The material is **hatched**, because it is a section through metal and
+ * nothing on the stack is.
+ */
+interface ClearanceOverlayProps {
+    /**
+     * The material around the feature, as a staircase in the drawing's own
+     * space: radius from the axis, height above the tip.
+     *
+     * Taken rather than derived, because whatever turns a reach curve into this
+     * staircase has drawing consumers of its own and stays with them.
+     */
+    readonly profile: ReadonlyArray<OutlinePoint>;
+    /**
+     * The frame, the extent and the ink.
+     *
+     * All three are taken from the surrounding `<ToolDrawing>` and are only worth
+     * passing to override it — framing a fixture in a test, or composing a
+     * drawing by hand. A consumer drawing an overlay the ordinary way, as a child,
+     * supplies none of them: it cannot, because the panel is measured inside the
+     * component it is a child of.
+     */
+    readonly frame?: Frame;
+    readonly outline?: Extent;
+    /** Where the cut is: the radius the material is measured out from. */
+    readonly cuttingRadius: number;
+    /** The two tightest points, each measured at its own. */
+    readonly gaps: Gaps;
+    /** Room the shop wants kept, drawn as a dashed line outside the wall. */
+    readonly margins?: Margins;
+    readonly sheet?: Sheet;
+    /** How a length is written out, for the two readouts. */
+    readonly formatLength: (millimetres: number) => string;
+}
+declare const ClearanceOverlay: ({ profile, frame: framed, outline: extent, cuttingRadius, gaps, margins, sheet: ink, formatLength, }: ClearanceOverlayProps) => react.JSX.Element | null;
+
+/**
+ * The caption's sentence for the tightest points, in the caller's own unit.
+ *
+ * **This is the drawing's half of the verdict, not the verdict.** It says what
+ * was measured and where; whether the assembly may be used is answered
+ * elsewhere, by the engine that answers it for everything else too.
+ */
+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 };