draftwright 0.3.4__tar.gz → 0.3.6__tar.gz

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

@@ -1,6 +1,88 @@
 # Changelog
 
-## Unreleased
+## v0.3.6 — 2026-07-21
+
+### Fixed
+
+- **`Sheet.step(boss)` on a prismatic part fails loudly instead of silently
+  dropping the height** (#631): declaring a turned `.step()` at a cylinder that is
+  really an external boss set `orientation="z"`, which made `render_height_ladder`
+  suppress the overall-height dim on the assumption the OD/step chain conveyed it —
+  but on a prismatic box that chain never renders, so the height vanished and
+  nothing replaced it (11 → 10 annotations). The build now detects a `StepFeature`
+  coincident with a `BossFeature` (same axis, origin, diameter) — a combination
+  that can never be legitimate — and raises a clear `ValueError` pointing to
+  `.boss()` (which renders its own ø and height per #632). Legitimate turned shafts
+  have steps but no coincident boss, so they are unaffected.
+- **`detail_view=True` no longer a silent no-op when the detail can't be placed**
+  (#630): a part whose lint recommends a detail view (`step_dim_dropped`) but whose
+  crowded band is full-width (e.g. a shelled cover's stacked face levels) can't be
+  enlarged legibly *and* still fit alongside the main views — so `detail_view=True`
+  produced a drawing byte-identical to `False`, silently ignoring the opt-in. It
+  now records a `detail_unplaceable` warning naming the reason and an actionable
+  remedy (dimension manually / move onto its own sheet), so the opt-in is
+  observable. Parts whose detail *does* fit are unchanged.
+- **Imperative `--script` round-trips the title-block fields + sheet furniture**
+  (#775): the imperative flavour reproduced only title/number/tolerance/drawn_by/
+  scale/page, dropping the `material`/`date`/`revision`/`company` fields (#766) and
+  the `frame`/`zones`/`projection` furniture (#767/#768/#769) — so a regenerated
+  imperative script didn't match the direct CLI. They now ride the emitted script's
+  cog config block and its `build_drawing(...)` call (the Sheet flavour already
+  round-tripped them), and the CLI forwards them to `generate_script`.
+
+### Internal
+
+- **Fast-tier dense-sheet canary for the #733/#734 strip-pressure regression**
+  (#737): a synthetic contended-front-strip fixture that drops a step-height
+  principal dim on the pre-#734 commit and stays clean on `main` — closing the
+  fast-tier gap the #733 regression fell through (only the CI-only slow CTC
+  fixtures exercised real strip pressure before).
+- **Layout-hypothesis fuzz tier is now a reproducible PR gate** (#692):
+  `derandomize=True` makes every run generate the same fixed example set (with
+  `print_blob` for paste-able reproduction), so a failure recurs deterministically
+  instead of surfacing on a seed-dependent minority of runs; exploratory fuzzing
+  moves behind `DRAFTWRIGHT_FUZZ_EXPLORE=1`. The two `test_make_drawing.py` xdist
+  observations (#669) were investigated and found non-reproducible — both tests are
+  non-flaky by construction/measurement on current `main`.
+
+## 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
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.4
+Version: 0.3.6
 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.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.4"
+version = "0.3.6"
 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.6}/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.6}/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.6}/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.6}/src/draftwright/annotations/sections.py

@@ -597,6 +597,23 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
                     dwg.pin(hname)
         if placed:
             n_placed += 1
+        elif req.kind == "prismatic-steps":
+            # (#630) The prismatic-steps request is the one queued only under the
+            # build_drawing(detail_view=True) opt-in (_request_prismatic_detail's gate),
+            # so a bail-out here means that opt-in produced nothing. Say so — with an
+            # actionable remedy — rather than returning a drawing byte-identical to
+            # detail_view=False (a full-width crowded band, e.g. a shelled cover's stacked
+            # face levels, can't be enlarged legibly and still fit alongside the main views).
+            # The automatic turned-head requests (queued unconditionally by
+            # render_step_lengths) are NOT opt-in — their bail-out is the normal path (the
+            # main view locates the head/block inline), so they stay silent.
+            ctx.record_issue(
+                "warning",
+                "detail_unplaceable",
+                f"{req.kind} detail view requested but could not be placed legibly on this "
+                "sheet (the crowded band is too wide to enlarge and still fit); dimension the "
+                "feature manually or move it onto its own sheet",
+            )
 
 
 def _overall_height_name(dwg, a: Analysis) -> str | None:

{draftwright-0.3.4 → draftwright-0.3.6}/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,
@@ -284,6 +287,33 @@ def _assemble(
             rot = build_rotational_feature(a)
             if rot is not None:
                 pm = replace(pm, features=[*pm.features, rot])
+        # A z step declares a segment of a z-turned profile; the height ladder then suppresses
+        # the overall height on the premise the step-length chain conveys it (from_model
+        # render_height_ladder). That premise holds only if the declared steps span the part's
+        # FULL z-extent — a boss, or even a stepped boss on a plate, declared via .step()
+        # leaves the bulk unspanned, so suppression silently drops the overall height (#631).
+        # Guard on that exact condition rather than a classifier proxy (is_rotational / prof
+        # both have blind spots): raise when the z-steps don't reach both ends of the part.
+        z_steps = [f for f in pm.features if isinstance(f, StepFeature) and f.frame.axis == "z"]
+        if pm.orientation == "z" and z_steps:
+            tol = 1e-3 * max(a.z_size, 1.0)  # small absolute float epsilon, floored
+            # The step lengths convey the overall height only if the steps TILE the z-extent
+            # contiguously — a single reach to each end isn't enough (an interior gap would
+            # still leave height unconveyed). Walk the spans low→high, extending coverage.
+            spans = sorted(
+                (min(p0[2], p1[2]), max(p0[2], p1[2])) for f in z_steps for (p0, p1) in [f.span]
+            )
+            covered = a.bb.min.Z
+            for lo, hi in spans:
+                if lo <= covered + tol:
+                    covered = max(covered, hi)
+            if spans[0][0] > a.bb.min.Z + tol or covered < a.bb.max.Z - tol:
+                raise ValueError(
+                    "step() declares a segment of a turned profile, but the declared steps "
+                    "don't span this part's full height — it is not a turned (rotational) "
+                    "body. For a boss (an external cylinder on a prismatic part) use .boss() "
+                    "— it renders its own ø and height."
+                )
         # PMI (STEP AP242) is likewise detection-sourced, so a declared / emitted-script model
         # carries none. When PMI annotation is on, synthesise the same imported drafting
         # annotations detection would (render_pmi reads them off the model, gated on a.pmi_mode)
@@ -336,6 +366,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 +445,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 +640,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 +730,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 +797,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 +845,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
@@ -953,6 +1002,13 @@ def _write_script(
             f"NUMBER = {a.number!r}",
             f"TOLERANCE = {a.tolerance!r}",
             f"DRAWN_BY = {a.drawn_by!r}",
+            f"MATERIAL = {a.material!r}",
+            f"DATE = {a.date!r}",
+            f"REVISION = {a.revision!r}",
+            f"COMPANY = {a.company!r}",
+            f"FRAME = {a.frame!r}",
+            f"ZONES = {a.zones!r}",
+            f"PROJECTION = {a.projection!r}",
             f"PMI = {a.pmi_mode!r}",
             f"SCALE = {scale!r}",
             f"PAGE = {page!r}",
@@ -967,6 +1023,13 @@ def _write_script(
         f"_NUMBER    = {a.number!r}\n"
         f"_TOLERANCE = {a.tolerance!r}\n"
         f"_DRAWN_BY  = {a.drawn_by!r}\n"
+        f"_MATERIAL  = {a.material!r}\n"
+        f"_DATE      = {a.date!r}\n"
+        f"_REVISION  = {a.revision!r}\n"
+        f"_COMPANY   = {a.company!r}\n"
+        f"_FRAME     = {a.frame!r}   # draw a sheet border (#767)\n"
+        f"_ZONES     = {a.zones!r}   # ISO 5457 zone ruler (implies frame, #768)\n"
+        f"_PROJECTION = {a.projection!r}   # 'third' | 'first' | None (#769)\n"
         f"_PMI       = {a.pmi_mode!r}   # 'off' | 'report' | 'annotate'\n"
         f"_SCALE     = {scale!r}   # None = auto; e.g. 5 for 5:1, 0.5 for 1:2\n"
         f"_PAGE      = {page!r}   # None = auto; e.g. 'A3' or (297, 210)\n"
@@ -975,7 +1038,11 @@ def _write_script(
         "    for _k, _v in [\n"
         "        ('STEP_FILE', repr(_STEP_FILE)), ('TITLE', repr(_TITLE)),\n"
         "        ('NUMBER', repr(_NUMBER)), ('TOLERANCE', repr(_TOLERANCE)),\n"
-        "        ('DRAWN_BY', repr(_DRAWN_BY)), ('PMI', repr(_PMI)),\n"
+        "        ('DRAWN_BY', repr(_DRAWN_BY)), ('MATERIAL', repr(_MATERIAL)),\n"
+        "        ('DATE', repr(_DATE)), ('REVISION', repr(_REVISION)),\n"
+        "        ('COMPANY', repr(_COMPANY)), ('FRAME', repr(_FRAME)),\n"
+        "        ('ZONES', repr(_ZONES)), ('PROJECTION', repr(_PROJECTION)),\n"
+        "        ('PMI', repr(_PMI)),\n"
         "        ('SCALE', repr(_SCALE)), ('PAGE', repr(_PAGE)),\n"
         "    ]:\n"
         "        cog.outl(f'{_k} = {_v}')\n"
@@ -1020,6 +1087,13 @@ def _write_script(
         "    number=NUMBER,\n"
         "    tolerance=TOLERANCE,\n"
         "    drawn_by=DRAWN_BY,\n"
+        "    material=MATERIAL,\n"
+        "    date=DATE,\n"
+        "    revision=REVISION,\n"
+        "    company=COMPANY,\n"
+        "    frame=FRAME,\n"
+        "    zones=ZONES,\n"
+        "    projection=PROJECTION,\n"
         "    pmi=PMI,\n"
         "    scale=SCALE,\n"
         "    page=PAGE,\n"
@@ -1081,6 +1155,13 @@ def generate_script(
     pmi: Literal["off", "report", "annotate"] = "off",
     scale: float | None = None,
     page: str | None = None,
+    material: str = "",
+    date: str = "",
+    revision: str = "A",
+    company: str = "",
+    frame: bool = False,
+    zones: bool = False,
+    projection: str | None = None,
     formats: Sequence[str] = ("pdf",),
 ) -> str:
     """Generate an editable Cog-enabled drawing script from a STEP file.
@@ -1109,7 +1190,22 @@ def generate_script(
     # here too would crash generation on an out-of-range value (e.g. --script --scale
     # 0.001 / --page A9) instead of writing the script and deferring — inconsistent with
     # a large unfittable scale, which already defers (review #401).
-    a = _analyse(step_file, title, number, tolerance, drawn_by, out, pmi=pmi)
+    a = _analyse(
+        step_file,
+        title,
+        number,
+        tolerance,
+        drawn_by,
+        out,
+        pmi=pmi,
+        material=material,
+        date=date,
+        revision=revision,
+        company=company,
+        frame=frame,
+        zones=zones,
+        projection=projection,
+    )
     return _write_script(a, scale=scale, page=page, formats=formats)