gridfinity-rebase 0.1.2__tar.gz → 0.2.0__tar.gz

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridfinity-rebase
-Version: 0.1.2
+Version: 0.2.0
 Summary: Fast, validated Gridfinity STL foot replacement
 License-Expression: MIT
 License-File: LICENSE
@@ -152,10 +152,12 @@ See [curve resolution](docs/segments.md) for `--segments` settings and visual co
 ## Key details
 
 - The CLI supports standard rectangular Gridfinity bins on a 42 mm grid. Use millimeters for STL units, with feet at the bottom and Z pointing up.
+- Any rotation around Z is detected automatically, including for a separately rotated donor. Processing uses a common local frame: feet aligned with X/Y, the first foot centered at X=Y=0, and the underside at Z=0. The result returns to the input's original position and rotation. Models lying on their side or upside down are not automatically reoriented.
 - The CLI detects the base and cut height. If the feet are valid Gridfinity but the full base is not recognized, it replaces only the bottom 4.75 mm foot profile and prints a warning. Geometry above the cut is preserved, including any old holes. Check these results in a slicer. Invalid meshes, incompatible seams and disconnected replacement feet still fail validation.
 - A donor base can match the input grid or have its X/Y dimensions swapped. The CLI can also tile a 1×1 donor base across the input.
 - Unmodified presets write to `bin-rebased-PRESET.stl`. `--thumbscrew` and `--only-corners` append their names to the filename. Modified settings use a descriptive suffix, such as `bin-rebased-magnets-bottom-crush-ribs-screws.stl`. Donor bases use `bin-rebased.stl`. Use `-o` to choose a filename and `--overwrite` to replace an existing output.
 - JSON reports include the resolved `geometry` settings and a `warnings` array (empty when there are no warnings). With `--json`, warnings are included in the report instead of printed to stderr. `base_height_mode` is `auto` when the program chooses the cut height, or `manual` when `--base-height` is supplied. Automatic 4.75 mm foot replacement includes a warning. `base` identifies the starting preset or donor path. The default preset is `plain`. For donor bases, `geometry` is `null`.
+- Inspection and rebase reports include `rotation_z_deg`, the local grid's rotation in the source coordinates, and `origin_mm`, its first foot's center at underside height in those same coordinates. Square feet determine rotation modulo 90°; the reported angle is in [-45°, 45°), so equivalent orientations can swap the reported grid's X/Y dimensions. Reported cut heights remain relative to the underside.
 - `--base-height MM` overrides automatic detection for custom models and replaces everything below that height. The minimum is 4.75 mm.
 
 Run `gridfinity-rebase --help` for all options.
@@ -176,7 +178,7 @@ for JSON output and environment details.
 
 Szymon here. I used AI to build this tool.
 
-I needed a way for quick replacement of base of custom Grdifnity bins downloaded from Internet, but I didn't want to spend too much of my free time on this. I collaborated with the AI, describing how it should work, how I want to use it and what's the important from the both code perspective and end-user perspective. It allowed me to iterate and create something that is exactly what I needed. Now I share it with you.
+I needed a way to quickly replace the base of custom Gridfinity bins downloaded from the Internet, but I didn't want to spend too much of my free time on this. I collaborated with the AI, describing how it should work, how I want to use it and what's the important from the both code perspective and end-user perspective. It allowed me to iterate and create something that is exactly what I needed. Now I share it with you.
 
 Just want you to know.
 

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/README.md

@@ -141,10 +141,12 @@ See [curve resolution](docs/segments.md) for `--segments` settings and visual co
 ## Key details
 
 - The CLI supports standard rectangular Gridfinity bins on a 42 mm grid. Use millimeters for STL units, with feet at the bottom and Z pointing up.
