draftwright 0.3.4__tar.gz → 0.3.5__tar.gz

{draftwright-0.3.4 → draftwright-0.3.5}/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## Unreleased
 
+## v0.3.5 — 2026-07-20
+
+### Fixed
+
+- **Generated `Sheet` script round-trips `--frame` / `--zones` / `--projection`**:
+  the sheet-furniture flags added in #767/#768/#769 were not emitted into the
+  generated `Sheet(...)` constructor (nor forwarded by the CLI's `--script` path),
+  so a regenerated script dropped the border / zone ruler / projection symbol —
+  the script no longer matched the direct CLI drawing. The emitter now emits
+  `frame=True` / `zones=True` / `projection=…` when set (a plain drawing keeps a
+  clean constructor), and the CLI forwards them to `generate_sheet_script`.
+
+### Added
+
+- **ISO 5457 zone-grid border ruler** (#768): `build_drawing(zones=True)` /
+  `Sheet(zones=True)` / `--zones` draws the grid reference system — numbers 1..
+  along the top/bottom edges, letters A.. (skipping I/O) down the sides — in the
+  band between the frame and the page edge, with the standard division count per
+  A-series page (~50 mm zones). Implies a frame (the ticks sit on it). Off by
+  default → byte-identical. The border ticks are lint-exempt like the frame; the
+  labels are exempt only from the page-bounds check (they legitimately sit outside
+  the drawable), still covered by overlap lint.
+- **Projection-method symbol** (#769): `build_drawing(projection="third"|"first")` /
+  `Sheet(projection=…)` / `--projection` draws the ISO 5456-2 third-/first-angle
+  glyph in the reserved title-block band (above the title block). Uses the new
+  `ProjectionSymbol` primitive from build123d-drafting-helpers **0.14.1** (the pin
+  is bumped). Off by default → byte-identical. Unlike the page-spanning frame, the
+  small well-placed glyph is *not* lint-exempt — lint covers it so a future
+  mispositioning is caught.
+- **Opt-in drawn sheet frame / border** (#767): `build_drawing(frame=True)` /
+  `Sheet(frame=True)` / `--frame` draws a border rectangle at the page margin. It's
+  the *content boundary* (Option B), not a rectangle over the drawing: turning it on
+  raises the effective content margin, and because `compose._layout_geometry` is the
+  single authority shared by scale/page selection **and** placement, the reservation
+  flows through `choose_scale` — so a framed drawing may pick a smaller scale / larger
+  page (ADR 0004), with content clearing the border. Default `frame=False` is
+  byte-identical (guarded by the golden + layout-cleanliness suites). The page-spanning
+  border carries an `is_sheet_frame` rider so lint skips it.
+
 ## v0.3.4 — 2026-07-20
 
 ### Changed

{draftwright-0.3.4 → draftwright-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.4
+Version: 0.3.5
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -682,7 +682,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
-Requires-Dist: build123d-drafting-helpers>=0.14.0
+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'
 Requires-Dist: numpy>=1.24

{draftwright-0.3.4 → draftwright-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.4"
+version = "0.3.5"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,7 +17,7 @@ dependencies = [
     # 3.13+. Mirrors pzfreo/build123d-mcp's dependency handling.
     "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.0",
+    "build123d-drafting-helpers>=0.14.1",
     "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.3.4 → draftwright-0.3.5}/src/draftwright/_core.py

@@ -50,6 +50,44 @@ _log = logging.getLogger(__name__)
 
 _MARGIN = 10.0
 
+# When a sheet frame is drawn (#767), content reserves this extra band inside the border so
+# it clears the drawn line rather than sitting on it. The frame draws AT _MARGIN (the old
+# drawable boundary); content insets to _content_margin(frame).
+_FRAME_BAND = 6.0
+
+
+def _content_margin(frame: bool) -> float:
+    """The effective content margin: ``_MARGIN``, plus the frame clearance band when a sheet
+    frame is drawn (#767). Threaded into the layout authority so the reservation flows through
+    scale/page selection (ADR 0004), not just the render."""
+    return _MARGIN + (_FRAME_BAND if frame else 0.0)
+
+
+# ISO 5457 zone-grid letters (vertical edges): A.. skipping I and O (confusable with 1 / 0).
+_ZONE_LETTERS = "ABCDEFGHJKLMNPQRSTUVWXYZ"
+
+# ISO 5457 reference-grid division counts (columns=numbers × rows=letters) per A-series page,
+# keyed by the full (width, height) so a same-width custom page doesn't borrow the count.
+_ZONE_DIVISIONS = {
+    (297, 210): (6, 4),
+    (420, 297): (8, 6),
+    (594, 420): (12, 8),
+    (841, 594): (16, 12),
+    (1189, 841): (24, 16),
+}
+
+
+def _zone_divisions(page_w: float, page_h: float) -> tuple[int, int]:
+    """``(columns, rows)`` for the ISO 5457 zone grid (#768) — the standard count for an
+    A-series page (matched on BOTH dimensions), else ~50 mm zones for a custom page. Rows are
+    clamped to the available letters (I/O skipped) so a very tall custom page can't over-index."""
+    std = _ZONE_DIVISIONS.get((int(round(page_w)), int(round(page_h))))
+    if std is not None:
+        return std
+    cols = max(2, round(page_w / 49.5))
+    rows = min(len(_ZONE_LETTERS), max(2, round(page_h / 49.5)))
+    return (cols, rows)
+
 
 _TB_CLEAR = _MARGIN + 1.0  # title-block inset: one extra mm over _MARGIN for clearance
 
@@ -711,6 +749,13 @@ class Analysis:
     date: str = ""
     revision: str = "A"
     company: str = ""
+    # Draw a sheet border/frame (#767). When True, `margin` is already the reserved content
+    # margin (`_content_margin(True)`), so content clears the frame drawn at `_MARGIN`.
+    frame: bool = False
+    # Projection-method symbol (#769): "third" / "first" (ISO 5456-2) or None (omit).
+    projection: str | None = None
+    # Draw the ISO 5457 zone-grid border ruler (#768). Implies a frame (the ticks sit on it).
+    zones: bool = False
     # The PartModel built by _analyse's pre-scale sizing pass (#584 WP1 A) — stored so
     # the render path reuses it instead of re-running the detectors (ADR 0008 Amdt 5:
     # one inventory, detected once; #602). Typed `object` to keep _core free of a
@@ -799,6 +844,105 @@ def _add_title_block(dwg, a: Analysis):
     dwg.add(tb, "title_block")
 
 
+def _make_sheet_frame(a: Analysis) -> Compound:
+    """The sheet border rectangle (#767) — a closed outline at the ``_MARGIN`` inset (the old
+    drawable boundary). Content clears it because ``a.margin`` is the reserved content margin.
+    Carries an ``is_sheet_frame`` rider (like ``is_centerline``) so lint skips its page-spanning
+    box, and so ``get_annotation`` / a removed frame drop it cleanly."""
+    x0, y0 = _MARGIN, _MARGIN
+    x1, y1 = a.PAGE_W - _MARGIN, a.PAGE_H - _MARGIN
+    frame = Compound(
+        children=[
+            Edge.make_line(Vector(x0, y0, 0), Vector(x1, y0, 0)),
+            Edge.make_line(Vector(x1, y0, 0), Vector(x1, y1, 0)),
+            Edge.make_line(Vector(x1, y1, 0), Vector(x0, y1, 0)),
+            Edge.make_line(Vector(x0, y1, 0), Vector(x0, y0, 0)),
+        ]
+    )
+    frame.is_sheet_frame = True  # furniture, not a dimension/view — exempt from overlap lint
+    return frame
+
+
+def _add_sheet_frame(dwg, a: Analysis):
+    """Add the sheet border (#767), drawn last like the title block. No-op is the caller's
+    (gated on ``a.frame``)."""
+    dwg.add(_make_sheet_frame(a), "sheet_frame")
+
+
+def _add_projection_symbol(dwg, a: Analysis):
+    """Place the ISO 5456-2 projection-method glyph (#769) in the reserved title-block band,
+    just above the drawn title block (deterministic empty space — the block reserves _TB_H but
+    draws shorter). Registered ``projection_symbol`` with an ``is_projection_symbol`` identity
+    rider. Unlike the page-spanning frame it is NOT lint-exempt: it's a small, well-placed glyph,
+    so lint covers it and a future mispositioning is caught. Gated on ``a.projection``."""
+    from build123d_drafting import ProjectionSymbol
+
+    sym = ProjectionSymbol(
+        a.projection,
+        draft=draft_preset(
+            font_size=dwg.draft.font_size,
+            decimal_precision=dwg.draft.decimal_precision,
+            font_path=PLEX_SANS_CONDENSED,
+        ),
+    )
+    b = sym.bounding_box()
+    bx, by = (b.min.X + b.max.X) / 2, (b.min.Y + b.max.Y) / 2
+    w, h = b.max.X - b.min.X, b.max.Y - b.min.Y
+    # Right side of the title-block column, near the top of its reserved band.
+    cx = a.PAGE_W - _TB_CLEAR - w / 2 - 3
+    cy = _TB_CLEAR + _TB_H - h / 2 - 2
+    sym = sym.locate(Location((cx - bx, cy - by, 0)))
+    sym.is_projection_symbol = True
+    dwg.add(sym, "projection_symbol")
+
+
+def _add_zone_grid(dwg, a: Analysis):
+    """Draw the ISO 5457 zone-grid border ruler (#768) — numbers 1.. along the top/bottom
+    edges, letters A.. (skipping I/O) down the left/right — in the band between the frame
+    (at ``_MARGIN``) and the page edge. Requires ``a.frame`` (the ticks sit on the border);
+    the caller gates on ``a.zones`` and ensures the frame. Tick lines register as ``zone_grid``
+    (``is_zone_grid``); each label carries an ``is_zone_label`` rider so it is exempt from the
+    page-bounds lint (it legitimately sits outside the drawable) — but NOT from overlap lint."""
+    from build123d_drafting import Note
+
+    cols, rows = _zone_divisions(a.PAGE_W, a.PAGE_H)
+    x0, y0, x1, y1 = _MARGIN, _MARGIN, a.PAGE_W - _MARGIN, a.PAGE_H - _MARGIN
+    cw, rh = (x1 - x0) / cols, (y1 - y0) / rows
+    band = _MARGIN
+    tick = min(3.0, band * 0.6)
+    draft = draft_preset(
+        font_size=dwg.draft.font_size * 0.8,
+        decimal_precision=dwg.draft.decimal_precision,
+        font_path=PLEX_SANS_CONDENSED,
+    )
+    ticks = []
+    for i in range(1, cols):  # interior column boundaries → ticks on top + bottom edges
+        xb = x0 + i * cw
+        ticks.append(Edge.make_line(Vector(xb, y0, 0), Vector(xb, y0 - tick, 0)))
+        ticks.append(Edge.make_line(Vector(xb, y1, 0), Vector(xb, y1 + tick, 0)))
+    for j in range(1, rows):  # interior row boundaries → ticks on left + right edges
+        yb = y0 + j * rh
+        ticks.append(Edge.make_line(Vector(x0, yb, 0), Vector(x0 - tick, yb, 0)))
+        ticks.append(Edge.make_line(Vector(x1, yb, 0), Vector(x1 + tick, yb, 0)))
+    grid = Compound(children=ticks)
+    grid.is_zone_grid = True
+    dwg.add(grid, "zone_grid")
+
+    def _label(text, cx, cy, name):
+        note = Note(text, (cx, cy), draft, align=(Align.CENTER, Align.CENTER))
+        note.is_zone_label = True
+        dwg.add(note, name)
+
+    for i in range(cols):  # numbers 1.. left→right, in the bottom + top bands
+        cx = x0 + (i + 0.5) * cw
+        _label(str(i + 1), cx, y0 - band / 2, f"zone_num_b_{i}")
+        _label(str(i + 1), cx, y1 + band / 2, f"zone_num_t_{i}")
+    for j in range(rows):  # letters A.. top→bottom, in the left + right bands
+        cy = y1 - (j + 0.5) * rh
+        _label(_ZONE_LETTERS[j], x0 - band / 2, cy, f"zone_ltr_l_{j}")
+        _label(_ZONE_LETTERS[j], x1 + band / 2, cy, f"zone_ltr_r_{j}")
+
+
 def _iso_bbox(dwg):
     """(min_x, min_y, max_x, max_y) of the placed iso view, hidden lines included."""
     return dwg.view_bounds("iso")

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/analysis.py

@@ -29,6 +29,7 @@ from draftwright._core import (
     _MIN_RENDER_MM,
     _MIN_VIEW_MM,
     Analysis,
+    _content_margin,
     _legible_steps,
     _Projector,
 )
@@ -409,6 +410,7 @@ def _validate_explicit_scale(
     strips_i,
     layout_section,
     layout_table_sizes,
+    margin=_MARGIN,
 ) -> None:
     """Enforce the two scale floors when the caller pinned an explicit *scale* (#489, #590 split
     of :func:`_analyse`). An explicit scale is the user's call — honour it, subject to:
@@ -441,6 +443,7 @@ def _validate_explicit_scale(
         strips=strips_i,
         section=layout_section,
         table_sizes=layout_table_sizes,
+        margin=margin,
     )
     # Warn only when omitting the scale would truly give a legible fit (auto scale itself is
     # legible) but the requested scale is below the floor. A part illegible at every
@@ -474,11 +477,20 @@ def _analyse(
     date="",
     revision="A",
     company="",
+    frame: bool = False,
+    projection: str | None = None,
+    zones: bool = False,
 ) -> Analysis:
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
     Returns an :class:`Analysis`.
     """
+    # The zone-grid ruler (#768) draws its ticks on the frame, so it implies one.
+    frame = frame or zones
+    # The content margin — raised by the sheet-frame band (#767) so scale/page selection and
+    # placement both reserve room for the border. Computed up front so the choose_scale inside
+    # step-count convergence sees it too.
+    margin = _content_margin(frame)
     if isinstance(step_file, Shape):
         part = step_file
         src = "build123d object"
@@ -609,6 +621,7 @@ def _analyse(
             strips=strips_i,
             section=layout_section,
             table_sizes=layout_table_sizes,
+            margin=margin,
         )
 
     (SCALE, PAGE_W, PAGE_H, TB_W), strips_i, n_for_sizing = _converge_step_sizing(
@@ -628,9 +641,10 @@ def _analyse(
         strips_i,
         layout_section,
         layout_table_sizes,
+        margin=margin,
     )
     DIM_PAD = _DIM_PAD
-    margin = _MARGIN
+    # margin was computed up front (_content_margin(frame)) so scale selection already saw it.
     # Refine: apply the same legibility gate _auto_annotate uses for dim_step.
     n_steps = len(_legible_steps(step_zs, bb.min.Z, SCALE)[0])
     strips = _measure_strips(
@@ -656,6 +670,7 @@ def _analyse(
         n_steps,
         section=layout_section,
         table_sizes=layout_table_sizes,
+        margin=margin,
     )
     fv_hw = _g.fv_hw
     fv_hh = _g.fv_hh
@@ -778,6 +793,9 @@ def _analyse(
         date=date,
         revision=revision,
         company=company,
+        frame=frame,
+        projection=projection,
+        zones=zones,
         out=out,
         pmi=pmi_records,
         pmi_mode=pmi,

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/annotations/orchestrator.py

@@ -21,7 +21,10 @@ from draftwright._core import (
     _TABULATE_MIN_HOLES,
     Analysis,
     HoleRef,
+    _add_projection_symbol,
+    _add_sheet_frame,
     _add_title_block,
+    _add_zone_grid,
     _concentric_with_axis,
     _fmt,
     _iso_bbox,
@@ -125,6 +128,9 @@ _PASS_SEQUENCE: tuple[str, ...] = (
     "details",
     "title_block",
     "tabulate",
+    "sheet_frame",
+    "zone_grid",
+    "projection_symbol",
 )
 
 
@@ -508,6 +514,22 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     def _s_title_block():
         _add_title_block(dwg, a)
 
+    def _s_sheet_frame():
+        # The sheet border, drawn LAST (#767) — gated on the frame opt-in; content already
+        # reserved room via the raised a.margin, so this only draws.
+        if a.frame:
+            _add_sheet_frame(dwg, a)
+
+    def _s_zone_grid():
+        # ISO 5457 zone-grid border ruler (#768), on the frame (a.zones implies a.frame).
+        if a.zones:
+            _add_zone_grid(dwg, a)
+
+    def _s_projection_symbol():
+        # ISO 5456-2 projection-method glyph (#769) in the reserved title-block band.
+        if a.projection:
+            _add_projection_symbol(dwg, a)
+
     def _s_tabulate():
         # Escalate to a hole table when the plan view is too dense to dimension
         # every hole — runs last so the table avoids every placed annotation
@@ -545,6 +567,9 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
             "details": _s_details,
             "title_block": _s_title_block,
             "tabulate": _s_tabulate,
+            "sheet_frame": _s_sheet_frame,
+            "zone_grid": _s_zone_grid,
+            "projection_symbol": _s_projection_symbol,
         }
     )
     if ctx.trace is not None:  # snapshot the run's escalations into the trace (#736)

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/builder.py

@@ -29,7 +29,10 @@ from draftwright._core import (
     _PAGE_SIZES,
     _SCALES,
     Analysis,
+    _add_projection_symbol,
+    _add_sheet_frame,
     _add_title_block,
+    _add_zone_grid,
     _iso_bbox,
     _log,
     _parse_page,
@@ -336,6 +339,12 @@ def _assemble(
     else:
         _fit_iso_view(dwg, a, annotate=False)
         _add_title_block(dwg, a)
+        if a.frame:  # sheet border, drawn last (#767) — auto path adds it via the orchestrator
+            _add_sheet_frame(dwg, a)
+        if a.zones:  # zone-grid ruler (#768), on the frame
+            _add_zone_grid(dwg, a)
+        if a.projection:  # projection-method glyph (#769) — auto path adds it via the orchestrator
+            _add_projection_symbol(dwg, a)
     return dwg
 
 
@@ -409,6 +418,7 @@ def _repack(
             section=a.layout_section,
             table_sizes=a.layout_table_sizes,
             warn_no_iso=False,
+            margin=a.margin,
         )
 
     candidates = _repack_candidates(a, scale, page)
@@ -603,6 +613,9 @@ def build_drawing(
     date: str = "",
     revision: str = "A",
     company: str = "",
+    frame: bool = False,
+    projection: str | None = None,
+    zones: bool = False,
 ) -> Drawing:
     """Build a customisable 4-view :class:`Drawing` without exporting it.
 
@@ -690,6 +703,9 @@ def build_drawing(
         date=date,
         revision=revision,
         company=company,
+        frame=frame,
+        projection=projection,
+        zones=zones,
     )
 
     # Pass 1: place + annotate from the estimated layout, then measure the real
@@ -754,6 +770,9 @@ def make_drawing(
     date: str = "",
     revision: str = "A",
     company: str = "",
+    frame: bool = False,
+    projection: str | None = None,
+    zones: bool = False,
 ) -> tuple[str, str]:
     """Generate a 4-view technical drawing from a STEP file or build123d object.
 
@@ -799,6 +818,9 @@ def make_drawing(
         date=date,
         revision=revision,
         company=company,
+        frame=frame,
+        projection=projection,
+        zones=zones,
     ).export()
     assert svg_path is not None and dxf_path is not None  # export() writes both by default
     return svg_path, dxf_path

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/cli.py

@@ -106,6 +106,15 @@ def main(
     date: str = typer.Option("", help="Date for the title block"),
     revision: str = typer.Option("A", help="Revision for the title block"),
     company: str = typer.Option("", help="Company / legal owner for the title block"),
+    frame: bool = typer.Option(
+        False, "--frame", help="Draw a sheet border; content reserves clearance inside it"
+    ),
+    projection: str = typer.Option(
+        "", "--projection", help="Projection-method symbol: 'third' or 'first' (default: none)"
+    ),
+    zones: bool = typer.Option(
+        False, "--zones", help="Draw the ISO 5457 zone-grid border ruler (implies --frame)"
+    ),
     scale: float | None = typer.Option(
         None, help="Drawing-scale override, e.g. 5 for 5:1 or 0.5 for 1:2 (default: auto)"
     ),
@@ -186,6 +195,9 @@ def main(
                     date=date,
                     revision=revision,
                     company=company,
+                    frame=frame,
+                    zones=zones,
+                    projection=projection or None,
                     part_expr=seam,
                     formats=tuple(formats),
                 )
@@ -203,6 +215,9 @@ def main(
                     date=date,
                     revision=revision,
                     company=company,
+                    frame=frame,
+                    zones=zones,
+                    projection=projection or None,
                     pmi=pmi.value,
                     formats=tuple(formats),
                 )
@@ -242,6 +257,9 @@ def main(
         date=date,
         revision=revision,
         company=company,
+        frame=frame,
+        projection=projection or None,
+        zones=zones,
     )
     for path in _emit(dwg, formats):
         print(path)

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/compose.py

@@ -435,6 +435,7 @@ def _fits(
     pack_iso_2d: bool = False,
     section: bool = False,
     table_sizes=(),
+    margin: float = _MARGIN,
 ) -> bool:
     """True if the composed 4-view footprint fits the page at this scale.
 
@@ -456,12 +457,24 @@ def _fits(
         section=section,
         table_sizes=table_sizes,
         warn_no_iso=False,
+        margin=margin,
     )
     return bool(g.fits if pack_iso_2d else g.auto_fits)
 
 
 def _bisect_fit_scale(
-    x_size, y_size, z_size, pw, ph, tb, n_steps, strips, pack_iso_2d, section=False, table_sizes=()
+    x_size,
+    y_size,
+    z_size,
+    pw,
+    ph,
+    tb,
+    n_steps,
+    strips,
+    pack_iso_2d,
+    section=False,
+    table_sizes=(),
+    margin=_MARGIN,
 ):
     """Largest scale at which the 4-view layout fits ``(pw, ph)``, found by bisection —
     the layout is monotone in scale (a smaller scale never fits worse). Used only as the
@@ -485,6 +498,7 @@ def _bisect_fit_scale(
             pack_iso_2d=pack_iso_2d,
             section=section,
             table_sizes=table_sizes,
+            margin=margin,
         ):
             lo = mid
         else:
@@ -502,6 +516,7 @@ def choose_scale(
     strips: StripDepths | None = None,
     section: bool = False,
     table_sizes=(),
+    margin: float = _MARGIN,
 ) -> tuple:
     """Return (SCALE, PAGE_W, PAGE_H, TB_W) for a 4-view layout.
 
@@ -539,6 +554,7 @@ def choose_scale(
             pack_iso_2d=True,
             section=section,
             table_sizes=table_sizes,
+            margin=margin,
         ):
             _log.warning(
                 "Requested scale %s on %s page may not fit the 4-view layout", scale, page
@@ -565,6 +581,7 @@ def choose_scale(
             pack_iso_2d=pack_iso_2d,
             section=section,
             table_sizes=table_sizes,
+            margin=margin,
         ):
             return cand
     # The ISO 5455 ladder exhausted with no standard fit (a part too large even for
@@ -586,6 +603,7 @@ def choose_scale(
             pack_iso_2d,
             section,
             table_sizes,
+            margin,
         )
         if s is not None:
             _log.warning(
@@ -758,6 +776,7 @@ def _layout_geometry(
     section: bool = False,
     table_sizes=(),
     warn_no_iso=True,
+    margin: float = _MARGIN,
 ):
     """Compute the 4-view layout geometry for a part at a given scale/page.
 
@@ -770,7 +789,9 @@ def _layout_geometry(
     step-count estimate (used during scale selection before strips are
     measured); otherwise the measured strip depths are used.
     """
-    margin = _MARGIN
+    # margin is a parameter (default _MARGIN) so a reserved content margin — e.g. the
+    # #767 sheet-frame band — flows through BOTH scale selection and placement, which
+    # share this one authority. Default keeps every existing caller byte-identical.
     DIM_PAD = _DIM_PAD
     bbox_max = max(x_size, y_size, z_size)
     fv_hw = x_size * scale / 2

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/linting/structural.py

@@ -278,7 +278,13 @@ def lint_drawing(
 
     boxes: list = []
     for item in items:
-        if getattr(item, "is_centerline", False):
+        # The sheet frame (#767) spans the page by design; a None box excludes it from every
+        # pairwise overlap (like a centerline), so it doesn't "overlap" every annotation.
+        if (
+            getattr(item, "is_centerline", False)
+            or getattr(item, "is_sheet_frame", False)
+            or getattr(item, "is_zone_grid", False)  # border ticks span the frame, like the frame
+        ):
             boxes.append(None)
             continue
         boxes.append(_label_box(item))
@@ -333,6 +339,13 @@ def lint_drawing(
     # (#701: unguarded — _ann_box absorbs the fragile measure; the rest is arithmetic.)
     if page_bbox is not None:
         for item in items:
+            if (
+                getattr(item, "is_sheet_frame", False)
+                or getattr(item, "is_zone_grid", False)
+                or getattr(item, "is_zone_label", False)
+            ):
+                # Frame + zone ruler sit ON / outside the drawable boundary by design (#767/#768).
+                continue
             bb = _ann_box(item, box_cache)
             if bb is None:
                 continue
@@ -498,6 +511,8 @@ def _lint_view_shapes(
                 continue  # a datum target sits on the part face by definition
             if getattr(ann, "is_section_hatch", False):
                 continue  # hatching is intentionally inside the section view
+            if getattr(ann, "is_sheet_frame", False) or getattr(ann, "is_zone_grid", False):
+                continue  # sheet border / zone ticks span the page, enclosing every view (#767/#768)
             # #701: unguarded — _label_bbox/_ann_box/_view_edge_entries absorb the
             # fragile reads; a bug in the check itself must fail loudly.
             label_box = _label_bbox(ann, warned)

{draftwright-0.3.4 → draftwright-0.3.5}/src/draftwright/sheet.py

@@ -374,6 +374,9 @@ class Sheet:
         date=None,
         revision=None,
         company=None,
+        frame=None,
+        projection=None,
+        zones=None,
     ):
         self._part = part
         self._features: list = []
@@ -404,6 +407,9 @@ class Sheet:
             ("date", date),
             ("revision", revision),
             ("company", company),
+            ("frame", frame),
+            ("projection", projection),
+            ("zones", zones),
         ):
             if _v is not None:
                 self._opts[_k] = _v