cdcad 0.4.0__py3-none-any.whl

cdcad/__init__.py

@@ -0,0 +1,18 @@
+"""CDCAD Python API for parametric, command-line driven CAD."""
+from ._common import CADError, VERSION as __version__
+
+__all__ = ["CADError", "Engine", "build_recipe", "read_recipe", "resolve_recipe"]
+
+
+def __getattr__(name):
+    # Keep package import and CLI help independent of geometry dependencies.
+    if name == "Engine":
+        from .engine import Engine
+        return Engine
+    if name == "build_recipe":
+        from .build import build
+        return build
+    if name in {"read_recipe", "resolve_recipe"}:
+        from . import recipe
+        return getattr(recipe, name)
+    raise AttributeError(name)

cdcad/__main__.py

@@ -0,0 +1,5 @@
+"""Run CDCAD through python -m cdcad."""
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cdcad/_common.py

@@ -0,0 +1,80 @@
+"""Shared serialization, file operations, and runtime configuration."""
+import functools
+import importlib.metadata
+import json
+import os
+from pathlib import Path, PureWindowsPath
+import secrets
+import sys
+
+VERSION = "0.4.0"
+UNITS = {"mm": 1.0, "cm": 10.0, "m": 1000.0, "in": 25.4}
+EXPORT_FORMATS = ("stl", "ply", "obj", "glb", "off")
+GEOMETRY_DEPENDENCIES = (
+    "numpy", "trimesh", "shapely", "manifold3d", "mapbox-earcut",
+    "svgelements", "ezdxf", "Pillow", "fast-simplification", "scipy", "networkx",
+)
+
+
+class CADError(Exception):
+    """Invalid input or an operation that could not produce a valid result."""
+
+
+@functools.lru_cache(maxsize=1)
+def dependency_versions():
+    return {name: importlib.metadata.version(name) for name in GEOMETRY_DEPENDENCIES}
+
+
+def parse_sets(settings):
+    values = {}
+    for setting in settings or ():
+        key, sep, raw = setting.partition("=")
+        if not sep or not key:
+            raise CADError("--set expects NAME=NUMBER or NAME==EXPRESSION")
+        try:
+            values[key] = json.loads(raw)
+        except json.JSONDecodeError:
+            values[key] = raw
+    return values
+
+
+def document_path(value):
+    """Interpret portable paths and relative paths saved by Windows clients."""
+    windows = PureWindowsPath(value)
+    if "\\" in value and not windows.anchor:
+        return Path(*windows.parts)
+    return Path(value)
+
+
+def read_stdin_json():
+    stream = getattr(sys.stdin, "buffer", None)
+    data = stream.read().decode("utf-8-sig") if stream is not None else sys.stdin.read().lstrip("\ufeff")
+    return json.loads(data)
+
+
+def read_json(path):
+    return json.loads(Path(path).read_text(encoding="utf-8-sig"))
+
+
+def atomic_bytes(path, data):
+    """Replace path with data in one step; readers see the old or the new file, never a part."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # Create the temporary file with the mode a normal write would get (0o666 minus
+    # the umask). tempfile.NamedTemporaryFile makes it 0o600, and that mode would
+    # survive os.replace, leaving every model and project file owner-only on POSIX.
+    tmp = path.parent/f".cdcad-{os.getpid():x}-{secrets.token_hex(6)}"
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0)
+    fd = os.open(tmp, flags, 0o666)
+    try:
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+            f.flush()
+            os.fsync(f.fileno())  # the recovery journal is only useful if it reached the disk
+        os.replace(tmp, path)
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+def json_bytes(value):
+    return (json.dumps(value, indent=2, allow_nan=False)+"\n").encode()

cdcad/_profiles.py

@@ -0,0 +1,219 @@
+"""Planar contours, drawing imports, and structural profiles."""
+import math
+
+import numpy as np
+from shapely import affinity, make_valid
+from shapely.geometry import Polygon, MultiPolygon, GeometryCollection, LineString, Point, box
+from shapely.ops import unary_union
+
+from ._common import CADError
+
+
+def polygonal(geom):
+    if not geom.is_valid:
+        raise CADError("Invalid 2D geometry; fix self intersections or hole boundaries")
+    if isinstance(geom, Polygon):
+        polys = [geom]
+    elif isinstance(geom, (MultiPolygon, GeometryCollection)):
+        polys = [p for p in geom.geoms if isinstance(p, Polygon) and p.area > 0]
+    else:
+        polys = []
+    if not polys or sum(p.area for p in polys) <= 1e-12:
+        raise CADError("Profile is empty or has zero area")
+    return unary_union(polys)
+
+
+def polygons(geom):
+    return [geom] if isinstance(geom, Polygon) else list(geom.geoms)
+
+
+def loops_fill(loops, rule="evenodd"):
+    """Polygonize nested contours with even-odd or true winding-number fill."""
+    from shapely.ops import polygonize
+    rings = []
+    for pts in loops:
+        xy = np.asarray(pts, dtype=float)
+        tolerance = max(float(np.ptp(xy, axis=0).max())*1e-12, 1e-12)
+        # SVG curves often finish a few ulps away from their start. Do not let
+        # the tiny closing edge turn into collapsed triangles after triangulation.
+        keep = np.r_[True, np.linalg.norm(np.diff(xy, axis=0), axis=1) > tolerance]
+        xy = xy[keep]
+        while len(xy) > 1 and np.linalg.norm(xy[-1]-xy[0]) <= tolerance:
+            xy = xy[:-1]
+        if len(xy) < 3:
+            raise CADError("Closed contour has fewer than three distinct points")
+        p = Polygon(xy).simplify(tolerance, preserve_topology=True)
+        if not p.is_valid or p.area <= 1e-12:
+            raise CADError("Input contains a degenerate or self-intersecting closed contour")
+        xy = np.asarray(p.exterior.coords)
+        signed = np.sum(xy[:-1, 0]*xy[1:, 1] - xy[1:, 0]*xy[:-1, 1])
+        rings.append((p, 1 if signed > 0 else -1))
+    if not rings:
+        raise CADError("No closed contours found")
+    regions = polygonize(unary_union([p.boundary for p, _ in rings]))
+    selected = []
+    for region in regions:
+        test = region.representative_point()
+        winding = sum(sign if rule == "nonzero" else 1 for p, sign in rings if p.covers(test))
+        if (winding != 0 if rule == "nonzero" else winding % 2):
+            selected.append(region)
+    return polygonal(unary_union(selected))
+
+
+def svg_path_geometry(path, step=0.5, width=None, rule="evenodd"):
+    from svgelements import Close, Move
+    loops, strokes = [], []
+    for sub in path.as_subpaths():
+        points = []
+        closed = False
+        for seg in sub:
+            if isinstance(seg, Move):
+                points.append([seg.end.x, seg.end.y])
+                continue
+            length = seg.length(error=1e-5)
+            count = max(1, math.ceil(length / step))
+            if count > 200000:
+                raise CADError("SVG segment exceeds sampling limit; increase step")
+            if not points:
+                points.append([seg.start.x, seg.start.y])
+            for i in range(1, count + 1):
+                p = seg.point(i/count)
+                points.append([p.x, p.y])
+            closed = closed or isinstance(seg, Close)
+        if len(points) < 2:
+            continue
+        if width is not None:
+            strokes.append(LineString(points).buffer(width / 2, quad_segs=16))
+        elif closed or np.allclose(points[0], points[-1], atol=1e-9, rtol=0):
+            loops.append(points)
+        else:
+            raise CADError("Open SVG path; close it with Z or use a path profile with width")
+    return polygonal(unary_union(strokes)) if width is not None else loops_fill(loops, rule)
+
+
+def read_svg(file, node):
+    from svgelements import SVG, Shape, Path as SVGPath
+    svg = SVG.parse(str(file), reify=True, ppi=96)
+    selected = set(node.get("ids", []))
+    found, geometries = set(), []
+    for element in svg.elements():
+        if not isinstance(element, Shape):
+            continue
+        eid = element.values.get("id")
+        if selected and eid not in selected:
+            continue
+        # Hidden and unfilled shapes aren't treated as filled CAD outlines.
+        if element.values.get("visibility") == "hidden" or element.values.get("display") == "none":
+            continue
+        if getattr(element.fill, "value", None) is None:
+            continue
+        if eid:
+            found.add(eid)
+        rule = node.get("fill_rule", element.values.get("fill-rule", "nonzero"))
+        if rule not in ("evenodd", "nonzero"):
+            raise CADError(f"Unsupported SVG fill rule: {rule}")
+        geometries.append(svg_path_geometry(SVGPath(element), node.get("step", .5), rule=rule))
+    if selected - found:
+        raise CADError(f"SVG filled shape IDs not found: {sorted(selected-found)}")
+    geom = polygonal(unary_union(geometries))
+    if node.get("flip_y", True):
+        geom = affinity.scale(geom, yfact=-1, origin=(0, 0))
+    return geom
+
+
+def read_dxf(file, node):
+    import ezdxf
+    from ezdxf.path import make_path
+    from shapely.ops import polygonize_full
+    doc = ezdxf.readfile(str(file))
+    layer_filter = set(node.get("layers", []))
+    lines = []
+    allowed = {"LWPOLYLINE", "POLYLINE", "LINE", "ARC", "CIRCLE", "ELLIPSE", "SPLINE"}
+    for entity in doc.modelspace():
+        if layer_filter and entity.dxf.layer not in layer_filter:
+            continue
+        if entity.dxftype() not in allowed:
+            raise CADError(f"Unsupported DXF entity {entity.dxftype()}; select contour layers or explode it first")
+        pts = np.asarray([tuple(p) for p in make_path(entity).flattening(node.get("tolerance", .05))])
+        if len(pts) < 2:
+            continue
+        if np.max(np.abs(pts[:, 2])) > 1e-7:
+            raise CADError("DXF must lie in the XY plane at Z=0")
+        lines.append(LineString(pts[:, :2]))
+    if not lines:
+        raise CADError("No supported DXF contours in selected layers")
+    # polygonize accepts line chains; reject dangling/open geometry instead of losing it.
+    result, cuts, dangles, invalid = polygonize_full(unary_union(lines))
+    if any(not g.is_empty for g in (cuts, dangles, invalid)):
+        raise CADError("DXF has open, dangling or invalid contour segments")
+    rings = {}
+    for p in result.geoms:
+        for ring in [p.exterior, *p.interiors]:
+            poly = Polygon(ring)
+            rings[poly.normalize().wkb_hex] = list(ring.coords)
+    return loops_fill(list(rings.values()))
+
+
+def arch_opening(node):
+    span = node["span"]
+    rise, leg = node.get("rise", span/2), node.get("leg", 0)
+    angles = np.unique(np.r_[np.linspace(0, np.pi, int(node.get("segments", 64))+1), np.pi/2])[::-1]
+    curve = np.column_stack([span/2*np.cos(angles), leg+rise*np.sin(angles)])
+    curve[0], curve[-1] = [-span/2, leg], [span/2, leg]
+    return polygonal(Polygon([[-span/2, 0], *curve.tolist(), [span/2, 0]]))
+
+
+def arch_profile(node):
+    opening = arch_opening(node)
+    t = node["thickness"]
+    # Explicit outer ellipse gives predictable overall dimensions. Thickness
+    # adds to the horizontal/vertical radii; elliptical normal thickness varies.
+    outer = arch_opening({**node, "span": node["span"]+2*t,
+                          "rise": node.get("rise", node["span"]/2)+t})
+    return polygonal(outer.difference(opening))
+
+
+def frame_profile(size, border):
+    w, h = size
+    if border*2 >= min(w, h):
+        raise CADError("Frame border must be less than half its smaller dimension")
+    return box(-w/2, -h/2, w/2, h/2).difference(box(-w/2+border, -h/2+border, w/2-border, h/2-border))
+
+
+def slot_profile(size, center=(0, 0)):
+    w, h = size
+    r = min(w, h)/2
+    a, b = ([-w/2+r, 0], [w/2-r, 0]) if w >= h else ([0, -h/2+r], [0, h/2-r])
+    geom = Point(0, 0).buffer(r, quad_segs=24) if w == h else LineString([a, b]).buffer(r, quad_segs=24)
+    return affinity.translate(geom, *center)
+
+
+def panel_cutouts(geom, cutouts):
+    holes = []
+    for cut in cutouts:
+        shape = cut["shape"]
+        if shape == "rectangle":
+            if "size" not in cut:
+                raise CADError("Rectangle cutout requires size")
+            w, h = cut["size"]
+            r = cut.get("radius", 0)
+            if r > min(w, h)/2:
+                raise CADError("Cutout radius is too large")
+            hole = slot_profile([w, h]) if r == min(w, h)/2 else box(-w/2+r, -h/2+r, w/2-r, h/2-r).buffer(r) if r else box(-w/2, -h/2, w/2, h/2)
+        elif shape == "circle":
+            if "radius" not in cut:
+                raise CADError("Circle cutout requires radius")
+            hole = Point(0, 0).buffer(cut["radius"], quad_segs=24)
+        elif shape == "slot":
+            if "size" not in cut:
+                raise CADError("Slot cutout requires size")
+            hole = slot_profile(cut["size"])
+        else:
+            if "span" not in cut:
+                raise CADError("Arch cutout requires span")
+            hole = arch_opening(cut)
+            h = cut.get("leg", 0)+cut.get("rise", cut["span"]/2)
+            hole = affinity.translate(hole, yoff=-h/2)
+        hole = affinity.rotate(hole, cut.get("rotate", 0), origin=(0, 0))
+        holes.append(affinity.translate(hole, *cut.get("center", [0, 0])))
+    return polygonal(geom.difference(unary_union(holes))) if holes else polygonal(geom)

cdcad/build.py

@@ -0,0 +1,51 @@
+"""Plan and build recipe exports."""
+import hashlib
+from pathlib import Path
+
+from ._common import CADError, EXPORT_FORMATS, UNITS, VERSION, atomic_bytes, document_path
+from .engine import Engine
+from .mesh import export_bytes, mesh_report
+
+
+def recipe_source_paths(recipe, base):
+    return {(Path(base)/document_path(node["path"])).resolve()
+            for kind in ("profiles", "solids")
+            for node in recipe.get(kind, {}).values() if "path" in node}
+
+
+def build(recipe, base, out_dir=None, targets=None, force=False, dry_run=False, cache_dir=None, *, protected_paths=()):
+    engine = Engine(recipe, base, cache_dir=cache_dir)
+    exports = [x for x in recipe["exports"] if not targets or x["solid"] in targets]
+    if targets and set(targets)-{x["solid"] for x in exports}:
+        raise CADError("--target must name an exported solid")
+    sources = recipe_source_paths(recipe, base) | {Path(p).resolve() for p in protected_paths}
+    paths = []
+    for exp in exports:
+        path = (Path(out_dir or base)/document_path(exp["path"])).resolve()
+        if out_dir and not path.is_relative_to(Path(out_dir).resolve()):
+            raise CADError("Export path escapes --out-dir")
+        if path in sources:
+            raise CADError(f"Export would overwrite a source file: {path}")
+        if path in paths:
+            raise CADError("Multiple exports resolve to the same path")
+        if path.exists() and not force and not dry_run:
+            raise CADError(f"Output exists: {path}; use --force to replace")
+        if path.suffix.lower()[1:] not in EXPORT_FORMATS:
+            raise CADError(f"Unsupported export extension: {path.suffix}")
+        paths.append(path)
+    if dry_run:
+        return {"ok": True, "dry_run": True, "units": engine.unit,
+                "exports": [{"solid": e["solid"], "path": str(p)} for e, p in zip(exports, paths)],
+                "note": "Schema and references checked; geometry and source files have not been evaluated."}
+    pending, reports = [], []
+    for exp, path in zip(exports, paths):
+        mesh = engine.get("solids", exp["solid"]).copy()
+        mesh.apply_scale(UNITS[engine.unit])
+        data = export_bytes(mesh, path, exp.get("allow_open", False))
+        pending.append((path, data))
+        reports.append({"solid": exp["solid"], "path": str(path), "sha256": hashlib.sha256(data).hexdigest(),
+                        **mesh_report(mesh)})
+    # Evaluate and validate every selected export before writing any model.
+    for path, data in pending:
+        atomic_bytes(path, data)
+    return {"ok": True, "version": VERSION, "units": "mm", "exports": reports, "trace": engine.trace}

cdcad/cli.py

@@ -0,0 +1,75 @@
+"""CDCAD command discovery, dispatch, and output."""
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from ._common import CADError, EXPORT_FORMATS, UNITS, VERSION, dependency_versions
+from .commands import mesh, model, project, recipe
+from .schema import PROFILE_OPS, SOLID_OPS
+
+
+class ArgumentParser(argparse.ArgumentParser):
+    """Use full option names so adding a flag cannot break existing scripts."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, allow_abbrev=False, **kwargs)
+
+
+def parser():
+    application = ArgumentParser(
+        prog="cdcad",
+        description="CDCAD | Command-line driven CAD for parametric models, assemblies, and mesh editing.",
+        epilog="Run cdcad COMMAND --help for options and examples.",
+    )
+    application.add_argument("--version", action="version", version=f"CDCAD {VERSION}")
+    application.add_argument("--debug", action="store_true", help="Show Python traceback on errors")
+    application.add_argument("--pretty", action="store_true", help="Indent JSON output for reading")
+    commands = application.add_subparsers(dest="command", required=True, metavar="COMMAND")
+    model.register(commands)
+    recipe.register(commands)
+    mesh.register(commands)
+    project_commands = project.add_parser(commands)
+    discovery = commands.add_parser("capabilities", help="List commands, modeling operations, and supported formats")
+    discovery.set_defaults(handler=capabilities, command_choices=commands.choices,
+                           project_choices=project_commands.choices)
+    commands.add_parser("serve", help="Run a persistent JSON-lines process on stdin/stdout")
+    return application
+
+
+def capabilities(args):
+    return {
+        "ok": True, "version": VERSION, "package": str(Path(__file__).resolve().parent),
+        "recipe_version": 1, "project_version": 1,
+        "profiles": list(PROFILE_OPS), "solids": list(SOLID_OPS),
+        "commands": list(args.command_choices), "project_commands": list(args.project_choices),
+        "units": dict(UNITS), "export_formats": list(EXPORT_FORMATS),
+        "dependencies": dependency_versions(),
+    }
+
+
+def execute(args):
+    if args.command == "serve":
+        raise CADError("serve is a top-level process mode and cannot be nested")
+    return args.handler(args)
+
+
+def main(argv=None):
+    application = parser()
+    args = application.parse_args(argv)
+    try:
+        if args.command == "serve":
+            from .worker import serve
+            return serve(application, execute)
+        indent = 2 if args.pretty else None
+        separators = None if args.pretty else (",", ":")
+        print(json.dumps(execute(args), indent=indent, separators=separators, allow_nan=False))
+        return 0
+    except KeyboardInterrupt:
+        print(json.dumps({"ok": False, "error": "Interrupted", "type": "KeyboardInterrupt"}), file=sys.stderr)
+        return 130
+    except Exception as exc:
+        if args.debug:
+            raise
+        print(json.dumps({"ok": False, "error": str(exc), "type": type(exc).__name__}), file=sys.stderr)
+        return 2