+- Any rotation around Z is detected automatically, including for a separately rotated donor. Processing uses a common local frame: feet aligned with X/Y, the first foot centered at X=Y=0, and the underside at Z=0. The result returns to the input's original position and rotation. Models lying on their side or upside down are not automatically reoriented.
 - The CLI detects the base and cut height. If the feet are valid Gridfinity but the full base is not recognized, it replaces only the bottom 4.75 mm foot profile and prints a warning. Geometry above the cut is preserved, including any old holes. Check these results in a slicer. Invalid meshes, incompatible seams and disconnected replacement feet still fail validation.
 - A donor base can match the input grid or have its X/Y dimensions swapped. The CLI can also tile a 1×1 donor base across the input.
 - Unmodified presets write to `bin-rebased-PRESET.stl`. `--thumbscrew` and `--only-corners` append their names to the filename. Modified settings use a descriptive suffix, such as `bin-rebased-magnets-bottom-crush-ribs-screws.stl`. Donor bases use `bin-rebased.stl`. Use `-o` to choose a filename and `--overwrite` to replace an existing output.
 - JSON reports include the resolved `geometry` settings and a `warnings` array (empty when there are no warnings). With `--json`, warnings are included in the report instead of printed to stderr. `base_height_mode` is `auto` when the program chooses the cut height, or `manual` when `--base-height` is supplied. Automatic 4.75 mm foot replacement includes a warning. `base` identifies the starting preset or donor path. The default preset is `plain`. For donor bases, `geometry` is `null`.
+- Inspection and rebase reports include `rotation_z_deg`, the local grid's rotation in the source coordinates, and `origin_mm`, its first foot's center at underside height in those same coordinates. Square feet determine rotation modulo 90°; the reported angle is in [-45°, 45°), so equivalent orientations can swap the reported grid's X/Y dimensions. Reported cut heights remain relative to the underside.
 - `--base-height MM` overrides automatic detection for custom models and replaces everything below that height. The minimum is 4.75 mm.
 
 Run `gridfinity-rebase --help` for all options.
@@ -165,7 +167,7 @@ for JSON output and environment details.
 
 Szymon here. I used AI to build this tool.
 
-I needed a way for quick replacement of base of custom Grdifnity bins downloaded from Internet, but I didn't want to spend too much of my free time on this. I collaborated with the AI, describing how it should work, how I want to use it and what's the important from the both code perspective and end-user perspective. It allowed me to iterate and create something that is exactly what I needed. Now I share it with you.
+I needed a way to quickly replace the base of custom Gridfinity bins downloaded from the Internet, but I didn't want to spend too much of my free time on this. I collaborated with the AI, describing how it should work, how I want to use it and what's the important from the both code perspective and end-user perspective. It allowed me to iterate and create something that is exactly what I needed. Now I share it with you.
 
 Just want you to know.
 

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "gridfinity-rebase"
-version = "0.1.2"
+version = "0.2.0"
 description = "Fast, validated Gridfinity STL foot replacement"
 requires-python = ">=3.10"
 readme = "README.md"
@@ -33,7 +33,6 @@ testpaths = ["tests"]
 [tool.uv.build-backend]
 source-include = [
     "tests/**",
-    "docs/**",
     "scripts/**",
     "uv.lock",
 ]

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "gridfinity-rebase"
-version = "0.1.2"
+version = "0.2.0"
 description = "Fast, validated Gridfinity STL foot replacement"
 requires-python = ">=3.10"
 readme = "README.md"
