draftwright 0.4.2__tar.gz → 0.4.4__tar.gz

{draftwright-0.4.2 → draftwright-0.4.4}/CHANGELOG.md

@@ -2,6 +2,142 @@
 
 ## Unreleased
 
+## v0.4.4 — 2026-08-15
+
+**A semantic-completeness and fail-closed layout patch release.** Hole requirements and drawing
+quality are now machine-readable, hole-table replacement is transactional, explicit scales
+preserve required output, notes tables use all viable sheet space, and gear declarations,
+recognition evidence, and callout metadata improve diagnostic trust.
+
+### Added
+
+- **External spur gears can be declared through the `Sheet` façade** (#1086). The declaration
+  records the correlated ISO 1328-1 manufacturing requirements, renders a structured gear-data
+  table, and survives script emission, declaration, export, and lint without inferring gear data
+  that the caller did not supply.
+
+- **Recognition carries serialisable repeating radial-profile evidence** (#1087). Exact
+  rotational whole-wire proof can reconcile a declared gear with its physical profile while
+  preserving ambiguity across separate bodies and without inventing module, pressure angle, or
+  other manufacturing intent.
+
+- **Explicit drawing scales now protect required annotation completeness** (#1146).
+  `build_drawing(...)`, `make_drawing(...)`, `Sheet(...)`, and the CLI accept
+  `scale_policy="fallback"|"strict"|"permissive"`. The safe default retries preferred ISO
+  5455 reductions and returns the largest complete scale; strict mode raises with structured
+  requirement blockers, while permissive mode is an explicit warned opt-in to the historical
+  best-effort result. Every returned `Drawing.scale_decision` reports the requested and
+  effective scales, status, attempted scales, and any semantic placement blockers.
+
+- **Hole and hole-pattern requirements now participate in semantic completeness accounting**
+  (#1143). `lint_summary()["quality"]["completeness"]` reconciles recognition-owned bore,
+  depth/through, grouping, pattern, and location requirements to placed, suppressed, dropped,
+  missing, or explicitly unverifiable outcomes. Ambiguous declared/automatic correspondence
+  fails closed without shrinking the physical denominator. Z-normal hole locations retain ADR
+  0016's feature-level `location.location` addressability while structured physical evidence
+  distinguishes the independently required X and Y ordinates for critique.
+
+- **`lint_summary()` exposes drawing-quality evidence as separate completeness, restraint,
+  and legibility components** (#1127). The legacy `score` remains byte-compatible and is also
+  returned as the honestly named `diagnostic_score`; no composite quality verdict is invented.
+  Completeness scores recognition-owned requirements in the families with semantic outcome
+  ledgers and states that conditional scope explicitly; recognized families not yet scored are
+  listed separately. Its scalar is `audited_score`, not `score`, because a feature recognition
+  missed never became a requirement — so a part with a recogniser gap can reach 1.0, and the
+  qualifier belongs where it survives being quoted. The block also lists what its denominator
+  `excludes` and counts `unrecognised_geometry_reports` (a floor on that gap, not a measure).
+  It is not a completion gate. Legibility includes only layout and placement diagnostics, and
+  scores information-severity ones — "place what fits" drops, a leader crossing a silhouette —
+  against the warning floor, so it cannot read 1.0 while itemising output it calls unreadable.
+  A drop is identified by its `*_dropped` code suffix unless its producer records an explicit
+  `outcome_stage`, so a drop code added later counts without being registered anywhere.
+  Restraint fails closed as unavailable until measurement provenance can classify every
+  annotation.
+
+### Fixed
+
+- **Generic notes/data tables use every viable free sheet region and explain failed placement**
+  (#1145). A drawn sheet frame or zone ruler now defines the usable inset instead of becoming a
+  page-sized solid obstacle, so a measured four-row notes block can use clear lower-left A4
+  space. Tables retain the drafting preset's external text clearance from named and anonymous
+  existing annotations. Failed placement diagnostics report the measured page-space footprint,
+  attempted candidate regions, and the named obstacles or clearance bands that blocked the
+  nearest candidates without materialising the candidate Cartesian product.
+
+- **Automatic hole-table escalation is transactional per semantic requirement** (#1144). The
+  engine suppresses replaceable callouts and location dimensions only after the table fits and
+  every visible row has its required feature-owned balloon. A failed or partial balloon attempt
+  rolls the shared table back as a unit and restores the exact annotations, ordering, registry
+  identities, coverage, and issues. Precise ring, glyph, and leader-segment tests keep placement
+  clear of retained callout labels, leader shafts, and existing public-balloon components without
+  changing the existing additive `add_hole_table()`/`add_balloons()` behavior; malformed component
+  metadata—including Boolean cardinalities or coordinate payloads—falls back conservatively or fails the
+  optional replacement closed. New balloon shafts must also remain mutually crossing-free.
+  Compound, thread,
+  profile, pattern, tolerance, and fit facts the table cannot state remain active, while
+  independently replaceable X/Y locations may still move to the table. Guarded interval solving
+  has deterministic pre-lane, pre-carve, and work/state budgets; an adversarially fragmented label
+  inventory or band fails the replacement closed before excessive work or allocation. Required row-key
+  balloons take priority over optional non-certifying pattern markers, so an independently complete
+  table cannot be displaced by an auxiliary marker.
+  Hole outcomes identify the winning representation per requirement;
+  mixed table/feature evidence deliberately claims no single winner. Exceptions restore those
+  semantic markers, and automatic escalation fails closed rather than overwrite an existing
+  annotation that owns a reserved table or balloon name.
+
+- **Generated hole-callout leaders expose their exact rendered semantic text through the public
+  `Leader.label` field** (#1142). Geometry and placement are unchanged, and structured coverage
+  remains authoritative instead of requiring downstream tools to parse display text.
+
+- **Leader placement probes use analytic footprint arithmetic instead of constructing temporary
+  OCCT geometry** (#1138). Representative probe-heavy layouts are substantially faster while
+  preserving custom-style containment and placement behavior.
+
+### Changed
+
+- **Pairwise lint detail no longer multiplies the legibility score penalty** (#1147). Raw
+  severity and code counts retain their existing finding-level semantics, and every offending
+  pair remains in `issues`. The legibility component now also reports its primary issue counts
+  and scores one producer-identified annotation/failure mechanism once, with `affected_pairs`
+  exposing how many raw pair findings were aggregated. The legacy top-level `score` and
+  `diagnostic_score` remain unchanged.
+
+- **Pull-request validation now reports a stable aggregate `ci-ok` check and runs the supported
+  Python matrix on Linux** (#1134/#1136). Weekly, manual, and labelled workflows retain the
+  cross-platform escape hatch, reducing routine Actions cost without narrowing supported Python
+  coverage.
+
+## v0.4.3 — 2026-08-09
+
+**A trust and validation-throughput patch release.** Whole-part hexagonal stock now receives its
+manufacturing definition, assembly recognition no longer combines evidence across bodies, and
+performance validation is both more stable and faster to run.
+
+### Added
+
+- **Whole-part regular hexagonal stock is recognised independently of an attached boss and
+  dimensioned as `HEX … A/F` plus its axial length** (#1082). In-plane rotation preserves the
+  geometric across-flats size instead of substituting an orientation-dependent bounding-box
+  width. Automatic and declared paths share the same compiler and placement machinery, while
+  completeness lint distinguishes placed, authored-suppressed, dropped, missing, and ambiguous
+  outcomes.
+
+### Fixed
+
+- **Slot and pocket patterns cannot group members from separate assembly bodies** (#1073).
+  Recognition carries solid ownership through grouping and fails closed when ownership is
+  unavailable, preventing plausible-looking phantom patterns across disconnected parts.
+
+- **The annotation-obstacle performance guard uses deterministic work-count evidence instead of
+  a wall-clock threshold** (#1071). The regression test remains load-bearing under mutation but
+  no longer flakes because of machine load or suite ordering.
+
+### Changed
+
+- **The post-merge slow tier distributes individual tests across workers** (#1108), using
+  `pytest-xdist`'s load scheduling after local benchmark evidence showed a material speed-up
+  without weakening fixture coverage. Hosted slow validation remains the single post-merge gate.
+
 ## v0.4.2 — 2026-08-09
 
 **The trustworthy manufacturing drawings release.** AP242 PMI is now accounted for from its

{draftwright-0.4.2 → draftwright-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.2
+Version: 0.4.4
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -743,6 +743,7 @@ Choose formats, scale, and page; or emit an editable drawing script:
 ```
 draftwright my_part.step --format pdf,dxf     # also: svg, all
 draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
+draftwright my_part.step --scale 1 --page A4 --scale-policy strict
 draftwright my_part.step --script             # write an editable declarative Sheet script
 ```
 
@@ -895,13 +896,18 @@ installed automatically as a dependency.
 ### Scale and page control
 
 ```python
-from draftwright import choose_scale
+from draftwright import build_drawing, choose_scale
 
 # Auto-select the best ISO/ASME standard scale for an A3 sheet
 scale, page_w, page_h, n_steps = choose_scale(80, 60, 20, page="A3")
 
-# Override
-make_drawing(part, out="drawing", scale=2.0, page="A2")
+# Override. Required annotations are protected by the default fallback policy.
+dwg = build_drawing(part, scale=1.0, page="A4")
+print(dwg.scale_decision)  # requested/effective scale, attempts, blockers
+
+# Refuse an incompatible request, or explicitly retain historical best-effort output.
+build_drawing(part, scale=1.0, page="A4", scale_policy="strict")
+build_drawing(part, scale=1.0, page="A4", scale_policy="permissive")
 ```
 
 ### Edit, critique, and self-repair
@@ -916,10 +922,40 @@ dwg = build_drawing(part)
 env = next(f for f in dwg.model().features if f.kind == "envelope")
 dwg.dimension(env, "length", role="width", side="below", pin=True)
 
-crit = dwg.lint_summary()   # {"passed", "score", "by_code", "issues":[…suggestion]}
+crit = dwg.lint_summary()
+# Legacy diagnostic severity heuristic (not overall drawing quality):
+assert crit["diagnostic_score"] == crit["score"]
+# Independently observable components; no composite quality score is invented:
+completeness = crit["quality"]["completeness"]
+# Named for its denominator: the requirements Draftwright recognized AND can audit.
+# 1.0 does NOT mean the drawing is complete — it means every requirement recognition did
+# identify was placed, however much of the part it missed. What was never recognized never
+# became a requirement. (Recognized nothing auditable at all? available is False, not 1.0.)
+audited = completeness["audited_score"]
+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"]
+# 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
+# when several pairwise comparisons found it. These fields make that denominator explicit.
+legibility["primary_issues"], legibility["primary_by_code"], legibility["affected_pairs"]
+assert legibility["score_inventory"] == "primary_issues"
+restraint = crit["quality"]["restraint"]  # unavailable until provenance is complete
 dwg.repair()                # auto-fix mechanically-fixable lint; never worsens
 ```
 
+Completeness is strict about authored omissions: removing a dimension from a complete authored
+set records a `suppressed` requirement and lowers the audited score. The evidence distinguishes
+that choice from a placement failure, but cannot certify that the omission is
+engineering-correct; plain deletion is not an accepted-waiver mechanism.
+
+**`audited_score` is not a completion gate.** It answers "of the requirements we recognised and
+can audit, how many were placed?" — so a part can score 1.0 with whole features missing from the
+drawing, if recognition never identified them. Gate on issue codes and severities, and read
+`excludes` and `unrecognised_geometry_reports` for what the denominator cannot account for.
+
 Each `LintIssue` carries a domain-meaningful `code` and, when computable, a
 ready-to-apply `suggestion`. See `docs/adr/` for the design (deterministic
 generation, the lint→repair loop, and collect-then-solve placement).

{draftwright-0.4.2 → draftwright-0.4.4}/README.md

@@ -44,6 +44,7 @@ Choose formats, scale, and page; or emit an editable drawing script:
 ```
 draftwright my_part.step --format pdf,dxf     # also: svg, all
 draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
+draftwright my_part.step --scale 1 --page A4 --scale-policy strict
 draftwright my_part.step --script             # write an editable declarative Sheet script
 ```
 
@@ -196,13 +197,18 @@ installed automatically as a dependency.
 ### Scale and page control
 
 ```python
-from draftwright import choose_scale
+from draftwright import build_drawing, choose_scale
 
 # Auto-select the best ISO/ASME standard scale for an A3 sheet
 scale, page_w, page_h, n_steps = choose_scale(80, 60, 20, page="A3")
 
-# Override
-make_drawing(part, out="drawing", scale=2.0, page="A2")
+# Override. Required annotations are protected by the default fallback policy.
+dwg = build_drawing(part, scale=1.0, page="A4")
+print(dwg.scale_decision)  # requested/effective scale, attempts, blockers
+
+# Refuse an incompatible request, or explicitly retain historical best-effort output.
+build_drawing(part, scale=1.0, page="A4", scale_policy="strict")
+build_drawing(part, scale=1.0, page="A4", scale_policy="permissive")
 ```
 
 ### Edit, critique, and self-repair
@@ -217,10 +223,40 @@ dwg = build_drawing(part)
 env = next(f for f in dwg.model().features if f.kind == "envelope")
 dwg.dimension(env, "length", role="width", side="below", pin=True)
 
-crit = dwg.lint_summary()   # {"passed", "score", "by_code", "issues":[…suggestion]}
+crit = dwg.lint_summary()
+# Legacy diagnostic severity heuristic (not overall drawing quality):
+assert crit["diagnostic_score"] == crit["score"]
+# Independently observable components; no composite quality score is invented:
+completeness = crit["quality"]["completeness"]
+# Named for its denominator: the requirements Draftwright recognized AND can audit.
+# 1.0 does NOT mean the drawing is complete — it means every requirement recognition did
+# identify was placed, however much of the part it missed. What was never recognized never
+# became a requirement. (Recognized nothing auditable at all? available is False, not 1.0.)
+audited = completeness["audited_score"]
+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"]
+# 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
+# when several pairwise comparisons found it. These fields make that denominator explicit.
+legibility["primary_issues"], legibility["primary_by_code"], legibility["affected_pairs"]
+assert legibility["score_inventory"] == "primary_issues"
+restraint = crit["quality"]["restraint"]  # unavailable until provenance is complete
 dwg.repair()                # auto-fix mechanically-fixable lint; never worsens
 ```
 
+Completeness is strict about authored omissions: removing a dimension from a complete authored
+set records a `suppressed` requirement and lowers the audited score. The evidence distinguishes
+that choice from a placement failure, but cannot certify that the omission is
+engineering-correct; plain deletion is not an accepted-waiver mechanism.
+
+**`audited_score` is not a completion gate.** It answers "of the requirements we recognised and
+can audit, how many were placed?" — so a part can score 1.0 with whole features missing from the
+drawing, if recognition never identified them. Gate on issue codes and severities, and read
+`excludes` and `unrecognised_geometry_reports` for what the denominator cannot account for.
+
 Each `LintIssue` carries a domain-meaningful `code` and, when computable, a
 ready-to-apply `suggestion`. See `docs/adr/` for the design (deterministic
 generation, the lint→repair loop, and collect-then-solve placement).

{draftwright-0.4.2 → draftwright-0.4.4}/docs/adr/README.md

@@ -34,6 +34,7 @@ architecture** table; open retired or superseded records only for design history
 | [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` |
 | [0017](0017-recognition-inventory-correspondence-and-measurement-provenance.md) | One recognition result per run; correspondence is evidence-gated | Produce one explicit recognition result owned by `BuildState`; require vertical-slice evidence before generalising correspondence, identity, requirements, outcomes, or reconciliation. | Accepted; ownership phase landed, extensions gated by #1018 | `test_recognition_manifest.py`, `test_recognition_result.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 |
 
 ## Historical records
 
@@ -47,8 +48,8 @@ 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.
-- Declared intent and the editable surface: 0001 → 0011 → 0012 → 0016.
+- Layout and placement: 0004 → 0014 → 0012 → 0018.
+- Declared intent and the editable surface: 0001 → 0011 → 0012 → 0016 → 0018.
 - Quality and correction: 0002, with provenance from 0010.
 - Recognition correspondence and completeness: 0007 → 0013 → 0015 → 0017.
 

{draftwright-0.4.2 → draftwright-0.4.4}/pyproject.toml

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

{draftwright-0.4.2 → draftwright-0.4.4}/src/draftwright/__init__.py

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING
 # on every TAB press (#313). Each name maps to the submodule that provides it.
 _LAZY = {
     "build_drawing": "draftwright.builder",
+    "ScaleIncompatibilityError": "draftwright.builder",
     "make_drawing": "draftwright.builder",
     "Drawing": "draftwright.drawing",
     "FeatureInfo": "draftwright.drawing",
@@ -40,6 +41,7 @@ _LAZY = {
     # dependency-free `_warnings` leaf for that second reason: defined in `_core` it cost ~6 s
     # to reach, and the pytest filterwarnings entry naming it paid that on every invocation.
     "SoftDeprecationWarning": "draftwright._warnings",
+    "ScaleCompletenessWarning": "draftwright._warnings",
 }
 
 
@@ -76,8 +78,8 @@ _sys.modules[__name__].__class__ = _DraftwrightModule
 
 
 if TYPE_CHECKING:  # static analysers / IDEs — no runtime import, no kernel cost
-    from draftwright._warnings import SoftDeprecationWarning
-    from draftwright.builder import build_drawing, make_drawing
+    from draftwright._warnings import ScaleCompletenessWarning, SoftDeprecationWarning
+    from draftwright.builder import ScaleIncompatibilityError, build_drawing, make_drawing
     from draftwright.compose import choose_scale
     from draftwright.drawing import Drawing, FeatureInfo
     from draftwright.linting import lint_feature_coverage
@@ -106,6 +108,8 @@ __all__ = [
     "PmiRecord",
     "PmiSourceEntity",
     "Sheet",
+    "ScaleIncompatibilityError",
+    "ScaleCompletenessWarning",
     "build_drawing",
     "choose_scale",
     "extract_pmi",

{draftwright-0.4.2 → draftwright-0.4.4}/src/draftwright/_core.py

@@ -280,6 +280,22 @@ def _tag_sequence(n):
 
 _DIAM_RE = re.compile(r"[øØ⌀]\s*(\d+(?:\.\d+)?)")
 
+
+def _annotation_diameter_sources(annotation) -> tuple[tuple[float, ...], tuple[float, ...]]:
+    """Return ``(structured, text)`` diameter mentions for one annotation.
+
+    Engine-produced annotations with ``covers_diameters`` describe their physical-feature
+    correspondence structurally.  Their formatted labels may contain other diameters (for
+    example ``ø60 BC``), so text parsing is a legacy/unstructured fallback and is never
+    combined with structured coverage (ADR 0017 / #1142).
+    """
+    structured = tuple(float(value) for value in getattr(annotation, "covers_diameters", ()))
+    if structured:
+        return structured, ()
+    label = getattr(annotation, "label", None) or ""
+    return (), tuple(float(match.group(1)) for match in _DIAM_RE.finditer(label))
+
+
 # A single-quoted label lifted from a lint message, e.g. "labels 'A' and 'B' …".
 # Shared by the #29 lint suggestions (linting.py) and the #30 repair loop.
 _QUOTED_RE = re.compile(r"'([^']*)'")
@@ -981,6 +997,7 @@ class Analysis:
     layout_n_steps: int
     layout_section: bool
     layout_table_sizes: tuple[tuple[float, float], ...]
+    layout_required_tables: tuple[tuple[tuple[float, float], str], ...]
     sv_right: float
     iso_right_limit: float
     SCALE: float

{draftwright-0.4.2 → draftwright-0.4.4}/src/draftwright/_geometry.py

@@ -109,6 +109,18 @@ def _axis_letter_of(axis) -> str:
     return max(zip("xyz", axis, strict=True), key=lambda t: abs(t[1]))[0]
 
 
+def _is_principal_axis(axis) -> bool:
+    """Whether *axis* is exactly along X, Y or Z after analytic-noise snapping.
+
+    ``Frame.axis`` can name only these directions. Exactness is evaluated after the same
+    ``1e-6`` component snap used for analytic STEP noise. A cosine-tolerance test would
+    admit a small but real second component (and millimetres of flattening over a long
+    part); requiring exactly one non-zero component expresses the representable contract.
+    """
+    snapped = [0.0 if abs(float(component)) < 1e-6 else float(component) for component in axis]
+    return sum(component != 0.0 for component in snapped) == 1
+
+
 def _axis_direction_components(axis: str, direction=None):
     """Validate a direction and return ``(raw, norm, dominant_index)``."""
     if axis not in "xyz" or len(axis) != 1:
@@ -269,11 +281,14 @@ def _segment_crosses_box(p1, p2, box) -> bool:
     return any(_seg_seg(p1, p2, corners[i], corners[(i + 1) % 4]) for i in range(4))
 
 
-def _segment_clips_box(p, q, box, pad=0.0) -> bool:
-    """Liang–Barsky: does segment *p*→*q* intersect the *pad*-inflated AABB
-    *box*? Inclusive at the boundary (a touch is a hit) — the tolerant form the
-    lint checks use; :func:`_segment_crosses_box` is the strict placement-side
-    sibling (#700)."""
+def _segment_clip_extent(p, q, box, pad=0.0):
+    """AABB of the part of *p*→*q* inside the *pad*-inflated *box*.
+
+    Return ``None`` when the segment is disjoint.  The Liang–Barsky clip is
+    inclusive at the boundary: lint uses the returned extent both as its
+    tolerant hit gate and to measure only the rendered part that actually
+    reaches a label (#1144).
+    """
     minx, miny, maxx, maxy = box[0] - pad, box[1] - pad, box[2] + pad, box[3] + pad
     x0, y0 = p
     dx, dy = q[0] - x0, q[1] - y0
@@ -281,15 +296,90 @@ def _segment_clips_box(p, q, box, pad=0.0) -> bool:
     for pp, qq in ((-dx, x0 - minx), (dx, maxx - x0), (-dy, y0 - miny), (dy, maxy - y0)):
         if abs(pp) < 1e-12:
             if qq < 0:
-                return False
+                return None
         else:
             r = qq / pp
             if pp < 0:
                 if r > t1:
-                    return False
+                    return None
                 t0 = max(t0, r)
             else:
                 if r < t0:
-                    return False
+                    return None
                 t1 = min(t1, r)
-    return t0 <= t1
+    if t0 > t1:
+        return None
+    first = (x0 + t0 * dx, y0 + t0 * dy)
+    second = (x0 + t1 * dx, y0 + t1 * dy)
+    return (
+        min(first[0], second[0]),
+        min(first[1], second[1]),
+        max(first[0], second[0]),
+        max(first[1], second[1]),
+    )
+
+
+def _segment_clips_box(p, q, box, pad=0.0) -> bool:
+    """Liang–Barsky: does segment *p*→*q* intersect the *pad*-inflated AABB
+    *box*? Inclusive at the boundary (a touch is a hit) — the tolerant form the
+    lint checks use; :func:`_segment_crosses_box` is the strict placement-side
+    sibling (#700)."""
+    return _segment_clip_extent(p, q, box, pad=pad) is not None
+
+
+def _segments_cross_or_overlap(a1, a2, b1, b2) -> bool:
+    """Whether two page-plane segments cross or overlap beyond a shared endpoint.
+
+    Proper interior crossings, a T-junction into the other segment's interior,
+    and collinear overlap are conflicts. Merely sharing one endpoint is not: two
+    leaders may legitimately terminate at the same feature/ring boundary.
+    """
+    epsilon = 1e-9
+
+    def cross(origin, first, second):
+        return (first[0] - origin[0]) * (second[1] - origin[1]) - (first[1] - origin[1]) * (
+            second[0] - origin[0]
+        )
+
+    def same(first, second):
+        return abs(first[0] - second[0]) <= epsilon and abs(first[1] - second[1]) <= epsilon
+
+    def on_segment(point, first, second):
+        return (
+            abs(cross(first, second, point)) <= epsilon
+            and min(first[0], second[0]) - epsilon
+            <= point[0]
+            <= max(first[0], second[0]) + epsilon
+            and min(first[1], second[1]) - epsilon
+            <= point[1]
+            <= max(first[1], second[1]) + epsilon
+        )
+
+    oa1 = cross(b1, b2, a1)
+    oa2 = cross(b1, b2, a2)
+    ob1 = cross(a1, a2, b1)
+    ob2 = cross(a1, a2, b2)
+    if oa1 * oa2 < -(epsilon**2) and ob1 * ob2 < -(epsilon**2):
+        return True
+
+    if all(abs(value) <= epsilon for value in (oa1, oa2, ob1, ob2)):
+        axis = (
+            0
+            if max(abs(a2[0] - a1[0]), abs(b2[0] - b1[0]))
+            >= max(abs(a2[1] - a1[1]), abs(b2[1] - b1[1]))
+            else 1
+        )
+        overlap = min(max(a1[axis], a2[axis]), max(b1[axis], b2[axis])) - max(
+            min(a1[axis], a2[axis]), min(b1[axis], b2[axis])
+        )
+        return bool(overlap > epsilon)
+
+    for point, first, second in (
+        (a1, b1, b2),
+        (a2, b1, b2),
+        (b1, a1, a2),
+        (b2, a1, a2),
+    ):
+        if on_segment(point, first, second) and not (same(point, first) or same(point, second)):
+            return True
+    return False

{draftwright-0.4.2 → draftwright-0.4.4}/src/draftwright/_warnings.py

@@ -37,3 +37,11 @@ class SoftDeprecationWarning(UserWarning):
     in notebooks, several test runners, and library-internal call paths, whereas this shows
     unconditionally.
     """
+
+
+class ScaleCompletenessWarning(UserWarning):
+    """An explicit scale was changed or honored with required placement loss (#1146).
+
+    Callers can filter this policy decision independently of unrelated user warnings while
+    still inspecting the complete machine-readable record on ``Drawing.scale_decision``.
+    """