draftwright 0.5.0rc4__tar.gz → 0.5.0rc5__tar.gz

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.5.0rc4
+Version: 0.5.0rc5
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.5.0rc4"
+version = "0.5.0rc5"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }

draftwright-0.5.0rc5/src/draftwright/_pmi_datum_geometry.py

@@ -0,0 +1,174 @@
+"""Exact imported datum attachment geometry in source or recognition frame."""
+
+from __future__ import annotations
+
+import math
+from typing import cast
+
+from quiddity import PartFrame
+
+
+def _bbox_centroid(bbox: tuple) -> tuple[float, float, float]:
+    xmin, ymin, zmin, xmax, ymax, zmax = bbox
+    return ((xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2)
+
+
+def _frame_point(
+    point: tuple[float, float, float], frame: PartFrame | None
+) -> tuple[float, float, float]:
+    """Express one source-space point in *frame*, preserving default extraction exactly."""
+    if frame is None:
+        return point
+    return frame.to_local(point)
+
+
+def _frame_vector(
+    vector: tuple[float, float, float], frame: PartFrame | None
+) -> tuple[float, float, float]:
+    """Express one free vector in *frame* without applying the frame origin."""
+    if frame is None:
+        return vector
+    return cast(
+        tuple[float, float, float],
+        tuple(
+            sum(component * basis[index] for index, component in enumerate(vector))
+            for basis in (frame.x, frame.y, frame.z)
+        ),
+    )
+
+
+def _cylindrical_datum_site(face, bbox, axis_index, frame):
+    """Find a normal axis-aligned projection site on the exact trimmed face."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeVertex
+    from OCP.BRepExtrema import BRepExtrema_DistShapeShape
+    from OCP.gp import gp_Pnt
+
+    cylinder = BRepAdaptor_Surface(face).Cylinder()
+    centre = _bbox_centroid(bbox)
+    location = cylinder.Axis().Location()
+    axis_site = _frame_point((location.X(), location.Y(), location.Z()), frame)
+    radial_index = 2 if axis_index < 2 else 0
+    preferred_signs = (-1, 1) if axis_index < 2 else (1, -1)
+    # The upper station avoids CTC-01's lower source label, but a trimmed
+    # sidewall may lose that station to a cross-hole. Try the midpoint too.
+    stations: tuple[float, ...] = (centre[axis_index],)
+    if axis_index == 2:
+        stations = (centre[axis_index] + min((bbox[5] - bbox[2]) / 4, 10.0), *stations)
+    for station in stations:
+        for sign in preferred_signs:
+            silhouette = list(axis_site)
+            silhouette[axis_index] = station
+            silhouette[radial_index] += sign * cylinder.Radius()
+            local_site = tuple(silhouette)
+            if not all(
+                bbox[index] - 1e-6 <= local_site[index] <= bbox[index + 3] + 1e-6
+                for index in range(3)
+            ):
+                continue
+            world_site = local_site if frame is None else frame.to_world(local_site)
+            vertex = BRepBuilderAPI_MakeVertex(gp_Pnt(*world_site)).Vertex()
+            distance = BRepExtrema_DistShapeShape(vertex, face)
+            distance.Perform()
+            if distance.IsDone() and distance.Value() <= 1e-6:
+                return local_site
+    return None
+
+
+def _datum_face_site(shape, bbox, kind, axis_index, frame):
+    """Choose a proven face site, on the projected silhouette for cylinders."""
+    from OCP.BRep import BRep_Tool
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.BRepMesh import BRepMesh_IncrementalMesh
+    from OCP.BRepTools import BRepTools
+    from OCP.gp import gp_Pnt, gp_Pnt2d
+    from OCP.TopAbs import TopAbs_IN
+    from OCP.TopLoc import TopLoc_Location
+    from OCP.TopoDS import TopoDS
+
+    face = TopoDS.Face_s(shape)
+    if kind == "cylinder":
+        return _cylindrical_datum_site(face, bbox, axis_index, frame)
+    u0, u1, v0, v1 = BRepTools.UVBounds_s(face)
+    surface = BRepAdaptor_Surface(face)
+    classifier = BRepClass_FaceClassifier()
+    centre = _bbox_centroid(bbox)
+    candidates = []
+    if all(math.isfinite(value) for value in (u0, u1, v0, v1)):
+        for ui in range(13):
+            u = u0 + (ui + 0.5) * (u1 - u0) / 13
+            for vi in range(13):
+                v = v0 + (vi + 0.5) * (v1 - v0) / 13
+                classifier.Perform(face, gp_Pnt2d(u, v), 1e-7)
+                if classifier.State() == TopAbs_IN:
+                    point = surface.Value(u, v)
+                    candidates.append((point.X(), point.Y(), point.Z()))
+    if not candidates:
+        # A narrow ring can lie entirely between grid samples. Mesh triangles
+        # cover the trimmed face, and their centroids supply interior sites.
+        for deflection in (0.1, 0.01, 0.001, 0.0001):
+            BRepMesh_IncrementalMesh(face, deflection, False, 0.5, False).Perform()
+            location = TopLoc_Location()
+            mesh = BRep_Tool.Triangulation_s(face, location)
+            if mesh is None:
+                continue
+            transform = location.Transformation()
+            for index in range(1, mesh.NbTriangles() + 1):
+                vertices = mesh.Triangle(index).Get()
+                nodes = [mesh.Node(vertex).Transformed(transform) for vertex in vertices]
+                point = tuple(sum(node.Coord()[axis] for node in nodes) / 3 for axis in range(3))
+                classifier.Perform(face, gp_Pnt(*point), 1e-7)
+                if classifier.State() == TopAbs_IN:
+                    candidates.append(point)
+            if candidates:
+                break
+    sites = []
+    for point in candidates:
+        site = _frame_point(point, frame)
+        hidden = 0 if axis_index == 1 else 1
+        key = (
+            abs(site[hidden] - centre[hidden]),
+            sum((site[i] - centre[i]) ** 2 for i in range(3)),
+        )
+        sites.append((key, site))
+    return min(sites)[1] if sites else None
+
+
+def _datum_reference_normal(shapes, points, frame) -> tuple[tuple[float, ...], str]:
+    """Measure a planar datum's oriented outward normal."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.TopAbs import TopAbs_FORWARD, TopAbs_REVERSED
+    from OCP.TopoDS import TopoDS
+
+    normals = []
+    for shape, _site in zip(shapes, points, strict=True):
+        face = TopoDS.Face_s(shape)
+        surface = BRepAdaptor_Surface(face)
+        kind = surface.GetType()
+        if kind == GeomAbs_Cylinder:
+            continue
+        if kind != GeomAbs_Plane:
+            return (), "datum reference surface has no supported oriented normal"
+        direction = surface.Plane().Axis().Direction()
+        vector: tuple[float, ...] = _frame_vector(
+            (direction.X(), direction.Y(), direction.Z()), frame
+        )
+        orientation = face.Orientation()
+        if orientation == TopAbs_REVERSED:
+            vector = tuple(-component for component in vector)
+        elif orientation != TopAbs_FORWARD:
+            return (), "datum reference surface has no outward orientation"
+        magnitude = math.sqrt(sum(component * component for component in vector))
+        if magnitude < 1e-9:
+            return (), "datum reference surface has no usable normal"
+        normals.append(tuple(component / magnitude for component in vector))
+    if not normals:
+        return (), ""
+    if any(
+        sum(a * b for a, b in zip(normals[0], normal, strict=True)) < 0.999
+        for normal in normals[1:]
+    ):
+        return (), "datum reference faces disagree about outward normal"
+    return normals[0], ""

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/src/draftwright/annotations/_gdt.py

@@ -298,6 +298,72 @@ def _attach_gdt_text_evidence(leader, glyph, item, draft) -> None:
         leader.gdt_visual_zone = zone if leader.gdt_visual_tolerance else ""
 
 
+def _gdt_retry_sides(side: str, *, normal_side_only: bool) -> tuple[str, ...]:
+    """Imported datums keep their proven outward side; other glyphs may relax."""
+    if normal_side_only:
+        return (side,)
+    return {
+        "above": ("below", "right", "left"),
+        "below": ("above", "right", "left"),
+        "left": ("right", "above", "below"),
+        "right": ("left", "above", "below"),
+    }[side]
+
+
+def _gdt_retry_geometry(state, tier, alt):
+    """Give the deferred carve its strip and glyph extent."""
+    alt_strip = getattr(state.zones, alt, None)
+    if alt_strip is None:
+        return None
+    hz = alt in ("above", "below")
+    axis = "y" if hz else "x"
+    extent = state.size[1] if hz else state.size[0]
+    perp = (
+        (state.px, state.px + state.size[0])
+        if hz
+        else (state.py - state.size[1] / 2, state.py + state.size[1] / 2)
+    )
+    return alt_strip, hz, axis, max(tier, extent), perp
+
+
+def _gdt_retry_blocker(dwg, state, dim) -> str | None:
+    """Check a post-drain glyph against the title block and settled ink."""
+    if _box_hits(_anno_box(dim), (state.title_block_box,)):
+        return "title_block_conflict"
+    if not annotation_ink_clear(dwg, dim):
+        return "ink_conflict"
+    return None
+
+
+def _gdt_retry_trace(ctx, state, nm):
+    """Start one optional trace entry for the deferred retry."""
+    trace = getattr(ctx, "trace", None)
+    event = (
+        trace.pass_event("gdt_post_drain_fallback", view=state.view, requested_side=state.side)
+        if trace is not None
+        else None
+    )
+    trace_item = {"name": nm, "outcome": "unmet", "attempts": []} if event is not None else None
+    if event is not None:
+        event["items"].append(trace_item)
+    return trace_item
+
+
+def _gdt_retry_unmet(ctx, state, nm, normal_side_only):
+    """Record why a required glyph could not stay on its legal corridor."""
+    ctx.record_issue(
+        "warning",
+        "pmi_dropped" if state.source_ids else "gdt_dropped",
+        (
+            f"{nm} not placed (no legible room on its surface-normal {state.side} strip)"
+            if normal_side_only
+            else f"{nm} not placed (no legible room in any {state.view} strip or sheet fallback)"
+        ),
+        source=state.source_ids,
+        outcome_stage="placement",
+    )
+
+
 def _gdt_drop_callback(
     dwg,
     ctx,
@@ -318,7 +384,6 @@ def _gdt_drop_callback(
     build_routed,
 ):
     """Return the deferred shared-solver fallback for one declared GD&T candidate."""
-
     state = _GdtDropState(
         view=item.view,
         side=item.side,
@@ -337,72 +402,24 @@ def _gdt_drop_callback(
     )
 
     def _drop(nm):
-        # Fallthrough: the declared/derived side is full — try the OPPOSITE side of
-        # the same view before dropping, so a congested default still places somewhere
-        # legible rather than vanishing. DEFERRED via ctx.post_drain (the plate
-        # pattern): the carve then runs after EVERY corridor has drained, so it cannot
-        # preempt a corner a later sibling's force candidate needs. Force semantics
-        # (no corridor-cross check) match the primary path, BUT reject a spot over the
-        # (not-yet-placed) title block — a below/right strip runs into it, and the
-        # carve can't see it.
         def _retry():
-            trace = getattr(ctx, "trace", None)
-            event = (
-                trace.pass_event(
-                    "gdt_post_drain_fallback", view=state.view, requested_side=state.side
-                )
-                if trace is not None
-                else None
-            )
-            trace_item = (
-                {"name": nm, "outcome": "unmet", "attempts": []} if event is not None else None
-            )
-            if event is not None:
-                event["items"].append(trace_item)
-
-            # Relax the requested side when its strip is full, so
-            # try the OPPOSITE side, then the two PERPENDICULAR sides, placing on the first
-            # with room. A note the caller asked to see should appear somewhere legible
-            # rather than vanish; when the requested strip has no room, an explicit `side=`
-            # is a preference, not a hard constraint. A perpendicular side flips the leader
-            # orientation (`state.build(pos, _hz=hz)`). If the placement lands on a side other than
-            # requested, record an INFO issue so the relaxation is visible.
-            # A requested annotation must never be silently lost.
-            relax_order = {
-                "above": ("below", "right", "left"),
-                "below": ("above", "right", "left"),
-                "left": ("right", "above", "below"),
-                "right": ("left", "above", "below"),
-            }[state.side]
-            for alt in relax_order:
-                alt_strip = getattr(state.zones, alt, None)
-                if alt_strip is None:
+            trace_item = _gdt_retry_trace(ctx, state, nm)
+            normal_side_only = item.kind == "datum_ref" and bool(item.reference_surface_kind)
+            for alt in _gdt_retry_sides(state.side, normal_side_only=normal_side_only):
+                geometry = _gdt_retry_geometry(state, tier, alt)
+                if geometry is None:
                     continue
-                hz = alt in ("above", "below")  # perpendicular sides flip the leader axis
-                axis2 = "y" if hz else "x"
-                extent = (
-                    state.size[1] if axis2 == "y" else state.size[0]
-                )  # the glyph's stacking-axis size
-                perp = (
-                    (state.px, state.px + state.size[0])
-                    if hz
-                    else (state.py - state.size[1] / 2, state.py + state.size[1] / 2)
-                )
-                pos = carve_position(dwg, alt_strip, state.view, axis2, max(tier, extent), perp)
+                strip, hz, axis, extent, perp = geometry
+                pos = carve_position(dwg, strip, state.view, axis, extent, perp)
                 if pos is None:
                     if trace_item is not None:
                         trace_item["attempts"].append({"side": alt, "outcome": "no_free_position"})
                     continue
                 dim = state.build(pos, _hz=hz)
-                if _box_hits(_anno_box(dim), (state.title_block_box,)):
+                blocker = _gdt_retry_blocker(dwg, state, dim)
+                if blocker:
                     if trace_item is not None:
-                        trace_item["attempts"].append(
-                            {"side": alt, "outcome": "title_block_conflict"}
-                        )
-                    continue
-                if not annotation_ink_clear(dwg, dim):
-                    if trace_item is not None:
-                        trace_item["attempts"].append({"side": alt, "outcome": "ink_conflict"})
+                        trace_item["attempts"].append({"side": alt, "outcome": blocker})
                     continue
                 ctx.place(
                     dim,
@@ -411,23 +428,28 @@ def _gdt_drop_callback(
                     feature=state.feature,
                     satisfaction=state.satisfaction,
                     declaration=state.declaration,
-                )  # relaxed side
-                ctx.record_issue(
-                    "info",
-                    "gdt_side_relaxed",
-                    f"{nm}: the {state.view} {state.side} strip was full — placed on {alt} instead",
                 )
+                if alt != state.side:
+                    ctx.record_issue(
+                        "info",
+                        "gdt_side_relaxed",
+                        f"{nm}: the {state.view} {state.side} strip was full — placed on {alt} instead",
+                    )
                 if trace_item is not None:
                     trace_item["attempts"].append({"side": alt, "outcome": "placed"})
                     trace_item.update(outcome="placed", side=alt)
                 return
-            fallback = sheet_fallback(
-                dwg,
-                (state.px, state.py),
-                state.view,
-                state.build_at,
-                state.build_routed,
-                state.size,
+            fallback = (
+                sheet_fallback(
+                    dwg,
+                    (state.px, state.py),
+                    state.view,
+                    state.build_at,
+                    state.build_routed,
+                    state.size,
+                )
+                if not normal_side_only
+                else None
             )
             if fallback is not None:
                 ctx.place(
@@ -448,15 +470,9 @@ def _gdt_drop_callback(
                     trace_item["attempts"].append({"side": "sheet", "outcome": "placed"})
                     trace_item.update(outcome="placed", side="sheet")
                 return
-            if trace_item is not None:
+            if trace_item is not None and not normal_side_only:
                 trace_item["attempts"].append({"side": "sheet", "outcome": "no_clear_route"})
-            ctx.record_issue(
-                "warning",
-                "pmi_dropped" if state.source_ids else "gdt_dropped",
-                f"{nm} not placed (no legible room in any {state.view} strip or sheet fallback)",
-                source=state.source_ids,
-                outcome_stage="placement",
-            )
+            _gdt_retry_unmet(ctx, state, nm, normal_side_only)
 
         ctx.post_drain.append(_retry)
 

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/src/draftwright/layout_selection.py

@@ -42,6 +42,14 @@ def choose_pre_render_profile(
     scheme = strips.scheme
     demand_count = len(scheme.demands) if scheme is not None else 0
     under_reserved_count = len(report.under_reserved)
+    only_unroutable_raw_pmi = (
+        scheme is not None
+        and bool(scheme.unplanned)
+        and all(
+            item.family == "pmi" and item.reason == "raw PMI has no typed corridor"
+            for item in scheme.unplanned
+        )
+    )
     missing_views = (
         sorted({demand.view for demand in scheme.demands} - set(views))
         if scheme is not None
@@ -87,6 +95,16 @@ def choose_pre_render_profile(
         # can displace the required mark even though the original strip fits it.
         # Keep those strips while allowing the ISO to use free space.
         profile, reason = "iso-growth", "sparse_authored_corridor"
+    elif (
+        demand_count <= 25
+        and under_reserved_count >= 3
+        and 6 * under_reserved_count >= demand_count
+        and only_unroutable_raw_pmi
+    ):
+        # Raw source PMI with no drawable carrier has no corridor to protect.
+        # When several typed corridors are short of space, reserve their planned
+        # depths before rendering the single normal build.
+        profile, reason = "planned", "sparse_typed_corridor_pressure"
     elif demand_count <= 25 and report.unplanned_count <= 5 and 0 < under_reserved_count <= 3:
         # Sparse uncertain routes keep baseline annotation placement while
         # granting the isometric view any sheet slack it can safely consume.

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/src/draftwright/model/detect.py

@@ -479,11 +479,52 @@ def build_pmi_features(
             continue
         if r.source_category == "datum" and not r.lowering_blockers and r.reference_axis:
             edge_view = {"X": "front", "Y": "side", "Z": "front"}[r.reference_axis]
-            vertical_index = 2 if edge_view in ("front", "side") else 1
             center = bbox.center()
-            center_coord = (center.X, center.Y, center.Z)[vertical_index]
-            side = "above" if pmi_origin[vertical_index] >= center_coord else "below"
-            datum_item = datum(r.label, raw, view=edge_view, side=side)
+            center_point = (center.X, center.Y, center.Z)
+            site = r.ref_pts[0] if r.ref_pts else pmi_origin
+            axial_index = "XYZ".index(r.reference_axis)
+            surface_kind = r.reference_surface_kind
+            if not surface_kind:
+                # Compatibility for hand-constructed records predating exact kind.
+                surface_kind = (
+                    "plane"
+                    if r.ref_bbox is not None
+                    and r.ref_bbox[axial_index + 3] - r.ref_bbox[axial_index] < 1e-4
+                    else "cylinder"
+                )
+            planar = surface_kind == "plane"
+            # A plane's leader follows its normal in the edge-on view. A
+            # cylindrical datum instead attaches radially to its profile.
+            if planar and axial_index < 2:
+                side_index = axial_index
+                low_side, high_side = "left", "right"
+            elif not planar and axial_index == 2:
+                side_index = 0
+                low_side, high_side = "left", "right"
+            else:
+                side_index = 2
+                low_side, high_side = "below", "above"
+            if len(r.reference_normal) == 3 and abs(r.reference_normal[side_index]) < 0.9:
+                out.append(
+                    replace(
+                        raw,
+                        lowering_blockers=(
+                            "datum surface normal cannot be shown by an axial leader in this view",
+                        ),
+                    )
+                )
+                continue
+            if len(r.reference_normal) == 3:
+                side = high_side if r.reference_normal[side_index] > 0 else low_side
+            else:
+                side = high_side if site[side_index] >= center_point[side_index] else low_side
+            datum_item = datum(
+                r.label,
+                replace(raw, frame=Frame(origin=site, axis=ax)),
+                view=edge_view,
+                side=side,
+            )
+            datum_item = replace(datum_item, reference_surface_kind=surface_kind)
             out.append(
                 replace(
                     datum_item,

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/src/draftwright/model/ir.py

@@ -2480,6 +2480,7 @@ class DatumRef:
     source_id: str = ""
     source_ids: tuple[str, ...] = ()
     part21_id: str = ""
+    reference_surface_kind: str = ""
     kind: ClassVar[str] = "datum_ref"
 
     def parameters(self) -> list[DimParameter]:

{draftwright-0.5.0rc4 → draftwright-0.5.0rc5}/src/draftwright/model/pmi_lowering.py

@@ -916,14 +916,9 @@ def _structured_thread_extent(
         if through:
             raise ValueError("structured external thread cannot be a through tap")
         if "thread length" in fields:
-            length = _structured_number(fields, "thread length")
-            if len(feature.cylindrical_refs) != 1 or not _same_number(
-                feature.cylindrical_refs[0].axial_interval[1]
-                - feature.cylindrical_refs[0].axial_interval[0],
-                length,
-                abs_tol=0.01,
-            ):
-                raise ValueError("structured thread length disagrees with source cylinder")
+            _structured_number(fields, "thread length")
+            # A tip chamfer can shorten the source face. Check its full owner span
+            # only after a unique geometric owner match is established.
         elif prose is None or not prose.full_available_length:
             raise ValueError("structured external thread has no length requirement")
     return (
@@ -1184,7 +1179,51 @@ def _remap_model_features(model: PartModel, replacements: dict[int, Feature]) ->
     )
 
 
-def _manufacturing_proposal(feature: PmiFeature, owners, bbox):
+def _turned_tip_chamfers_cover_gap(
+    reference: CylindricalReference,
+    owner: StepFeature | BossFeature,
+    chamfers: tuple[ChamferFeature, ...],
+) -> bool:
+    """Require recognised equal-leg end chamfers for a shortened source cylinder."""
+    span = owner.span
+    if span is None:
+        return False
+    axis_index = "xyz".index(owner.frame.axis)
+    owner_lo, owner_hi = sorted((span[0][axis_index], span[1][axis_index]))
+    source_lo, source_hi = reference.axial_interval
+    gaps = ((owner_lo, source_lo), (source_hi, owner_hi))
+    found_gap = False
+    for gap_lo, gap_hi in gaps:
+        gap = gap_hi - gap_lo
+        if gap <= 0.01:
+            continue
+        found_gap = True
+        station = (gap_lo + gap_hi) / 2
+        if not any(
+            chamfer.turned
+            and chamfer.axis == owner.frame.axis
+            and _same_number(chamfer.leg1, gap, abs_tol=0.01)
+            and _same_number(chamfer.leg2, gap, abs_tol=0.01)
+            and _same_number(chamfer.angle, 45.0, abs_tol=0.01)
+            and _same_number(chamfer.frame.origin[axis_index], station, abs_tol=0.01)
+            and _same_number(
+                math.sqrt(
+                    sum(
+                        (chamfer.frame.origin[index] - reference.axis_origin[index]) ** 2
+                        for index in range(3)
+                        if index != axis_index
+                    )
+                ),
+                reference.radius - gap / 2,
+                abs_tol=0.01,
+            )
+            for chamfer in chamfers
+        ):
+            return False
+    return found_gap
+
+
+def _manufacturing_proposal(feature: PmiFeature, owners, chamfers, bbox):
     """Validate one source against its exact cylinder and unique canonical owner."""
     requirement = (
         _knurl_requirement(feature)
@@ -1226,7 +1265,31 @@ def _manufacturing_proposal(feature: PmiFeature, owners, bbox):
             if not matches
             else f"ambiguous manufacturing requirement: source topology matches {len(matches)} canonical features"
         )
-    return matches[0], requirement
+    owner = matches[0]
+    if (
+        isinstance(requirement, ThreadRequirement)
+        and requirement.application == "external"
+        and isinstance(owner, (StepFeature, BossFeature))
+        and "thread length" in dict(feature.structured_fields)
+    ):
+        length = _structured_number(dict(feature.structured_fields), "thread length")
+        source_length = reference.axial_interval[1] - reference.axial_interval[0]
+        span = owner.span
+        if span is None:
+            raise ValueError("external thread owner has no axial span")
+        axis_index = "xyz".index(owner.frame.axis)
+        owner_length = abs(span[1][axis_index] - span[0][axis_index])
+        if not (
+            _same_number(source_length, length, abs_tol=0.01)
+            or (
+                _same_number(owner_length, length, abs_tol=0.01)
+                and _turned_tip_chamfers_cover_gap(reference, owner, chamfers)
+            )
+        ):
+            raise ValueError(
+                "structured thread length disagrees with source cylinder or evidenced owner span"
+            )
+    return owner, requirement
 
 
 def lower_ap242_manufacturing_requirements(
@@ -1248,6 +1311,7 @@ def lower_ap242_manufacturing_requirements(
         for feature in model.features
         if isinstance(feature, (StepFeature, BossFeature, HoleFeature, PatternFeature))
     ]
+    chamfers = tuple(feature for feature in model.features if isinstance(feature, ChamferFeature))
     replacements: dict[int, Feature] = {}
     consumed: set[int] = set()
     blocked: dict[int, str] = {}
@@ -1265,7 +1329,7 @@ def lower_ap242_manufacturing_requirements(
         if feature.lowering_blockers:
             continue
         try:
-            owner, requirement = _manufacturing_proposal(feature, owners, model.bbox)
+            owner, requirement = _manufacturing_proposal(feature, owners, chamfers, model.bbox)
         except ValueError as exc:
             blocked[index] = str(exc)
             continue