@@ -28,4 +28,4 @@ dev = [
 testpaths = ["tests"]
 
 [tool.uv.build-backend]
-source-include = ["tests/**", "docs/**", "scripts/**", "uv.lock"]
+source-include = ["tests/**", "scripts/**", "uv.lock"]

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/scripts/benchmark.py

@@ -16,14 +16,15 @@ from time import perf_counter
 
 import manifold3d as m
 
-from gridfinity_rebase.geometry import (
-    Grid,
-    detect_grid,
-    detect_standard_base,
-    donor_base,
-    replace_base,
-    validate_height,
+from gridfinity_rebase import (
+    DonorBase,
+    GeneratedBase,
+    load_stl,
+    rebase,
+    resolve_options,
+    save_stl,
 )
+from gridfinity_rebase.geometry import Grid
 from gridfinity_rebase.presets import preset_base, rounded_prism
 from gridfinity_rebase.stl import read_stl, write_stl
 
@@ -42,19 +43,13 @@ def synthetic_bin(nx, ny):
 
 
 def run_engine(source, option, output):
-    solid = read_stl(source)
-    grid = detect_grid(solid)
-    height = detect_standard_base(solid, grid).height
-    validate_height(solid, grid, height)
+    model = load_stl(source)
     if option[0] == "--preset":
-        base = preset_base(option[1], grid, height, segments=SEGMENTS)
+        base = GeneratedBase(resolve_options(option[1]), segments=SEGMENTS)
     else:
-        other = read_stl(option[1])
-        donor_grid = detect_grid(other)
-        assert detect_standard_base(other, donor_grid).height >= height
-        base = donor_base(other, donor_grid, grid, height)
-    result = replace_base(solid, base, grid, height)
-    write_stl(result, output, overwrite=True)
+        base = DonorBase(load_stl(option[1]))
+    result = rebase(model, base=base)
+    save_stl(result.model, output, overwrite=True)
 
 
 def main():

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/src/gridfinity_rebase/api.py

@@ -1,6 +1,8 @@
 """In-memory orchestration shared by CLI and other clients.
 
 All coordinates and heights are millimetres, with feet down and Z pointing up.
+Operations normalize Z rotation and translation internally; meshes and report
+origins retain source coordinates. Cut heights are relative to the underside.
 Functions are synchronous and never print or write files implicitly.
 """
 
@@ -19,10 +21,10 @@ from numpy.typing import NDArray
 from .errors import RebaseError
 from .geometry import (
     PROFILE_HEIGHT,
-    Grid,
-    detect_grid,
+    NormalizedModel,
     detect_standard_base,
     donor_base,
+    normalize_model,
     replace_base,
     validate_height,
 )
@@ -71,7 +73,11 @@ class Model:
 
 @dataclass(frozen=True)
 class Inspection:
-    """Grid and standard-base detection; an unrecognized base is non-fatal."""
+    """Grid and base detection; an unrecognized base is non-fatal.
+
+    origin_mm and rotation_z_deg map the normalized grid back to source
+    coordinates. Rotation is modulo 90 degrees, in [-45, 45).
+    """
 
     grid: tuple[int, int]
     origin_mm: tuple[float, float, float]
@@ -82,12 +88,14 @@ class Inspection:
     nominal_base_height_mm: float | None = None
     base_detection_error: str | None = None
     base_detection_error_code: str | None = None
+    rotation_z_deg: float = 0.0
 
     def describe(self) -> dict:
         """Return a JSON-ready report, compatible with CLI inspection fields."""
         report = {
             "grid": list(self.grid),
             "origin_mm": list(self.origin_mm),
+            "rotation_z_deg": self.rotation_z_deg,
             "triangles": self.triangles,
             "standard_bin": self.standard_bin,
         }
@@ -169,12 +177,14 @@ class RebaseReport:
     elapsed_ms: float
     inspection: Inspection | None
     warnings: tuple[str, ...] = ()
+    rotation_z_deg: float = 0.0
 
     def describe(self) -> dict:
         report = self.inspection.describe() if self.inspection is not None else {}
         report.update(
             grid=list(self.grid),
             origin_mm=list(self.origin_mm),
+            rotation_z_deg=self.rotation_z_deg,
             base_height_mm=self.base_height_mm,
             base_height_mode=self.base_height_mode,
             geometry=self.geometry.describe() if self.geometry is not None else None,
@@ -215,21 +225,25 @@ def _require_model(model: Model) -> None:
         raise RebaseError("Expected a Model from load_stl()", code="invalid_model")
 
 
-def _grid(model: Model) -> Grid:
+def _normalize(model: Model) -> NormalizedModel:
     with _geometry_errors("invalid_grid"):
-        return detect_grid(model._solid, str(model.source) if model.source else "Model")
+        return normalize_model(
+            model._solid, str(model.source) if model.source else "Model"
+        )
 
 
-def _inspect(model: Model, grid: Grid) -> Inspection:
+def _inspect(model: Model, normalized: NormalizedModel) -> Inspection:
+    grid = normalized.grid
     fields = {
         "grid": (grid.nx, grid.ny),
-        "origin_mm": (grid.x, grid.y, grid.z),
+        "origin_mm": normalized.frame.origin_mm,
+        "rotation_z_deg": normalized.frame.rotation_z_deg,
         "triangles": model.triangles,
     }
     try:
         with _geometry_errors("unrecognized_base"):
             standard = detect_standard_base(
-                model._solid, grid, str(model.source) if model.source else "Model"
+                normalized.solid, grid, str(model.source) if model.source else "Model"
             )
     except RebaseError as exc:
         if exc.code != "unrecognized_base":
@@ -255,9 +269,9 @@ def inspect_model(
     """Detect the grid and base; invalid grids raise, custom bases are reported."""
     _require_model(model)
     _notify(on_progress, "detecting_grid")
-    grid = _grid(model)
+    normalized = _normalize(model)
     _notify(on_progress, "detecting_base")
-    info = _inspect(model, grid)
+    info = _inspect(model, normalized)
     _notify(on_progress, "complete")
     return info
 
@@ -277,6 +291,9 @@ def rebase(
     absolute Z=0. Donor bases must match the grid, match after rotation, or
     be 1x1 for tiling.
 
+    Target and donor are normalized independently before geometry operations.
+    The returned model retains the target's original position and Z rotation.
+
     Callbacks run synchronously on the calling thread. Their exceptions
     propagate unchanged; callers are responsible for dispatching GUI updates.
     """
@@ -291,12 +308,13 @@ def rebase(
     ):
         raise RebaseError("Base height must be numeric", code="invalid_height")
     _notify(on_progress, "detecting_grid")
-    grid = _grid(model)
+    normalized = _normalize(model)
+    grid = normalized.grid
     info = None
     warnings = ()
     if base_height_mm is None:
         _notify(on_progress, "detecting_base")
-        info = _inspect(model, grid)
+        info = _inspect(model, normalized)
         if info.standard_bin:
             height = info.recommended_base_height_mm
             assert height is not None
@@ -313,7 +331,7 @@ def rebase(
     else:
         height = float(base_height_mm)
     with _geometry_errors("invalid_height", base_height_mm=height):
-        validate_height(model._solid, grid, height)
+        validate_height(normalized.solid, grid, height)
 
     if isinstance(base, GeneratedBase):
         _notify(on_progress, "generating_base")
@@ -323,14 +341,14 @@ def rebase(
     else:
         _notify(on_progress, "preparing_donor")
         with _geometry_errors("incompatible_donor"):
-            donor_grid = detect_grid(
+            donor = normalize_model(
                 base.model._solid,
                 str(base.model.source) if base.model.source else "Donor",
             )
             if base_height_mm is None and height > PROFILE_HEIGHT:
                 donor_standard = detect_standard_base(
-                    base.model._solid,
-                    donor_grid,
+                    donor.solid,
+                    donor.grid,
                     str(base.model.source) if base.model.source else "Donor",
                 )
                 if donor_standard.height < height - 0.001:
@@ -342,17 +360,20 @@ def rebase(
                             "base_height_mm": height,
                         },
                     )
-            replacement = donor_base(base.model._solid, donor_grid, grid, height)
+            replacement = donor_base(donor.solid, donor.grid, grid, height)
         geometry = None
 
     _notify(on_progress, "replacing_base")
     with _geometry_errors("replacement_failed"):
-        solid = replace_base(model._solid, replacement, grid, height)
+        solid = normalized.frame.to_source(
+            replace_base(normalized.solid, replacement, grid, height)
+        )
     result = RebaseResult(
         model=Model._from_solid(solid),
         report=RebaseReport(
             grid=(grid.nx, grid.ny),
-            origin_mm=(grid.x, grid.y, grid.z),
+            origin_mm=normalized.frame.origin_mm,
+            rotation_z_deg=normalized.frame.rotation_z_deg,
             base_height_mm=height,
             base_height_mode="auto" if base_height_mm is None else "manual",
             geometry=geometry,

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/src/gridfinity_rebase/geometry.py

@@ -92,7 +92,7 @@ def detect_grid(solid: m.Manifold, label="Model", tolerance=0.35) -> Grid:
         raise RebaseError(
             f"{label}: unsupported Gridfinity footprint: expected a complete rectangular grid"
         )
-    expected_centres = sorted(map(tuple, centres))
+    expected_centres = dict(zip(map(tuple, lattice), centres))
     # Bounds alone would accept an ordinary 41.5 mm box or a baseplate.
     for height, width in [(0.3, 36.2), (1.4, 37.2), (3.5, 39.0), (4.6, 41.2)]:
         sections = outer_boxes(solid, z + height)
@@ -100,15 +100,20 @@ def detect_grid(solid: m.Manifold, label="Model", tolerance=0.35) -> Grid:
             raise RebaseError(
                 f"{label}: not Gridfinity: unexpected foot sections at Z+{height:g} mm"
             )
-        sections.sort(key=lambda box: tuple((box[0] + box[1]) / 2))
-        for (low, high), centre in zip(sections, expected_centres):
+        seen = set()
+        for low, high in sections:
+            centre = (low + high) / 2
+            cell = tuple(np.rint((centre - origin) / PITCH).astype(int))
             if (
-                np.max(np.abs(high - low - width)) > tolerance
-                or np.max(np.abs((low + high) / 2 - centre)) > tolerance
+                cell not in expected_centres
+                or cell in seen
+                or np.max(np.abs(high - low - width)) > tolerance
+                or np.max(np.abs(centre - expected_centres[cell])) > tolerance
             ):
                 raise RebaseError(
                     f"{label}: not Gridfinity: incorrect chamfer/profile at Z+{height:g} mm; expected {width:g} mm feet (mm, Z up)"
                 )
+            seen.add(cell)
         filled = m.CrossSection(
             [p for p in solid.slice(z + height).to_polygons() if signed_area(p) > 0]
         )
@@ -120,6 +125,99 @@ def detect_grid(solid: m.Manifold, label="Model", tolerance=0.35) -> Grid:
     return Grid(nx, ny, float(origin[0]), float(origin[1]), float(z))
 
 
+@dataclass(frozen=True)
+class ModelFrame:
+    """Rigid XY frame: first foot at the origin, underside at Z=0.
+
+    rotation_z_deg maps the local +X direction to the source coordinates.
+    Square feet only determine orientation modulo 90 degrees; use [-45, 45).
+    """
+
+    origin_mm: tuple[float, float, float]
+    rotation_z_deg: float
+
+    def to_local(self, solid: m.Manifold) -> m.Manifold:
+        return solid.translate(tuple(-v for v in self.origin_mm)).rotate(
+            (0, 0, -self.rotation_z_deg)
+        )
+
+    def to_source(self, solid: m.Manifold) -> m.Manifold:
+        return solid.rotate((0, 0, self.rotation_z_deg)).translate(self.origin_mm)
+
+
+@dataclass(frozen=True)
+class NormalizedModel:
+    """Validated Gridfinity geometry in a common frame for all operations."""
+
+    solid: m.Manifold
+    grid: Grid
+    frame: ModelFrame
+
+
+def _foot_rotation(solid: m.Manifold, label: str) -> float:
+    # Simplification removes collinear slice/triangulation vertices before
+    # measuring edges. Use only outer contours, never hardware holes or the
+    # body's principal axes (which need not follow the feet).
+    polygons = [
+        np.asarray(p)
+        for p in solid.slice(1.4).simplify(0.0001).to_polygons()
+        if signed_area(p) > 1
+    ]
+    if not polygons:
+        raise RebaseError(
+            f"{label}: not Gridfinity: no feet found (use millimetres, Z up)"
+        )
+    edges = np.concatenate([np.roll(p, -1, axis=0) - p for p in polygons])
+    lengths = np.linalg.norm(edges, axis=1)
+    # Straight sides dominate a foot; short rounded-corner segments should
+    # not bias the estimate. Opposite/perpendicular sides share one phase
+    # after multiplying their angles by four.
+    longest = lengths >= lengths.max() * 0.5
+    angles = np.arctan2(edges[longest, 1], edges[longest, 0])
+    direction = np.sum(lengths[longest] * np.exp(4j * angles))
+    angle = (float(np.degrees(np.angle(direction)) / 4) + 45) % 90 - 45
+    # Stabilize the symmetric boundaries against float32 STL roundoff.
+    if abs(angle) < 0.00001:
+        return 0.0
+    if abs(abs(angle) - 45) < 0.00001:
+        return -45.0
+    return angle
+
+
+def normalize_model(solid: m.Manifold, label="Model") -> NormalizedModel:
+    """Recover a Z rotation, validate the feet, and move to a local frame.
+
+    No scaling, mirroring or X/Y rotations are inferred. Angle estimation is
+    only a hypothesis: the full lattice and mating-profile checks must pass.
+    Centre before measuring to keep calculations independent of source offset.
+    """
+    bounds = solid.bounding_box()
+    if bounds[5] - bounds[2] < PROFILE_HEIGHT - 0.05:
+        raise RebaseError(
+            f"{label}: not Gridfinity: shorter than the 4.75 mm foot profile"
+        )
+    pivot = np.array(
+        [(bounds[0] + bounds[3]) / 2, (bounds[1] + bounds[4]) / 2, bounds[2]]
+    )
+    centred = solid.translate(tuple(-pivot))
+    angle = _foot_rotation(centred, label)
+    aligned = centred.rotate((0, 0, -angle))
+    detected = detect_grid(aligned, label)
+    origin = np.array([detected.x, detected.y, 0.0])
+    radians = np.radians(angle)
+    source_origin = (
+        origin[0] * np.cos(radians) - origin[1] * np.sin(radians) + pivot[0],
+        origin[0] * np.sin(radians) + origin[1] * np.cos(radians) + pivot[1],
+        pivot[2],
+    )
+    frame = ModelFrame(tuple(float(v) for v in source_origin), angle)
+    return NormalizedModel(
+        aligned.translate(tuple(-origin)),
+        Grid(detected.nx, detected.ny, 0.0, 0.0, 0.0),
+        frame,
+    )
+
+
 def lower(solid, height):
     return solid.trim_by_plane((0, 0, -1), -height)
 
@@ -244,8 +342,19 @@ def donor_base(solid, donor: Grid, target: Grid, height: float):
         # Tile feet and hardware cutouts, then join them with a continuous
         # standard bridge; copying whole 1x1 tiles would leave 0.5 mm slots.
         feet = lower(base, PROFILE_HEIGHT)
-        donor_envelope = rounded_prism(41.5, 41.5, 3.75, PROFILE_HEIGHT, height)
-        cutouts = donor_envelope - base.trim_by_plane((0, 0, 1), PROFILE_HEIGHT)
+        donor_bridge = base.trim_by_plane((0, 0, 1), PROFILE_HEIGHT)
+        # Derive the envelope from the donor's own vertices. Subtracting a
+        # separately tessellated nominal outline also copies tiny exterior
+        # slivers caused by STL quantization/rotation as if they were holes.
+        cutouts = donor_bridge.hull() - donor_bridge
+        holes = []
+        for part in cutouts.decompose():
+            points = np.asarray(part.to_mesh64().vert_properties)[:, :3]
+            # Hull subtraction can leave exactly coplanar shells in any
+            # direction. Keep every volumetric part, regardless of its size.
+            if np.linalg.matrix_rank(points - points[0]) == 3:
+                holes.append(part)
+        cutouts = m.Manifold.batch_boolean(holes, m.OpType.Add)
         bridge = rounded_prism(
             target.nx * PITCH - 0.5,
             target.ny * PITCH - 0.5,

{gridfinity_rebase-0.1.2 → gridfinity_rebase-0.2.0}/src/gridfinity_rebase/stl.py

@@ -85,10 +85,32 @@ def write_stl(solid: m.Manifold, path: str | Path, *, overwrite: bool = False) -
     mesh = quantized.to_mesh()
     triangles = np.asarray(mesh.vert_properties)[:, :3][mesh.tri_verts]
     normals = np.cross(
-        triangles[:, 1] - triangles[:, 0], triangles[:, 2] - triangles[:, 0]
+        np.subtract(triangles[:, 1], triangles[:, 0], dtype=np.float64),
+        np.subtract(triangles[:, 2], triangles[:, 0], dtype=np.float64),
     )
+    if np.any(np.all(normals == 0, axis=1)):
+        # Float32 can make a previously non-collinear triangle flat. Only
+        # in that case simplify at the engine's existing tolerance; leave
+        # ordinary exports alone and never raise tolerance to force a repair.
+        # STL has no face ancestry; clearing boolean face boundaries lets
+        # the engine collapse flat triangles across those boundaries too.
+        quantized = quantized.as_original().simplify(0)
+        if quantized.status() != m.Error.NoError or quantized.is_empty():
+            raise RebaseError(
+                "Cannot collapse degenerate float32 STL faces", code="export_failed"
+            )
+        mesh = quantized.to_mesh()
+        triangles = np.asarray(mesh.vert_properties)[:, :3][mesh.tri_verts]
+        normals = np.cross(
+            np.subtract(triangles[:, 1], triangles[:, 0], dtype=np.float64),
+            np.subtract(triangles[:, 2], triangles[:, 0], dtype=np.float64),
+        )
     lengths = np.linalg.norm(normals, axis=1)
-    normals /= np.where(lengths > 0, lengths, 1)[:, None]
+    if np.any(lengths == 0):
+        raise RebaseError(
+            "Cannot export degenerate float32 STL faces", code="export_failed"
+        )
+    normals /= lengths[:, None]
     records = np.zeros(len(triangles), dtype=FACET)
     records["vertices"] = triangles
     records["normal"] = normals