Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity

Act I — The Tooling Problem, Open Formats & Historical Turning Points (X.02)

In the drafty computer laboratories of Cambridge University during the early 1970s, Ian Braid and Charles Lang wrestled with a quiet revolution on glowing cathode-ray screens. For generations, machinists and patternmakers had shaped turbine housings and gearbox casings using chalk markings, wooden templates, and steel calipers. Translating those curved, interlocking metal solids into computer memory seemed almost impossible. Wireframe sketches looked like ghostly spiderwebs that could not tell solid metal from empty air, while faceted polygon approximations stripped away the silky smooth curves of cylindrical bores. Alongside Hungarian researcher Timothy Varady in Budapest, Braid helped pioneer boundary representation, defining physical objects by their true geometric boundaries: smooth analytical planes, cylinders, and topological loops. Decades later, international standards teams codified that vision into the universal STEP AP242 standard, ensuring that precise geometric forms could travel freely between different software tools without losing their exact analytical curvature or dimensional truth.

For decades, mechanical and structural engineering remained tethered to expensive, closed-source CAD ecosystems that stored geometry in proprietary binary formats. Sharing a model between different modeling programs frequently resulted in translated geometry losing its parametric history, trimming curves failing to evaluate, and cylindrical surfaces collapsing into crude triangle approximations. The ratification of ISO 10303-21 STEP AP242 (DOI: DOI 10.1016/j.cad.2016.07.003 [Scite ↗]) — established an open, model-based engineering foundation for boundary representations. Instead of approximating curved shapes as flat polygons, STEP AP242 defines solids through explicit topological hierarchies: CARTESIAN_POINT, VERTEX_POINT, POLY_LOOP, and ADVANCED_FACE entities bounded within a CLOSED_SHELL. In Folio X.02, we demonstrate how open Python libraries such as build123d and CadQuery liberate engineers from commercial lock-in. A single version-controlled Python script generates our stepped structural clevis pedestal, producing an exact ISO STEP AP242 boundary representation alongside modern 3MF and binary GLB mesh files. Our byte-level verifier inspects all three formats simultaneously, confirming that analytical volumes match exactly while measuring the chordal tessellation error introduced whenever smooth analytic surfaces are converted into faceted meshes.

For an independent mechanical consultant or a small hardware team, file exchange discrepancies between software tools create costly friction. When a client sends a model exported through an unchecked conversion pipeline, subtle geometric corruptions can slip through unnoticed. A circular cylindrical bore faceted into thirty-two chords shrinks by more than seventy microns along its radius. If an assembler tries to slide a hardened steel locating dowel into that faceted opening, the pin seizes tight, halting physical assembly. Worse still, proprietary CAD vendors charge upwards of five thousand dollars per seat each year, locking solo practitioners out of professional revision-control and file-checking workflows. Open, script-driven CAD coupled with offline verification democratizes this entire engineering cycle. By parameterizing parts in readable Python code and executing byte-level audits across STEP, 3MF, and GLB exports, solo practitioners can mathematically prove geometric integrity, verify clearance limits, and collaborate seamlessly with machining facilities without costly proprietary software.

§ I.1 · Classical Obstruction, Open Standards & Historical Turning Points

Every enduring engineering and architectural tool begins as a human effort to turn tacit workshop craft into an inspectable, shareable language. Tracing the evolution of Toolbox X.02 (TOOL-ENG-1) from its earliest formulation in 1973–1980 (Ian Braid (Cambridge) and Charles Eastman pioneer boundary-representation (B-rep) and constructive solid geometry (CSG) kernels.) to its modern open-toolchain implementation in 2018–2026 (CadQuery 2 and build123d (Apache-2.0) bring algebraic Python scripting to OpenCascade, liberating solo engineers from proprietary CAD lock-in.) reveals why closed binary formats and unverified polygon exports repeatedly stalled small practices. Whenever a studio or fabricator is forced to exchange geometry without an explicit mathematical invariant—here governed by h_sagitta = R (1 − cos(π / N)) · V_step = V_flange + V_boss = 43,200 mm³ · ΔV / V < 10⁻⁶—silent topological defects such as boundary cracks, flipped face normals, or missing clearance tolerances corrupt the handoff between design and physical making.

