draftwright 0.4.14__tar.gz → 0.4.16__tar.gz

{draftwright-0.4.14 → draftwright-0.4.16}/CHANGELOG.md

@@ -4,6 +4,26 @@
 
 ### Added
 
+- Referential and measured Sheet dimensions accept optional `view=` / `side=` placement
+  intent. Supported pairs survive IR/compiler and generated-script round trips, constrain
+  ordinary corridor candidates without exposing page coordinates, and fail clearly when a
+  renderer cannot honour the requested view/strip. Compound hole callouts can therefore be
+  authored to opposite sides of one end view while retaining normal solve and lint behavior
+  (#563).
+- Feature-linked Sheet notes can explicitly satisfy one or more canonical requirement ids with
+  `.note(..., satisfies=(...))`. Placed structured notes retain each requirement's identity in
+  coverage reports and generated scripts without masquerading as dimensions or parsing prose;
+  removing the note restores the ordinary missing/suppressed diagnostics (#1351).
+- `Sheet.from_part(...).take_over(...)` now adopts detected features in place while choosing
+  authored or automatic dimension, principal-view, and derived-view sources explicitly. This
+  preserves detected handles, supports automatic principal views with authored requirements,
+  replaces or suppresses inferred sections without duplicates, and round-trips the adopted view
+  request through generated Sheet code (#1350).
+- Referential Sheet dimensions can preserve an explicit number of decimal places with
+  `sheet.dimension(feature, "parameter.id").format(decimals=n)`. The policy changes only
+  printed display text: numeric reconciliation, tolerances, suppression and dimension
+  provenance continue to use the feature parameter, and generated Sheet scripts round-trip the
+  policy (#1349).
 - New lint code `annotation_ink_overlap`: reports another annotation's line-work —
   a dimension line, an extension line or a leader shaft — drawn through a label's
   text, which `annotation_overlap` cannot see because it compares label boxes to
@@ -17,6 +37,11 @@
 
 ### Changed
 
+- Declared Double-D bore, countersink, chamfer, fillet, and groove geometry reads now use the
+  stable `b123d_recognisers.inspection` namespace from the exact 0.4.5 wheel. A separate
+  Draftwright-owned format-1 contract fails closed on changes to the consumed signatures, result
+  schemas, units, bevel rejection reasons, or cylindrical surface layout (#1362).
+
 - `annotation_overlap` now reports the whole defect when the same pair also draws
   line-work through one of the two labels: the message names the crosser, the label
   crossed and the millimetres, and replaces the "use `label_offset_x`" remedy, which
@@ -40,6 +65,9 @@
 
 ### Fixed
 
+- Non-1:1 orthographic and isometric projection now scales extracted solids about the world
+  origin, matching the view-coordinate mapper and solver zones. Solids carrying a non-zero
+  build123d `Location` no longer shift their silhouette away from dimensions and callouts.
 - Notes and generic table cells now render U+2300 `⌀` with the established supported drafting
   glyph instead of IBM Plex Mono's missing-glyph square. The substitution happens at the one
   shared measurement/render seam, so source rows remain unchanged and table sizing stays exact

{draftwright-0.4.14 → draftwright-0.4.16}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.14
+Version: 0.4.16
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
 Project-URL: Issues, https://github.com/pzfreo/draftwright/issues
 Project-URL: Changelog, https://github.com/pzfreo/draftwright/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://pzfreo.github.io/draftwright/
-Author-email: Paul Fremantle <pzfreo@gmail.com>
+Author-email: Paul Fremantle <paul@fremantle.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
                                Version 3, 19 November 2007
         
@@ -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.3.1
+Requires-Dist: b123d-recognisers==0.4.5
 Requires-Dist: build123d-drafting-helpers>=0.14.2
 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'
@@ -823,6 +823,24 @@ a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs
 targets are placed automatically — the view and strip are derived from the referenced
 feature or face, with `view=`/`side=` overrides.
 
+A feature-linked note can explicitly satisfy requirements that are legitimately communicated
+as one compound shop instruction instead of separate dimensions. Use the canonical ids exposed
+by the handle; free prose alone never changes coverage:
+
+```python
+assert "counterbore.diameter" in hole.dimension_ids()
+hole.note(
+    "PROFILED BORE: ⌀14 × 8 DEEP",
+    satisfies=("counterbore.diameter", "counterbore.depth"),
+)
+```
+
+Each id remains independent provenance in `drawing.registry.satisfaction_of(annotation_name)`;
+the semantic family outcomes report `satisfied_by_structured_note`, while
+`drawing.lint_summary()["quality"]["completeness"]` aggregates the count. The assertion counts
+only if the normal placement solve places the note. Generated Sheet scripts preserve the
+structured claim. Invalid, duplicate, ambiguous, or face-only claims fail at declaration time.
+
 ### From a part to an object-referenced script
 
 `draftwright part.step --script` writes an editable `Sheet` script. When you built the part

{draftwright-0.4.14 → draftwright-0.4.16}/README.md

@@ -123,6 +123,24 @@ a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs
 targets are placed automatically — the view and strip are derived from the referenced
 feature or face, with `view=`/`side=` overrides.
 
+A feature-linked note can explicitly satisfy requirements that are legitimately communicated
+as one compound shop instruction instead of separate dimensions. Use the canonical ids exposed
+by the handle; free prose alone never changes coverage:
+
+```python
+assert "counterbore.diameter" in hole.dimension_ids()
+hole.note(
+    "PROFILED BORE: ⌀14 × 8 DEEP",
+    satisfies=("counterbore.diameter", "counterbore.depth"),
+)
+```
+
+Each id remains independent provenance in `drawing.registry.satisfaction_of(annotation_name)`;
+the semantic family outcomes report `satisfied_by_structured_note`, while
+`drawing.lint_summary()["quality"]["completeness"]` aggregates the count. The assertion counts
+only if the normal placement solve places the note. Generated Sheet scripts preserve the
+structured claim. Invalid, duplicate, ambiguous, or face-only claims fail at declaration time.
+
 ### From a part to an object-referenced script
 
 `draftwright part.step --script` writes an editable `Sheet` script. When you built the part

{draftwright-0.4.14 → draftwright-0.4.16}/docs/reference/recogniser-capabilities.md

@@ -11,6 +11,15 @@ completeness treatment, and documentation. A stage is either `supported`, `defer
 other CAD consumers apply different policy without making Draftwright policy part of the geometry
 library.
 
+Declared-feature geometry reads use a different public boundary. The installed package's
+inspection manifest format 1 is joined to the separate Draftwright-owned declaration in
+`draftwright.inspection_contract`. That contract admits inspection API major 1 and exactly the
+consumed `b123d_recognisers.inspection` symbol schemas: the five geometry readers, their public
+result/error types, the cylindrical surface parameter layout, bevel rejection reasons, and the
+semantic names and units of the Double-D tuple. It also checks the exact installed package
+version. Recognition-family policy does not leak into this smaller measurement contract, and an
+additive inspection symbol does not pretend to be a new recogniser family.
+
 ## What failures mean
 
 Validation fails closed and names the family and boundary whenever possible:
@@ -67,31 +76,23 @@ with no inferred gear feature added to fill the table.
 
 ## Passage compatibility boundary
 
-The installed `b123d-recognisers==0.3.1` release already contains the `passages` family introduced
-in 0.2.6. Draftwright declares its schema-v1 `Passage` output exhaustively but deliberately keeps
-the family `unsupported`, with the drafting decision tracked by issue #1245. This is a truthful
-consumer disposition: the geometry remains visible in the aggregate inventory, while Draftwright
-does not invent an IR feature, DSL declaration, generated code, drawing annotation, or completeness
-requirement for it.
-
-Draftwright's exact dependency pin must remain on a reviewed released version in the interval
-`>=0.2.6,<0.4.0` until the separately reviewed F4b transition is ready. The lower boundary ensures
-the installed manifest really contains `passages`; the upper boundary prevents accidental adoption
-of the planned 0.4 compatibility change.
+The installed `b123d-recognisers==0.4.5` release contains the `passages` family introduced
+in 0.2.6. Version 0.4.0 makes `SectionPassage` the authoritative physical output and retains
+schema-v1 `Passage` as its compatibility projection. Draftwright declares all six public and nested
+record schemas exhaustively but deliberately keeps the family `unsupported`, with the drafting
+decision tracked by issue #1245. This is a truthful consumer disposition: both aggregate
+inventories are visible and explicitly unscored, while Draftwright does not invent an IR feature,
+DSL declaration, generated code, drawing annotation, or completeness requirement for them.
 
-The reviewed future 0.4 model is a distinct migration, not latent behavior in this declaration:
+The 0.4 contract is explicit:
 
 - `SectionPassage` will be the authoritative physical output and aggregate census source;
 - legacy `Passage` values will be an accepted-only compatibility projection;
 - `recognise_passages(..., ledger=...)` will be a fail-loud unavailable compatibility operation;
 - the writer-free `recognise_passages` name will remain public but non-authoritative; and
-- rich split-junction passages can supersede a currently rendered Slot claim, moving ownership to
-  the Passage family through `SLOT_SUPERSEDED_BY_PASSAGE`; and
-- the capability contract must represent those API and per-output roles exhaustively before the
-  dependency pin can cross 0.4.
-
-That migration must update the package release, Draftwright adapter and declaration model,
-validator, tests, exact pin, and lockfile together. The current validator remains unchanged and
-fail closed; there is no forward declaration or stale-manifest exception. Crossing 0.4 also
-requires #1245 to decide what those newly Passage-owned occurrences draw, or an explicit reviewed
-decision to accept the resulting loss of the existing Slot callout.
+- rich split-junction passages can supersede a Slot claim, moving physical ownership to the
+  unsupported Passage family through `SLOT_SUPERSEDED_BY_PASSAGE`.
+
+The exact 0.4.5 pin, manifest-v2 validator and explicit unsupported inventories make that limitation
+fail-visible rather than silently treating rich passages as supported. Issue #1245 still owns the
+decision about what newly Passage-owned occurrences draw and how they participate in completeness.

draftwright-0.4.16/docs/reference/sheet.md

@@ -0,0 +1,174 @@
+# Sheet and fluent handles
+
+`Sheet` is the declared authoring façade. Feature verbs return fluent handles; those handles
+are documented here because they are part of normal use even though their Python names begin
+with an underscore.
+
+## Sheet
+
+::: draftwright.sheet.Sheet
+    options:
+      filters: public
+
+### Authored views and layout
+
+View declarations are semantic constraints. They name projections, relationships and whole-view
+anchors; the layout solve owns the resulting page positions. Authored views must be paired with
+authored dimensions so a deliberately omitted view cannot strand planner-selected annotations:
+
+```python
+s = Sheet(part).authored_dimensions().authored_views()
+front = s.view("front")
+plan = s.view("plan").above(front, gap=4).align_x(front)
+s.view("iso").scale(0.75)
+
+section = s.section_view("A", through=hole)
+detail = s.detail_view("B", around=hole).scale(2)
+dwg = s.build()
+```
+
+`view(...)`, `section_view(...)` and `detail_view(...)` define complete authored sets;
+omission suppresses a view. `add_view(...)`, `add_section_view(...)` and
+`add_detail_view(...)` augment an explicitly selected `auto_views()` source. `row(...)` and
+`column(...)` are shorthand for whole-view relations. A principal-view handle's `pin((x, y))`
+anchors its projection origin in page millimetres; it never positions an annotation.
+
+Principal orthographic views share the sheet scale and reject `.scale(...)`. Detail and
+isometric handles may carry an independent positive factor. Infeasible relations, scales and
+pins raise with their declaration source; unsupported pins on derived or pictorial views are
+refused at declaration and constraints are never silently relaxed. The immutable authored
+snapshot is available as `sheet.view_constraints`, while `drawing.view_plan` is the distinct
+resolved result.
+
+### Taking over a detected baseline
+
+`Sheet.from_part(part)` retains the detector's feature set and starts with implicit automatic
+dimensions. Use `take_over(...)` to adopt that same Sheet as an explicit editable request without
+copying features into a second Sheet:
+
+```python
+s = Sheet.from_part(part)
+hole = s.of(next(feature for feature in s.features if feature.kind == "hole"))
+s.take_over(
+    dimensions="authored",
+    principal_views="automatic",
+    derived_views="authored",
+)
+s.dimension(hole, "bore.diameter")
+s.section_view("A", through=hole)
+```
+
+The three sources are chosen atomically. In this example the principal planner keeps the
+automatic front/plan/side/isometric baseline, while the authored derived set replaces inferred
+sections. Leaving that authored set empty suppresses inferred derived views; selecting
+`derived_views="automatic"` accepts them. Matching declarations may appear before or after
+`take_over(...)` with the same result. Explicit source contradictions fail without partially
+changing the Sheet, and automatic dimensions remain incompatible with authored views under ADR
+0018.
+
+To emit editable Python from an adopted Sheet, pass both request halves to the script emitter;
+the model carries the feature/dimension semantics and `view_constraints` carries the independent
+view sources and semantic targets:
+
+```python
+from draftwright.sheet_emit import emit_sheet_script
+
+source = emit_sheet_script(
+    s.model(),
+    "part = make_part()",
+    "drawing",
+    title="BRACKET",
+    number="DWG-001",
+    view_constraints=s.view_constraints,
+)
+```
+
+### Refining a staged hole into manufacturing authority
+
+A detected hole remains a live feature handle after takeover. Enrich that handle instead of
+declaring a second, unrelated annotation. Counterbore/spotface tools can supply their geometry;
+thread and fit are authored manufacturing intent:
+
+```python
+s = Sheet.from_part(part, page="A2", scale=1)
+stack = s.of(next(feature for feature in s.features if feature.kind == "hole"))
+s.take_over(
+    dimensions="authored",
+    principal_views="automatic",
+    derived_views="authored",
+)
+
+stack.cbore(collar_tool)                 # diameter and depth re-read from the tool
+stack.thread("M6x1", depth=12).fit("H8")
+for parameter_id in stack.dimension_ids():
+    intent = s.dimension(stack, parameter_id)
+    if parameter_id == "counterbore.diameter":
+        intent.format(decimals=2)        # 6.35 remains 6.35, still feature-linked
+
+s.section_view("A", through=stack)       # replaces inferred derived views
+drawing = s.build()
+assert not [issue for issue in drawing.lint() if issue.severity != "info"]
+drawing.export("quote/grm01", formats=("pdf", "svg", "dxf"))
+```
+
+An explicit tap depth is a real `thread.depth` parameter: it appears in
+`dimension_ids()`, participates in authored-set suppression and placement, and round-trips
+through generated Sheet code. `fit("H8")` applies only to `bore.diameter`; it does not leak
+onto a counterbore diameter. A plain `thread("M6x1")` remains valid when no independent depth is
+specified.
+
+This surface models the common bore + recess + tap-depth stack in one solver-participating
+callout. More general ordered operation stacks remain tracked by issue #1360. Until a physical
+requirement has a structured parameter, use a feature-linked `note(..., satisfies=(...))` only
+for parameter ids the handle actually exposes; free prose does not satisfy coverage.
+
+## View handle
+
+::: draftwright.sheet._View
+    options:
+      filters: public
+
+## Dimension intent handle
+
+`dimension(feature, parameter_id)` and `add_dimension(feature, parameter_id)` return a
+referential `DimensionIntent`. The handle never carries a replacement nominal and never chooses
+page coordinates. Use `format(decimals=n)` to preserve between 0 and 15 decimal places in the
+printed nominal while reconciliation, tolerance, suppression and provenance continue to read the
+numeric parameter from the feature. Optional `view="front|plan|side"` and
+`side="above|below|left|right"` arguments select a supported semantic corridor when authored
+routing must override the derived default; the normal placement solve still chooses coordinates
+and reports capacity/crossing failures. Trailing zeroes are intentional manufacturing display text:
+
+```python
+sheet.authored_dimensions()
+sheet.dimension(envelope, "width.length").format(decimals=2)  # 13.5 prints as 13.50
+sheet.dimension(tapped_hole, "bore.diameter", view="plan", side="left")
+```
+
+::: draftwright.sheet.DimensionIntent
+    options:
+      filters: public
+
+## Hole handle
+
+::: draftwright.sheet._Hole
+    options:
+      filters: public
+
+## Diameter and step handle
+
+::: draftwright.sheet._Dim
+    options:
+      filters: public
+
+## Multi-parameter handle
+
+::: draftwright.sheet._Params
+    options:
+      filters: public
+
+## GD&T control builder
+
+::: draftwright.sheet._Control
+    options:
+      filters: public

{draftwright-0.4.14 → draftwright-0.4.16}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.14"
+version = "0.4.16"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
-authors = [{ name = "Paul Fremantle", email = "pzfreo@gmail.com" }]
+authors = [{ name = "Paul Fremantle", email = "paul@fremantle.org" }]
 requires-python = ">=3.10,<3.15"
 dependencies = [
     # build123d ≤0.10 pulls cadquery-ocp (VTK), whose VTK caps at Python 3.12; 0.11 switched to
@@ -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.2",
-    "b123d-recognisers==0.3.1",
+    "b123d-recognisers==0.4.5",
     "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

{draftwright-0.4.14 → draftwright-0.4.16}/src/draftwright/_core.py

@@ -29,7 +29,18 @@ if TYPE_CHECKING:
 
     from draftwright.compose import StripDepths
 
-from build123d import Align, BoundBox, Compound, Edge, Location, Mode, Shape, Text, Vector
+from build123d import (
+    Align,
+    BoundBox,
+    Compound,
+    Edge,
+    FontStyle,
+    Location,
+    Mode,
+    Shape,
+    Text,
+    Vector,
+)
 from build123d_drafting.helpers import (
     Dimension,
     TitleBlock,
@@ -86,7 +97,16 @@ def _decode_hole_location_fact(fact):
     return feature, parameter, point
 
 
-def place_annotation(registry, items, obj, name=None, view=None, feature=None, measurement=None):
+def place_annotation(
+    registry,
+    items,
+    obj,
+    name=None,
+    view=None,
+    feature=None,
+    measurement=None,
+    satisfaction=None,
+):
     """The annotation-placement primitive (#817): register *obj* under *name* — replacing any
     prior object of that name (dropped from the render list *items*) so a name maps to one
     object — append it to *items*, and record its owning *view* + source *feature* in *registry*.
@@ -94,13 +114,15 @@ def place_annotation(registry, items, obj, name=None, view=None, feature=None, m
     annotations without reaching into the ``Drawing``. Returns *obj*.
 
     *measurement* is the `DimensionId` *obj* draws, where the caller holds one (#1002) —
-    one axis finer than *feature*, since a feature has several measurements."""
+    one axis finer than *feature*, since a feature has several measurements. *satisfaction*
+    is the separate set of requirements a structured note explicitly satisfies (#1351); it
+    never claims that the note drew a measurement."""
     displaced = registry.named(name) if name is not None else None
     if displaced is not None:
         items.remove(displaced)
     annotate(obj, name)
     items.append(obj)
-    registry.add(obj, name, view, feature, measurement)
+    registry.add(obj, name, view, feature, measurement, satisfaction)
     return obj
 
 
@@ -362,6 +384,7 @@ def _text_size(
     font_size: float,
     font_path: str | None = PLEX_MONO,
     font: str = "Arial",
+    font_style: FontStyle = FontStyle.REGULAR,
 ) -> tuple[float, float]:
     """Measured rendered (width, height) (page-mm) of *text* at *font_size*.
 
@@ -383,12 +406,43 @@ def _text_size(
         font_size=font_size,
         font=font,
         font_path=font_path,
+        font_style=font_style,
         align=(Align.CENTER, Align.CENTER),
         mode=Mode.PRIVATE,
     ).bounding_box()
     return (bb.size.X, bb.size.Y)
 
 
+@functools.lru_cache(maxsize=32)
+def _text_line_spacing_em(
+    font_size: float,
+    font_path: str | None = PLEX_MONO,
+    font: str = "Arial",
+) -> float:
+    """Return OCCT's actual newline advance for a regular face, in em units.
+
+    The advance is face-dependent (Plex Mono is 1.3 em; named Arial on macOS is
+    about 1.15 em).  Measure the same repeated glyph twice through build123d so
+    the invisible PDF layer follows the renderer instead of baking either value.
+    """
+    probe = Text(
+        txt="A\nA",
+        font_size=font_size,
+        font=font,
+        font_path=font_path,
+        font_style=FontStyle.REGULAR,
+        align=(Align.CENTER, Align.CENTER),
+        mode=Mode.PRIVATE,
+    )
+    centres = sorted(
+        ((face.bounding_box().min.Y + face.bounding_box().max.Y) / 2.0 for face in probe.faces()),
+        reverse=True,
+    )
+    if len(centres) < 2:  # pragma: no cover - defensive for a pathological font
+        return 1.3
+    return abs(centres[0] - centres[-1]) / font_size
+
+
 def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> float:
     """Measured rendered width (page-mm) of *text* — see :func:`_text_size`."""
     return _text_size(text, font_size, font_path)[0]
@@ -1207,16 +1261,25 @@ def _make_title_block(dwg, a: Analysis):
     drawn-by cell bbox (for the hyperlink rect). Shared by :func:`_add_title_block` (which adds
     it, last) and :func:`_title_block_box` (which measures its footprint for GD&T avoidance, #481)
     so the two never drift."""
+    title = _font_safe_text(a.title)
+    number = _font_safe_text(a.number)
+    tolerance = _font_safe_text(a.tolerance)
+    designed_by = _font_safe_text(_attribution_author(a.drawn_by))
+    material = _font_safe_text(a.material)
+    date = _font_safe_text(a.date)
+    revision = _font_safe_text(a.revision)
+    legal_owner = _font_safe_text(a.company)
+    scale = format_drawing_scale(a.SCALE)
     tb = TitleBlock(
-        _font_safe_text(a.title),
-        _font_safe_text(a.number),
-        scale=format_drawing_scale(a.SCALE),
-        general_tolerance=_font_safe_text(a.tolerance),
-        designed_by=_font_safe_text(_attribution_author(a.drawn_by)),
-        material=_font_safe_text(a.material),
-        date=_font_safe_text(a.date),
-        revision=_font_safe_text(a.revision),
-        legal_owner=_font_safe_text(a.company),
+        title,
+        number,
+        scale=scale,
+        general_tolerance=tolerance,
+        designed_by=designed_by,
+        material=material,
+        date=date,
+        revision=revision,
+        legal_owner=legal_owner,
         width=a.TB_W,
         # Title block renders in condensed sans (the tight ISO 7200 cells), a
         # different face from the monospace dimensions — so it carries its own
@@ -1231,7 +1294,37 @@ def _make_title_block(dwg, a: Analysis):
     # than hardcoded column fractions, so the hyperlink rect tracks any upstream
     # TitleBlock layout change. Build-frame bbox; translated to page space below.
     cell = tb.drawn_by_cell_bbox()
-    tb = tb.locate(Location((a.PAGE_W - a.TB_W - _TB_CLEAR, _TB_CLEAR, 0)))
+    bx, by = a.PAGE_W - a.TB_W - _TB_CLEAR, _TB_CLEAR
+    tb = tb.locate(Location((bx, by, 0)))
+
+    # Retain authoritative title-block values at their public cell centres for the PDF semantic
+    # text layer.  The visible block stays path-rendered; these specs merely let export embed the
+    # same bundled condensed face as invisible selectable text without parsing SVG geometry.
+    fields = (
+        ("title", title),
+        ("drawing_number", number),
+        ("scale", scale),
+        ("material", material),
+        ("revision", revision or date),
+        ("general_tolerance", tolerance),
+        ("designed_by", designed_by),
+        ("legal_owner", legal_owner),
+    )
+    specs = []
+    for field, value in fields:
+        if not value:
+            continue
+        box = tb.cell_bbox(field)
+        specs.append(
+            (
+                value,
+                bx + (box["min_x"] + box["max_x"]) / 2.0,
+                by + (box["min_y"] + box["max_y"]) / 2.0,
+                dwg.draft.font_size,
+                PLEX_SANS_CONDENSED,
+            )
+        )
+    tb.pdf_text_specs = tuple(specs)
     return tb, cell
 
 

{draftwright-0.4.14 → draftwright-0.4.16}/src/draftwright/_geometry.py

@@ -14,9 +14,10 @@ from __future__ import annotations
 import logging
 import math
 from dataclasses import dataclass
+from inspect import signature
 
 from b123d_recognisers import full_cylinders
-from build123d import Compound
+from build123d import Compound, Shape
 
 _log = logging.getLogger(__name__)
 
@@ -190,6 +191,23 @@ def _solids_body(part, src: str = "part"):
     return body
 
 
+_SCALE_SUPPORTS_ABOUT = "about" in signature(Shape.scale).parameters
+
+
+def _scale_world(shape, factor: float):
+    """Scale a build123d shape about the world origin on every supported version.
+
+    build123d 0.9/0.10's factor-only ``Shape.scale`` uses the world origin. Version 0.11 added
+    ``about=`` and changed the default to ``shape.location.position``. Draftwright supports both
+    dependency lines, so select the signature once and state the same world-origin transform on
+    either API without converting analytic geometry through a general affine transform.
+    """
+
+    if _SCALE_SUPPORTS_ABOUT:
+        return shape.scale(factor, about=(0, 0, 0))
+    return shape.scale(factor)
+
+
 def _axis_letter(obj) -> str:
     """Letter (``"x"``/``"y"``/``"z"``) of ``obj.axis``'s dominant component.
 
@@ -337,11 +355,18 @@ def _axis_direction_is_aligned(axis: str, direction, *, tol: float = 1e-3) -> bo
     )
 
 
-def _fmt(v: float) -> str:
+def _fmt(v: float, decimals: int | None = None) -> str:
     """Format a float as integer string if whole, otherwise 1 dp. The one number
     formatter the IR (:mod:`draftwright.model.ir`) and the drawing layers
     (:mod:`draftwright._core`) share (#700 — the two copies had already begun to
-    drift on ``-0``)."""
+    drift on ``-0``).
+
+    ``decimals`` is an explicit referential-dimension display policy (#1349). It preserves
+    trailing zeroes by design; ``None`` retains the established automatic formatting.
+    """
+    if decimals is not None:
+        normalized = 0.0 if round(float(v), decimals) == 0 else float(v)
+        return f"{normalized:.{decimals}f}"
     r = round(v)
     return str(r) if abs(v - r) < 1e-6 else f"{v:.1f}"