feat(mech): shared foundation - primitives, XDATA codec, standards registry, ISO 128-50 materials

engineering/mech/ opens with the four modules every track-B/G branch imports,
so the four worktrees can be cut from this commit and none of them has to
invent a name the others will conflict with.

- primitives.py: the typed descriptions the pure modules emit (Line, Arc,
  Circle, Poly, HatchArea, Text, DimIntent) with bbox / translate / rotate /
  scale, and ROLE_LAYER - the one place an ISO 128 line role becomes a layer
  name, so no module hardcodes a layer. The arc bbox sweeps its quadrants: a
  0-180 arc reports y=+r, not its endpoints, which is what keeps the view
  layout from stacking two views on top of each other.
- xdata.py: the ACADMCP_MECH codec in Track A's shape - a 1001 application
  marker, 1000 chunks of at most 255 ASCII characters, the 16 KB per-entity
  ceiling enforced before anything is written, and a foreign application, a
  corrupt chunk stream, a wrong version or an unknown kind refused with
  ValueError instead of decoded into something plausible.
- standards/__init__.py: the table registry. A size outside the coverage is
  refused against the coverage; a size inside it that is not a listed row is
  refused against the rows. Nothing is interpolated, an ambiguous variant is
  never resolved by taking the first row, and a registration whose SOURCE does
  not name the table it was transcribed from is refused.
- standards/materials.py: the section-hatch map for nine materials. ISO
  128-50 standardises only the general hatching (narrow continuous lines at 45
  degrees) - that is acadiso.pat ANSI31 and what engineering/gear.py already
  draws for steel. The distinguishing symbols are ASME Y14.2M's section lining
  as shipped in AutoCAD 2026's acadiso.pat, read off the installed file; cast
  iron's departure from ASME and the absence of any mechanical symbol for
  concrete and wood are stated in the rows themselves. Angles are 0.0 because
  the patterns already carry 45 degrees, and the two architectural patterns'
  scales are derived from the ANSI31 line spacing and recomputed by the test
  rather than chosen.

No tool is registered here.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FKFStjEFzpGyLq5bMpWxTd

tests/test_mech_materials.py

