draftwright 0.1.6__tar.gz → 0.1.7__tar.gz

draftwright-0.1.7/CHANGELOG.md

@@ -0,0 +1,148 @@
+# Changelog
+
+## Unreleased
+
+### Changed
+
+- **Hole callouts are no longer capped at four per view.** Every distinct bore
+  is attempted; the per-view placement bounds (front-view shaft rows, plan/side
+  strip Y-solver) are the real limit, and a callout that genuinely doesn't fit
+  surfaces as `callout_dropped` (a warning, with its diameter, excluded from
+  `feature_not_dimensioned`). Three previously-silent front-view skip paths now
+  surface too. The bore-callout "no room"/"strip full" drops are reclassified
+  from error (`placement_unsatisfiable`) to this warning, since under the
+  adaptive model an unplaceable callout is an incomplete — not invalid —
+  drawing. Completes the adaptive-caps work (#36); NIST CTC parts now place
+  5–9 callouts (vs a capped 4) with no error-severity lint.
+- **Step-height dimensions are no longer capped at three.** The `fv_zones.right`
+  corridor is now sized for every legible step (`_est_right_strip_depth` no
+  longer caps the count), and a step dim is placed for each legible level. A
+  part with several shoulders gets them all dimensioned instead of an arbitrary
+  three; the strip allocator remains the real bound (an unplaceable step
+  surfaces as `placement_unsatisfiable`). Verified the NIST CTC parts (8–16
+  step faces each) build with no error-severity lint. Second step of the
+  adaptive-caps work (#36); the per-view callout cap follows. The
+  `step_dim_dropped` lint code is removed (the cap that produced it is gone).
+- Hole **location dimensions are no longer capped at four** per part: they are
+  placed nearest-datum-first (baseline practice) until the above-view tier
+  strips fill, so a part with room gets all its holes located instead of an
+  arbitrary four. Refs that genuinely don't fit are skipped (never
+  force-placed) and surface as `location_ref_dropped` (#36). First step of the
+  adaptive-caps work; step-height and per-view callout caps follow.
+
+### Added
+
+- `Drawing.lint_summary()` — a JSON-friendly aggregate of `lint()` for
+  non-interactive callers (scripts, or an LLM via the API): severity counts,
+  per-code counts, a `geometry_issues` tally (standards/geometry checks vs pure
+  layout), a `passed` flag, a coarse 0–1 `score`, and the full issue list. Gives
+  a single signal to gate and optimise on without rendering the SVG (#32).
+
+### Fixed
+
+- Annotations the layout had to drop (hole callouts past the per-view cap,
+  location references past the per-part cap, step-height dimensions past the
+  first three, bore callouts with no room or an unsatisfiable strip) are no
+  longer silent: each is recorded during the build and surfaced by `lint()`
+  under a dedicated code (`callout_dropped`, `location_ref_dropped`,
+  `step_dim_dropped`, `placement_unsatisfiable`), so a short drawing always
+  carries a machine-readable reason (#32).
+- `placement_unsatisfiable` (the engine could not place an annotation it wanted
+  to, as opposed to a deliberate cap) is **error** severity, so it fails the
+  `lint_summary()` `passed` gate; the deliberate-cap drops stay warnings (#32).
+- A callout dropped by the per-view cap is no longer double-reported: the
+  dropped diameters are named in the `callout_dropped` message and excluded from
+  `feature_not_dimensioned` (#32).
+- `_auto_annotate` is idempotent for build-time lint records — re-annotating a
+  drawing no longer accumulates duplicate drop reports (#32).
+
+## v0.1.6 — 2026-06-15
+
+### Fixed
+
+- Section-view boolean cut on cast geometry: the exact `body - Box(...)` boolean
+  raised an uncatchable `Standard_DomainError` (C++ abort, SIGABRT) on some parts
+  (NIST CTC-04), crashing the whole drawing. `_fuzzy_cut()` now runs
+  `BRepAlgoAPI_Cut` with a small fuzzy tolerance and keeps solids-only, making
+  the section cut robust (#20, #22).
+
+### Tests
+
+- NIST CTC-04 (both AP203 and AP242) now build with a clean section view and are
+  covered by the CTC build tests.
+- Known: CTC-02 AP242 still segfaults inside OCCT's AP242/PMI STEP read (#20),
+  excluded from build tests.
+
+## v0.1.5 — 2026-06-15
+
+### Fixed
+
+- CTC-02 spurious full-page line: build123d's `ExportSVG` projected
+  circle-edge-on edges (hole/fillet rims seen edge-on) as elliptical arcs with
+  a near-zero minor radius, which renderers blow up into full-page lines.
+  `sanitize_svg_arcs()` rewrites any arc with a sub-1e-3 mm radius into the
+  straight line it actually is, leaving real arcs untouched (#19). Not a PMI
+  issue — the file is AP203 geometry-only.
+
+### Tests
+
+- Added the full NIST CTC set (01–05) as fixtures, both AP203 geometry-only and
+  AP242 (with-PMI) variants.
+- Heavy end-to-end CTC fixture builds are marked `slow` and deselected from the
+  default `pytest` run (fast normal run, ~4.5 min); CI runs the fast tier across
+  the OS/Python matrix and the slow tier once.
+- Known: AP242 CTC-02 and both CTC-04 variants crash OCCT on import (#20); their
+  fixtures are excluded from build tests.
+
+## v0.1.4 — 2026-06-15
+
+### Changed
+
+- Feature annotations (hole callouts, location dimensions, section view) now
+  fire on feature presence independent of the turned/prismatic classification,
+  so turned-and-drilled parts (e.g. flanges) get both the OD/centreline base
+  set and per-hole callouts plus bolt-circle furniture (#10).
+- Isometric view placement now uses a general largest-empty-rectangle search in
+  place of the wide/flat-on-A3 special case (#11).
+- Concentric bore-leader stacking is generalised beyond three, and the
+  step-height dimension gate is now a single derived constant (#10, #12).
+
+### Internal
+
+- Single-sourced duplicated geometry constants from the draft preset (#12).
+- Minor comment and logging cleanups.
+
+## v0.1.0 — 2026-06-14
+
+Initial release — spun out of `build123d-drafting-helpers` v0.9.1.
+
+The automated drawing engine (`make_drawing`, `build_drawing`, `Drawing`)
+was previously part of `build123d-drafting-helpers`. It is now a separate
+AGPL-licensed package that depends on `build123d-drafting-helpers>=0.9.1`
+for annotation primitives.
+
+### Migration from build123d-drafting-helpers
+
+```python
+# Before
+from build123d_drafting import make_drawing, Drawing, build_drawing
+
+# After
+from draftwright import make_drawing, Drawing, build_drawing
+```
+
+### Features (carried over from build123d-drafting-helpers)
+
+- **`make_drawing`** / **`build_drawing`** — automatic multi-view technical
+  drawing from a build123d solid: view layout, scale selection, orthographic
+  projection, dimension placement, title block.
+- **`Drawing`** — composable drawing object with `.lint()`, `.add()`,
+  `.export_svg()`, `.export_dxf()`.
+- **`choose_scale`** — ISO/ASME standard scale selection.
+- **`lint_feature_coverage`** — checks annotation coverage against detected
+  part features (holes, bosses, bolt circles).
+- **Section A–A views** — automatic section view for blind/stepped holes,
+  with ISO 128-44 solid filled cutting-plane arrows and ISO 128-50 45°
+  hatching on the cut face.
+- **`generate_script`** — generates a standalone drawing script from a STEP
+  file.

{draftwright-0.1.6 → draftwright-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.1.6
+Version: 0.1.7
 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.1.6 → draftwright-0.1.7}/pyproject.toml

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

{draftwright-0.1.6 → draftwright-0.1.7}/src/draftwright/make_drawing.py

@@ -17,6 +17,7 @@ CLI (registered as ``make-drawing``)::
 """
 
 import argparse
+import functools
 import logging
 import math
 import re
@@ -26,6 +27,7 @@ from types import SimpleNamespace
 from typing import Literal
 
 from build123d import (
+    Align,
     Arrow,
     Box,
     Color,
@@ -40,8 +42,8 @@ from build123d import (
     Mode,
     Pos,
     Shape,
+    Text,
     Vector,
-    import_step,
 )
 from build123d_drafting.features import (
     BoltCircle,
@@ -73,6 +75,8 @@ from build123d_drafting.helpers import (
 from OCP.BRepAdaptor import BRepAdaptor_Surface
 from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut
 from OCP.GeomAbs import GeomAbs_Plane
+from OCP.IFSelect import IFSelect_ReturnStatus
+from OCP.STEPControl import STEPControl_Reader
 from OCP.TopTools import TopTools_ListOfShape
 
 _log = logging.getLogger(__name__)
@@ -167,6 +171,23 @@ def sanitize_svg_arcs(svg_path: str) -> int:
     return n
 
 
+def _import_step(path) -> Compound:
+    """Read solid geometry from a STEP file via OCCT's ``STEPControl_Reader``.
+
+    build123d's ``import_step`` uses the XCAF reader (colours, names, PMI), which
+    **segfaults** on some AP242 files carrying semantic PMI — e.g. NIST CTC-02
+    AP242 (#20) — before any Python code can intervene. draftwright needs only
+    the solid geometry (it drops PMI presentation data anyway), so we read the
+    geometry directly. Verified to produce identical shapes (solids, edges, bbox)
+    to ``import_step`` on the files that read in both, minus the unused metadata.
+    """
+    reader = STEPControl_Reader()
+    if reader.ReadFile(str(path)) != IFSelect_ReturnStatus.IFSelect_RetDone:
+        raise ValueError(f"could not read STEP file {path!r}")
+    reader.TransferRoots()
+    return Compound(reader.OneShape())
+
+
 # ---------------------------------------------------------------------------
 # Geometry analysis
 # ---------------------------------------------------------------------------
@@ -188,6 +209,30 @@ def _fmt(v: float) -> str:
     return str(r) if abs(v - r) < 1e-6 else f"{v:.1f}"
 
 
+@functools.lru_cache(maxsize=512)
+def _text_width(text: str, font_size: float, font: str = "Arial") -> float:
+    """Measured rendered width (page-mm) of *text* in *font* at *font_size*.
+
+    Uses build123d's ``Text`` — the same primitive ``Dimension``/``HoleCallout``
+    stroke their labels with — so callout-width estimates use real glyph metrics
+    instead of a character-count fudge (#31).  Cached because the same numeric
+    labels recur across holes and the rasterisation is the costly part.
+    """
+    if not text:
+        return 0.0
+    return (
+        Text(
+            txt=text,
+            font_size=font_size,
+            font=font,
+            align=(Align.CENTER, Align.CENTER),
+            mode=Mode.PRIVATE,
+        )
+        .bounding_box()
+        .size.X
+    )
+
+
 _DIAM_RE = re.compile(r"[øØ⌀]\s*(\d+(?:\.\d+)?)")
 
 # Turned-part classification (#81): a rotational part's bounding box is
@@ -252,9 +297,14 @@ def _concentric_bore_diams(a) -> list:
     return [d for d in a.z_diams if d != a.od_diam and any(abs(d - c) <= 0.15 for c in concentric)]
 
 
-def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None) -> list:
+def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None, exclude=None) -> list:
     """Coarse completeness check: report part diameters with no callout (#80).
 
+    ``exclude`` is an optional iterable of diameters already accounted for by a
+    more specific build-time lint (e.g. the per-view callout cap's
+    ``callout_dropped``); these are skipped here so a dropped callout is not
+    double-reported as ``feature_not_dimensioned``.
+
     Builds a feature inventory from *part*'s hole/boss diameters (cylinder
     patches spanning at least ~half a turn around their axis in total, so
     fillets are ignored) and diffs it against every ø value mentioned in the
@@ -294,6 +344,7 @@ def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None) -> li
             mentioned.add(float(v))
             provided[float(v)] = provided.get(float(v), 0) + count
 
+    exclude = exclude or ()
     issues = [
         LintIssue(
             severity="warning",
@@ -302,6 +353,7 @@ def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None) -> li
         )
         for d in inventory
         if not any(abs(d - v) <= tol for v in mentioned)
+        and not any(abs(d - e) <= tol for e in exclude)
     ]
 
     required: dict[float, int] = {}
@@ -326,6 +378,30 @@ def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None) -> li
     return issues
 
 
+# --- lint scoring (see Drawing.lint_summary) -------------------------------
+# Codes that check standards/geometry correctness rather than pure page
+# layout. Grouped so a caller (and the #30 repair loop) can tell a wrong
+# drawing from a merely tight one.
+_GEOMETRY_AWARE_CODES = frozenset(
+    {
+        "feature_not_dimensioned",
+        "feature_count_mismatch",
+        "missing_principal_dimension",
+        "label_vs_measured",
+        "dim_inside_part",
+        "callout_dropped",
+        "location_ref_dropped",
+        "placement_unsatisfiable",
+    }
+)
+
+# Coarse 0–1 quality heuristic: a clean sheet scores 1.0; each issue subtracts
+# a flat per-severity penalty (clamped at 0). A convenience signal only — the
+# severity/code counts in the summary are the authoritative output.
+_SCORE_ERROR_PENALTY = 0.2
+_SCORE_WARNING_PENALTY = 0.05
+
+
 def analyse_face_levels(part, tol: float = 0.5) -> list:
     """Return sorted unique Z-coords of horizontal (normal≈±Z) planar faces.
 
@@ -501,14 +577,37 @@ def _parse_page(page) -> tuple:
 _STRIP_GAP = 8.0
 _STRIP_SPACING = 4.0
 
+# Horizontal page budget to reserve for the isometric view during scale
+# selection and view placement, as a fraction of bbox_max * scale.  This is a
+# deliberate *under-estimate*, not the true projected size (a cube's iso
+# projection is ~1.63*bbox_max wide): the iso is the last column and is fitted
+# to the actual largest-empty-rect afterwards by _fit_iso_view(), which shrinks
+# it to whatever space is genuinely left.  A true fit test here is circular —
+# the empty rect depends on the very view positions this estimate feeds — so
+# the budget stays a single, named factor rather than a recomputed fit (#31).
+_ISO_WIDTH_BUDGET = 0.7
+
 # Slot sizes for the annotations that allocate from fv/pv/sv strips.
 # Shared between the depth estimators below and the allocate() call-sites in
 # _auto_annotate() so that a slot-size change is automatically reflected in
 # the estimator-driven corridor widths.
-_SLOT_DIM_HEIGHT = 10.0  # fv_zones.right: overall height dimension
-_SLOT_DIM_STEP = 14.0  # fv_zones.right: step-height dimension
-_SLOT_DIM_WIDTH = 8.0  # pv_zones.below: overall width dimension
-_SLOT_DIM_DEPTH = 8.0  # sv_zones.below: overall depth dimension
+#
+# A slot is the perpendicular depth (page-mm) reserved for one Dimension: its
+# dim-line offset from the view edge plus the label, which sits exactly
+# pad_around_text beyond the line (measured: a "right"/"below" Dimension's
+# perpendicular span equals offset + pad_around_text - extension_gap, and
+# pad == extension_gap in the draft preset).  Each slot is therefore derived
+# from text metrics (font_size + pad_around_text), like _MIN_STEP_DIM_MM, so it
+# rescales with _FONT_SIZE instead of being a bare mm guess (#31).
+_PAD = draft_preset(font_size=_FONT_SIZE, decimal_precision=1).pad_around_text
+# Single overall dim: two glyph-heights of line offset + the outboard label pad.
+_SLOT_DIM_WIDTH = 2 * _FONT_SIZE + _PAD  # pv_zones.below: overall width dimension
+_SLOT_DIM_DEPTH = 2 * _FONT_SIZE + _PAD  # sv_zones.below: overall depth dimension
+# The overall height dim leads the right ladder, so it carries an extra pad of
+# clearance from the view above the first step dim's witness.
+_SLOT_DIM_HEIGHT = 2 * _FONT_SIZE + 2 * _PAD  # fv_zones.right: overall height dim
+# Stacked step dims sit deeper so each ladder rung's label clears the rung below.
+_SLOT_DIM_STEP = 4 * _FONT_SIZE + _PAD  # fv_zones.right: step-height dimension
 
 # Smallest projected step height (page-mm) that can still carry a *legible*
 # stacked dimension between its two extension lines.  Derived from what has to
@@ -536,12 +635,11 @@ _MIN_STEP_DIM_MM = (
 def _est_right_strip_depth(n_steps: int) -> float:
     """Depth needed to the right of the front view.
 
-    Always includes dim_height (1 slot).  Up to *n_steps* dim_step slots
-    (capped at 3) follow if any step levels are present.  Returns the minimum
-    corridor width (from view edge to outer_limit) that makes all those
-    allocations succeed.
+    Always includes dim_height (1 slot).  *n_steps* dim_step slots follow if
+    any step levels are present.  Returns the minimum corridor width (from view
+    edge to outer_limit) that makes all those allocations succeed.
     """
-    n = 1 + min(max(n_steps, 0), 3)  # dim_height + up to 3 step dims
+    n = 1 + max(n_steps, 0)  # dim_height + one slot per step dim
     # gap + dim_height + (n-1) step slots each preceded by one spacing
     return _STRIP_GAP + _SLOT_DIM_HEIGHT + (n - 1) * (_STRIP_SPACING + _SLOT_DIM_STEP)
 
@@ -597,10 +695,13 @@ def _est_bore_callout_width(
                 bc_by_spec[_spec_key(p.holes[0])] = p
 
     h_fs = font_size
+    # gap (inter-token spacing) and sym_w (geometry-symbol cell width) mirror
+    # HoleCallout's own internal layout constants so the estimate matches what
+    # the primitive actually strokes.  Variable text tokens are measured with
+    # real glyph metrics (_text_width) rather than a character-count fudge (#31).
     gap = 0.45 * h_fs
     sym_w = h_fs
     pad = pad_around_text
-    char_w = 0.6 * h_fs  # avg character width
 
     max_w = 0.0
     for spec_key, group in groups.items():
@@ -611,26 +712,26 @@ def _est_bore_callout_width(
 
         token_w: list[float] = []
         if count:
-            token_w.append(len(f"{count}×") * char_w)
+            token_w.append(_text_width(f"{count}×", h_fs))
         token_w.append(sym_w)  # ⌀ symbol
-        token_w.append(len(_fmt(rep.diameter)) * char_w)
+        token_w.append(_text_width(_fmt(rep.diameter), h_fs))
         if through:
-            token_w.append(len("THRU") * char_w)
+            token_w.append(_text_width("THRU", h_fs))
         elif rep.depth:
             token_w.append(sym_w)  # depth symbol
-            token_w.append(len(_fmt(rep.depth)) * char_w)
+            token_w.append(_text_width(_fmt(rep.depth), h_fs))
         if step:
             token_w.append(sym_w)  # counterbore/spotface symbol
             token_w.append(sym_w)  # ⌀
-            token_w.append(len(_fmt(step.diameter)) * char_w)
+            token_w.append(_text_width(_fmt(step.diameter), h_fs))
             if step.depth:
                 token_w.append(sym_w)  # depth symbol
-                token_w.append(len(_fmt(step.depth)) * char_w)
+                token_w.append(_text_width(_fmt(step.depth), h_fs))
 
         # BoltCircle suffix: "EQ SP ON ø{bc_dia} BC"
         bc = bc_by_spec.get(spec_key)
         if bc is not None:
-            token_w.append(len(f"EQ SP ON ø{_fmt(bc.diameter)} BC") * char_w)
+            token_w.append(_text_width(f"EQ SP ON ø{_fmt(bc.diameter)} BC", h_fs))
 
         n = len(token_w)
         w = sum(token_w) + max(n - 1, 0) * gap + pad
@@ -705,7 +806,7 @@ def _fits(
         + gap_fv_sv
         + y_size * scale
         + _DIM_PAD
-        + bbox_max * scale * 0.7
+        + bbox_max * scale * _ISO_WIDTH_BUDGET
         + _DIM_PAD
         + tb_w
         + _MARGIN
@@ -840,7 +941,7 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
         part = step_file
         src = "build123d object"
     else:
-        part = import_step(step_file)
+        part = _import_step(step_file)
         src = str(step_file)
     # AP242 STEP files carry PMI presentation geometry (annotation-plane
     # border wires, leader curves) beside the solid; left in, it draws as
@@ -923,7 +1024,7 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
 
     # Conservative upper bound for page selection: count all candidate step
     # faces without the SCALE-dependent _MIN_STEP_DIM_MM gate (SCALE not yet known).
-    n_steps_ub = len(step_zs[:3])
+    n_steps_ub = len(step_zs)
     strips_ub = _measure_strips(
         holes,
         patterns,
@@ -954,7 +1055,7 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
     DIM_PAD = _DIM_PAD
     margin = _MARGIN
     # Refine: apply the same legibility gate _auto_annotate uses for dim_step.
-    n_steps = len([z for z in step_zs[:3] if (z - bb.min.Z) * SCALE >= _MIN_STEP_DIM_MM])
+    n_steps = len([z for z in step_zs if (z - bb.min.Z) * SCALE >= _MIN_STEP_DIM_MM])
     strips = _measure_strips(
         holes,
         patterns,
@@ -980,7 +1081,7 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
         + x_size * SCALE
         + y_size * SCALE
         + 2 * DIM_PAD
-        + bbox_max * SCALE * 0.7
+        + bbox_max * SCALE * _ISO_WIDTH_BUDGET
     )
     x_offset = max(0.0, (PAGE_W - 2 * margin - TB_W - total_content_w) / 2)
 
@@ -1220,6 +1321,14 @@ class Drawing:
         self.svg_path: str | None = None
         self.dxf_path: str | None = None
         self._analysis: SimpleNamespace | None = None
+        # Lint issues found while building (e.g. annotations the layout had to
+        # drop). Recorded here so :meth:`lint` can surface them — a dropped
+        # feature must never be silent. Diameters dropped by the per-view
+        # callout cap are tracked separately so :meth:`lint` can suppress the
+        # redundant feature_not_dimensioned for them. Both are reset at the
+        # top of :func:`_auto_annotate` so re-annotation does not accumulate.
+        self._build_issues: list = []
+        self._dropped_callout_diams: list = []
 
     # -- views ----------------------------------------------------------------
     def add_view(self, name, shape, camera, up, position, *, look_at=None, scaled=False):
@@ -1311,11 +1420,18 @@ class Drawing:
         self._named = kept_named
         return removed
 
+    def _record_build_issue(self, severity, code, message):
+        """Record a lint issue discovered during construction (e.g. an
+        annotation the layout had to drop). Surfaced by :meth:`lint` so a
+        dropped feature is never silent."""
+        self._build_issues.append(LintIssue(severity=severity, code=code, message=message))
+
     # -- output ---------------------------------------------------------------
     def lint(self):
         """Lint all annotations against all views; returns the list of issues.
 
         When :attr:`part` is set, also runs :func:`lint_feature_coverage`.
+        Build-time drops recorded via :meth:`_record_build_issue` are included.
         """
         set_page(self.page_w, self.page_h, margin=10)
         view_shapes = [vis for vis, _ in self.views.values()]
@@ -1323,9 +1439,59 @@ class Drawing:
         if self.part is not None:
             if self._cyl_cache is None:
                 self._cyl_cache = analyse_cylinders(self.part)
-            issues += lint_feature_coverage(self.part, self.annotations, cyls=self._cyl_cache)
+            issues += lint_feature_coverage(
+                self.part,
+                self.annotations,
+                cyls=self._cyl_cache,
+                exclude=self._dropped_callout_diams,
+            )
+        issues += list(self._build_issues)
         return issues
 
+    def lint_summary(self) -> dict:
+        """Aggregate :meth:`lint` into a JSON-friendly quality summary.
+
+        Gives a non-interactive caller (a script, or an LLM via the API) a
+        single signal to gate and optimise on without rendering the SVG:
+
+        - ``passed`` — no error-severity issues;
+        - ``score`` — coarse 0–1 quality heuristic (see ``_SCORE_*``);
+        - ``errors`` / ``warnings`` / ``infos`` — counts by severity;
+        - ``by_code`` — per-check counts;
+        - ``geometry_issues`` — count of standards/geometry-correctness issues
+          as opposed to pure layout (see ``_GEOMETRY_AWARE_CODES``);
+        - ``issues`` — the full list, each as a plain dict.
+        """
+        issues = self.lint()
+        errors = sum(1 for i in issues if i.severity == "error")
+        warnings = sum(1 for i in issues if i.severity == "warning")
+        infos = sum(1 for i in issues if i.severity == "info")
+        by_code: dict[str, int] = {}
+        for i in issues:
+            by_code[i.code] = by_code.get(i.code, 0) + 1
+        score = max(
+            0.0,
+            1.0 - errors * _SCORE_ERROR_PENALTY - warnings * _SCORE_WARNING_PENALTY,
+        )
+        return {
+            "passed": errors == 0,
+            "score": score,
+            "errors": errors,
+            "warnings": warnings,
+            "infos": infos,
+            "by_code": by_code,
+            "geometry_issues": sum(1 for i in issues if i.code in _GEOMETRY_AWARE_CODES),
+            "issues": [
+                {
+                    "severity": i.severity,
+                    "code": i.code,
+                    "message": i.message,
+                    "location": i.location,
+                }
+                for i in issues
+            ],
+        }
+
     def export(self, out=None):
         """Lint, then write SVG and DXF. Returns ``(svg_path, dxf_path)``."""
         out = out if out is not None else self.out
@@ -1464,6 +1630,10 @@ def _export_shape(exporter, shape, layer, ctx):
 def _auto_annotate(dwg, a):
     """Add the standard automatic dimensions, centrelines, and title block."""
     draft = dwg.draft
+    # Idempotent: clear build-time lint state so a second annotation pass does
+    # not accumulate duplicate drop records.
+    dwg._build_issues = []
+    dwg._dropped_callout_diams = []
 
     def FX(x):
         return a.FV_X + (x - a.cx) * a.SCALE
@@ -1644,13 +1814,24 @@ def _auto_annotate(dwg, a):
 
     # Step heights — only where the step is tall enough to fit a label;
     # each step witnesses from the previous dim's line (_right_ladder) so
-    # extension lines are adjacent rather than coincident
-    for col, z in enumerate(
-        [z for z in a.step_zs[:3] if (z - a.bb.min.Z) * a.SCALE >= _MIN_STEP_DIM_MM]
-    ):
+    # extension lines are adjacent rather than coincident. No fixed cap: the
+    # fv_zones.right corridor is sized for every legible step (#36), and the
+    # strip allocator is the real bound — a step that doesn't fit surfaces via
+    # lint rather than being silently dropped.
+    def _step_legible(z):
+        return (z - a.bb.min.Z) * a.SCALE >= _MIN_STEP_DIM_MM
+
+    _step_zs = [z for z in a.step_zs if _step_legible(z)]
+    for col, z in enumerate(_step_zs):
         _px = a.fv_zones.right.allocate(_SLOT_DIM_STEP)
         if _px is None:
             _log.warning("dim_step_%d skipped: fv_zones.right strip full", col)
+            dwg._record_build_issue(
+                "error",
+                "placement_unsatisfiable",
+                f"{len(_step_zs) - col} step-height dimension(s) dropped "
+                "(front-view right strip full)",
+            )
             break
         dwg.add(
             Dimension(
@@ -2111,10 +2292,20 @@ def _annotate_pmi(dwg, a, draft) -> None:
     _log.info("PMI annotate: %d/%d dims placed", emitted, len(usable))
 
 
-_MAX_CALLOUTS_PER_VIEW = 4
+def _record_callout_drop(dwg, view, diam, reason):
+    """Record a hole callout the layout could not place (#36).
 
-
-_MAX_LOCATION_REFS = 4
+    A warning (the drawing is incomplete, not invalid), whose diameter is
+    excluded from ``feature_not_dimensioned`` like the old per-view cap drop —
+    so a callout that genuinely doesn't fit is surfaced once, with a reason,
+    and not double-reported.
+    """
+    dwg._dropped_callout_diams.append(diam)
+    dwg._record_build_issue(
+        "warning",
+        "callout_dropped",
+        f"hole callout ø{_fmt(diam)} dropped from the {view} view ({reason})",
+    )
 
 
 def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
@@ -2123,11 +2314,13 @@ def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
     The datum corner is a *default* — the part's minimum-X/minimum-Y corner
     (lower-left in the plan view), per inspection practice; a human/LLM pass
     can re-anchor it. One reference per pattern (bolt-circle centre, array
-    first hole) plus each unpatterned hole, capped at
-    ``_MAX_LOCATION_REFS`` (largest holes first, the rest logged). X dims
-    tier above the plan view (below sit dim_width and the front view),
-    Y dims tier to its left; a tier that would leave the page is skipped,
-    never force-placed. Cross-axis holes are not located yet (logged).
+    first hole) plus each unpatterned hole. There is no fixed cap: dims are
+    placed nearest-datum-first (baseline practice) until the above-view tier
+    strips fill — a tier that would leave the page is skipped, never
+    force-placed, and the unplaced ref surfaces as ``location_ref_dropped``
+    (#36). X dims tier above the plan view (below sit dim_width and the front
+    view), Y dims tier above the side view. Cross-axis holes are not located
+    yet (logged).
     """
     draft = dwg.draft
     all_holes = a.holes if holes_in is None else holes_in
@@ -2160,14 +2353,6 @@ def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
     refs = unique
     if not refs:
         return
-    if len(refs) > _MAX_LOCATION_REFS:
-        refs.sort(key=lambda r: r[2], reverse=True)
-        _log.info(
-            "%d location references; dimensioning the %d largest",
-            len(refs),
-            _MAX_LOCATION_REFS,
-        )
-        refs = refs[:_MAX_LOCATION_REFS]
 
     def PX(x):
         return a.PV_X + (x - a.cx) * a.SCALE
@@ -2194,6 +2379,11 @@ def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
         _py = a.pv_zones.above.allocate(tier)
         if _py is None:
             _log.info("X location dim for x=%s skipped (no room above plan view)", _fmt(rx))
+            dwg._record_build_issue(
+                "warning",
+                "location_ref_dropped",
+                f"X location dim for x={_fmt(rx)} not placed (no room above the plan view)",
+            )
             continue
         dwg.add(
             Dimension(
@@ -2249,6 +2439,11 @@ def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
         _py = a.sv_zones.above.allocate(tier)
         if _py is None:
             _log.info("Y location dim for y=%s skipped (no room above the side view)", _fmt(ry))
+            dwg._record_build_issue(
+                "warning",
+                "location_ref_dropped",
+                f"Y location dim for y={_fmt(ry)} not placed (no room above the side view)",
+            )
             continue
         dwg.add(
             Dimension(
@@ -2652,7 +2847,11 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
     """
     draft = dwg.draft
     gap = draft.pad_around_text
-    min_gap = draft.font_size * 2.2
+    # Minimum vertical separation between stacked bore-callout labels: one label
+    # height (font_size) plus pad_around_text clearance above and below, so
+    # adjacent labels never touch.  Derived from text metrics rather than a bare
+    # font-size ratio (#31).
+    min_gap = draft.font_size + 2 * gap
     # Group on the same machining-spec key pattern detection uses (snapped
     # axis vector included): blind holes drilled from opposite faces are
     # different operations and get separate callouts, and a spec group's
@@ -2739,19 +2938,12 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
         for holes in view_groups:
             pattern = patterns.get(frozenset(holes))
             specs.append((holes, _build_callout(holes, pattern), pattern))
-        if len(specs) > _MAX_CALLOUTS_PER_VIEW:
-            # annotate the largest features; the rest surface via the lint
-            # (their pattern furniture is withheld too — a bare pitch circle
-            # with no callout referencing it explains nothing)
-            specs.sort(key=lambda s: s[0][0].diameter, reverse=True)
-            _log.info(
-                "%d hole specs in %s view; annotating the %d largest "
-                "(the rest surface as feature_not_dimensioned)",
-                len(specs),
-                view,
-                _MAX_CALLOUTS_PER_VIEW,
-            )
-            specs = specs[:_MAX_CALLOUTS_PER_VIEW]
+        # No fixed cap (#36): every spec is attempted; the per-view placement
+        # bounds below (front-view shaft rows, plan/side strip Y-solver) are the
+        # real limit, and any callout that genuinely doesn't fit surfaces as
+        # callout_dropped. Largest diameters first so the most significant
+        # features win the available room.
+        specs.sort(key=lambda s: s[0][0].diameter, reverse=True)
 
         if view == "front":
             # Below the view, vertical shafts. Rows are assigned right-to-
@@ -2769,6 +2961,7 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
                     side, x0, x1 = "left", centre[0] - gap - w, centre[0] - gap
                 else:
                     _log.info("Hole callout ø%s skipped (no room)", _fmt(holes[0].diameter))
+                    _record_callout_drop(dwg, view, holes[0].diameter, "no room beside the view")
                     continue
                 # the title block only constrains rows that reach its x-range
                 floor = (tb_top + 4) if x1 > tb_left - 4 else a.margin + 4
@@ -2776,6 +2969,7 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
                     _log.info(
                         "Hole callout ø%s skipped (front strip full)", _fmt(holes[0].diameter)
                     )
+                    _record_callout_drop(dwg, view, holes[0].diameter, "front strip full")
                     continue
                 if any(
                     ox0 <= centre[0] <= ox1 and row_y > elbow_y for ox0, ox1, row_y in occupied
@@ -2784,6 +2978,9 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
                         "Hole callout ø%s skipped (shaft would cross another callout)",
                         _fmt(holes[0].diameter),
                     )
+                    _record_callout_drop(
+                        dwg, view, holes[0].diameter, "shaft would cross another callout"
+                    )
                     continue
                 elbow = (centre[0], elbow_y)
                 occupied.append((x0, x1, elbow_y))
@@ -2843,6 +3040,7 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
 
             if not can_right and not can_left:
                 _log.info("Hole callout ø%s skipped (no room)", _fmt(holes[0].diameter))
+                _record_callout_drop(dwg, view, holes[0].diameter, "no room beside the view")
                 continue
 
             if can_right and (not can_left or d_right <= d_left):
@@ -2869,6 +3067,8 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
                     n_drop,
                     len(right_queue),
                 )
+                for holes, *_ in right_queue[len(right_ys) :]:
+                    _record_callout_drop(dwg, view, holes[0].diameter, "right strip full")
             right_queue = right_queue[: len(right_ys)]
         if left_ys is None and left_queue:
             left_ys = _greedy_strip_ys(
@@ -2881,6 +3081,8 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=
                     n_drop,
                     len(left_queue),
                 )
+                for holes, *_ in left_queue[len(left_ys) :]:
+                    _record_callout_drop(dwg, view, holes[0].diameter, "left strip full")
             left_queue = left_queue[: len(left_ys)]
 
         for i, ((holes, callout, pattern, _, rep), elbow_y) in enumerate(
@@ -2922,9 +3124,6 @@ def _add_title_block(dwg, a):
     dwg.add(tb, "title_block")
 
 
-_ISO_SHRINK_FACTORS = (0.5, 0.2, 0.1)
-
-
 def _iso_bbox(dwg):
     """(min_x, min_y, max_x, max_y) of the placed iso view, hidden lines included."""
     vis, hid = dwg.views["iso"]

{draftwright-0.1.6 → draftwright-0.1.7}/tests/test_e2e_standards.py

@@ -91,15 +91,15 @@ def test_e2e_from_step_meets_standards(tmp_path):
 
 # ---------------------------------------------------------------------------
 # NIST MBE PMI Combined Test Cases (CTC), public-domain models.
-# All 10 variants ship as fixtures. CTC-04 used to abort in the section-view
-# boolean cut; the fuzzy cut (_fuzzy_cut, #20) fixed that, so it now builds.
-# CTC-02 AP242 still segfaults inside OCCT's AP242/PMI STEP read (#20) — a
-# segfault would kill the whole test run, so it stays excluded.
+# All 10 variants ship as fixtures and now build. Two #20 fixes got them there:
+# the fuzzy section cut (_fuzzy_cut) unblocked CTC-04, and the direct
+# STEPControl_Reader importer (_import_step) avoids the XCAF/PMI segfault that
+# build123d's import_step hit on CTC-02 AP242.
 # ---------------------------------------------------------------------------
 
 FIXTURES = Path(__file__).parent / "fixtures"
-_CTC_AP203_OK = ["01", "02", "03", "04", "05"]  # all build (#20 section-cut fix)
-_CTC_AP242_OK = ["01", "03", "04", "05"]  # 02 segfaults in OCCT STEP+PMI read (#20)
+_CTC_AP203_OK = ["01", "02", "03", "04", "05"]
+_CTC_AP242_OK = ["01", "02", "03", "04", "05"]
 
 
 @pytest.mark.slow

{draftwright-0.1.6 → draftwright-0.1.7}/tests/test_make_drawing.py

@@ -533,11 +533,18 @@ class TestDepthEstimators:
         # dim_height (10) + 3×dim_step (14 each) + 3×spacing (4 each) = 8+10+4+14+4+14+4+14 = 72
         assert _est_right_strip_depth(3) == pytest.approx(72.0, abs=0.01)
 
-    def test_right_depth_capped_at_three_steps(self):
-        from draftwright.make_drawing import _est_right_strip_depth
+    def test_right_depth_grows_per_step_uncapped(self):
+        from draftwright.make_drawing import (
+            _SLOT_DIM_STEP,
+            _STRIP_SPACING,
+            _est_right_strip_depth,
+        )
 
-        # n_steps is capped at 3 in the estimator
-        assert _est_right_strip_depth(3) == _est_right_strip_depth(10)
+        # #36: no cap — each further step adds one slot + one spacing.
+        assert _est_right_strip_depth(10) > _est_right_strip_depth(3)
+        assert _est_right_strip_depth(10) - _est_right_strip_depth(3) == pytest.approx(
+            7 * (_STRIP_SPACING + _SLOT_DIM_STEP), abs=0.01
+        )
 
     def test_right_depth_increases_with_steps(self):
         from draftwright.make_drawing import _est_right_strip_depth
@@ -586,6 +593,54 @@ class TestDepthEstimators:
         assert s.allocate(_SLOT_DIM_WIDTH) is not None, "dim_width must fit in pv_below corridor"
 
 
+# ---------------------------------------------------------------------------
+# #31: layout constants derived from text metrics
+# ---------------------------------------------------------------------------
+
+
+class TestDerivedLayoutConstants:
+    """Slots / callout widths / iso budget derive from text metrics, not bare mm."""
+
+    def test_slots_derive_from_font_metrics(self):
+        from draftwright.make_drawing import (
+            _FONT_SIZE,
+            _PAD,
+            _SLOT_DIM_DEPTH,
+            _SLOT_DIM_HEIGHT,
+            _SLOT_DIM_STEP,
+            _SLOT_DIM_WIDTH,
+        )
+
+        assert _SLOT_DIM_WIDTH == pytest.approx(2 * _FONT_SIZE + _PAD)
+        assert _SLOT_DIM_DEPTH == pytest.approx(2 * _FONT_SIZE + _PAD)
+        assert _SLOT_DIM_HEIGHT == pytest.approx(2 * _FONT_SIZE + 2 * _PAD)
+        assert _SLOT_DIM_STEP == pytest.approx(4 * _FONT_SIZE + _PAD)
+        # The slots are linear in font metrics — a hypothetical larger font
+        # would yield larger slots — so they are not frozen mm constants.
+        assert (2 * (2 * _FONT_SIZE) + 2 * _PAD) > _SLOT_DIM_HEIGHT
+
+    def test_text_width_returns_real_glyph_metrics(self):
+        from draftwright.make_drawing import _text_width
+
+        assert _text_width("", 3.0) == 0.0
+        # A real measurement is positive and grows with the string.
+        w1 = _text_width("8", 3.0)
+        w3 = _text_width("888", 3.0)
+        assert 0.0 < w1 < w3
+        # Wider glyphs (uppercase) measure wider than the old 0.6*font fudge
+        # would have estimated — the whole point of using real metrics (#31).
+        assert _text_width("THRU", 3.0) > 4 * 0.6 * 3.0
+
+    def test_bore_callout_width_scales_with_font_size(self):
+        from draftwright.make_drawing import _est_bore_callout_width, find_holes
+
+        part = Box(60, 40, 12) - Pos(0, 0, 6) * Cylinder(3, 12)
+        holes = find_holes(part)
+        small = _est_bore_callout_width(holes, font_size=3.0)
+        large = _est_bore_callout_width(holes, font_size=6.0)
+        assert large > small
+
+
 # ---------------------------------------------------------------------------
 # Phase 3 (#118): dynamic FV→SV corridor
 # ---------------------------------------------------------------------------
@@ -1633,7 +1688,10 @@ class TestAutoHoleAnnotations:
         assert [i for i in dwg.lint() if i.severity != "info"] == []
 
     @pytest.mark.timeout(60)
-    def test_callout_cap_keeps_the_largest_holes(self):
+    def test_all_distinct_bores_get_callouts(self):
+        # #36: no per-view callout cap — six distinct-diameter holes in a row
+        # all get callouts (previously capped at the four largest), and nothing
+        # is dropped because they fit.
         part = Box(120, 80, 10)
         for i, r in enumerate([1, 1.5, 2, 2.5, 3, 4]):
             part = part - Pos(-50 + i * 20, 0, 0) * Cylinder(r, 10)
@@ -1642,10 +1700,8 @@ class TestAutoHoleAnnotations:
         for name, ann in dwg._named.items():
             if name.startswith("hc_"):
                 covered.update(ann.covers_diameters)
-        assert covered == {4.0, 5.0, 6.0, 8.0}
-        # the dropped specs surface through the coverage lint by design
-        flagged = {i.message for i in dwg.lint() if i.code == "feature_not_dimensioned"}
-        assert len(flagged) == 2
+        assert covered == {2.0, 3.0, 4.0, 5.0, 6.0, 8.0}
+        assert "callout_dropped" not in {i.code for i in dwg.lint()}
 
     @pytest.mark.timeout(60)
     def test_rotational_part_keeps_leader_annotations(self):
@@ -2254,3 +2310,250 @@ class TestSanitizeSvgArcs:
         n = sanitize_svg_arcs(f)
         assert n == 0
         assert "A 5.0 5.0 0 0 1 20 20" in Path(f).read_text(encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Lint summary + surfacing of build-time annotation drops (#32)
+# ---------------------------------------------------------------------------
+
+
+class TestLintSummaryAndDrops:
+    def test_summary_shape_is_consistent_with_lint(self):
+        from build123d import Box, Cylinder
+
+        from draftwright import build_drawing
+
+        dwg = build_drawing(Box(80, 60, 20) - Cylinder(5, 20))
+        issues = dwg.lint()
+        s = dwg.lint_summary()
+
+        assert set(s) == {
+            "passed",
+            "score",
+            "errors",
+            "warnings",
+            "infos",
+            "by_code",
+            "geometry_issues",
+            "issues",
+        }
+        assert s["errors"] + s["warnings"] + s["infos"] == len(issues)
+        assert s["passed"] is (s["errors"] == 0)
+        assert 0.0 <= s["score"] <= 1.0
+        assert sum(s["by_code"].values()) == len(issues)
+        assert len(s["issues"]) == len(issues)
+        # A single-hole plate doesn't overflow the per-view callout cap.
+        assert "callout_dropped" not in s["by_code"]
+
+    def test_recorded_build_issue_surfaces_and_counts(self):
+        from build123d import Box
+
+        from draftwright import build_drawing
+
+        dwg = build_drawing(Box(60, 40, 30))
+        before = dwg.lint_summary()
+        dwg._record_build_issue("warning", "callout_dropped", "synthetic drop")
+
+        codes = {i.code for i in dwg.lint()}
+        assert "callout_dropped" in codes
+
+        after = dwg.lint_summary()
+        assert after["warnings"] == before["warnings"] + 1
+        assert after["by_code"]["callout_dropped"] == 1
+        # callout_dropped is a geometry-aware code, so it lifts that count too.
+        assert after["geometry_issues"] == before["geometry_issues"] + 1
+
+    def test_dropped_callout_diameter_excluded_from_feature_lint(self):
+        # The de-dup contract: a diameter recorded as a dropped callout is
+        # excluded from feature_not_dimensioned, so a callout the layout could
+        # not place (#36) is surfaced once (as callout_dropped) and not
+        # double-reported.
+        from build123d import Box, Cylinder
+
+        from draftwright.make_drawing import lint_feature_coverage
+
+        part = Box(60, 40, 20) - Cylinder(5, 20)  # one undimensioned ø10 bore
+        base = lint_feature_coverage(part, [])
+        assert any(i.code == "feature_not_dimensioned" for i in base)
+        excluded = lint_feature_coverage(part, [], exclude=[10.0])
+        assert not any(i.code == "feature_not_dimensioned" for i in excluded)
+
+    @pytest.mark.timeout(120)
+    def test_step_dims_are_adaptive_not_capped(self):
+        # #36: no fixed 3-step cap. Five stacked ledges → a step dim for each
+        # legible ledge (well over the old cap of three), corridor sized to fit
+        # them all, no error-severity lint.
+        from build123d import Box, Pos
+
+        from draftwright import build_drawing
+
+        tower = Box(120, 120, 15)
+        for i in range(1, 6):
+            side = 120 - i * 18
+            tower += Pos(0, 0, i * 15) * Box(side, side, 15)
+        dwg = build_drawing(tower)
+        n_steps = len([n for n in dwg._named if n.startswith("dim_step")])
+        assert n_steps > 3, f"expected adaptive >3 step dims, got {n_steps}"
+        assert [i for i in dwg.lint() if i.severity == "error"] == []
+
+    @pytest.mark.timeout(120)
+    def test_location_dims_are_adaptive_not_capped(self):
+        # #36: location dims have no fixed cap. Six scattered holes (distinct X
+        # and Y, varied diameters so no array collapses them) get far more than
+        # the old cap of four location dims, with nothing dropped — they fit.
+        from build123d import Box, Cylinder, Pos
+
+        from draftwright import build_drawing
+
+        plate = Box(140, 90, 8)
+        for x, y, r in [
+            (-55, -35, 2.0),
+            (-33, -12, 2.5),
+            (-11, 15, 3.0),
+            (12, -20, 3.5),
+            (34, 28, 2.0),
+            (55, 5, 2.5),
+        ]:
+            plate -= Pos(x, y, 0) * Cylinder(r, 8)
+        dwg = build_drawing(plate)
+        n_loc = len([n for n in dwg._named if n.startswith(("dim_locx", "dim_locy"))])
+        assert n_loc > 4, f"expected adaptive >4 location dims, got {n_loc}"
+        assert "location_ref_dropped" not in {i.code for i in dwg.lint()}
+
+    @pytest.mark.timeout(120)
+    def test_auto_annotate_clears_stale_build_issues(self):
+        # Re-annotating starts build-time lint tracking from a clean slate:
+        # stale drop records from a prior pass are cleared, not accumulated.
+        # (A full second pass is not idempotent — strip cursors advance — but
+        # the records always reflect only the latest pass.)
+        from build123d import Box
+
+        from draftwright import build_drawing
+        from draftwright.make_drawing import _auto_annotate
+
+        dwg = build_drawing(Box(60, 40, 30))
+        dwg._record_build_issue("warning", "callout_dropped", "stale")
+        assert any(i.message == "stale" for i in dwg._build_issues)
+        _auto_annotate(dwg, dwg._analysis)
+        assert not any(i.message == "stale" for i in dwg._build_issues)
+        assert dwg._dropped_callout_diams == []
+
+    def test_repeated_lint_is_stable(self):
+        # lint()/lint_summary() are idempotent — repeated calls return the same
+        # issues and never accumulate the build-time drop records.
+        from build123d import Box, Cylinder, Pos
+
+        from draftwright import build_drawing
+
+        plate = Box(120, 60, 8)
+        for x, r in zip((-48, -24, 0, 24, 48), (2.0, 2.5, 3.0, 3.5, 4.0)):
+            plate -= Pos(x, 0, 0) * Cylinder(r, 8)
+        dwg = build_drawing(plate)
+        first, second = dwg.lint(), dwg.lint()
+        assert len(first) == len(second)
+        assert dwg.lint_summary()["by_code"] == dwg.lint_summary()["by_code"]
+
+    def test_placement_unsatisfiable_is_error_severity(self):
+        # placement_unsatisfiable (engine could not place a wanted annotation)
+        # is error-severity, so it fails the `passed` gate.
+        from build123d import Box
+
+        from draftwright import build_drawing
+
+        dwg = build_drawing(Box(60, 40, 30))
+        assert dwg.lint_summary()["passed"] is True
+        dwg._record_build_issue("error", "placement_unsatisfiable", "synthetic")
+        s = dwg.lint_summary()
+        assert s["passed"] is False
+        assert s["errors"] >= 1
+        assert s["by_code"]["placement_unsatisfiable"] == 1
+
+
+# ---------------------------------------------------------------------------
+# Layout generalisation guards (#13) — pin the *general* behaviour the
+# algorithm should have on turned/hybrid parts and at the step-legibility
+# boundary, so the overfitting that #10–#12/#31 removed cannot creep back.
+# ---------------------------------------------------------------------------
+
+
+class TestLayoutGeneralisation:
+    @pytest.mark.timeout(120)
+    def test_turned_flange_gets_both_od_and_hole_furniture(self):
+        # A turned-and-drilled flange (cylinder OD + centre bore + bolt circle)
+        # must get the turned base set (OD dim + centrelines) AND the drilled
+        # furniture (hole callout + pitch circle) — not one or the other. This
+        # is the feature-presence composition from #10, on a genuinely
+        # rotational part rather than a prismatic plate.
+        import math
+
+        from build123d import Cylinder, Pos
+
+        from draftwright import build_drawing
+
+        flange = Cylinder(radius=40, height=10) - Cylinder(radius=8, height=10)
+        for i in range(6):
+            ang = math.radians(60 * i)
+            flange -= Pos(28 * math.cos(ang), 28 * math.sin(ang), 0) * Cylinder(2.5, 10)
+        dwg = build_drawing(flange)
+
+        assert dwg._analysis.is_rotational, "flange should classify as rotational"
+        # Turned base set.
+        assert "dim_od" in dwg._named
+        assert "centerline_front" in dwg._named
+        assert "centerline_side" in dwg._named
+        # Drilled furniture.
+        assert any(n.startswith("hc_") for n in dwg._named), "expected a hole callout"
+        assert any(n.startswith("bc_") for n in dwg._named), "expected a pitch circle"
+        # No error-severity lint (warnings tolerated).
+        assert [i for i in dwg.lint() if i.severity == "error"] == []
+
+    @pytest.mark.timeout(120)
+    def test_turned_flange_dimensions_all_its_bores(self):
+        # #36: no per-view callout cap — a turned part with five distinct bores
+        # gets a callout for every one (was capped at four largest), more than
+        # the old cap, with nothing dropped because they fit.
+        import math
+
+        from build123d import Cylinder, Pos
+
+        from draftwright import build_drawing
+
+        flange = Cylinder(radius=45, height=10) - Cylinder(radius=8, height=10)
+        for i, r in enumerate((2.0, 2.5, 3.0, 3.5, 4.0)):
+            ang = math.radians(72 * i)
+            flange -= Pos(30 * math.cos(ang), 30 * math.sin(ang), 0) * Cylinder(r, 10)
+        dwg = build_drawing(flange)
+
+        n_callouts = len([n for n in dwg._named if n.startswith("hc_")])
+        assert n_callouts > 4, f"expected adaptive >4 callouts, got {n_callouts}"
+        assert "callout_dropped" not in {i.code for i in dwg.lint()}
+
+    @pytest.mark.timeout(120)
+    def test_step_height_legibility_threshold(self):
+        # The step-height dimension gate is the legibility constant
+        # (_MIN_STEP_DIM_MM), not an incidental cutoff: a shoulder whose
+        # page-projected height falls just below the gate gets no step dim;
+        # just above, it does. Pin the gate, not a magic millimetre value.
+        from build123d import Cylinder, Pos
+
+        from draftwright import build_drawing
+        from draftwright.make_drawing import _MIN_STEP_DIM_MM
+
+        def shaft_with_shoulder_at(length):
+            # Lower segment height == `length`; shoulder sits `length` above the
+            # base (bb.min.Z), so legibility = length * SCALE.
+            return Pos(0, 0, length / 2) * Cylinder(22, length) + Pos(
+                0, 0, length + 12.5
+            ) * Cylinder(11, 25)
+
+        for length, expect in ((12.0, False), (13.0, True)):
+            dwg = build_drawing(shaft_with_shoulder_at(length))
+            a = dwg._analysis
+            legible = length * a.SCALE >= _MIN_STEP_DIM_MM
+            assert legible is expect, (
+                f"length={length} scale={a.SCALE}: legibility expectation wrong"
+            )
+            has_step = "dim_step_0" in dwg._named
+            assert has_step is expect, (
+                f"length={length}: step dim present={has_step}, expected {expect}"
+            )

draftwright-0.1.6/CHANGELOG.md

@@ -1,77 +0,0 @@
-# Changelog
-
-## Unreleased
-
-## v0.1.5 — 2026-06-15
-
-### Fixed
-
-- CTC-02 spurious full-page line: build123d's `ExportSVG` projected
-  circle-edge-on edges (hole/fillet rims seen edge-on) as elliptical arcs with
-  a near-zero minor radius, which renderers blow up into full-page lines.
-  `sanitize_svg_arcs()` rewrites any arc with a sub-1e-3 mm radius into the
-  straight line it actually is, leaving real arcs untouched (#19). Not a PMI
-  issue — the file is AP203 geometry-only.
-
-### Tests
-
-- Added the full NIST CTC set (01–05) as fixtures, both AP203 geometry-only and
-  AP242 (with-PMI) variants.
-- Heavy end-to-end CTC fixture builds are marked `slow` and deselected from the
-  default `pytest` run (fast normal run, ~4.5 min); CI runs the fast tier across
-  the OS/Python matrix and the slow tier once.
-- Known: AP242 CTC-02 and both CTC-04 variants crash OCCT on import (#20); their
-  fixtures are excluded from build tests.
-
-## v0.1.4 — 2026-06-15
-
-### Changed
-
-- Feature annotations (hole callouts, location dimensions, section view) now
-  fire on feature presence independent of the turned/prismatic classification,
-  so turned-and-drilled parts (e.g. flanges) get both the OD/centreline base
-  set and per-hole callouts plus bolt-circle furniture (#10).
-- Isometric view placement now uses a general largest-empty-rectangle search in
-  place of the wide/flat-on-A3 special case (#11).
-- Concentric bore-leader stacking is generalised beyond three, and the
-  step-height dimension gate is now a single derived constant (#10, #12).
-
-### Internal
-
-- Single-sourced duplicated geometry constants from the draft preset (#12).
-- Minor comment and logging cleanups.
-
-## v0.1.0 — 2026-06-14
-
-Initial release — spun out of `build123d-drafting-helpers` v0.9.1.
-
-The automated drawing engine (`make_drawing`, `build_drawing`, `Drawing`)
-was previously part of `build123d-drafting-helpers`. It is now a separate
-AGPL-licensed package that depends on `build123d-drafting-helpers>=0.9.1`
-for annotation primitives.
-
-### Migration from build123d-drafting-helpers
-
-```python
-# Before
-from build123d_drafting import make_drawing, Drawing, build_drawing
-
-# After
-from draftwright import make_drawing, Drawing, build_drawing
-```
-
-### Features (carried over from build123d-drafting-helpers)
-
-- **`make_drawing`** / **`build_drawing`** — automatic multi-view technical
-  drawing from a build123d solid: view layout, scale selection, orthographic
-  projection, dimension placement, title block.
-- **`Drawing`** — composable drawing object with `.lint()`, `.add()`,
-  `.export_svg()`, `.export_dxf()`.
-- **`choose_scale`** — ISO/ASME standard scale selection.
-- **`lint_feature_coverage`** — checks annotation coverage against detected
-  part features (holes, bosses, bolt circles).
-- **Section A–A views** — automatic section view for blind/stepped holes,
-  with ISO 128-44 solid filled cutting-plane arrows and ISO 128-50 45°
-  hatching on the cut face.
-- **`generate_script`** — generates a standalone drawing script from a STEP
-  file.