@code3d/screws 0.0.1-alpha.4 → 0.0.1-alpha.7

package/src/library/gb-818.ts

@@ -0,0 +1,7 @@
+/**
+ * GB/T 818-2016 (MOD ISO 7045:2011).
+ * Shares the corresponding ISO module's nominal geometry within our preset
+ * range. See the package README for sizes, hole allowances and modeling limits.
+ * https://std.samr.gov.cn/gb/search/gbDetailed?id=71F772D813A1D3A7E05397BE0A0AB82A
+ */
+export * from './iso-7045.js';

package/src/library/hex-head.ts

@@ -0,0 +1,53 @@
+import {frustum, intersect, regularPrism} from '@code3d/core';
+import {
+  metric,
+  validateHead,
+  positive,
+  type HeadSpecification,
+  type MetricSize,
+} from './common.js';
+
+export type Specification = HeadSpecification & Readonly<{headWidth: number}>;
+
+// Shared head dimensions of ISO 4014 and ISO 4017. ISO widths, not DIN 931/933.
+// https://www.vipafasteners.com/files/0/801-PARTIAL_THREAD_HEXAGON_HEAD_SCREWS_ISO_4014_UNI_5737_DIN_931.pdf
+function specification(
+  size: MetricSize,
+  headWidth: number,
+  headHeight: number,
+  underHeadRadius: number,
+): Specification {
+  return {
+    ...metric(size),
+    headWidth,
+    headHeight,
+    underHeadRadius,
+    headDiameter: (2 * headWidth) / Math.sqrt(3),
+  };
+}
+
+export const specifications = {
+  M3: specification('M3', 5.5, 2, 0.1),
+  M4: specification('M4', 7, 2.8, 0.2),
+  M5: specification('M5', 8, 3.5, 0.2),
+  M6: specification('M6', 10, 4, 0.25),
+  M8: specification('M8', 13, 5.3, 0.4),
+  M10: specification('M10', 16, 6.4, 0.4),
+  M12: specification('M12', 18, 7.5, 0.6),
+} as const;
+
+export function hexHead(spec: Specification) {
+  validateHead(spec);
+  positive('Head width', spec.headWidth);
+  if (Math.abs(spec.headDiameter - (2 * spec.headWidth) / Math.sqrt(3)) > 1e-6)
+    throw new Error('Hex head diameter must describe its corner envelope.');
+  const radius = spec.headWidth / Math.sqrt(3);
+  const blank = regularPrism(radius, spec.headHeight, 6, 30);
+  // The cone produces the circular crown and six curved chamfer boundaries.
+  const chamferEnvelope = frustum(
+    spec.headWidth / 2 + spec.headHeight * Math.sqrt(3),
+    spec.headWidth / 2,
+    spec.headHeight,
+  );
+  return intersect([blank, chamferEnvelope]);
+}

package/src/library/index.ts

@@ -1 +1,21 @@
 export * as ISO4762 from './iso-4762.js';
+export * as ISO10642 from './iso-10642.js';
+export * as ISO7380_1 from './iso-7380-1.js';
+export * as ISO4017 from './iso-4017.js';
+export * as ISO4014 from './iso-4014.js';
+export * as ISO7380_2 from './iso-7380-2.js';
+export * as ISO4029 from './iso-4029.js';
+export * as ISO7045 from './iso-7045.js';
+export * as ISO14583 from './iso-14583.js';
+export * as ISO7379 from './iso-7379.js';
+
+export * as GB70_1 from './gb-70-1.js';
+export * as GB70_2 from './gb-70-2.js';
+export * as GB70_3 from './gb-70-3.js';
+export * as GB70_4 from './gb-70-4.js';
+export * as GB5782 from './gb-5782.js';
+export * as GB5783 from './gb-5783.js';
+export * as GB818 from './gb-818.js';
+export * as GB2672 from './gb-2672.js';
+export * as GB80 from './gb-80.js';
+export * as GB5281 from './gb-5281.js';

package/src/library/iso-10642.ts