@@ -0,0 +1,126 @@
+"""The section-hatch map: every pattern exists in both engines, every row cites.
+
+The ezdxf failure this guards is silent: ``Hatch.set_pattern_fill`` falls back
+to ANSI31 for a name it does not know (``ezdxf/entities/polygon.py``), so a
+typo'd pattern draws steel hatching on a cast-iron part and says nothing.
+"""
+
+from __future__ import annotations
+
+import pytest
+from ezdxf.tools import pattern as ezpattern
+
+from engineering.mech.standards.materials import (
+    ALIASES,
+    MATERIAL_TABLE,
+    MATERIALS,
+    hatch_for,
+)
+
+ANSI31_SPACING = 2.2450640303  # acadiso.pat ANSI31, the ISO 128-50 general hatching
+
+
+def _spacing(name: str, defs: dict) -> float:
+    """The finest perpendicular line spacing in a pattern definition."""
+    return min(abs(line[2][1]) for line in defs[name] if abs(line[2][1]) > 1e-9)
+
+
+def test_the_map_covers_the_nine_named_materials():
+    assert MATERIALS == (
+        "steel",
+        "cast_iron",
+        "aluminium",
+        "copper_alloy",
+        "plastic",
+        "rubber",
+        "concrete",
+        "wood",
+        "insulation",
+    )
+
+
+def test_hatch_for_returns_exactly_pattern_angle_scale():
+    assert set(hatch_for("steel")) == {"pattern", "angle", "scale"}
+
+
+@pytest.mark.parametrize(
+    ("material", "expected"),
+    [
+        ("steel", "ANSI31"),
+        ("cast_iron", "ANSI32"),
+        ("aluminium", "ANSI38"),
+        ("copper_alloy", "ANSI33"),
+        ("plastic", "ANSI34"),
+        ("rubber", "ANSI34"),
+        ("insulation", "ANSI37"),
+        ("concrete", "AR-CONC"),
+        ("wood", "JIS_WOOD"),
+    ],
+)
+def test_each_material_keeps_its_pattern(material, expected):
+    assert hatch_for(material)["pattern"] == expected
+
+
+def test_aliases_resolve_and_are_case_and_separator_insensitive():
+    assert hatch_for("Cast Iron")["pattern"] == "ANSI32"
+    assert hatch_for("cast-iron")["pattern"] == "ANSI32"
+    assert hatch_for("aluminum")["pattern"] == "ANSI38"
+    assert hatch_for("BRASS")["pattern"] == "ANSI33"
+    assert hatch_for("bronze")["pattern"] == "ANSI33"
+    assert hatch_for("copper")["pattern"] == "ANSI33"
+    assert set(ALIASES.values()) <= set(MATERIALS)
+
+
+def test_an_unknown_material_is_refused_with_the_list():
+    with pytest.raises(ValueError, match="unobtainium.*cast_iron"):
+        hatch_for("unobtainium")
+
+
+def test_every_pattern_exists_in_both_measurement_sets():
+    """Guards ezdxf's silent ANSI31 fallback and AutoCAD's unknown-pattern error."""
+    iso = ezpattern.load(measurement=1)
+    imperial = ezpattern.load(measurement=0)
+    for material in MATERIALS:
+        name = hatch_for(material)["pattern"]
+        assert name in iso, f"{material}: {name} is not an ezdxf ISO pattern"
+        assert name in imperial, f"{material}: {name} is not an ezdxf imperial pattern"
+
+
+def test_the_map_adds_no_rotation_because_the_patterns_already_carry_45_degrees():
+    defs = ezpattern.load(measurement=1)
+    for material in MATERIALS:
+        row = hatch_for(material)
+        assert row["angle"] == 0.0
+        if row["pattern"].startswith("ANSI3"):
+            assert defs[row["pattern"]][0][0] == 45.0
+
+
+def test_the_ansi_rows_ship_at_the_pattern_definition_scale():
+    for material in (
+        "steel",
+        "cast_iron",
+        "aluminium",
+        "copper_alloy",
+        "plastic",
+        "rubber",
+        "insulation",
+    ):
+        assert hatch_for(material)["scale"] == 1.0
+
+
+def test_the_two_non_ansi_patterns_are_scaled_to_the_iso_line_spacing():
+    """Concrete and wood are architectural patterns: AR-CONC is defined at
+    building scale and JIS_WOOD at 0.5 mm. Their scale is derived, not chosen —
+    the finest line in the pattern is brought to ANSI31's spacing."""
+    defs = ezpattern.load(measurement=1)
+    assert abs(_spacing("ANSI31", defs) - ANSI31_SPACING) < 1e-6
+    for material in ("concrete", "wood"):
+        row = hatch_for(material)
+        derived = round(ANSI31_SPACING / _spacing(row["pattern"], defs), 3)
+        assert row["scale"] == derived
+
+
+def test_every_row_states_where_its_symbol_comes_from():
+    for material in MATERIALS:
+        source = MATERIAL_TABLE[material]["source"]
+        assert any(token in source for token in ("ISO 128-50", "ASME Y14.2M", "acadiso.pat"))

tests/test_mech_primitives.py

