draftwright 0.4.32__tar.gz → 0.4.33__tar.gz

{draftwright-0.4.32 → draftwright-0.4.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.32
+Version: 0.4.33
 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: build123d-drafting-helpers>=0.15.4
+Requires-Dist: build123d-drafting-helpers>=0.15.5
 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'
 Requires-Dist: cadquery-ocp-novtk!=7.9.3.1.1; python_full_version >= '3.13'

{draftwright-0.4.32 → draftwright-0.4.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.32"
+version = "0.4.33"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -22,7 +22,7 @@ dependencies = [
     # This novtk release lacks OCP.GccEnt on macOS. The exclusion must reach
     # published wheels, not only uv's development resolver constraints.
     "cadquery-ocp-novtk!=7.9.3.1.1 ; python_full_version >= '3.13'",
-    "build123d-drafting-helpers>=0.15.4",
+    "build123d-drafting-helpers>=0.15.5",
     "quiddity==0.3.3",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/__init__.py

@@ -57,6 +57,7 @@ _LAZY = {
     # to reach, and the pytest filterwarnings entry naming it paid that on every invocation.
     "SoftDeprecationWarning": "draftwright._warnings",
     "ScaleCompletenessWarning": "draftwright._warnings",
+    "ProjectionGeometryWarning": "draftwright._warnings",
 }
 
 
@@ -93,7 +94,11 @@ _sys.modules[__name__].__class__ = _DraftwrightModule
 
 
 if TYPE_CHECKING:  # static analysers / IDEs — no runtime import, no kernel cost
-    from draftwright._warnings import ScaleCompletenessWarning, SoftDeprecationWarning
+    from draftwright._warnings import (
+        ProjectionGeometryWarning,
+        ScaleCompletenessWarning,
+        SoftDeprecationWarning,
+    )
     from draftwright.builder import ScaleIncompatibilityError, build_drawing, make_drawing
     from draftwright.compose import choose_scale
     from draftwright.document import Document, DocumentBuildError, DocumentResult
@@ -147,6 +152,7 @@ __all__ = [
     "Sheet",
     "ScaleIncompatibilityError",
     "ScaleCompletenessWarning",
+    "ProjectionGeometryWarning",
     "ViewPlanIncomplete",
     "ViewConstraints",
     "ViewSpec",

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/_warnings.py

@@ -45,3 +45,7 @@ class ScaleCompletenessWarning(UserWarning):
     Callers can filter this policy decision independently of unrelated user warnings while
     still inspecting the complete machine-readable record on ``Drawing.scale_decision``.
     """
+
+
+class ProjectionGeometryWarning(UserWarning):
+    """A projector emitted geometry outside the source shape's possible view envelope."""

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/annotations/_common.py

@@ -3583,18 +3583,39 @@ def place_strip_candidates(
         todo = todo + rejected_total
         solved.extend(placed)
 
-    if len(solved) > 1:
+    if solved:
         assert len({name for name, _dim_obj in solved}) == len(solved), (
             "strip survivor names must be unique before label selection"
         )
         natural_solved = dict(solved)
-        adjusted = prevent_dimension_label_ink(
-            solved,
+        # Local dimensions already participate through strip occupancy, and dimensions
+        # owned by another view retain their independent corridor/repair contract.  The
+        # missing class is non-dimension ink whose semantic owner is another view: an
+        # outboard leader can physically enter this corridor even though the projected
+        # view blocks are disjoint (#1781).
+        committed = []
+        for name, annotation in dwg.iter_annotations():
+            owner = dwg.view_of(name)
+            if (
+                owner is not None
+                and owner != view
+                and not isinstance(annotation, (Dimension, SafeDimension, AngularDimension))
+                and type(annotation).__name__ not in CROSSABLE_TYPES
+            ):
+                committed.append((name, annotation))
+        committed_names = {name for name, _annotation in committed}
+        adjusted_batch = prevent_dimension_label_ink(
+            [*committed, *solved],
             page=(
                 _drawing_bounds(dwg) if hasattr(dwg, "page_w") and hasattr(dwg, "page_h") else None
             ),
-            immutable={name for name, _dim_obj in solved if (anchored or {}).get(name, False)},
+            immutable={
+                *committed_names,
+                *(name for name, _dim_obj in solved if (anchored or {}).get(name, False)),
+            },
+            perpendicular_step=tier + strip.spacing,
         )
+        adjusted = adjusted_batch[len(committed) :]
         # A label shift normally stays inside the dimension's measured span and
         # therefore inside its already-validated footprint.  Keep the validation
         # contract explicit nevertheless: if an unusual helper/style grows the real

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/annotations/from_model.py

@@ -990,8 +990,10 @@ def _obround_radius_candidates(
 
 
 # Corridor-ladder ordering (ADR 2 (was 0009) end state, #346): feature-SIZE dims sit nearer the
-# view (inner run), datum-referenced LOCATION dims stack outward (a single ascending chain
-# by datum distance). Segregating the two runs keeps a slot length from landing mid-ladder.
+# view (inner run), while datum-referenced LOCATION dims form one ascending outer chain.
+# Step-height rungs measure from the common height datum, so they belong to that value-ordered
+# run rather than to producer registration order (#1779). Segregating ordinary feature sizes
+# keeps a slot length or local boss height from landing mid-ladder.
 _SIZE_SUBCHAIN = 0
 _LOC_SUBCHAIN = 1
 _OVERALL_SUBCHAIN = 2
@@ -3729,6 +3731,37 @@ def _flat_label(across_text, sfx="") -> str:
     return f"{across_text}{sfx} A/F"
 
 
+def _flat_definition_count(members) -> int:
+    """Count repeated flat definitions without counting one centred opposed set as many.
+
+    ``axis_line`` and ``stock_span`` identify the provider's stock region, but interrupted
+    housing geometry can give several independent flat supports that share both.  A true
+    double-D or hex remains one definition because every support has its reflection through
+    that stock axis; a non-centred family retains one instance per source support.
+    """
+
+    if len(members) <= 1:
+        return 1
+    facts = members[0][0].facts
+    transverse = tuple(index for index, axis in enumerate("xyz") if axis != facts.axis)
+    centre = tuple(float(value) for value in facts.axis_line)
+    points = tuple(
+        tuple(float(member.facts.frame.origin[index]) for index in transverse)
+        for member, _dimension in members
+    )
+    centred = all(
+        any(
+            all(
+                abs(candidate[index] - (2.0 * centre[index] - point[index])) <= 0.01
+                for index in range(2)
+            )
+            for candidate in points
+        )
+        for point in points
+    )
+    return 1 if centred else len(members)
+
+
 def render_flats(dwg, plan, a, *, ctx, only=None) -> int:
     """Render physical stock definitions, counting identical ones without counting faces.
 
@@ -3791,8 +3824,9 @@ def render_flats(dwg, plan, a, *, ctx, only=None) -> int:
         vb = dwg.view_bounds(view)
         if vb is None:
             continue
-        if len(stocks) > 1:
-            label = f"{len(stocks)}× {label}"
+        definition_count = sum(_flat_definition_count(members) for _, members, _ in stocks)
+        if definition_count > 1:
+            label = f"{definition_count}× {label}"
         candidates = _flat_candidates(
             dwg,
             view,
@@ -6841,8 +6875,10 @@ def _render_height_ladder_in_view(dwg, plan, frame, *, ctx, detail_view, view) -
     # compiler's own number instead of re-deriving a convention from the rendered string,
     # which is the pattern ADR 4 (was 0016 Amendment 1) exists to stop.
     chain: list = []
+    order_values: dict[str, float] = {}
     if rung_set is not None and rung_set.representative:
         (rep,) = rungs
+        order_values["dim_step_typ"] = rep.value
         chain.append(
             (
                 "dim_step_typ",
@@ -6933,6 +6969,7 @@ def _render_height_ladder_in_view(dwg, plan, frame, *, ctx, detail_view, view) -
             if has_shoulders and rung.value * frame.scale < _MIN_STEP_DIM_MM:
                 short_rungs.append(rung)
                 continue
+            order_values[f"dim_step_{col}"] = rung.value
             chain.append(
                 (
                     f"dim_step_{col}",
@@ -7103,11 +7140,13 @@ def _render_height_ladder_in_view(dwg, plan, frame, *, ctx, detail_view, view) -
                 build=_build,
                 # Steps stack inner→outer in chain order; the overall height rides the
                 # OVERALL subchain so it lands outermost by construction (as the envelope
-                # dims do), replacing the old carve's outermost=True.
+                # dims do). Ordinary rungs join the same value-ordered baseline run as
+                # off-axis-hole heights (#1779), outside the inner boss-size run, instead
+                # of retaining producer registration order.
                 order=(
                     (_OVERALL_SUBCHAIN, 0, name)
                     if name == "dim_height"
-                    else (_SIZE_SUBCHAIN, k, name)
+                    else (_LOC_SUBCHAIN, order_values[name], name)
                 ),
                 on_place=lambda nm: None,
                 on_drop=_drop,

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/annotations/orchestrator.py

@@ -125,16 +125,50 @@ from draftwright.model.planner import annotation_groups, internal_section_rows
 from draftwright.progress import stage
 from draftwright.registry import MeasurementCell
 from draftwright.repair import reconcile_witness_labels
-from draftwright.view_plan import ViewConstraints
+from draftwright.view_plan import (
+    DERIVED_VIEW_IDENTIFIERS,
+    DerivedViewIdentifierPool,
+    ViewConstraints,
+    derived_view_identifier,
+)
+
+
+def _derived_view_identifier_pool(a) -> DerivedViewIdentifierPool:
+    """Reserve every authored section/detail identity before any derived view renders."""
+
+    constraints = a.view_constraints
+    if not isinstance(constraints, ViewConstraints):
+        return DerivedViewIdentifierPool(candidates=DERIVED_VIEW_IDENTIFIERS)
+    requested = (
+        constraints.derived
+        if constraints.derived_source == "authored"
+        else constraints.added_derived
+    )
+    identifiers = []
+    for item in requested:
+        identifier = derived_view_identifier(item.spec.kind, item.spec.name)
+        if identifier is None:
+            raise ValueError(
+                f"derived view {item.spec.name!r} from {item.source} has no canonical identifier"
+            )
+        identifiers.append(identifier)
+    return DerivedViewIdentifierPool(identifiers, candidates=DERIVED_VIEW_IDENTIFIERS)
 
 
-def _planned_sections(a, model, feature_keys) -> tuple[SectionPlan, ...]:
+def _planned_sections(a, model, feature_keys, *, identifiers) -> tuple[SectionPlan, ...]:
     """Combine the automatic section candidate with ADR 2 (was 0018) authored/add requests."""
 
     constraints = a.view_constraints
     if not isinstance(constraints, ViewConstraints):
         automatic = plan_sections(model, feature_keys)
-        return (automatic,) if automatic is not None else ()
+        if automatic is None:
+            return ()
+        label = identifiers.allocate()
+        if label is None:
+            raise ValueError(
+                "automatic section cannot be named: derived-view identifiers exhausted"
+            )
+        return (replace(automatic, label=label),)
 
     requested = (
         constraints.derived
@@ -158,8 +192,9 @@ def _planned_sections(a, model, feature_keys) -> tuple[SectionPlan, ...]:
                 f"section {item.spec.name!r} from {item.source} cuts at y={cut_y:g}, outside "
                 f"the part interior ({a.bb.min.Y:g}, {a.bb.max.Y:g})"
             )
-        slug = item.spec.name.removeprefix("section_")
-        label = slug[0].upper() if len(set(slug)) == 1 else slug.upper()
+        label = derived_view_identifier(item.spec.kind, item.spec.name)
+        if label is None:
+            raise ValueError(f"section {item.spec.name!r} has no canonical identifier")
         plans.append(
             SectionPlan(
                 cut_y,
@@ -173,12 +208,13 @@ def _planned_sections(a, model, feature_keys) -> tuple[SectionPlan, ...]:
 
     if constraints.derived_source != "authored":
         automatic = plan_sections(model, feature_keys)
+        if automatic is not None and any(plan.cut_y == automatic.cut_y for plan in plans):
+            automatic = None
         if automatic is not None:
-            used = {plan.label for plan in plans}
-            auto_label = next((letter for letter in "ABCDEFGH" if letter not in used), None)
+            auto_label = identifiers.allocate()
             if auto_label is None:
                 raise ValueError(
-                    "automatic section cannot be named: authored labels A-H are exhausted"
+                    "automatic section cannot be named: derived-view identifiers exhausted"
                 )
             plans.insert(0, replace(automatic, label=auto_label))
     return tuple(plans)
@@ -202,7 +238,9 @@ def _queue_authored_details(dwg, a, ctx, plan) -> None:
         if not (isinstance(target, tuple) and len(target) == 2 and target[0] == "feature"):
             raise ValueError(f"detail {item.spec.name!r} has no semantic feature target")
         feature = target[1]
-        label = item.spec.name.removeprefix("detail_").upper()
+        label = derived_view_identifier(item.spec.kind, item.spec.name)
+        if label is None:
+            raise ValueError(f"detail {item.spec.name!r} has no canonical identifier")
         factor = item.spec.scale_factor or 2.0
         if queue_step_detail(
             dwg,
@@ -626,7 +664,8 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     # Decide the section trigger + cut-plane row now (pure function of _model/
     # feature_keys, no placement dependency); the "reserve_section" stage reserves
     # its row and the "section" stage renders it.
-    _sections = _planned_sections(a, _model, feature_keys)
+    _derived_identifiers = _derived_view_identifier_pool(a)
+    _sections = _planned_sections(a, _model, feature_keys, identifiers=_derived_identifiers)
     ctx.dense_internal_section = any(section.internal_detail for section in _sections)
 
     # ── the stage thunks, run in _PASS_SEQUENCE order (#699 slice b) ─────────
@@ -902,7 +941,8 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
         # still render after it and avoid the section view.
         if _sections:
             for section in _sections:
-                _add_section_view(dwg, a, section, ctx=ctx)
+                if not _add_section_view(dwg, a, section, ctx=ctx):
+                    _derived_identifiers.release(section.label)
         else:
             # Recorded, not left at the initial `not_evaluated`: the planner DID run and
             # found no counterbore/spotface/blind Z-hole, which is a different fact from
@@ -917,7 +957,7 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
         # crowded turned heads alike — through the one generic detailer, now that all
         # views and main-view annotations are placed (so the detail avoids them).
         _queue_authored_details(dwg, a, ctx, _compiled)
-        _resolve_details(dwg, a, ctx=ctx)
+        _resolve_details(dwg, a, ctx=ctx, identifiers=_derived_identifiers)
 
     def _s_title_block():
         _add_title_block(dwg, a)

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/annotations/sections.py

@@ -53,8 +53,7 @@ from draftwright.annotations._common import carve_free_segments, strip_obstacles
 from draftwright.annotations.leaders import feature_leader_fixed_conflicts
 from draftwright.model import plan_sections
 from draftwright.projection import project_view_geometry
-
-_DETAIL_LETTERS = "ABCDEFGH"
+from draftwright.view_plan import DERIVED_VIEW_IDENTIFIERS, DerivedViewIdentifierPool
 
 
 def _section_identity(section) -> tuple[str, str, str]:
@@ -134,6 +133,8 @@ def add_section(dwg, model, a, *, ctx) -> list[str]:
     plan = plan_sections(model, feature_hole_keys(model, a))
     if plan is None:
         return []  # no qualifying internal detail — no section warranted
+    if _has_rendered_section(dwg, plan):
+        return []
     before = set(dwg.annotations())
     _add_section_view(
         dwg, a, plan, ctx=ctx
@@ -141,6 +142,17 @@ def add_section(dwg, model, a, *, ctx) -> list[str]:
     return sorted(set(dwg.annotations()) - before)
 
 
+def _has_rendered_section(dwg, section) -> bool:
+    """Whether this semantic cut plane already owns a rendered section view."""
+
+    cut_y = float(section.cut_y)
+    return any(
+        getattr(annotation, "_dw_section_cut_y", None) == cut_y
+        and getattr(annotation, "_dw_section_view", None) in dwg.views
+        for _name, annotation in dwg.iter_annotations()
+    )
+
+
 def _section_hatch_edges(face, SX, SZ, spacing):
     """Return 45° ISO 128-50 hatch Edge objects for one cut face in page coords.
 
@@ -260,7 +272,7 @@ def _cut_section(body, cutter):
     return shape, faces
 
 
-def _add_section_view(dwg, a: Analysis, section, *, ctx):
+def _add_section_view(dwg, a: Analysis, section, *, ctx) -> bool:
     """Render the planned full section A–A (#94, #207).
 
     The *trigger* + cut-plane row are decided by the planner (`plan_sections` →
@@ -324,7 +336,7 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
             f"{2 * half_w:.1f} mm section within x<={right_limit:.1f}",
             section=section,
         )
-        return
+        return False
     # The section's row dips into the title-block band only when its CAPTION does —
     # the view itself can clear the block while the caption at `-half_h - 7` does not,
     # which is exactly why GRM-01 is refused on A4 (view bottom y 49.5, caption y 42.5,
@@ -347,7 +359,7 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
             f"y={_TB_CLEAR + _TB_H:.1f} out to x={tb_left:.1f}",
             section=section,
         )
-        return
+        return False
     pos_x = usable[0][0] + half_w
 
     big = 4 * a.bbox_max
@@ -357,7 +369,7 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
     solids = a.part.solids()
     if not solids:
         _skip_section(dwg, ctx, "no_solids", "no solid bodies to cut", section=section)
-        return
+        return False
     body = solids[0] if len(solids) == 1 else Compound(children=list(solids))
     try:
         # Fuzzy boolean: the exact `body - Box(...)` aborts uncatchably
@@ -365,16 +377,16 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
         cut = _cut_section(body, Pos(a.cx, y_star - big / 2, a.cz) * Box(big, big, big))
     except Exception as exc:  # noqa: BLE001 — OCC booleans raise broadly
         _skip_section(dwg, ctx, "cut_failed", f"cut failed: {exc}", section=section)
-        return
+        return False
     if cut is None:
         _skip_section(dwg, ctx, "cut_empty", "boolean cut produced no solid", section=section)
-        return
+        return False
     keep_behind, cut_faces = cut
     if not cut_faces:
         _skip_section(
             dwg, ctx, "cut_no_intersection", "cut plane creates no section faces", section=section
         )
-        return
+        return False
     # Resolve the final cutting-plane ink before committing the section view.
     # Optional section furniture yields if a required landed feature leader
     # consumed the conservative provisional row.
@@ -434,7 +446,7 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
             + ", ".join(f"{leader}/{component}" for leader, component in conflicts),
             section=section,
         )
-        return
+        return False
 
     camera = (dwg.look_at[0], dwg.look_at[1] - dwg.dist, dwg.look_at[2])
     dwg._add_view(view_name, keep_behind, camera, (0, 0, 1), (pos_x, a.FV_Y))
@@ -462,13 +474,17 @@ def _add_section_view(dwg, a: Analysis, section, *, ctx):
         hatch = Compound(children=hatch_edges)
         hatch.is_section_hatch = True  # exempt from view_annotation_overlap lint
         ctx.place(hatch, f"{prefix}_hatch")
+    return True
 
 
 def _place_cutting_plane(dwg, y_page, x0, x1, *, section, ctx):
     """Place one complete, unmeasured cutting-plane furniture candidate."""
 
-    _label, _view, prefix = _section_identity(section)
-    ctx.place(Centerline((x0, y_page, 0), (x1, y_page, 0)), f"{prefix}_line")
+    _label, view_name, prefix = _section_identity(section)
+    line = Centerline((x0, y_page, 0), (x1, y_page, 0))
+    line._dw_section_cut_y = float(section.cut_y)
+    line._dw_section_view = view_name
+    ctx.place(line, f"{prefix}_line")
     _add_cutting_plane_arrows(dwg, y_page, x0, x1, section=section, ctx=ctx)
     _add_section_letters(dwg, y_page, x0, x1, section=section, ctx=ctx)
 
@@ -893,7 +909,7 @@ def _render_detail(
     return True
 
 
-def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
+def _resolve_details(dwg, a: Analysis, *, ctx, identifiers=None) -> None:
     """Resolve every queued :class:`DetailRequest` (#307) through the one generic
     detailer, lettering DETAIL A/B/… On a placement bail-out nothing is drawn for that
     request — the main view already carries the located head/block inline, so lint
@@ -901,10 +917,11 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
     the queue."""
     reqs = list(ctx.detail_requests)
     ctx.detail_requests = []
-    reserved = {req.label for req in reqs if req.label is not None}
-    if len(reserved) != sum(req.label is not None for req in reqs):
-        raise ValueError("authored detail labels must be unique")
-    used: set[str] = set()
+    if identifiers is None:
+        identifiers = DerivedViewIdentifierPool(
+            (req.label for req in reqs if req.label is not None),
+            candidates=DERIVED_VIEW_IDENTIFIERS,
+        )
 
     def _record_prismatic_failure(req, message):
         if req.kind != "prismatic-steps":
@@ -918,14 +935,13 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
         )
 
     for req in reqs:
-        letter = req.label or next(
-            (candidate for candidate in _DETAIL_LETTERS if candidate not in reserved | used), None
-        )
+        automatic_identifier = req.label is None
+        letter = req.label or identifiers.allocate()
         if letter is None:
-            _log.info("detail request '%s' dropped: detail letters A–H exhausted", req.kind)
+            _log.info("detail request '%s' dropped: derived-view identifiers exhausted", req.kind)
             _record_prismatic_failure(
                 req,
-                f"{req.kind} detail view requested but detail letters A–H are exhausted",
+                f"{req.kind} detail view requested but derived-view identifiers are exhausted",
             )
             continue
         view_name = req.view_name or f"detail_{letter.lower()}"
@@ -959,14 +975,12 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
                 # behind when it was added (Codex r2).
                 ctx.place(hobj, hname)
                 dwg.registry.reapply(hname, ident)
-        if placed:
-            used.add(letter)
-        elif req.keep_without_annotations or req.view_name is not None:
+        if not placed and (req.keep_without_annotations or req.view_name is not None):
             raise ValueError(
                 f"authored detail {letter!r} from {req.source} is infeasible on this sheet; "
                 "its target, scale, or whole-view footprint was not relaxed"
             )
-        elif req.kind == "prismatic-steps":
+        elif not placed and req.kind == "prismatic-steps":
             # (#630) The prismatic-steps request is queued when detail recovery is enabled
             # (_request_prismatic_detail's gate), so a bail-out here means the requested
             # recovery produced nothing. Say so — with an
@@ -990,6 +1004,8 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
                     "sheet (the crowded band is too wide to enlarge and still fit); dimension "
                     "the feature manually or move it onto its own sheet",
                 )
+        if not placed and automatic_identifier:
+            identifiers.release(letter)
 
 
 def _overall_height_name(dwg, a: Analysis) -> str | None:

{draftwright-0.4.32 → draftwright-0.4.33}/src/draftwright/builder.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import collections
 import json
+import math
 import os
 import warnings
 from collections.abc import Callable, Iterable, Sequence
@@ -2145,6 +2146,7 @@ def build_drawing(
     margin_bottom: float | None = None,
     title_block_width: float | None = None,
     leader_region: Literal["auto", "interior", "exterior"] = "auto",
+    _replayed_scale: float | None = None,
 ) -> Drawing:
     """Build a drawing, protecting required annotations under an explicit scale.
 
@@ -2177,6 +2179,16 @@ def build_drawing(
     validate_projection(projection, projection_symbol=projection_symbol)
     _dimension_draft(text_position, text_orientation)
     leader_region = leader_region_policy(leader_region).value
+    if _replayed_scale is not None:
+        _replayed_scale = float(_replayed_scale)
+        if not math.isfinite(_replayed_scale) or _replayed_scale <= 0:
+            raise ValueError(
+                f"_replayed_scale must be finite and positive, got {_replayed_scale!r}"
+            )
+        if scale is not None:
+            raise ValueError("_replayed_scale cannot be combined with authored scale=")
+        if page is None:
+            raise ValueError("_replayed_scale requires the settled page")
     if scale_policy not in {"strict", "fallback", "permissive"}:
         raise ValueError(
             f"scale_policy must be 'strict', 'fallback', or 'permissive', got {scale_policy!r}"
@@ -2981,6 +2993,39 @@ def build_drawing(
                                     drawing = larger
                                     settled_issues = issues
                                     replanned = True
+        if _replayed_scale is not None and abs(drawing.scale - _replayed_scale) > 1e-12:
+            # Let the declared model take the complete automatic recovery path first. Most
+            # replays (including detail-bearing step drawings) naturally recover the recorded
+            # scale and must retain that measured history unchanged. Only a final scale drift
+            # pays for one bounded rebuild under the already settled topology/arrangement.
+            replayed = _build(
+                _replayed_scale,
+                arrangements=(settled_arrangement,),
+                views=_principal_names(drawing),
+                include_iso="iso" in drawing.views,
+                retry_reason="replay_settled_scale",
+            )
+            replay_issues, replay_blockers, rejection = _qualify_candidate(
+                replayed,
+                require_axial_coverage=False,
+                allow_recovery_detail=True,
+            )
+            if rejection is not None:
+                raise ValueError(
+                    f"settled scale replay {_replayed_scale!r} is no longer valid: {rejection}; "
+                    f"issues={[(issue.code, issue.severity) for issue in replay_issues]}"
+                )
+            _record_attempt(
+                replayed.scale,
+                "complete",
+                replay_blockers,
+                reason="replay_settled_scale",
+                candidate=replayed,
+            )
+            drawing = replayed
+            settled_issues = replay_issues
+            replanned = True
+
         # The default record, set BEFORE the completeness pass so that pass can replace it.
         # It used to be assigned afterwards and silently overwrote whatever the pass had
         # decided, so an incomplete plan reported itself as an ordinary automatic one.