Resolving that bottleneck requires pairing neutral, royalty-free file specifications (.glb, .step AP242, .3mf, .dxf) with a zero-dependency code generator (skills/toolchain/x02/make_x02.py) and a deterministic byte-level verifier (skills/toolchain/x02/verify_x02_toolchain_x02_parametric_step_3mf_roundtrip.py). Within the parametric state space governed by parameter P_1 (Circumferential Tessellation Facets N) spanning [8, 64] (reference N = 32); and parameter P_2 (Upper Boss Height H_boss) spanning [10, 30] (reference mm18), every exported file is treated not as an opaque drawing, but as a falsifiable mathematical certificate whose chronology of breakthroughs is summarized below:

Code-first CAD turns a mechanical drawing from an opaque binary blob into a pure function: parameters go in, and verified STEP AP242, 3MF, and GLB artifacts come out with known chordal error bounds.

Act II — 4-Stage Geometry Synthesis & Byte-Level Verification Spine (X.02)

When an exact boundary representation is converted into a triangle mesh for visualization or additive fabrication, curved geometries undergo inevitable discretization error. Consider a circular cylindrical bore or boss of nominal radius R approximated by an inscribed regular polygon with N flat facets. The distance between the true circular arc and the center of each inscribed facet chord is governed by the chordal sagitta formula: h = R(1 − cos(π / N)). Using Taylor series expansion for large N, this geometric deviation scales inversely with the square of facet count: h ≈ R π² / (2 N²). For a cylindrical locating bore with radius R = 15 mm, setting N = 12 creates a chordal sagitta of 0.511 mm—an error massive enough to prevent mating pins from fitting. Doubling N to 24 reduces the sagitta to 0.128 mm, while N = 32 reaches 0.0722 mm, fitting within standard sliding tolerances. In contrast, planar stepped B-rep faces retain their exact analytic volume V = 43,200.0 mm³ identically across STEP AP242, 3MF, and GLB containers, illustrating the mathematical distinction between exact boundary geometry and faceted representations. Live parameter coupling: N = 32 and 18 mm under governing law h_sagitta = R (1 − cos(π / N)) · V_step = V_flange + V_boss = 43,200 mm³ · ΔV / V < 10⁻⁶.

Inside a boundary representation kernel, solid bodies are not stored as loose surface meshes, but as evaluated topological graphs anchored by precise geometric definitions. A closed solid shell is constructed through the Boolean union of oriented half-spaces, where each planar face is bounded by a directed closed wire known in ISO 10303-21 syntax as a POLY_LOOP. In our stepped clevis pedestal, the base flange (sixty by forty by twelve millimeters) merges with the upper boss (forty by twenty by eighteen millimeters) along a shared planar boundary at elevation z = 12 mm. Rather than retaining an internal dividing wall, the kernel executes half-space regularization, dissolving redundant internal faces and sewing outer faces into a single MANIFOLD_SOLID_BREP bounded by a CLOSED_SHELL entity. Each ADVANCED_FACE explicitly references its underlying surface equation, boundary orientation flag, and bounding vertex loop. This topological rigor guarantees that every edge is shared by exactly two adjacent faces with opposing parameter orientations, ensuring that analytical mass properties and volume integrals evaluate without approximation drift across neutral CAD exchange formats.

Act III — Live WebGL2 3D Inspector, Downloadable CAD Files & Interactive Workbench

§ III.2 · Downloadable Neutral 3D CAD & Fabrication Files + Provenance Manifest

Every file below is generated deterministically by skills/toolchain/x02/make_x02.py and verified byte-for-byte against manifest.json. Click any card to download the neutral artifact and open it directly in 100% Free & Open-Source Software (Blender 4.2+, FreeCAD 1.0, Bonsai BIM, OrcaSlicer, PrusaSlicer, QCAD Community Edition, LibreCAD, Inkscape):

Act IV — Small-Studio Empowerment, T0–T3 Truth Boundary & Bridged Folios (X.02)