@@ -0,0 +1,135 @@
+"""The typed primitive descriptions every pure mechanical module emits.
+
+Geometry is asserted on the emitted tuples to 1e-9 — never on a rendered
+drawing. That is what lets the view engine be tested without a backend.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from engineering.mech.primitives import (
+    ROLE_LAYER,
+    ROLES,
+    Arc,
+    Circle,
+    DimIntent,
+    HatchArea,
+    Line,
+    Poly,
+    Text,
+    bbox,
+    layer_for,
+    points_of,
+    rotate,
+    scale,
+    translate,
+)
+
+EPS = 1e-9
+
+
+def test_role_layer_maps_every_role_to_an_engineering_layer():
+    assert ROLE_LAYER == {
+        "visible": "GEOMETRY",
+        "hidden": "HIDDEN",
+        "center": "CENTER",
+        "phantom": "PHANTOM",
+        "hatch": "HATCH",
+        "dim": "DIM",
+        "text": "TEXT",
+    }
+    assert ROLES == tuple(ROLE_LAYER)
+
+
+def test_defaults_match_the_pinned_interface():
+    assert Line((0.0, 0.0), (1.0, 0.0)).role == "visible"
+    assert Arc((0.0, 0.0), 5.0, 0.0, 90.0).role == "visible"
+    assert Circle((0.0, 0.0), 5.0).role == "visible"
+    poly = Poly(((0.0, 0.0), (1.0, 0.0)))
+    assert poly.closed is False and poly.role == "visible"
+    assert HatchArea((((0.0, 0.0), (1.0, 0.0), (1.0, 1.0)),)).material == "steel"
+    label = Text((0.0, 0.0), "M20")
+    assert (label.height, label.rotation, label.role) == (3.5, 0.0, "text")
+    intent = DimIntent("linear", (0.0, 0.0), (10.0, 0.0))
+    assert intent.text_at is None
+    assert intent.text_override is None
+    assert intent.fit is None
+    assert intent.tol is None
+    assert intent.feature == ""
+
+
+def test_layer_for_uses_the_role_map_and_a_hatch_has_no_role():
+    assert layer_for(Line((0.0, 0.0), (1.0, 0.0), "hidden")) == "HIDDEN"
+    assert layer_for(Text((0.0, 0.0), "A")) == "TEXT"
+    assert layer_for(HatchArea((((0.0, 0.0), (1.0, 0.0), (1.0, 1.0)),))) == "HATCH"
+
+
+def test_arc_bbox_includes_the_quadrant_it_sweeps_through():
+    """A 0-180 arc of r=5 reaches y=+5 at 90 deg; an endpoint-only bbox misses it."""
+    x0, y0, x1, y1 = bbox([Arc((0.0, 0.0), 5.0, 0.0, 180.0)])
+    assert abs(x0 + 5.0) < EPS
+    assert abs(x1 - 5.0) < EPS
+    assert abs(y0) < EPS
+    assert abs(y1 - 5.0) < EPS
+
+
+def test_circle_bbox_is_the_full_square():
+    assert bbox([Circle((10.0, 0.0), 2.0)]) == (8.0, -2.0, 12.0, 2.0)
+
+
+def test_bbox_of_nothing_is_refused_rather_than_reported_as_zero():
+    with pytest.raises(ValueError, match="no primitives"):
+        bbox([])
+
+
+def test_translate_moves_every_primitive_kind():
+    prims = (
+        Line((0.0, 0.0), (10.0, 0.0)),
+        Arc((0.0, 0.0), 5.0, 0.0, 90.0),
+        Circle((0.0, 0.0), 5.0),
+        Poly(((0.0, 0.0), (1.0, 1.0)), closed=True, role="hidden"),
+        HatchArea((((0.0, 0.0), (1.0, 0.0), (1.0, 1.0)),), material="cast_iron"),
+        Text((0.0, 0.0), "A-A"),
+    )
+    moved = translate(prims, 3.0, -2.0)
+    assert moved[0] == Line((3.0, -2.0), (13.0, -2.0))
+    assert moved[1] == Arc((3.0, -2.0), 5.0, 0.0, 90.0)
+    assert moved[2] == Circle((3.0, -2.0), 5.0)
+    assert moved[3] == Poly(((3.0, -2.0), (4.0, -1.0)), closed=True, role="hidden")
+    assert moved[4] == HatchArea((((3.0, -2.0), (4.0, -2.0), (4.0, -1.0)),), material="cast_iron")
+    assert moved[5] == Text((3.0, -2.0), "A-A")
+
+
+def test_rotate_turns_arc_angles_with_the_geometry():
+    turned = rotate([Arc((10.0, 0.0), 5.0, 0.0, 90.0)], 90.0)[0]
+    assert abs(turned.center[0]) < EPS
+    assert abs(turned.center[1] - 10.0) < EPS
+    assert abs(turned.start_deg - 90.0) < EPS
+    assert abs(turned.end_deg - 180.0) < EPS
+
+
+def test_rotate_adds_to_a_text_rotation():
+    label = rotate([Text((1.0, 0.0), "N", rotation=10.0)], 90.0)[0]
+    assert abs(label.at[0]) < EPS
+    assert abs(label.at[1] - 1.0) < EPS
+    assert abs(label.rotation - 100.0) < EPS
+
+
+def test_scale_scales_radius_height_and_position_about_a_point():
+    prims = scale(
+        [Circle((10.0, 0.0), 2.0), Text((10.0, 0.0), "x", height=3.5)],
+        2.0,
+        about=(0.0, 0.0),
+    )
+    assert prims[0] == Circle((20.0, 0.0), 4.0)
+    assert prims[1].height == 7.0
+
+
+def test_scale_refuses_a_non_positive_factor():
+    with pytest.raises(ValueError, match="scale factor"):
+        scale([Circle((0.0, 0.0), 1.0)], 0.0)
+
+
+def test_points_of_reports_the_text_anchor_only():
+    assert points_of(Text((4.0, 5.0), "long label")) == ((4.0, 5.0),)

tests/test_mech_standards.py

@@ -0,0 +1,94 @@
+"""The standards registry: one row or a named refusal, never an interpolation."""
+
+from __future__ import annotations
+
+import pytest
+
+import engineering.mech.standards as standards_mod
+from engineering.mech.standards import (
+    Coverage,
+    coverage_of,
+    lookup,
+    register,
+    source_of,
+    standards,
+)
+
+SOURCE = "TEST 1 (2026), table 1 — fixture rows, not a real standard"
+
+
+@pytest.fixture(autouse=True)
+def _fixture_tables():
+    """Swap the process-wide registry for three fixture tables, then restore it."""
+    saved = dict(standards_mod._REGISTRY)
+    standards_mod._REGISTRY.clear()
+    register(
+        "TEST 1",
+        {10: {"d": 10.0, "w": 3.0}, 20: {"d": 20.0, "w": 6.0}},
+        Coverage(10.0, 20.0),
+        SOURCE,
+    )
+    register(
+        "TEST 2",
+        {18: ({"form": "E", "r": 0.6}, {"form": "F", "r": 0.8})},
+        Coverage(18.0, 18.0),
+        SOURCE,
+    )
+    register("TEST 3", {"M12": {"pitch": 1.75}}, Coverage(12.0, 12.0), SOURCE)
+    yield
+    standards_mod._REGISTRY.clear()
+    standards_mod._REGISTRY.update(saved)
+
+
+def test_registered_standards_are_listed_and_carry_their_source():
+    assert standards() == ("TEST 1", "TEST 2", "TEST 3")
+    assert source_of("TEST 1") == SOURCE
+    assert coverage_of("TEST 1") == Coverage(10.0, 20.0, "mm")
+
+
+def test_a_listed_size_returns_a_copy_of_its_row():
+    row = lookup("TEST 1", 10)
+    assert row == {"d": 10.0, "w": 3.0}
+    row["w"] = 99.0
+    assert lookup("TEST 1", 10)["w"] == 3.0
+
+
+def test_a_size_outside_the_coverage_is_refused_by_name():
+    with pytest.raises(ValueError, match="TEST 1 covers 10-20 mm; 95 mm is outside the table"):
+        lookup("TEST 1", 95)
+
+
+def test_a_size_inside_the_coverage_but_not_in_the_table_is_never_interpolated():
+    with pytest.raises(ValueError, match="no row for 15"):
+        lookup("TEST 1", 15)
+
+
+def test_a_variant_is_selected_by_keyword():
+    assert lookup("TEST 2", 18, form="E")["r"] == 0.6
+    assert lookup("TEST 2", 18, form="F")["r"] == 0.8
+
+
+def test_an_unknown_variant_is_refused_and_an_ambiguous_one_too():
+    with pytest.raises(ValueError, match="no form='G' row"):
+        lookup("TEST 2", 18, form="G")
+    with pytest.raises(ValueError, match="ambiguous"):
+        lookup("TEST 2", 18)
+
+
+def test_a_designation_key_is_case_insensitive():
+    assert lookup("TEST 3", "m12")["pitch"] == 1.75
+
+
+def test_an_unregistered_standard_names_the_ones_that_exist():
+    with pytest.raises(ValueError, match="DIN 9999.*TEST 1"):
+        lookup("DIN 9999", 10)
+
+
+def test_a_source_that_does_not_name_its_table_is_refused():
+    with pytest.raises(ValueError, match="SOURCE"):
+        register("TEST 4", {1: {"a": 1}}, Coverage(1.0, 1.0), "made up")
+
+
+def test_registering_the_same_standard_twice_is_refused():
+    with pytest.raises(ValueError, match="already registered"):
+        register("TEST 1", {10: {"d": 10.0}}, Coverage(10.0, 10.0), SOURCE)

tests/test_mech_xdata.py

@@ -0,0 +1,85 @@
+"""The ACADMCP_MECH chunking codec: Track A's shape, one app, 255-char chunks."""
+
+from __future__ import annotations
+
+import pytest
+
+from backends.xdata_specs import encode_values
+from engineering.mech.xdata import APP_ID, KINDS, PAYLOAD_VERSION, decode, encode, to_values
+
+PART = {
+    "v": 1,
+    "kind": "part",
+    "id": "1A2B",
+    "view": "front",
+    "part": {"name": "shaft", "segments": [{"length": 60.0, "d_outer": 40.0}]},
+}
+
+
+def test_app_id_version_and_kinds_are_the_pinned_ones():
+    assert APP_ID == "ACADMCP_MECH"
+    assert PAYLOAD_VERSION == 1
+    assert KINDS == ("part", "std_part", "balloon")
+
+
+def test_encode_opens_with_the_app_id_and_chunks_at_255():
+    rows = encode({"v": 1, "kind": "balloon", "item": 3, "targets": ["1A2B"] * 60})
+    assert rows[0] == (1001, APP_ID)
+    assert all(code == 1000 for code, _value in rows[1:])
+    assert len(rows) > 2, "the payload must actually have been split"
+    assert all(len(value) <= 255 for _code, value in rows[1:])
+
+
+def test_roundtrip_is_exact():
+    assert decode(encode(PART)) == PART
+
+
+def test_decode_reads_the_bare_value_list_a_backend_returns():
+    """`entity_get_xdata` hands back decoded values, not (code, value) rows."""
+    assert decode(to_values(PART)) == PART
+
+
+def test_the_version_is_injected_when_absent_and_a_wrong_one_is_refused():
+    payload = {
+        "kind": "std_part",
+        "designation": "ISO 4014 - M12x60",
+        "standard": "ISO 4014",
+        "size": "M12x60",
+        "qty": 1,
+        "material": "8.8",
+    }
+    assert decode(encode(payload))["v"] == PAYLOAD_VERSION
+    with pytest.raises(ValueError, match="version"):
+        encode({**payload, "v": 99})
+
+
+def test_a_foreign_application_is_refused():
+    with pytest.raises(ValueError, match="ACADMCP_PID"):
+        decode([(1001, "ACADMCP_PID"), (1000, '{"v":1,"kind":"part"}')])
+
+
+def test_a_corrupt_payload_is_refused_not_silently_dropped():
+    with pytest.raises(ValueError, match="not JSON"):
+        decode([(1001, APP_ID), (1000, '{"v":1,"kind":')])
+
+
+def test_an_unknown_kind_is_refused_on_both_sides():
+    with pytest.raises(ValueError, match="kind"):
+        encode({"v": 1, "kind": "sheet_frame"})
+    with pytest.raises(ValueError, match="kind"):
+        decode([(1001, APP_ID), (1000, '{"v":1,"kind":"sheet_frame"}')])
+
+
+def test_the_16_kb_entity_ceiling_is_enforced_before_writing():
+    huge = {"v": 1, "kind": "part", "id": "1", "view": "front", "part": {"n": "x" * 20000}}
+    with pytest.raises(ValueError, match="16 KB"):
+        encode(huge)
+
+
+def test_every_chunk_is_a_value_the_backend_will_accept():
+    """`entity_set_xdata` runs the values through `encode_values`; ASCII-only
+    JSON means no line separator can reach a 1000 tag and split the DXF."""
+    rows = encode(PART)
+    tags = encode_values(to_values(PART))
+    assert all(code == 1000 for code, _value in tags)
+    assert len(tags) == len(rows) - 1