cdcad/commands/__init__.py

@@ -0,0 +1 @@
+"""Command registration and CLI handlers."""

cdcad/commands/_output.py

@@ -0,0 +1,13 @@
+"""Shared options for commands exporting one model."""
+
+
+def add_output(parser):
+    parser.add_argument("-o", "--output", required=True)
+    parser.add_argument("--force", action="store_true", help="Replace an existing output")
+    parser.add_argument("--allow-open", action="store_true", help="Permit export without positive-volume validation")
+
+
+def add_units(parser):
+    from .._common import UNITS
+
+    parser.add_argument("--units", choices=UNITS, default="mm", help="Input dimensions (default: mm)")

cdcad/commands/mesh.py

@@ -0,0 +1,164 @@
+"""Mesh inspection, editing, boolean, component, and section commands."""
+from pathlib import Path
+
+from ._output import add_output
+from .._common import CADError, atomic_bytes
+from ..schema import TRANSFORM
+
+
+def register(s):
+    i = s.add_parser("inspect", help="Print mesh topology, bounds and volume; assumes coordinates are mm")
+    i.set_defaults(handler=inspect)
+    i.add_argument("input")
+    i.add_argument("--require-solid", action="store_true")
+    i.add_argument("--bed", nargs=3, type=float, metavar=("X", "Y", "Z"),
+                   help="Build volume in mm; reports whether the part fits as modeled and in any axis-aligned orientation")
+    i.add_argument("--require-fit", action="store_true", help="With --bed, fail unless the part fits in some axis-aligned orientation")
+    edit = s.add_parser("edit", help="Transform/repair/cut/simplify an existing mesh in that order")
+    edit.set_defaults(handler=edit_mesh)
+    edit.add_argument("input")
+    edit.add_argument("--scale", nargs=3, type=float, metavar=("X", "Y", "Z"))
+    edit.add_argument("--rotate", nargs=3, type=float, metavar=("X", "Y", "Z"), help="Euler degrees")
+    edit.add_argument("--translate", nargs=3, type=float, metavar=("X", "Y", "Z"))
+    edit.add_argument("--repair", action="store_true")
+    edit.add_argument("--cut-origin", nargs=3, type=float)
+    edit.add_argument("--cut-normal", nargs=3, type=float)
+    edit.add_argument("--no-cap", action="store_true")
+    edit.add_argument("--faces", type=int)
+    edit.add_argument("--hull", action="store_true")
+    add_output(edit)
+    bo = s.add_parser("boolean", help="Solid mesh union/difference/intersection; first input is base for difference")
+    bo.set_defaults(handler=boolean_meshes)
+    bo.add_argument("operation", choices=["union", "difference", "intersection"])
+    bo.add_argument("inputs", nargs="+")
+    add_output(bo)
+    sp = s.add_parser("split", help="Export disconnected components as separate STLs")
+    sp.set_defaults(handler=split_mesh)
+    sp.add_argument("input")
+    sp.add_argument("--out-dir", required=True)
+    sp.add_argument("--force", action="store_true")
+    sp.add_argument("--allow-open", action="store_true")
+    sec = s.add_parser("section", help="Export a horizontal cross section as SVG (coordinates assumed mm)")
+    sec.set_defaults(handler=section_mesh)
+    sec.add_argument("input")
+    sec.add_argument("--z", required=True, type=float)
+    sec.add_argument("--output", "-o", required=True)
+    sec.add_argument("--force", action="store_true")
+
+
+def single_export(mesh, args):
+    from ..mesh import export_bytes, mesh_report
+
+    path = Path(args.output).resolve()
+    if path.exists() and not args.force:
+        raise CADError(f"Output exists: {path}; use --force")
+    data = export_bytes(mesh, path, args.allow_open)
+    atomic_bytes(path, data)
+    return {"ok": True, "path": str(path), "units": "mm", **mesh_report(mesh)}
+
+
+def inspect(args):
+    from ..mesh import load_mesh, mesh_report, valid_mesh
+
+    if args.require_fit and not args.bed:
+        raise CADError("--require-fit needs --bed")
+    mesh = load_mesh(Path(args.input))
+    if args.require_solid:
+        valid_mesh(mesh)
+    report = {"ok": True, "units": "mm", **mesh_report(mesh)}
+    if args.bed:
+        report["bed_fit"] = bed_fit(report["extents"], args.bed)
+        if args.require_fit and not report["bed_fit"]["fits_any_orientation"]:
+            raise CADError(f"Part {[round(e, 3) for e in report['extents']]} mm does not fit a {args.bed} mm build volume "
+                           "in any axis-aligned orientation")
+    return report
+
+
+FIT_TOLERANCE = 1e-4  # mm; STL stores float32, so a 140 mm part can read 140.00001
+
+
+def bed_fit(extents, bed):
+    """Compare part extents with a build volume, as modeled and with the axes reassigned freely."""
+    if any(size <= 0 for size in bed):
+        raise CADError("--bed sizes must be positive")
+    as_modeled = all(e <= b + FIT_TOLERANCE for e, b in zip(extents, bed))
+    # Axis-aligned orientations are permutations of the axes; the part fits in one
+    # of them exactly when its sorted extents fit the sorted build volume.
+    any_orientation = all(e <= b + FIT_TOLERANCE for e, b in zip(sorted(extents), sorted(bed)))
+    return {"bed": list(bed), "fits": as_modeled, "fits_any_orientation": any_orientation,
+            "clearance": [round(b - e, 6) for e, b in zip(extents, bed)]}
+
+
+def boolean_meshes(args):
+    from ..mesh import boolean, load_mesh
+
+    if len(args.inputs) < 2:
+        raise CADError("Boolean command requires at least two input files")
+    return single_export(boolean(args.operation, [load_mesh(Path(x)) for x in args.inputs]), args)
+
+
+def edit_mesh(args):
+    from ..mesh import clean_mesh, cut_mesh, load_mesh, transform_mesh
+
+    mesh = load_mesh(Path(args.input))
+    mesh = transform_mesh(mesh, {k: getattr(args, k) for k in TRANSFORM if getattr(args, k, None) is not None})
+    if args.repair:
+        mesh = clean_mesh(mesh)
+    if bool(args.cut_origin) != bool(args.cut_normal):
+        raise CADError("Supply both --cut-origin and --cut-normal")
+    if args.cut_origin:
+        mesh = cut_mesh(mesh, args.cut_origin, args.cut_normal, cap=not args.no_cap)
+    if args.faces is not None:
+        if args.faces < 4:
+            raise CADError("--faces must be >= 4")
+        if args.faces < len(mesh.faces):
+            mesh = mesh.simplify_quadric_decimation(face_count=args.faces)
+    if args.hull:
+        mesh = mesh.convex_hull
+    return single_export(mesh, args)
+
+
+def split_mesh(args):
+    from ..mesh import export_bytes, load_mesh
+
+    parts = load_mesh(Path(args.input)).split(only_watertight=False)
+    parts = sorted(parts, key=lambda m: (-abs(m.volume), *m.centroid))
+    pending = []
+    for i, part in enumerate(parts):
+        path = Path(args.out_dir).resolve()/f"part_{i:03d}.stl"
+        if path.exists() and not args.force:
+            raise CADError(f"Output exists: {path}; use --force")
+        pending.append((path, export_bytes(part, path, args.allow_open)))
+    for path, data in pending:
+        atomic_bytes(path, data)
+    return {"ok": True, "parts": [str(p) for p, _ in pending]}
+
+
+def section_mesh(args):
+    from shapely import affinity
+
+    from .._profiles import loops_fill, polygons
+    from ..mesh import load_mesh
+
+    if Path(args.output).exists() and not args.force:
+        raise CADError("Section output exists; use --force")
+    section = load_mesh(Path(args.input)).section(plane_origin=[0, 0, args.z], plane_normal=[0, 0, 1])
+    if section is None:
+        raise CADError("Plane does not intersect mesh")
+    xy_loops = [loop[:, :2] for loop in section.discrete]
+    geom = loops_fill(xy_loops)
+    # SVG's Y axis points down while the mesh's points up. Write -Y so the drawing
+    # looks like the part seen from +Z, and so the SVG importer (flip_y by default)
+    # restores the original handedness instead of returning a mirror image.
+    drawing = affinity.scale(geom, yfact=-1, origin=(0, 0))
+    xmin, ymin, xmax, ymax = drawing.bounds
+    paths = []
+    for p in polygons(drawing):
+        for ring in [p.exterior, *p.interiors]:
+            xy = list(ring.coords)
+            paths.append("M " + " L ".join(f"{x:.10g},{y:.10g}" for x, y in xy) + " Z")
+    svg = (f'<svg xmlns="http://www.w3.org/2000/svg" width="{xmax-xmin}mm" height="{ymax-ymin}mm" '
+           f'viewBox="{xmin} {ymin} {xmax-xmin} {ymax-ymin}">'
+           f'<path fill-rule="evenodd" d="{" ".join(paths)}"/></svg>\n')
+    atomic_bytes(args.output, svg.encode())
+    return {"ok": True, "path": str(Path(args.output).resolve()), "z": args.z, "area": geom.area}