In modern parametric CAD engineering, artificial intelligence tools can generate complex solid modeling scripts in Python upon request. However, large language models frequently invent nonexistent API methods, misplace Boolean coordinate offsets, or hallucinate topological connections that produce invalid non-manifold geometry or unstitched boundary shells. Folio X.02 introduces a disciplined co-design workflow that prevents these failure modes. The human engineer defines the mechanical interface requirements, dimensional tolerances, and aesthetic proportions. The AI coding agent implements the parametric recipe in Python using build123d or CadQuery syntax, adhering to portable rules documented in our companion SKILL.md guide. Before any generated STEP AP242, 3MF, or GLB file is accepted into production, verify_x02 executes a fully automated, offline verification pass. The verifier parses the STEP entity graph, audits XML triangle indices in 3MF archives, validates binary GLB buffers, and checks the chordal sagitta error against specified pin-clearance tolerances. This mathematical gatekeeper ensures that the generative speed of artificial intelligence is harnessed safely, leaving human engineers in complete command of physical intent and functional geometry.

The boundary-representation and round-trip verification methodologies developed in Folio X.02 form a vital connective bridge across Informatico.ai. In Civil and Structural Engineering, modeling elastomeric bearings for seismic base isolation (Folio E.06) demands precise parametric cylindrical boss geometry to verify lead-core confinement clearances under cyclic lateral shear displacement. In Advanced Manufacturing, toolpath synthesis for 3D concrete printing (Folio E.10) requires exact STEP B-rep solids to compute thixotropic bead slicing and avoid nozzle trajectory deviations. In Computational Mechanics, SIMP topology optimization (Folio E.11) outputs organic density distributions that must be reconstructed into smooth boundary-representation solids for CNC milling operations. In Mathematics, neuro-symbolic geometry synthesis (Folio M.05) bridges algebraic constraint systems with Euclidean constructive geometry, matching the dual representation of parametric code and evaluated B-rep entities. By mastering code-first CAD modeling in open Python, solo engineers acquire a unified computational toolchain capable of expressing complex physical concepts across civil, mechanical, and mathematical disciplines without proprietary constraints or commercial software barriers.

§ IV.1 · Certified Geometry in Repository (T0/T1) vs. Educational Boundary & Edition 2 Horizon (T2/T3)

Act V — Reproducible Generator (`make_x02.py`), Stdlib Verifier & Portable SKILL.md

