draftwright 0.4.7__tar.gz → 0.4.9__tar.gz

draftwright-0.4.9/.gitignore

@@ -0,0 +1,28 @@
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+testenv/
+.coverage
+.coverage.*
+coverage.xml
+coverage*.json
+htmlcov/
+site/
+.DS_Store
+
+# Drawing exports. `Drawing.export()` writes wherever the calling script runs from, so
+# ad-hoc scripts drop artefacts in the repo root — `bracket.pdf` and `grm01.pdf` were
+# swept into a commit that way. These are build products, never sources.
+#
+# PDF and DXF have no tracked instances, so they are ignored anywhere. SVG and PNG DO
+# (docs/images/), so only the repo root is ignored — the one place throwaway scripts
+# write to — rather than hiding a legitimate new docs image.
+*.pdf
+*.dxf
+/*.svg
+/*.png

{draftwright-0.4.7 → draftwright-0.4.9}/CHANGELOG.md

@@ -1,6 +1,167 @@
 # Changelog
 
-## Unreleased
+## v0.4.9 — 2026-08-21
+
+### Added
+
+- Lint now verifies that an annotation claiming to carry a measurement actually renders it
+  (#1217). Coverage checks read provenance riders the annotations carry about themselves and
+  believed them; nothing checked the claim against what the annotation draws. Four new codes —
+  `claimed_value_absent`, `claimed_measurement_not_compiled`, and two that report an
+  unverifiable claim rather than passing it — and `Drawing.add_table` now keeps the rows it
+  draws so a table's claims are readable back. Measured over all 21 STEP fixtures: 1,081
+  claims, 1,078 confirmed, and three findings — all instances of one genuine provenance
+  defect, see #1219.
+
+- `lint_summary()["quality"]` gains a fourth component, `fidelity`: whether what the drawing
+  says is TRUE. The existing three ask whether required content landed (completeness),
+  whether there is too much of it (restraint), and whether a reader can make it out
+  (legibility) — none asked whether it is correct, so a drawing labelled 99 over a 16 mm
+  path reported a perfect score on every component available to it. Also covers a callout
+  drawn for a feature the part does not have, and a gear data table stating a tooth count
+  the geometry contradicts — the last of which reports `passed: True` and zero errors, so
+  the only existing channel that names it is `by_code`. Completeness, restraint and fidelity
+  report `available: False` with a `reason` rather than a flattering number when they have no
+  evidence, and every lint code the engine emits is classified onto exactly one component,
+  an explicit unscored register, or a register of codes whose component depends on the
+  issue's `outcome_stage`. `quality["unscored"]` reports the findings that reached no
+  component at all and flags any whose classification nobody made — `section_dropped` was
+  found scoring on nothing while a comment beside its emission said the opposite, and eleven
+  more `*_dropped` codes reach the engine as `drop_code` data with the same shape (#1176).
+
+### Changed
+
+- Updated the exact `b123d-recognisers` production lock from 0.2.4 to 0.2.6.
+  The immutable PyPI wheel/sdist hashes and capability-manifest digest `aa52bc04216cd1eccc05796d2262547c7f476b80a3ec77334a77b9d8e3241a58` are
+  recorded in `.github/recogniser-release.json`; focused compatibility evidence and the
+  normal consumer gates run on the generated PR.
+- `HoleRequirementOutcome` gains `members` and `features`, `ClaimOutcome` gains `measurement`,
+  and `linting.hole_coverage.canonical_hole_sites` is public (#1217). A consumer attributing a
+  requirement outcome to a specific recognised hole needs the evidence the outcome accounts
+  for, and needs to key into the canonical space the ledger publishes it in — a through hole's
+  own-axis coordinate is zeroed there.
+- The STEP-analysis benchmark's `drawing_consumer` boundary now consumes
+  `hole_requirement_outcomes` instead of a second correspondence implementation of its own
+  (#1206), and follows the ledger's pointer through `linting.evidence` rather than trusting it.
+  Holes the ledger reports `unverifiable` now score `unknown` where the duplicate credited them
+  by guessing: 26 holes, five on each CTC-03 fixture and eight on each CTC-04 fixture. The
+  five-case evaluation corpus is unchanged, and one lint message on CTC-03 now reports its
+  coordinates in the ledger's own canonical space.
+
+- `Drawing.suppressions()` rows gain a `conveyed_by` key: the dimension that states a
+  withheld measurement instead, or `None` when nothing takes the fact over (#1154). It is not
+  a synonym for the existing `authored` flag — that says whose decision it was, this says
+  where the measurement went.
+
+- Updated the exact `b123d-recognisers` production lock from 0.2.2 to 0.2.4.
+  The immutable PyPI wheel/sdist hashes and capability-manifest digest `d0023d30e583c03abc55f09dfeaaa56fddf56334afa0417818480b2fa2ce3f0f` are
+  recorded in `.github/recogniser-release.json`; focused compatibility evidence and the
+  normal consumer gates run on the generated PR.
+- Updated the exact `b123d-recognisers` production lock from 0.2.1 to 0.2.2.
+  The immutable PyPI wheel/sdist hashes and capability-manifest digest `7985befc8572bfe6d1c0805dfdf690d74a5a4a5f14d5988cc29c366315ff04ca` are
+  recorded in `.github/recogniser-release.json`; focused compatibility evidence and the
+  normal consumer gates run on the generated PR.
+
+### Fixed
+
+- An authored tolerance the compiler approved now reaches the sheet wherever the measurement
+  is drawn (#1215, #1216). `build123d_drafting` resolves a dimension's text as
+  `label if label is not None else _number_with_units(measured, tolerance)`, and every
+  dimension this engine emits passes a label — so a forwarded `tolerance=` rendered nothing
+  while type-checking and reading back correctly from `Dimension.label`. Ten render paths
+  discarded the band that way: envelope extents, the height ladder, the turned-step chain, two
+  public `Drawing` verbs, the deferred corridor route, the detail-view redraw, the short-rise
+  escape, step shoulders, pattern pitch, compound-callout recess terms, grid pitch, and both
+  hole tables. A general guard now decorates every parameter of every feature across a corpus,
+  through both `decorations=` key shapes, and joins what the compiler approved against what the
+  claiming annotation renders.
+
+- Collapsed `N×` marks no longer state a tolerance their members do not share (#1216). A
+  pattern's pitch claimed the authored band of every gap although the recogniser admits 2%
+  jitter — holes at −30, −10, 10.3, 30 printed `3× 20 ±0.1` over a 20.3 mm gap — and fillet and
+  flat collapses took the "first-authored" band, so one of four fillets at ±0.1 printed
+  `4× R5 ±0.1`. Equality is now judged at the drawn precision, and a withheld band is reported
+  (`pattern_pitch_tolerance_withheld`, `collapsed_tolerance_withheld`) rather than dropped
+  silently.
+
+- An approved dimension that cannot be placed is now reported instead of vanishing (#1216).
+  The overall extents' corridor candidate carried a no-op drop handler — the only drop in the
+  engine that recorded nothing — and the step ladder's legibility floor skipped rungs without
+  incrementing any counter. Both now record against the measurement they concern, and a
+  withholding is withdrawn if a later pass draws the measurement after all.
+
+- A feature leader filling a view's below corridor no longer costs the part its overall extent
+  (#1236). The mandatory width or depth now retries on the view's above strip after every
+  corridor has drained, the fallthrough starved slot and plate dimensions already use. Live on
+  three NIST CTC fixtures, which drew no overall width.
+
+- The iso view and the above strips are no longer invisible to each other (#1240). Strip
+  placement never saw the iso, and the iso fit re-scaled after annotation without consulting
+  what had been placed — so growth could invade dimension ink, which it did on CTC-01. The fit
+  is now capped by measured re-projection rather than by a linear model of it: the projected
+  bbox translates as it scales, by up to 7.35 mm on a part carrying a Location, which no
+  prediction about the page centre can express.
+
+
+- A part whose feature-local extent runs between the same two faces as an overall extent
+  is no longer dimensioned twice (#1154). GRM-04's drive plate printed `4.5` twice — once
+  as the hub's height and once as the overall thickness — because two detected records
+  claim one physical fact. The overall extent keeps it; the feature-local one is withheld
+  and records which dimension the reader finds it on. Reconciliation is by exact
+  support-plane coincidence, never by value: a square part's two equal extents run between
+  different faces and remain two facts (#997). A measurement is handed over only when the
+  extent receiving it is actually drawn — by the planner's rules, by the compiler's
+  overall-height rules, and by an authored set — and never when the yielding dimension
+  carries a tolerance, since a toleranced dimension and an untoleranced one are not the same
+  requirement. (A tolerance on the *receiving* extent is the same requirement on the same two
+  faces, and does not prevent the consolidation.)
+
+## v0.4.8 — 2026-08-16
+
+### Fixed
+
+- Compatible automatic/deferred sparse ordinary side/plan hole and post-drain
+  machined-feature callouts now share one bounded same-view leader inventory
+  (#1166). Pattern, profiled-bore, and dense table-eligible hole queues retain
+  their specialised established paths because their winners affect downstream
+  furniture/table semantics or await #798 silhouette-aware routing. The solve
+  preserves required/priority-ranked evidence, rejects new-leader crossings,
+  checks complete leader ink against actual-width fixed dimension/witness,
+  arrow, label, and centre-furniture components (including rendered arrows on
+  shifted dimensions and component-local dashed circular centre furniture);
+  fixed residual faces and the selected survivor both require each tessellation
+  triangle to fit one same analytical component rather than merely the union,
+  plus exact continuous OCC containment for curved faces; residual lowering
+  also retains filled datum/GD&T faces absent from segment metadata; if candidate
+  or selected-survivor construction raises, or a survivor fails validation, the
+  bad alternative fails closed and the canonical lazy producer tail is replayed
+  instead of falsely dropping an otherwise valid callout; an all-invalid tail is
+  reported as validation-stage geometry failure rather than no clear room (so
+  scale fallback does not retry a non-spatial helper defect), while compiler
+  invariant violations such as a missing semantic callout label remain loud;
+  only explicitly marked global turning axes permit an arrow-local leader-tip
+  attachment; near-collinear shaft travel and ownerless section/cutting lines
+  remain fixed ink. The solve prefers
+  clear routes over explicit Policy-B fallbacks, and then minimises real leader
+  length. Provisional sections cannot veto that primary result: one separately
+  bounded refinement may choose an equally complete leader inventory that clears
+  their exact components, after which the final section performs one bounded
+  end-symbol repair and yields if exact ink still conflicts. The selected OCC survivor is validated against the same analytical
+  ink contract. A retained fixed-ink crossing now emits the machine-readable
+  `feature_leader_crossing` info finding instead of appearing lint-clean. Candidate,
+  fixed-component lowering, fixed-obstacle-probe, pair, and exact-search work is
+  bounded; the fixed inventory is lowered once and reused with the producer's
+  legacy lazy result as the floor, including state-cap exhaustion; page,
+  own-silhouette, and title-reservation constraints remain hard in every fallback.
+  A replay that exhausts exact fixed-probe classification is retained visibly as
+  `feature_leader_fixed_ink_unverified` rather than rescanning past the cap, and
+  that uncertainty participates in the legibility quality inventory.
+  Trace output preserves an abandoned fully admitted inventory when state search
+  exhausts, records the producer-floor replay separately, and names exact committed/provisional components,
+  refinement status, and competing blockers; live
+  single-callout edits remain immediate.
+
+## v0.4.7 — 2026-08-16
 
 ### Added
 

{draftwright-0.4.7 → draftwright-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.7
+Version: 0.4.9
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,7 +684,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: antlr4-python3-runtime<4.10
-Requires-Dist: b123d-recognisers==0.2.1
+Requires-Dist: b123d-recognisers==0.2.6
 Requires-Dist: build123d-drafting-helpers>=0.14.1
 Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
 Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
@@ -937,6 +937,12 @@ assert completeness["scope"] == "audited_recognized_requirements"
 completeness["excludes"]                     # what the denominator cannot see
 completeness["unrecognised_geometry_reports"]  # a floor on that gap, never a measure
 legibility = crit["quality"]["legibility"]
+# `quality` also carries `fidelity` (#1176): is what the drawing says TRUE? A drawing can
+# be complete, restrained and legible and still assert a measurement the part lacks.
+fidelity = crit["quality"]["fidelity"]
+# …and `unscored`, the findings no component priced, so four components reading "fine"
+# cannot conceal that some of the critique was scored by nothing.
+unscored = crit["quality"]["unscored"]
 # Raw pair findings remain available and keep the original count semantics.
 legibility["warnings"], legibility["by_code"], crit["issues"]
 # The legibility scalar uses primary issues: one affected annotation/failure mechanism even

{draftwright-0.4.7 → draftwright-0.4.9}/README.md

@@ -237,6 +237,12 @@ assert completeness["scope"] == "audited_recognized_requirements"
 completeness["excludes"]                     # what the denominator cannot see
 completeness["unrecognised_geometry_reports"]  # a floor on that gap, never a measure
 legibility = crit["quality"]["legibility"]
+# `quality` also carries `fidelity` (#1176): is what the drawing says TRUE? A drawing can
+# be complete, restrained and legible and still assert a measurement the part lacks.
+fidelity = crit["quality"]["fidelity"]
+# …and `unscored`, the findings no component priced, so four components reading "fine"
+# cannot conceal that some of the critique was scored by nothing.
+unscored = crit["quality"]["unscored"]
 # Raw pair findings remain available and keep the original count semantics.
 legibility["warnings"], legibility["by_code"], crit["issues"]
 # The legibility scalar uses primary issues: one affected annotation/failure mechanism even

{draftwright-0.4.7 → draftwright-0.4.9}/docs/adr/README.md

@@ -30,11 +30,12 @@ architecture** table; open retired or superseded records only for design history
 | [0011](0011-ir-as-public-input.md) | The IR as a public input: declare features, don't only detect them | Accept the feature IR as public input through declarations and the `Sheet` façade. | Accepted; core landed; #62/#462/#495 remain | `test_declare.py`, `test_object_aspects.py`, `test_sheet_gdt.py` |
 | [0012](0012-edits-as-pinned-priority-candidates-in-the-global-solve.md) | User annotation edits are pinned, priority-ranked corridor candidates | Drain recorded semantic edits through corridor placement with pin and priority. | Accepted; partially landed; full recomposition/parity remains #426/#707 (#661 detail views landed) | `test_make_drawing.py`, `test_sheet_emit.py` |
 | [0013](0013-uniform-recognition-and-shared-package.md) | A uniform recogniser/feature contract and shared `b123d-recognisers` deployment | Enforce the geometry-only contract in the shared package and consume it through Draftwright's record→IR boundary. | Accepted; Phases 1–2 deployed | `test_external_recognition_boundary.py`, `test_detect_registry.py`, package semantic goldens |
-| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering; post-drain feature leaders also assign jointly within each pass. | Accepted; supersedes 0009; #740 Amendment 1 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_issue_740_leader_assignment.py`, `test_import_boundaries.py` |
+| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering; compatible sparse ordinary side/plan hole and post-drain machined leaders share one bounded late inventory. | Accepted; supersedes 0009; #740 Amendment 1; #1166 Amendment 2 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_issue_740_leader_assignment.py`, `test_issue_1166_cross_pass_feature_leaders.py`, `test_import_boundaries.py` |
 | [0015](0015-part-drawing-compiler-as-built.md) | The part-drawing compiler, as built | Use one detected-or-declared feature IR and planner-fed dimension groups as the compiler waist. | Accepted; supersedes 0008 | `test_part_model.py`, `test_detect_once.py`, `test_import_boundaries.py` |
-| [0016](0016-declared-dimensioning-intent.md) | Declared dimensioning intent: capture what to measure, let the engine place it | Declare which measurements matter as scale-independent intent routed through the planner and corridor solve; never hardcode dimension geometry. | Accepted; epic #867 complete; phase 6 landed (#940) | `test_compiled_plan_boundary.py`, `test_label_provenance.py`, `test_sheet_emit.py`, `test_add_dimension.py` |
+| [0016](0016-declared-dimensioning-intent.md) | Declared dimensioning intent: capture what to measure, let the engine place it | Declare which measurements matter as scale-independent intent routed through the planner and corridor solve; never hardcode dimension geometry. | Accepted; epic #867 complete; phase 6 landed (#940) | `test_compiled_plan_boundary.py`, `test_issue_1215_no_approved_tolerance_is_dropped.py`, `test_label_provenance.py`, `test_sheet_emit.py`, `test_add_dimension.py` |
 | [0017](0017-recognition-inventory-correspondence-and-measurement-provenance.md) | One recognition result per run; correspondence is evidence-gated | Produce one external immutable recognition result held by Draftwright's per-run cache; require vertical-slice evidence before generalising correspondence, identity, requirements, outcomes, or reconciliation. | Accepted; external cache ownership clarified, extensions gated by #1018 | `test_external_recognition_boundary.py`, `test_recognition_manifest.py`, `test_declared_recognition_gate.py` |
-| [0018](0018-requirement-driven-view-planning-and-editable-sheet-layout.md) | Requirement-driven view planning and editable sheet layout | Use one `ViewSpec` vocabulary and planner with distinct authored `ViewConstraints` and immutable `ResolvedViewPlan`; jointly validate views, typography, convention, scale, paper and layout against requirement survival. If accepted, supersedes ADR 0004's fixed-topology assumption while retaining compose-then-pack. | Proposed; tracked by #1130 | Required guards are listed in the ADR |
+| [0018](0018-requirement-driven-view-planning-and-editable-sheet-layout.md) | Requirement-driven view planning and editable sheet layout | Use one `ViewSpec` vocabulary and planner with distinct authored `ViewConstraints` and immutable `ResolvedViewPlan`; jointly validate views, typography, convention, scale, paper and layout against requirement survival. Supersedes ADR 0004's fixed-topology assumption while retaining compose-then-pack. | Accepted 2026-08-16 (nothing implemented yet); tracked by #1130 | Required guards are listed in the ADR |
+| [0019](0019-display-complete-labels-and-dimension-outcomes.md) | Display-complete labels and a dimension-outcome ledger | The compiled plan carries the full label text (tolerance and collapse wording included) so renderers render and never compose; dimension outcomes reconcile at one seam on both build routes; ladder rungs get per-mark identity. Finishes the ADR 0016 Amdt 1 boundary; supersedes Amdt 6's enforcement mechanism. | Proposed | `test_issue_1215_no_approved_tolerance_is_dropped.py` reduces to plan-equality when implemented |
 
 ## Historical records
 
@@ -49,7 +50,7 @@ architecture** table; open retired or superseded records only for design history
 - Compiler and state ownership: 0001 → 0005 → 0015.
 - Recognition and public declaration: 0007 → 0013 → 0011 → 0015.
 - Layout and placement: 0004 → 0014 → 0012 → 0018.
-- Declared intent and the editable surface: 0001 → 0011 → 0012 → 0016 → 0018.
+- Declared intent and the editable surface: 0001 → 0011 → 0012 → 0016 → 0018 → 0019.
 - Quality and correction: 0002, with provenance from 0010.
 - Recognition correspondence and completeness: 0007 → 0013 → 0015 → 0017.
 

{draftwright-0.4.7 → draftwright-0.4.9}/docs/reference/recogniser-capabilities.md

@@ -15,9 +15,16 @@ library.
 
 Validation fails closed and names the family and boundary whenever possible:
 
-- **family inventory mismatch** — the installed package added, removed, or renamed a family.
-  Update the package pin deliberately, add or remove the Draftwright declaration, and provide the
-  downstream behavior or an explicit non-supported state.
+- **family inventory mismatch (`stale=`)** — Draftwright declares a family the installed package
+  no longer ships, so a declared adapter would call a recogniser that is gone. Remove or repoint
+  the declaration.
+
+  The opposite direction does **not** fail this validation. A family the package ships and
+  Draftwright has not declared cannot reach any Draftwright code path, and blocking on it made the
+  package unreleasable until its consumer caught up. It is reported by
+  `pending_family_declarations` and fails `tests/test_recogniser_adoption.py` in Draftwright's own
+  CI instead — adoption is still required, and is enforced where the decision is made. Provide the
+  downstream behavior or an explicit non-supported state as before.
 - **record schema mismatch** — a consumed record schema changed. Review the record fields and
   compatibility notes, update the relevant adapter and tests, then pin the accepted schema version.
 - **stale implementation** — a declared adapter, `Sheet` method, emitter, renderer, or completeness

{draftwright-0.4.7 → draftwright-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.7"
+version = "0.4.9"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,7 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.14.1",
-    "b123d-recognisers==0.2.1",
+    "b123d-recognisers==0.2.6",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2
     # Apache-2.0 wrapping Google PDFium BSD-3) and ship pre-built wheels with NO native system
@@ -89,6 +89,7 @@ timeout = 300
 markers = [
     "slow: heavy end-to-end CTC fixture builds (deselected by default)",
     "smoke: curated build-light subset for a fast local check (~30 s)",
+    "unit: pure-logic inner-loop tier — constructs NO OCC geometry (enforced by conftest, #656)",
 ]
 # `SoftDeprecationWarning` marks a surface that is discouraged but SUPPORTED and not going
 # away (#1043). The suite exercises `Sheet.auto_dimensions()` in ~170 places, deliberately —
@@ -164,6 +165,7 @@ dev = [
     "mypy>=2.1.0",
     "pytest>=8",
     "pytest-cov>=5",
+    "pytest-split>=0.8",
     "pytest-timeout>=2",
     "pytest-xdist>=3",
     "ruff>=0.4",

{draftwright-0.4.7 → draftwright-0.4.9}/skills/SKILL.md

@@ -281,9 +281,22 @@ dwg = build_drawing(part)
 
 # 1. Critique — the machine channel. JSON-friendly aggregate of lint().
 crit = dwg.lint_summary()
-#   {"passed": bool, "score": 0..1, "errors": n, "warnings": n, "infos": n,
-#    "by_code": {code: n}, "issues": [{code, severity, message, suggestion?}, ...]}
+#   {"passed": bool, "score": 0..1, "diagnostic_score": 0..1,
+#    "errors": n, "warnings": n, "infos": n, "by_code": {code: n},
+#    "issues": [{code, severity, message, suggestion?}, ...],
+#    "quality": {"completeness": …, "restraint": …, "legibility": …, "fidelity": …,
+#                "unscored": {"available": True, "score": None, "issues": n,
+#                             "by_code": {…}, "unclassified": [...], "reason": …}}}
 # Gate on the severity/code COUNTS, not the scalar score.
+#
+# The four `quality` components answer four different questions and none substitutes for
+# another: did required content land, is there too much of it, can a reader make it out,
+# and — `fidelity` — is what it says TRUE. Completeness, restraint and fidelity report
+# `available: False` with a `reason` rather than a flattering number when they have no
+# evidence, so read `available` first. (Legibility is always available: an empty sheet
+# genuinely IS legible, which is not the same kind of 1.0 as an empty sheet being truthful.)
+# `quality["unscored"]` lists the findings none of the four priced; a non-empty
+# `unclassified` there means a lint code reached no component and nobody decided it should.
 
 # 2. Each issue names the problem in DOMAIN terms and (when computable) carries a
 #    ready-to-apply suggestion — a domain-API call you paste in, not page maths.

{draftwright-0.4.7 → draftwright-0.4.9}/src/draftwright/_core.py

@@ -507,6 +507,36 @@ _MIN_STEP_SEP_MM = _FONT_SIZE + 2 * _PAD
 _MIN_LOC_SEP_MM = draft_preset(font_size=_FONT_SIZE, decimal_precision=1).arrow_length + _PAD
 
 
+def _classify_steps(step_zs, bb_min_z, scale, *, allow_short=False):
+    """``(kept, too_close, too_short)`` — every step height, sorted into its outcome.
+
+    The one predicate. :func:`_legible_steps` is the historical two-value view of this and
+    delegates here, so the "which steps are dimensioned" rule cannot be stated twice and
+    drift; the third list exists because it was previously stated ZERO times.
+
+    ``too_short`` is the silent case (#1216 review r9). A step whose page distance from the
+    part's base cannot carry a dimension is skipped, and unlike ``too_close`` the skip
+    incremented no counter, raised no escalation and produced no lint — so a blind hole in a
+    plate had its ``step_height`` approved by the compiler, dropped here, and the drawing
+    linted perfectly clean with the measurement nowhere on it. Callers report it; the guard in
+    ``tests/test_issue_1215_no_approved_tolerance_is_dropped.py`` requires that they do.
+    """
+    kept: list[float] = []
+    too_close: list[float] = []
+    too_short: list[float] = []
+    last = None
+    for z in sorted(step_zs):
+        if not allow_short and (z - bb_min_z) * scale < _MIN_STEP_DIM_MM:
+            too_short.append(z)
+            continue
+        if last is not None and (z - last) * scale < _MIN_STEP_SEP_MM:
+            too_close.append(z)
+            continue
+        kept.append(z)
+        last = z
+    return kept, too_close, too_short
+
+
 def _legible_steps(step_zs, bb_min_z, scale, *, allow_short=False):
     """Step heights worth dimensioning at *scale*, and how many were too close.
 
@@ -518,19 +548,14 @@ def _legible_steps(step_zs, bb_min_z, scale, *, allow_short=False):
     when they do not fit inline (#565). Returns ``(kept_zs, n_too_close)``:
     the heights to dimension, and the count dropped for spacing (the caller
     surfaces these via lint; the full-fidelity answer is a detail view, #42).
+
+    The steps dropped as too SHORT are not in either return value — see
+    :func:`_classify_steps`, which is where this rule now lives.
     """
-    kept: list[float] = []
-    n_too_close = 0
-    last = None
-    for z in sorted(step_zs):
-        if not allow_short and (z - bb_min_z) * scale < _MIN_STEP_DIM_MM:
-            continue
-        if last is not None and (z - last) * scale < _MIN_STEP_SEP_MM:
-            n_too_close += 1
-            continue
-        kept.append(z)
-        last = z
-    return kept, n_too_close
+    kept, too_close, _too_short = _classify_steps(
+        step_zs, bb_min_z, scale, allow_short=allow_short
+    )
+    return kept, len(too_close)
 
 
 def _legible_locations(positions, scale):