@@ -0,0 +1,173 @@
+import {frustum, union, type SolidModel} from '@code3d/core';
+import {
+  metric,
+  validateHead,
+  headedScrew,
+  hexSocket,
+  plainHole,
+  atY,
+  positive,
+  type MetricSize,
+  type HeadSpecification,
+  type Screw,
+  type ClearanceHole,
+  type HoleElements,
+  type ClearanceHoleOptions as CommonHoleOptions,
+} from './common.js';
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+} from './common.js';
+import type {Bound} from '@code3d/core';
+
+export type Specification = HeadSpecification &
+  Readonly<{hexSocketWidth: number; hexSocketDepth: number; headAngle: 90}>;
+// ISO 10642 dimensions (not the smaller DIN 7991 head), millimetres.
+// https://www.vipafasteners.com/files/0/886-HEXAGON_SOCKET_COUNTERSUNK_HEAD_SCREWS_ISO_10642_UNI_5933_DIN_7991.pdf
+function specification(
+  size: MetricSize,
+  headDiameter: number,
+  headHeight: number,
+  hexSocketWidth: number,
+  hexSocketDepth: number,
+  underHeadRadius: number,
+): Specification {
+  return {
+    ...metric(size),
+    headDiameter,
+    headHeight,
+    hexSocketWidth,
+    hexSocketDepth,
+    underHeadRadius,
+    headAngle: 90,
+  };
+}
+export const specifications = {
+  M3: specification('M3', 6.72, 1.86, 2, 1.1, 0.1),
+  M4: specification('M4', 8.96, 2.48, 2.5, 1.5, 0.2),
+  M5: specification('M5', 11.2, 3.1, 3, 1.9, 0.2),
+  M6: specification('M6', 13.44, 3.72, 4, 2.2, 0.25),
+  M8: specification('M8', 17.92, 4.96, 5, 3, 0.4),
+  M10: specification('M10', 22.4, 6.2, 6, 3.6, 0.4),
+  M12: specification('M12', 26.88, 7.44, 8, 4.3, 0.6),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export type CountersinkOptions = Readonly<{diameter?: number}>;
+export type ClearanceHoleOptions = Omit<CommonHoleOptions, 'counterbore'> &
+  Readonly<{countersink?: boolean | CountersinkOptions}>;
+export type PlainHoleOptions = ClearanceHoleOptions &
+  Readonly<{countersink: false}>;
+export type CountersunkHoleOptions = ClearanceHoleOptions &
+  Readonly<{countersink?: true | CountersinkOptions}>;
+export type CountersunkHoleElements = HoleElements &
+  Readonly<{countersinkTop: Bound; countersinkBottom: Bound}>;
+export type CountersunkHole = SolidModel<CountersunkHoleElements>;
+
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+function validateCountersink(spec: Specification): void {
+  if (
+    spec.headAngle !== 90 ||
+    Math.abs(spec.headDiameter - spec.nominalDiameter - 2 * spec.headHeight) >
+      1e-6
+  )
+    throw new Error(
+      'Countersunk head dimensions must define a 90-degree cone.',
+    );
+}
+export function threadLength(spec: Specification, length: number): number {
+  return (
+    2 * spec.nominalDiameter + (length <= 125 ? 6 : length <= 200 ? 12 : 25)
+  );
+}
+/**
+ * Length includes the countersunk head.
+ * @code3d.arguments ['M6', 20]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  validateHead(spec);
+  validateCountersink(spec);
+  const blank = frustum(
+    spec.nominalDiameter / 2,
+    spec.headDiameter / 2,
+    spec.headHeight,
+  );
+  const head = hexSocket(
+    blank,
+    spec.hexSocketWidth,
+    spec.hexSocketDepth,
+    spec.headHeight,
+  );
+  return headedScrew(
+    head,
+    spec,
+    length - spec.headHeight,
+    threadLength(spec, length),
+  );
+}
+
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(
+  input: ScrewInput,
+  depth: number,
+): CountersunkHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CountersunkHoleOptions,
+): CountersunkHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CountersunkHole;
+export function clearanceHole(
+  input: ScrewInput,
+  optionsOrDepth: number | ClearanceHoleOptions,
+): ClearanceHole | CountersunkHole {
+  const spec = resolveSpecification(input);
+  const options =
+    typeof optionsOrDepth === 'number'
+      ? {depth: optionsOrDepth}
+      : optionsOrDepth;
+  validateCountersink(spec);
+  const shaft = plainHole(spec, options);
+  if (options.countersink === false) return shaft;
+  const sink =
+    options.countersink === true || options.countersink === undefined
+      ? {}
+      : options.countersink;
+  const diameter = sink.diameter ?? spec.headDiameter + 0.5;
+  const shaftDiameter =
+    options.diameter ?? spec.clearance[options.fit ?? 'normal'];
+  positive('Countersink diameter', diameter);
+  if (diameter < spec.headDiameter || diameter <= shaftDiameter)
+    throw new Error(
+      'Countersink must accommodate the screw head and exceed the shaft diameter.',
+    );
+  const depth =
+    (diameter - shaftDiameter) /
+    (2 * Math.tan((spec.headAngle * Math.PI) / 360));
+  if (!Number.isFinite(depth) || depth <= 0 || depth > options.depth)
+    throw new Error('Countersink depth must be within the total hole depth.');
+  const recess = atY(
+    frustum(shaftDiameter / 2, diameter / 2, depth),
+    (options.depth - depth) / 2,
+  );
+  return union([shaft, recess]).expose({
+    shaftTop: shaft.shaftTop,
+    shaftBottom: shaft.shaftBottom,
+    shaftAxis: shaft.shaftAxis,
+    countersinkTop: recess.up,
+    countersinkBottom: recess.down,
+  });
+}

package/src/library/iso-14583.ts

@@ -0,0 +1,181 @@
+import {cut} from '@code3d/core';
+import {
+  definePrimitive,
+  replicad,
+  type Point2D,
+  type Sketch,
+} from '@code3d/core/replicad';
+import {
+  metric,
+  validateHead,
+  headedScrew,
+  panHead,
+  positive,
+  clearanceHole as buildClearanceHole,
+  type HeadSpecification,
+  type MetricSize,
+  type Screw,
+  type ClearanceHole,
+  type CounterboredHole,
+  type ClearanceHoleOptions,
+  type PlainHoleOptions,
+  type CounterboredHoleOptions,
+} from './common.js';
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  ClearanceHoleOptions,
+  PlainHoleOptions,
+  CounterboredHoleOptions,
+  CounterboreOptions,
+} from './common.js';
+
+export type HexalobularRecess = Readonly<{
+  number: number;
+  diameter: number;
+  innerDiameter: number;
+  depth: number;
+}>;
+export type Specification = HeadSpecification &
+  Readonly<{headCurvatureRadius: number; recess: HexalobularRecess}>;
+// ISO 14583:2011 head dimensions and minimum recess penetration.
+// https://www.finesz.com/ISO14583.php
+// ISO 10664:2014 nominal driving envelopes A/B (size 45 A = 7.93).
+function specification(
+  size: MetricSize,
+  headDiameter: number,
+  headHeight: number,
+  headCurvatureRadius: number,
+  underHeadRadius: number,
+  number: number,
+  diameter: number,
+  innerDiameter: number,
+  depth: number,
+): Specification {
+  return {
+    ...metric(size),
+    headDiameter,
+    headHeight,
+    headCurvatureRadius,
+    underHeadRadius,
+    recess: {number, diameter, innerDiameter, depth},
+  };
+}
+export const specifications = {
+  M3: specification('M3', 5.6, 2.4, 5, 0.1, 10, 2.8, 2.05, 1.01),
+  M4: specification('M4', 8, 3.1, 6.5, 0.2, 20, 3.95, 2.85, 1.27),
+  M5: specification('M5', 9.5, 3.7, 8, 0.2, 25, 4.5, 3.25, 1.52),
+  M6: specification('M6', 12, 4.6, 10, 0.25, 30, 5.6, 4.05, 2.02),
+  M8: specification('M8', 16, 6, 13, 0.4, 45, 7.93, 5.64, 2.79),
+  M10: specification('M10', 20, 7.5, 16, 0.4, 50, 8.95, 6.45, 3.62),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+export function threadLength(spec: Specification, _length: number): number {
+  return spec.nominalDiameter <= 3 ? 25 : 38;
+}
+
+/** Nominal representation: twelve tangent circular arcs, not an inspection gauge. */
+const hexalobularTool = definePrimitive(
+  (diameter: number, innerDiameter: number, depth: number) => {
+    positive('Recess diameter', diameter);
+    positive('Inner recess diameter', innerDiameter);
+    positive('Recess depth', depth);
+    const a = diameter / 2,
+      b = innerDiameter / 2,
+      re = diameter * 0.1;
+    const p = a - re,
+      c = Math.cos(Math.PI / 6);
+    const ri =
+      (re ** 2 - p ** 2 - b ** 2 + 2 * p * b * c) / (2 * (b - p * c - re));
+    positive('Recess inner arc radius', ri);
+    const radial = (radius: number, angle: number): Point2D => [
+      radius * Math.cos(angle),
+      radius * Math.sin(angle),
+    ];
+    const tangent = (angle: number, side: number): Point2D => {
+      const outer = radial(p, angle),
+        inner = radial(b + ri, angle + (side * Math.PI) / 6);
+      return [
+        outer[0] + (re / (re + ri)) * (inner[0] - outer[0]),
+        outer[1] + (re / (re + ri)) * (inner[1] - outer[1]),
+      ];
+    };
+    const start = tangent(0, -1);
+    const drawing = replicad.draw(start);
+    for (let i = 0; i < 6; i++) {
+      const angle = (i * Math.PI) / 3;
+      drawing.threePointsArcTo(tangent(angle, 1), radial(a, angle));
+      drawing.threePointsArcTo(
+        i === 5 ? start : tangent(angle + Math.PI / 3, -1),
+        radial(b, angle + Math.PI / 6),
+      );
+    }
+    const profile = drawing.close();
+    return (profile.sketchOnPlane('XY') as Sketch)
+      .extrude(depth)
+      .rotate(-90, [0, 0, 0], [1, 0, 0])
+      .translate([0, -depth / 2, 0]);
+  },
+);
+
+/**
+ * @code3d.arguments ['M6', 18]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  validateHead(spec);
+  const recess = spec.recess;
+  if (
+    recess.innerDiameter >= recess.diameter ||
+    recess.diameter >= spec.headDiameter ||
+    recess.depth >= spec.headHeight
+  )
+    throw new Error('Recess must fit inside the head.');
+  const head = panHead(
+    spec.headDiameter,
+    spec.headHeight,
+    recess.diameter * 1.05,
+    spec.headCurvatureRadius,
+  );
+  const tool = hexalobularTool(
+    recess.diameter,
+    recess.innerDiameter,
+    recess.depth,
+  ).relate(part => part.up.on(head.up));
+  return headedScrew(
+    cut(head, [tool]),
+    spec,
+    length,
+    threadLength(spec, length),
+  );
+}
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  return buildClearanceHole(resolveSpecification(input), options);
+}

package/src/library/iso-4014.ts

@@ -0,0 +1,64 @@
+import {
+  headedScrew,
+  clearanceHole as buildClearanceHole,
+  type Screw,
+  type ClearanceHole,
+  type CounterboredHole,
+  type ClearanceHoleOptions,
+  type PlainHoleOptions,
+  type CounterboredHoleOptions,
+} from './common.js';
+import {hexHead, specifications, type Specification} from './hex-head.js';
+export {specifications};
+export type {Specification};
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  ClearanceHoleOptions,
+  PlainHoleOptions,
+  CounterboredHoleOptions,
+  CounterboreOptions,
+} from './common.js';
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+export function threadLength(spec: Specification, length: number): number {
+  return (
+    2 * spec.nominalDiameter + (length <= 125 ? 6 : length <= 200 ? 12 : 25)
+  );
+}
+/**
+ * @code3d.arguments ['M6', 30]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  return headedScrew(hexHead(spec), spec, length, threadLength(spec, length));
+}
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  return buildClearanceHole(resolveSpecification(input), options);
+}

package/src/library/iso-4017.ts

@@ -0,0 +1,62 @@
+import {
+  headedScrew,
+  clearanceHole as buildClearanceHole,
+  type Screw,
+  type ClearanceHole,
+  type CounterboredHole,
+  type ClearanceHoleOptions,
+  type PlainHoleOptions,
+  type CounterboredHoleOptions,
+} from './common.js';
+import {hexHead, specifications, type Specification} from './hex-head.js';
+export {specifications};
+export type {Specification};
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  ClearanceHoleOptions,
+  PlainHoleOptions,
+  CounterboredHoleOptions,
+  CounterboreOptions,
+} from './common.js';
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+export function threadLength(spec: Specification, length: number): number {
+  return length;
+}
+/**
+ * @code3d.arguments ['M6', 30]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  return headedScrew(hexHead(spec), spec, length, threadLength(spec, length));
+}
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  return buildClearanceHole(resolveSpecification(input), options);
+}

package/src/library/iso-4029.ts

@@ -0,0 +1,101 @@
+import {
+  cut,
+  frustum,
+  intersect,
+  type Bound,
+  type CanonicalElements,
+  type LineAnchor,
+  type SolidModel,
+} from '@code3d/core';
+import {definePrimitive, replicad, type Sketch} from '@code3d/core/replicad';
+import {
+  metric,
+  externalThread,
+  hexSocket,
+  atY,
+  positive,
+  type MetricSize,
+  type MetricSpecification,
+} from './common.js';
+
+export type Specification = MetricSpecification &
+  Readonly<{
+    hexSocketWidth: number;
+    hexSocketDepth: number;
+    cupDiameter: number;
+  }>;
+// ISO 4029 cup-point set screws, nominal driving width and minimum socket depth.
+// https://www.jcfasteners.com/wp-content/uploads/DIN-916-Grub-Screw-Cup-PT-B4A07-SS304.pdf
+function specification(
+  size: MetricSize,
+  hexSocketWidth: number,
+  hexSocketDepth: number,
+  cupDiameter: number,
+): Specification {
+  return {...metric(size), hexSocketWidth, hexSocketDepth, cupDiameter};
+}
+export const specifications = {
+  M3: specification('M3', 1.5, 1.2, 1.4),
+  M4: specification('M4', 2, 1.5, 2),
+  M5: specification('M5', 2.5, 2, 2.5),
+  M6: specification('M6', 3, 2, 3),
+  M8: specification('M8', 4, 3, 5),
+  M10: specification('M10', 5, 4, 6),
+  M12: specification('M12', 6, 4.8, 8),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export type ScrewElements = CanonicalElements &
+  Readonly<{driveTop: Bound; pointBottom: Bound; threadAxis: LineAnchor}>;
+export type Screw = SolidModel<ScrewElements>;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+const cupTool = definePrimitive((radius: number, depth: number) => {
+  const profile = replicad
+    .draw([0, 0])
+    .lineTo([radius, 0])
+    .lineTo([0, depth])
+    .close();
+  return (profile.sketchOnPlane('XZ') as Sketch)
+    .revolve([0, 0, 1])
+    .rotate(-90, [0, 0, 0], [1, 0, 0])
+    .translate([0, -depth / 2, 0]);
+});
+/**
+ * Length is the complete headless screw, including its cup point.
+ * @code3d.arguments ['M6', 10]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  positive('Screw length', length);
+  positive('Cup diameter', spec.cupDiameter);
+  if (spec.cupDiameter >= spec.nominalDiameter)
+    throw new Error('Cup diameter must be smaller than the nominal diameter.');
+  const cupRadius = spec.cupDiameter / 2;
+  const cupDepth = cupRadius / Math.sqrt(3);
+  if (length <= spec.hexSocketDepth + cupDepth + spec.pitch)
+    throw new Error(
+      'Screw length must separate the socket from the cup point.',
+    );
+  const thread = externalThread(spec, length);
+  const outerPoint = frustum(cupRadius, cupRadius + length, length);
+  const blank = intersect([thread, outerPoint]);
+  const driven = hexSocket(
+    blank,
+    spec.hexSocketWidth,
+    spec.hexSocketDepth,
+    length,
+  );
+  // A narrow annular lip remains at the end of the external point chamfer.
+  const cup = atY(
+    cupTool(cupRadius * 0.85, cupDepth),
+    -length / 2 + cupDepth / 2,
+  );
+  return cut(driven, [cup]).expose({
+    driveTop: thread.up,
+    pointBottom: thread.down,
+    threadAxis: thread.axis,
+  });
+}