#!/usr/bin/env python3
"""Deterministic Geometry Generator for Toolbox X.02 (TOOL-ENG-1): Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity.
Canonical URL: https://informatico.ai/toolchain/x02/
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))

from toolchain_uga import generate_folio_assets  # noqa: E402


def main() -> int:
    files_dir = ROOT / "src" / "research" / "toolchain" / "x02" / "files"
    manifest = generate_folio_assets(
        slug="x02",
        folio_id="X.02",
        title="Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity",
        script_path=Path(__file__).resolve(),
        files_dir=files_dir,
        formats=('glb', 'step', '3mf'),
    )
    print(json.dumps({"status": "GENERATED", "folio_id": "X.02", "files": [f["filename"] for f in manifest["files"]]}, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.02 (TOOL-ENG-1): Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity.
Canonical URL: https://informatico.ai/toolchain/x02/
Governing Law: h_sagitta = R (1 − cos(π / N)) · V_step = V_flange + V_boss = 43,200 mm³ · ΔV / V < 10⁻⁶
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))

from toolchain_uga import verify_folio_assets  # noqa: E402


def main(argv: list[str] | None = None) -> int:
    args = argv if argv is not None else sys.argv[1:]
    planted_only = "--planted-defect" in args
    files_dir = ROOT / "src" / "research" / "toolchain" / "x02" / "files"
    make_script = Path(__file__).resolve().parent / "make_x02.py"
    try:
        result = verify_folio_assets(
            slug="x02",
            files_dir=files_dir,
            script_path=make_script,
            planted_defect_only=planted_only,
        )
    except AssertionError as exc:
        print(json.dumps({"status": "FAIL", "folio_id": "X.02", "error": str(exc)}), file=sys.stderr)
        return 1
    print(json.dumps(result, indent=2, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

---
name: toolchain-x02-parametric-step-3mf-roundtrip
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.02 (TOOL-ENG-1) - Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity (X.02 · TOOL-ENG-1)

> **Fixed Educational Boundary (`EN`):** Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
>
> **Frontera Educativa Fija (`ES-MX`):** Cada archivo en esta página es un artefacto educativo generado por el script que lo acompaña. Nada aquí está certificado como estructural, imprimible, seguro ni apto para ningún propósito. El verificador comprueba la geometría, no la aptitud.

## 1. Governing Law, Open Standard & Canonical URL
- **Toolbox Folio**: `X.02` (`TOOL-ENG-1` · `REV 1.2`, Redated `2026-11-09`)
- **Canonical URL**: https://informatico.ai/toolchain/x02/ (Spanish: https://informatico.ai/es-mx/toolchain/x02/)
- **Track Badge**: TOOLBOX X.02 · BUILD123D / CADQUERY KERNEL → STEP AP242 · 3MF · GLB AUDIT
- **Reference Standard / Repository**: [gumyr/build123d (Apache-2.0 Python BREP CAD)](https://github.com/gumyr/build123d)
- **Governing Equation**: `h_sagitta = R (1 − cos(π / N)) · V_step = V_flange + V_boss = 43,200 mm³ · ΔV / V < 10⁻⁶`
- **Deterministic Generator**: `python skills/toolchain/x02/make_x02.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x02/verify_x02_toolchain_x02_parametric_step_3mf_roundtrip.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x02/verify_x02_toolchain_x02_parametric_step_3mf_roundtrip.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1016/j.cad.2021.103018 (Scite Report: https://scite.ai/reports/10.1016/j.cad.2021.103018)

## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Independent Engineer's Zero-Cost Stack (build123d Apache-2.0 + FreeCAD 1.0 + OrcaSlicer): Author parametric parts in Python, export ISO 10303-21 STEP AP242 for CNC machine shops and 3MF for additive prototyping, and run verify_x02 to confirm zero volume drift between B-rep and mesh.
- **ES-MX**: Stack sin Costo para Ingenieros Independientes (build123d Apache-2.0 + FreeCAD 1.0 + OrcaSlicer): Modela piezas paramétricas en Python, exporta STEP AP242 (ISO 10303-21) para maquinado CNC y 3MF para manufactura aditiva, y ejecuta verify_x02 para certificar cero deriva volumétrica.

## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x02/make_x02.py` inside the repository working directory to emit `src/research/toolchain/x02/files/x02_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x02/verify_x02_toolchain_x02_parametric_step_3mf_roundtrip.py` to verify GLB chunk bounds, 2-manifold half-edge pairing (`3F = 2E`), Euler–Poincaré characteristic (`χ = V - E + F`), divergence-theorem signed volume against the analytical formula, SHA-256 manifest match, and planted-defect rejection.
3. **Security Boundary (`security-runtime`)**: Never grant an AI agent or CAD MCP server shell execution, home-directory access, or outbound network scope when inspecting 3D binaries. Restrict file operations strictly to the project workspace directory.

## 4. Deterministic Verification & Falsification Rules
1. Cross-Format Topological Identity: The vertex count (V = 16), face count (F = 28), and Euler characteristic (χ = 2) must match identically across x02_artifact.step, x02_artifact.3mf, and x02_artifact.glb.
2. Chordal Sagitta Tolerance Bound: For any cylindrical feature of radius R discretized into N segments, the radial deviation is strictly h = R(1 − cos(π/N)); keeping h ≤ 0.10 mm at R = 15 mm requires N ≥ 28.
3. Provenance & Planted-Defect Gate: Every exported file must embed the generator script SHA-256 and boundary statement, and verify_x02 must reject any flipped-normal or corrupted-schema mutation.

## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Algebraic Python Solid Definition — Parameterize the stepped flange (60 × 40 × 12 mm) and boss (40 × 20 × 18 mm) as a single closed 2-manifold boundary with V_exact = 28,800 + 14,400 = 43,200.0 mm³.
- Stage 2: ISO 10303-21 STEP AP242 B-Rep Serialization — Emit explicit CARTESIAN_POINT, VERTEX_POINT, POLY_LOOP, ADVANCED_FACE, CLOSED_SHELL, and MANIFOLD_SOLID_BREP entities with millimeter length units (#7) and 10⁻⁵ mm uncertainty (#6).
- Stage 3: Deterministic 3MF ZIP & GLB Binary Packaging — Package the identical 16-vertex, 28-triangle topology into 3MF Core 1.2.3 XML (fixed ZIP timestamp) and Khronos GLB binary buffers with embedded provenance metadata.
- Stage 4: Cross-Format Round-Trip & Chordal Deviation Audit — Verify that STEP, 3MF, and GLB agree on vertex/face counts and analytical volume, and bound circular bore discretization error via h = R(1 − cos(π/N)).

## 6. Certified Reference Telemetry (T0/T1)
- **Exact B-Rep / Mesh Volume**: `43,200.0 mm³ (ΔV = 0.00%)`
- **Chordal Sagitta Error h(N)**: `0.0722 mm (at R=15, N=32)`
- **STEP AP242 Schema Audit**: `CLOSED_SHELL · 28 FACES PASS`
- **3MF & GLB Parity Verdict**: `PASS · SHA-256 VERIFIED`

## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Deterministic generator (skills/toolchain/x02/make_x02.py) emitting byte-reproducible STEP AP242 (.step), 3MF Core 1.2.3 (.3mf), and glTF 2.0 (.glb) solids.
- Stdlib cross-format verifier (verify_x02_toolchain_x02_parametric_step_3mf_roundtrip.py) checking ISO-10303-21 AP242 B-rep entities, 3MF ZIP XML structure, GLB manifoldness, and V = 43,200.0 mm³.
- Explicit Round-Trip Survival Matrix documenting what survives across STEP AP242, 3MF, and GLB (units, topology, colors, provenance).

### Educational Boundary & Edition 2 Horizon (T2/T3)
- Educational Geometry Boundary: Every file on this page is an educational artifact; nothing is certified as load-bearing, printable, safe, or fit for any purpose.
- Future Edition 2 Extensions: Analytic NURBS trimmed-surface STEP AP242 export via build123d/OCCT C++ bindings and automated PMI semantic tolerance extraction.

#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.02 (TOOL-ENG-1): Code-First Parametric Solids & Measured STEP AP242, 3MF, and GLB Round-Trip Fidelity.
Canonical URL: https://informatico.ai/toolchain/x02/
Governing Law: h_sagitta = R (1 − cos(π / N)) · V_step = V_flange + V_boss = 43,200 mm³ · ΔV / V < 10⁻⁶
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))

from toolchain_uga import verify_folio_assets  # noqa: E402


def main(argv: list[str] | None = None) -> int:
    args = argv if argv is not None else sys.argv[1:]
    planted_only = "--planted-defect" in args
    files_dir = ROOT / "src" / "research" / "toolchain" / "x02" / "files"
    make_script = Path(__file__).resolve().parent / "make_x02.py"
    try:
        result = verify_folio_assets(
            slug="x02",
            files_dir=files_dir,
            script_path=make_script,
            planted_defect_only=planted_only,
        )
    except AssertionError as exc:
        print(json.dumps({"status": "FAIL", "folio_id": "X.02", "error": str(exc)}), file=sys.stderr)
        return 1
    print(json.dumps(result, indent=2, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

§ V.2 · Primary Peer-Reviewed Sources & Open Specification Anchors

1. ISO 10303-242:2022. Industrial automation systems and integration — Product data representation and exchange — Part 242: Application protocol: Managed model-based 3D engineering.
2. Feeney, A. B., Frechette, S. P., & Srinivasan, V. (2015). A portrait of an ISO STEP tolerancing standard as an enabler of smart manufacturing systems. Journal of Computing and Information Science in Engineering, 15(2), 021001. DOI DOI 10.1115/1.4029050 [Scite ↗]
3. 3MF Consortium. (2023). 3D Manufacturing Format Core Specification & Reference Guide v1.2.3. github.com/3MFConsortium/spec_core
4. build123d Contributors. (2023–2026). build123d: A python CAD programming library (Apache-2.0). github.com/gumyr/build123d