feat(ship): HNX-02 Copernicus rework — continuous hull, few-large-element scale, Draco pipeline, side-on framing

1 files changed, 1023 insertions, 682 deletions

diff --git a/stage/blender/ship.py b/stage/blender/ship.py
index e1dd30c..0f30d54 100644
--- a/stage/blender/ship.py
+++ b/stage/blender/ship.py
@@ -1,697 +1,1051 @@
-"""HNX-01 crewed interstellar starship dataset for the artifact pipeline.
+"""HNX-02 "Copernicus-class" crewed interplanetary transfer vehicle.
 
-Concept A "Keel" — a crewed fusion-torch starship study built on the same
-Blender contract as the YJ-01 probe dataset (stage/blender/probe.py):
+Rebuild of the crewed starship with procedural engineering structures
+(space trusses, pressure vessels, habitat modules, a spin-gravity
+centrifuge, an NTP engine cluster, and a docked Orion-class shuttle as
+the scale reference) instead of stacked primitives.
 
     --step-id <id> --output <glb> --result-output <json> [--render-output <png>]
 
-Design intent (visual research, NOT a closed engineering design):
-    - Long axial keel so the crew habitat sits as far as practical from the
-      reactor section (inverse-square separation for neutron/gamma dose).
-    - Rotating habitat torus for continuous spin gravity; six spokes carry
-      the pressurized transfer tunnels; the hub is the zero-g docking core.
-    - Heavy water-shadow shield collar and a storm cellar between the
-      habitat and the reactor.
-    - Aft fusion core with a magnetic nozzle; six droop radiators reject the
-      waste heat. These hardware positions are placeholders — the script
-      does not claim thrust, burn time, shielding closure, or life-support
-      closure.
-
-Object ids: starship.<part>[.<index>], lowercase dotted, stable per step.
+Design intent (display-scale visual research, NOT closed engineering):
+    - Nuclear-thermal propulsion (NERVA-class stainless/epoxy composite
+      fuel element heritage) with a shadow shield between reactor and crew.
+    - Axial layout keeps the crew section as far from the reactor as the
+      truss allows; the water-wall tanks double as radiation shielding.
+    - The centrifuge ring provides spin gravity; cars are the pressurized
+      crew volumes. No mass/thrust/shielding closure is claimed.
+
+Object ids: hnx02.<part>[.<index>], lowercase dotted, stable per step.
 Cumulative object lists must stay in lockstep with Design.shipSteps in
 src/SomhairlesDream.Modeling/Definitions.fs.
 """
-
 import argparse
 import json
 import math
 import os
+import random
 import sys
-from datetime import datetime, timezone
 
-import bpy  # noqa: F401  (must be imported before mathutils: registers the bundled mathutils module)
+import bpy  # noqa: F401  (must be imported first: registers bundled bmesh/mathutils)
+import bmesh
 from mathutils import Vector
 
+# --------------------------------------------------------------- contract
+
 STEP_OBJECTS = {
     "ship-01-keel": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
     ],
     "ship-02-hab": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
     ],
     "ship-03-radiation": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
-        "starship.shadow.collar",
-        "starship.storm.cellar",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
+        "hnx02.rad.waterwall",
+        "hnx02.centrifuge.ring",
     ],
     "ship-04-reactor": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
-        "starship.shadow.collar",
-        "starship.storm.cellar",
-        "starship.core.pressure",
-        "starship.core.shield.plug",
-        "starship.nozzle.magnetic",
-        "starship.radiator.00",
-        "starship.radiator.01",
-        "starship.radiator.02",
-        "starship.radiator.03",
-        "starship.radiator.04",
-        "starship.radiator.05",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
+        "hnx02.rad.waterwall",
+        "hnx02.centrifuge.ring",
+        "hnx02.prop.tank",
+        "hnx02.reactor.core",
+        "hnx02.thrust.cone",
+        "hnx02.nozzle.cluster",
     ],
     "ship-05-power": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
-        "starship.shadow.collar",
-        "starship.storm.cellar",
-        "starship.core.pressure",
-        "starship.core.shield.plug",
-        "starship.nozzle.magnetic",
-        "starship.radiator.00",
-        "starship.radiator.01",
-        "starship.radiator.02",
-        "starship.radiator.03",
-        "starship.radiator.04",
-        "starship.radiator.05",
-        "starship.power.truss",
-        "starship.capacitor.ring",
-        "starship.comm.dish",
-        "starship.comm.feed",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
+        "hnx02.rad.waterwall",
+        "hnx02.centrifuge.ring",
+        "hnx02.prop.tank",
+        "hnx02.reactor.core",
+        "hnx02.thrust.cone",
+        "hnx02.nozzle.cluster",
+        "hnx02.power.solar",
+        "hnx02.power.radiator",
     ],
     "ship-06-cabin": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
-        "starship.shadow.collar",
-        "starship.storm.cellar",
-        "starship.core.pressure",
-        "starship.core.shield.plug",
-        "starship.nozzle.magnetic",
-        "starship.radiator.00",
-        "starship.radiator.01",
-        "starship.radiator.02",
-        "starship.radiator.03",
-        "starship.radiator.04",
-        "starship.radiator.05",
-        "starship.power.truss",
-        "starship.capacitor.ring",
-        "starship.comm.dish",
-        "starship.comm.feed",
-        "starship.window.00",
-        "starship.window.01",
-        "starship.window.02",
-        "starship.window.03",
-        "starship.airlock.ring",
-        "starship.airlock.tunnel",
-        "starship.cargo.pod.00",
-        "starship.cargo.pod.01",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
+        "hnx02.rad.waterwall",
+        "hnx02.centrifuge.ring",
+        "hnx02.prop.tank",
+        "hnx02.reactor.core",
+        "hnx02.thrust.cone",
+        "hnx02.nozzle.cluster",
+        "hnx02.power.solar",
+        "hnx02.power.radiator",
+        "hnx02.cabin.airlock",
+        "hnx02.shuttle.orion",
     ],
     "ship-07-livery": [
-        "starship.keel.spine",
-        "starship.nose.cone",
-        "starship.dock.ring",
-        "starship.hab.torus",
-        "starship.hub.core",
-        "starship.spoke.00",
-        "starship.spoke.01",
-        "starship.spoke.02",
-        "starship.spoke.03",
-        "starship.spoke.04",
-        "starship.spoke.05",
-        "starship.shadow.collar",
-        "starship.storm.cellar",
-        "starship.core.pressure",
-        "starship.core.shield.plug",
-        "starship.nozzle.magnetic",
-        "starship.radiator.00",
-        "starship.radiator.01",
-        "starship.radiator.02",
-        "starship.radiator.03",
-        "starship.radiator.04",
-        "starship.radiator.05",
-        "starship.power.truss",
-        "starship.capacitor.ring",
-        "starship.comm.dish",
-        "starship.comm.feed",
-        "starship.window.00",
-        "starship.window.01",
-        "starship.window.02",
-        "starship.window.03",
-        "starship.airlock.ring",
-        "starship.airlock.tunnel",
-        "starship.cargo.pod.00",
-        "starship.cargo.pod.01",
+        "hnx02.hull.core",
+        "hnx02.spine.truss",
+        "hnx02.node.forward",
+        "hnx02.hab.a",
+        "hnx02.hab.b",
+        "hnx02.hab.whipple",
+        "hnx02.rad.waterwall",
+        "hnx02.centrifuge.ring",
+        "hnx02.prop.tank",
+        "hnx02.reactor.core",
+        "hnx02.thrust.cone",
+        "hnx02.nozzle.cluster",
+        "hnx02.power.solar",
+        "hnx02.power.radiator",
+        "hnx02.cabin.airlock",
+        "hnx02.shuttle.orion",
+        "hnx02.detail.greeble",
+        "hnx02.detail.antenna",
     ],
 }
 
-LIVERY_STEPS = {"ship-07-livery"}
+# Material keys per object id.
+OBJECT_MATERIAL = {
+    "hnx02.hull.core": "white",
+    "hnx02.spine.truss": "hull",
+    "hnx02.node.forward": "white",
+    "hnx02.hab.a": "white",
+    "hnx02.hab.b": "white",
+    "hnx02.hab.whipple": "shield",
+    "hnx02.rad.waterwall": "hull",
+    "hnx02.centrifuge.ring": "hull",
+    "hnx02.reactor.core": "dark",
+    "hnx02.prop.tank": "gold",
+    "hnx02.thrust.cone": "hull",
+    "hnx02.nozzle.cluster": "dark",
+    "hnx02.power.solar": "pv",
+    "hnx02.power.radiator": "radiator",
+    "hnx02.cabin.airlock": "white",
+    "hnx02.shuttle.orion": "white",
+    "hnx02.detail.greeble": "hull",
+    "hnx02.detail.antenna": "hull",
+}
 
 
 def utc_now():
-    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
 def fail(message, code):
-    print(message, file=sys.stderr)
-    raise SystemExit(code)
+    print(json.dumps({"status": "failed", "message": message}))
+    sys.exit(code)
 
 
-def rgba(rgb, alpha=1.0):
-    return (*rgb, alpha)
+# --------------------------------------------------------------- materials
 
 
-def make_material(bpy, name, color, *, metallic=0.0, roughness=0.45, emission=None, emission_strength=0.0):
-    material = bpy.data.materials.get(name) or bpy.data.materials.new(name)
+def make_material(bpy, name, color, *, metallic=0.0, roughness=0.45):
+    material = bpy.data.materials.get(name)
+    if material is not None:
+        return material
+    material = bpy.data.materials.new(name)
     material.use_nodes = True
-    material.diffuse_color = rgba(color)
-    shader = material.node_tree.nodes.get("Principled BSDF")
-    shader.inputs["Base Color"].default_value = rgba(color)
-    shader.inputs["Metallic"].default_value = metallic
-    shader.inputs["Roughness"].default_value = roughness
-    if emission is not None:
-        emission_input = shader.inputs.get("Emission Color") or shader.inputs.get("Emission")
-        if emission_input:
-            emission_input.default_value = rgba(emission)
-        strength_input = shader.inputs.get("Emission Strength")
-        if strength_input:
-            strength_input.default_value = emission_strength
+    bsdf = material.node_tree.nodes.get("Principled BSDF")
+    bsdf.inputs["Base Color"].default_value = (*color, 1.0)
+    bsdf.inputs["Metallic"].default_value = metallic
+    bsdf.inputs["Roughness"].default_value = roughness
     return material
 
 
 def build_materials(bpy):
     return {
-        "clay_body": make_material(bpy, "CLAY BODY", (0.38, 0.42, 0.46), metallic=0.20, roughness=0.38),
-        "clay_structure": make_material(bpy, "CLAY STRUCTURE", (0.17, 0.21, 0.25), metallic=0.65, roughness=0.32),
-        "clay_dark": make_material(bpy, "CLAY DARK", (0.045, 0.055, 0.065), metallic=0.45, roughness=0.28),
-        "clay_white": make_material(bpy, "CLAY REFLECTOR", (0.62, 0.65, 0.67), metallic=0.18, roughness=0.34),
-        "clay_glass": make_material(bpy, "CLAY GLASS", (0.035, 0.10, 0.13), metallic=0.12, roughness=0.14, emission=(0.01, 0.05, 0.07), emission_strength=0.15),
-        "livery_hull": make_material(bpy, "LIVERY HULL BONE", (0.72, 0.70, 0.64), metallic=0.30, roughness=0.30),
-        "livery_structure": make_material(bpy, "LIVERY STRUCTURE", (0.13, 0.18, 0.22), metallic=0.78, roughness=0.24),
-        "livery_dark": make_material(bpy, "LIVERY GRAPHITE", (0.018, 0.025, 0.032), metallic=0.70, roughness=0.24),
-        "livery_ceramic": make_material(bpy, "LIVERY SHADOW CERAMIC", (0.10, 0.115, 0.125), metallic=0.25, roughness=0.42),
-        "livery_amber": make_material(bpy, "LIVERY AMBER STRIPE", (0.62, 0.34, 0.05), metallic=0.25, roughness=0.30),
-        "livery_white": make_material(bpy, "LIVERY DISH WHITE", (0.78, 0.81, 0.79), metallic=0.15, roughness=0.28),
-        "livery_glass": make_material(bpy, "LIVERY GLASS", (0.008, 0.055, 0.085), metallic=0.20, roughness=0.10, emission=(0.005, 0.045, 0.09), emission_strength=0.20),
-        "livery_nozzle": make_material(bpy, "LIVERY NOZZLE COIL", (0.16, 0.17, 0.20), metallic=0.85, roughness=0.20),
+        "hull": make_material(bpy, "hnx02.hull", (0.62, 0.64, 0.66), metallic=0.88, roughness=0.38),
+        "white": make_material(bpy, "hnx02.white", (0.86, 0.86, 0.84), metallic=0.18, roughness=0.52),
+        "shield": make_material(bpy, "hnx02.shield", (0.44, 0.46, 0.50), metallic=0.30, roughness=0.72),
+        "dark": make_material(bpy, "hnx02.dark", (0.10, 0.11, 0.13), metallic=0.72, roughness=0.48),
+        "radiator": make_material(bpy, "hnx02.radiator", (0.90, 0.91, 0.92), metallic=0.08, roughness=0.30),
+        "pv": make_material(bpy, "hnx02.pv", (0.07, 0.10, 0.24), metallic=0.35, roughness=0.28),
+        "gold": make_material(bpy, "hnx02.gold", (0.82, 0.58, 0.19), metallic=1.0, roughness=0.30),
+        "copper": make_material(bpy, "hnx02.copper", (0.70, 0.44, 0.19), metallic=1.0, roughness=0.34),
     }
 
 
-def clear_scene(bpy):
-    bpy.ops.wm.read_factory_settings(use_empty=True)
-
+# ------------------------------------------------------------ bmesh kit
+
+
+def basis(axis):
+    z = Vector(axis).normalized()
+    ref = Vector((0.0, 0.0, 1.0)) if abs(z.z) < 0.9 else Vector((1.0, 0.0, 0.0))
+    x = ref.cross(z).normalized()
+    y = z.cross(x).normalized()
+    return x, y, z
+
+
+def cyl(bm, p1, p2, r1, r2=None, seg=12, cap1=True, cap2=True):
+    p1, p2 = Vector(p1), Vector(p2)
+    r2 = r1 if r2 is None else r2
+    d = p2 - p1
+    if d.length < 1e-7:
+        return
+    x, y, _ = basis(d)
+    ring1, ring2 = [], []
+    for i in range(seg):
+        a = 2.0 * math.pi * i / seg
+        off = x * math.cos(a) + y * math.sin(a)
+        ring1.append(bm.verts.new(p1 + off * r1))
+        ring2.append(bm.verts.new(p2 + off * r2))
+    for i in range(seg):
+        j = (i + 1) % seg
+        bm.faces.new((ring1[i], ring1[j], ring2[j], ring2[i]))
+    if cap1:
+        bm.faces.new(tuple(reversed(ring1)))
+    if cap2:
+        bm.faces.new(tuple(ring2))
+
+
+def torus(bm, center, R, r, axis=(0.0, 0.0, 1.0), seg=24, rseg=8):
+    center = Vector(center)
+    x, y, z = basis(axis)
+    rings = []
+    for i in range(seg):
+        a = 2.0 * math.pi * i / seg
+        radial = x * math.cos(a) + y * math.sin(a)
+        c = center + radial * R
+        ring = []
+        for j in range(rseg):
+            b = 2.0 * math.pi * j / rseg
+            ring.append(bm.verts.new(c + radial * (r * math.cos(b)) + z * (r * math.sin(b))))
+        rings.append(ring)
+    for i in range(seg):
+        i2 = (i + 1) % seg
+        for j in range(rseg):
+            j2 = (j + 1) % rseg
+            bm.faces.new((rings[i][j], rings[i][j2], rings[i2][j2], rings[i2][j]))
+
+
+def dome(bm, base, direction, radius, seg=20, layers=5):
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    prev = None
+    for i in range(layers + 1):
+        t = i / layers
+        phi = t * math.pi / 2.0
+        r = radius * math.cos(phi)
+        h = radius * math.sin(phi)
+        c = Vector(base) + d * h
+        if r < 1e-6:
+            tip = bm.verts.new(c)
+            if prev:
+                for j in range(seg):
+                    bm.faces.new((prev[j], prev[(j + 1) % seg], tip))
+            break
+        ring = []
+        for j in range(seg):
+            a = 2.0 * math.pi * j / seg
+            ring.append(bm.verts.new(c + (x * math.cos(a) + y * math.sin(a)) * r))
+        if prev:
+            for j in range(seg):
+                j2 = (j + 1) % seg
+                bm.faces.new((prev[j], prev[j2], ring[j2], ring[j]))
+        prev = ring
+
+
+def bell(bm, throat, direction, length, r_throat, r_exit, seg=32, layers=14, exponent=1.7):
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    prev = None
+    for i in range(layers + 1):
+        t = i / layers
+        r = r_throat + (r_exit - r_throat) * (t ** exponent)
+        c = Vector(throat) + d * (length * t)
+        ring = []
+        for j in range(seg):
+            a = 2.0 * math.pi * j / seg
+            ring.append(bm.verts.new(c + (x * math.cos(a) + y * math.sin(a)) * r))
+        if prev:
+            for j in range(seg):
+                j2 = (j + 1) % seg
+                bm.faces.new((prev[j], prev[j2], ring[j2], ring[j]))
+        prev = ring
+
+
+def box(bm, center, ex, ey, ez, ax, ay, az):
+    c = Vector(center)
+    ax, ay, az = Vector(ax), Vector(ay), Vector(az)
+    vs = {}
+    for sx in (-1, 1):
+        for sy in (-1, 1):
+            for sz in (-1, 1):
+                vs[(sx, sy, sz)] = bm.verts.new(c + ax * (sx * ex) + ay * (sy * ey) + az * (sz * ez))
+    quads = [
+        (vs[(-1, -1, -1)], vs[(-1, 1, -1)], vs[(-1, 1, 1)], vs[(-1, -1, 1)]),
+        (vs[(1, 1, -1)], vs[(1, -1, -1)], vs[(1, -1, 1)], vs[(1, 1, 1)]),
+        (vs[(-1, 1, -1)], vs[(1, 1, -1)], vs[(1, 1, 1)], vs[(-1, 1, 1)]),
+        (vs[(1, -1, -1)], vs[(-1, -1, -1)], vs[(-1, -1, 1)], vs[(1, -1, 1)]),
+        (vs[(-1, -1, 1)], vs[(-1, 1, 1)], vs[(1, 1, 1)], vs[(1, -1, 1)]),
+        (vs[(1, -1, -1)], vs[(1, 1, -1)], vs[(-1, 1, -1)], vs[(-1, -1, -1)]),
+    ]
+    for q in quads:
+        bm.faces.new(q)
+
+
+# ------------------------------------------------------------ structures
+
+
+def truss(bm, p1, p2, width, bays=6, chord_r=0.09, strut_r=0.05, angles=None):
+    p1, p2 = Vector(p1), Vector(p2)
+    if angles is None:
+        angles = [90.0, 210.0, 330.0]
+    x, y, _ = basis(p2 - p1)
+    nodes = []
+    for deg in angles:
+        a = math.radians(deg)
+        off = (x * math.cos(a) + y * math.sin(a)) * width
+        nodes.append((p1 + off, p2 + off))
+    for a, b in nodes:
+        cyl(bm, a, b, chord_r, seg=8)
+    n = len(nodes)
+    for i in range(bays + 1):
+        t = i / bays
+        pts = [a.lerp(b, t) for a, b in nodes]
+        for k in range(n):
+            cyl(bm, pts[k], pts[(k + 1) % n], strut_r, seg=6)
+        if i < bays:
+            t2 = (i + 1) / bays
+            pts2 = [a.lerp(b, t2) for a, b in nodes]
+            for k in range(n):
+                cyl(bm, pts[k], pts2[(k + 1) % n], strut_r, seg=6)
+
+
+def ring_frame(bm, center, radius, axis, tube=0.07, seg=28, spokes=0, spoke_r=0.05):
+    center = Vector(center)
+    torus(bm, center, radius, tube, axis=axis, seg=seg, rseg=6)
+    if spokes:
+        x, y, _ = basis(axis)
+        for k in range(spokes):
+            a = 2.0 * math.pi * k / spokes
+            radial = x * math.cos(a) + y * math.sin(a)
+            cyl(bm, center + radial * radius * 0.12, center + radial * radius, spoke_r, seg=6)
+
+
+def pressure_vessel(bm, p1, p2, radius, rings=5, seg=24, ports=True):
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    cyl(bm, p1, p2, radius, seg=seg, cap1=False, cap2=False)
+    dome(bm, p1, -d, radius, seg=seg)
+    dome(bm, p2, d, radius, seg=seg)
+    for i in range(1, rings + 1):
+        t = i / (rings + 1)
+        torus(bm, p1.lerp(p2, t), radius, 0.06, axis=d, seg=seg, rseg=6)
+    if ports:
+        x, y, _ = basis(d)
+        for t in (0.2, 0.5, 0.8):
+            c = p1.lerp(p2, t)
+            off = x * radius
+            cyl(bm, c + off * 0.88, c + off * 1.45, 0.10, seg=8)
+            torus(bm, c + off * 1.45, 0.13, 0.04, axis=x, seg=10, rseg=5)
+
+
+def hab_module(bm, p1, p2, radius, ribs=8, windows=10, seg=28, hatch=True):
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    x, y, _ = basis(d)
+    cyl(bm, p1, p2, radius, seg=seg)
+    for i in range(1, ribs + 1):
+        t = i / (ribs + 1)
+        torus(bm, p1.lerp(p2, t), radius, 0.075, axis=d, seg=seg, rseg=6)
+    length = (p2 - p1).length
+    for row, tt in ((0, 0.34), (1, 0.66)):
+        for k in range(windows):
+            a = 2.0 * math.pi * k / windows + row * math.pi / windows
+            radial = x * math.cos(a) + y * math.sin(a)
+            c = p1.lerp(p2, tt) + radial * radius
+            cyl(bm, c - radial * 0.08, c + radial * 0.14, 0.17, seg=12, cap1=False)
+            torus(bm, c + radial * 0.14, 0.185, 0.04, axis=radial, seg=14, rseg=5)
+            box(bm, c + radial * 0.16, 0.10, 0.30, 0.012, radial, d, d.cross(radial))
+    if hatch:
+        for end, dirv in ((p2, d), (p1, -d)):
+            torus(bm, end + dirv * 0.05, radius * 0.52, 0.11, axis=d, seg=seg, rseg=6)
+            for k in range(8):
+                a = 2.0 * math.pi * k / 8
+                radial = x * math.cos(a) + y * math.sin(a)
+                cyl(bm, end + radial * radius * 0.52 + dirv * 0.05,
+                    end + radial * radius * 0.70 + dirv * 0.05, 0.05, seg=6)
+
+
+def centrifuge_ring(bm, center, radius, axis=(0.0, 1.0, 0.0), cars=6, seg=44):
+    """Rotating gravity ring: twin truss hoops, spokes, suspended cars."""
+    center = Vector(center)
+    x, y, z = basis(axis)
+    for off in (-0.55, 0.55):
+        c = center + z * off
+        torus(bm, c, radius, 0.085, axis=z, seg=seg, rseg=6)
+        torus(bm, c, radius * 0.995, 0.045, axis=z, seg=seg, rseg=5)
+    # cross bracing between the two hoops
+    for k in range(0, seg, 2):
+        a = 2.0 * math.pi * k / seg
+        a2 = 2.0 * math.pi * (k + 1) / seg
+        radial = x * math.cos(a) + y * math.sin(a)
+        radial2 = x * math.cos(a2) + y * math.sin(a2)
+        p_a0 = center + radial * radius + z * -0.55
+        p_a1 = center + radial * radius + z * 0.55
+        p_b0 = center + radial2 * radius + z * -0.55
+        p_b1 = center + radial2 * radius + z * 0.55
+        cyl(bm, p_a0, p_b1, 0.035, seg=5)
+        cyl(bm, p_a1, p_b0, 0.035, seg=5)
+        cyl(bm, p_a0, p_a1, 0.035, seg=5)
+    # spokes to hub
+    for k in range(cars):
+        a = 2.0 * math.pi * k / cars
+        radial = x * math.cos(a) + y * math.sin(a)
+        outer = center + radial * radius
+        cyl(bm, center, outer, 0.17, seg=10)
+        for tang in (-1.0, 1.0):
+            tangent = z * tang
+            p0 = center + radial * radius * 0.18 + tangent * 0.7
+            p1 = center + radial * radius * 0.55 + tangent * 0.7
+            cyl(bm, p0, p1, 0.07, seg=6)
+        cyl(bm, center + radial * radius * 0.5 - z * 0.9, center + radial * radius * 0.5 + z * 0.9, 0.09, seg=6)
+    # de-spin bearing rings at the hub
+    for zz in (-0.9, 0.9):
+        torus(bm, center + z * zz, radius * 0.135, 0.11, axis=z, seg=28, rseg=6)
+    # suspended cars
+    for k in range(cars):
+        a = 2.0 * math.pi * k / cars + math.pi / cars
+        radial = x * math.cos(a) + y * math.sin(a)
+        car = center + radial * (radius + 0.62)
+        cyl(bm, car - z * 0.85, car + z * 0.85, 0.62, seg=18)
+        torus(bm, car - z * 0.85, 0.64, 0.07, axis=z, seg=18, rseg=5)
+        torus(bm, car + z * 0.85, 0.64, 0.07, axis=z, seg=18, rseg=5)
+        cyl(bm, center + radial * radius, car, 0.075, seg=7)
+        for kk in range(5):
+            aa = 2.0 * math.pi * kk / 5
+            off = (z * math.cos(aa) + radial * math.sin(aa)) * 0.2
+            cyl(bm, car + off, car + off * 2.6, 0.03, seg=5)
+
+
+def gimbal(bm, pos, direction, radius=0.28, s=1.0):
+    pos = Vector(pos)
+    d = Vector(direction).normalized()
+    x, _, _ = basis(d)
+    torus(bm, pos, radius * s, 0.055 * s, axis=d, seg=16, rseg=5)
+    torus(bm, pos + d * 0.15 * s, radius * s * 0.9, 0.055 * s, axis=x, seg=16, rseg=5)
+    for k in (0, 1):
+        side = 1.0 if k == 0 else -1.0
+        cyl(bm, pos + x * side * radius * s * 1.35 - d * 0.12 * s,
+            pos + x * side * radius * s * 0.8 + d * 0.3 * s, 0.04 * s, seg=6)
+
+
+def regen_channels(bm, throat, direction, length, r_throat, r_exit, turns=6, tube=0.035, seg_pts=15):
+    throat = Vector(throat)
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    steps = turns * seg_pts
+    pts = []
+    for i in range(steps + 1):
+        t = i / steps
+        r = r_throat + (r_exit - r_throat) * (t ** 1.7) + tube * 1.3
+        a = 2.0 * math.pi * turns * t
+        c = throat + d * (length * t)
+        pts.append(c + (x * math.cos(a) + y * math.sin(a)) * r)
+    for a, b in zip(pts, pts[1:]):
+        cyl(bm, a, b, tube, seg=5)
+
+
+def ntp_engine(bm, mount, direction, scale=1.0):
+    """Nuclear thermal engine: thrust structure, chamber, bell, turbopump."""
+    mount = Vector(mount)
+    d = Vector(direction).normalized()
+    s = scale
+    x, y, _ = basis(d)
+    cyl(bm, mount, mount + d * 0.5 * s, 0.44 * s, seg=14)
+    chamber = mount + d * 0.5 * s
+    cyl(bm, chamber, chamber + d * 0.45 * s, 0.36 * s, 0.31 * s, seg=18)
+    bell(bm, chamber + d * 0.45 * s, d, 2.3 * s, 0.31 * s, 1.05 * s, seg=32, layers=14)
+    for t in (0.3, 0.55, 0.78, 0.95):
+        c = chamber + d * (0.45 * s + 2.3 * s * t)
+        r = 0.31 * s + (1.05 * s - 0.31 * s) * (t ** 1.7)
+        torus(bm, c, r + 0.02 * s, 0.032 * s, axis=d, seg=24, rseg=5)
+    regen_channels(bm, chamber + d * 0.45 * s, d, 2.3 * s, 0.31 * s, 1.05 * s)
+    # turbopump cluster
+    pump = mount + d * 0.75 * s + x * 0.5 * s
+    cyl(bm, pump, pump + d * 0.6 * s, 0.21 * s, seg=12)
+    cyl(bm, pump - x * 0.22 * s, pump + x * 0.6 * s, 0.10 * s, seg=8)
+    cyl(bm, chamber + x * 0.32 * s, pump + d * 0.32 * s + x * 0.27 * s, 0.075 * s, seg=7)
+    cyl(bm, mount + d * 0.18 * s + x * 0.48 * s, chamber + x * 0.32 * s, 0.055 * s, seg=6)
+    # nozzle exit stiffener ring
+    exit_c = chamber + d * (0.45 * s + 2.3 * s)
+    torus(bm, exit_c - d * 0.05 * s, 1.05 * s, 0.05 * s, axis=d, seg=32, rseg=6)
+
+
+def shadow_shield(bm, center, direction, radius, seg=32, ribs=10):
+    center = Vector(center)
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    cyl(bm, center - d * 0.12, center + d * 0.12, radius, seg=seg)
+    for k in range(ribs):
+        a = 2.0 * math.pi * k / ribs
+        radial = x * math.cos(a) + y * math.sin(a)
+        cyl(bm, center + radial * radius * 0.12 - d * 0.12,
+            center + radial * radius * 0.96 - d * 0.12, 0.05, seg=6)
+    torus(bm, center, radius, 0.06, axis=d, seg=seg, rseg=6)
+    for k in range(6):
+        a = 2.0 * math.pi * k / 6
+        radial = x * math.cos(a) + y * math.sin(a)
+        cyl(bm, center + radial * radius * 0.55, center + radial * radius * 0.55 - d * 1.2, 0.08, seg=7)
+
+
+def thrust_cone(bm, mount, direction, r_base, r_top, length, struts=10):
+    mount = Vector(mount)
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    top = mount + d * length
+    for i, (c, r) in enumerate(((mount, r_base), (top, r_top))):
+        torus(bm, c, r, 0.06, axis=d, seg=28, rseg=5)
+    for k in range(struts):
+        a = 2.0 * math.pi * k / struts
+        radial = x * math.cos(a) + y * math.sin(a)
+        cyl(bm, mount + radial * r_base, top + radial * r_top, 0.055, seg=6)
+    for k in range(struts):
+        a = 2.0 * math.pi * k / struts
+        b = 2.0 * math.pi * (k + 1) / struts
+        ra = x * math.cos(a) + y * math.sin(a)
+        rb = x * math.cos(b) + y * math.sin(b)
+        mid = mount + d * (length * 0.5)
+        cyl(bm, mount + ra * r_base, mid + rb * ((r_base + r_top) * 0.5), 0.04, seg=5)
+
+
+def mli_bands(bm, p1, p2, radius, bands=10, seg=24, wobble=0.035):
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    for i in range(1, bands + 1):
+        t = i / (bands + 1)
+        c = p1.lerp(p2, t)
+        w = 1.0 + wobble * math.sin(i * 2.3)
+        torus(bm, c, radius * w, 0.085, axis=d, seg=seg, rseg=7)
+
+
+def solar_array(bm, root, direction, span, width, cells=72, rows=14, face_normal=(0.0, 0.0, 1.0)):
+    """Deployable PV blanket: cell grid, frame rails, torque tube, hinge."""
+    root = Vector(root)
+    d = Vector(direction).normalized()
+    x, _y, _z = basis(d)
+    fn = Vector(face_normal).normalized()
+    if abs(fn.dot(d)) > 0.9:
+        fn = _z
+    x = d.cross(fn).normalized()
+    cw = span / cells
+    ch = width / rows
+    for i in range(cells):
+        for j in range(rows):
+            c = root + d * (cw * (i + 0.5)) + x * ((j - rows * 0.5 + 0.5) * ch)
+            box(bm, c, cw * 0.40, ch * 0.38, 0.02, d, x, fn)
+    for side in (-1.0, 1.0):
+        off = x * side * width * 0.5
+        box(bm, root + d * (span * 0.5) + off, span * 0.5, 0.05, 0.05, d, x, fn)
+    cyl(bm, root - x * width * 0.5, root + x * width * 0.5, 0.10, seg=10)
+    cyl(bm, root, root - d * 0.6, 0.13, seg=10)
+    torus(bm, root, 0.24, 0.06, axis=x, seg=16, rseg=5)
+
+
+def fin_radiator(bm, p1, p2, width, fins=48, fin_h=0.42, coolant=True):
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    x, y, _ = basis(d)
+    cyl(bm, p1, p2, width * 0.5, seg=4)
+    for i in range(fins):
+        t = (i + 0.5) / fins
+        c = p1.lerp(p2, t)
+        for side in (0.5, -0.5):
+            off = y * side * 0.05
+            box(bm, c + off + y * side * fin_h * 0.5, width * 0.46, fin_h * 0.5, 0.014, x, y, d)
+    if coolant:
+        for side in (-0.30, 0.0, 0.30):
+            off = x * (width * side)
+            cyl(bm, p1 + off, p2 + off, 0.035, seg=6)
+
+
+def pipe_run(bm, points, r=0.06, seg=8):
+    for a, b in zip(points, points[1:]):
+        cyl(bm, a, b, r, seg=seg)
+
+
+def rcs_cluster(bm, pos, direction, s=1.0):
+    pos = Vector(pos)
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    cyl(bm, pos, pos + d * 0.22 * s, 0.17 * s, seg=12)
+    for k in range(4):
+        a = 2.0 * math.pi * k / 4 + math.pi / 4
+        off = (x * math.cos(a) + y * math.sin(a)) * 0.14 * s
+        cyl(bm, pos + d * 0.22 * s + off, pos + d * 0.40 * s + off * 1.35, 0.055 * s, 0.032 * s, seg=6)
+
+
+def antenna_dish(bm, base, direction, radius, depth=0.4, ribs=8, s=1.0):
+    base = Vector(base)
+    d = Vector(direction).normalized()
+    x, y, _ = basis(d)
+    cyl(bm, base - d * 0.1 * s, base + d * 0.28 * s, 0.16 * s, seg=10)
+    gimbal(bm, base + d * 0.28 * s, d, radius=0.2 * s, s=s)
+    dish_center = base + d * 0.45 * s
+    layers = 5
+    prev = None
+    for i in range(layers + 1):
+        t = i / layers
+        r = radius * t
+        h = depth * (1.0 - t * t)
+        ring = []
+        for j in range(24):
+            a = 2.0 * math.pi * j / 24
+            ring.append(bm.verts.new(dish_center + (x * math.cos(a) + y * math.sin(a)) * r + d * h))
+        if prev:
+            for j in range(24):
+                j2 = (j + 1) % 24
+                bm.faces.new((prev[j], prev[j2], ring[j2], ring[j]))
+        prev = ring
+    for k in range(ribs):
+        a = 2.0 * math.pi * k / ribs
+        radial = x * math.cos(a) + y * math.sin(a)
+        cyl(bm, dish_center + radial * radius * 0.06, dish_center + radial * radius * 0.92 + d * 0.02, 0.03 * s, seg=5)
+    feed = dish_center + d * (depth + 1.15 * s * 0.6)
+    cyl(bm, dish_center + d * 0.06, feed, 0.035 * s, seg=6)
+    cyl(bm, feed - d * 0.06 * s, feed + d * 0.10 * s, 0.09 * s, seg=8)
+    for k in range(3):
+        a = 2.0 * math.pi * k / 3
+        radial = x * math.cos(a) + y * math.sin(a)
+        cyl(bm, dish_center + radial * radius * 0.8 + d * depth * 0.9, feed, 0.022 * s, seg=5)
+
+
+def whipple_panels(bm, p1, p2, radius, rows=6, cols=14, gap=0.04):
+    """MMOD shield: arc panels in a regular grid over a cylinder."""
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    x, y, _ = basis(d)
+    length = (p2 - p1).length
+    for i in range(cols):
+        t = (i + 0.5) / cols
+        for j in range(rows):
+            a = 2.0 * math.pi * (j + 0.5) / rows
+            radial = x * math.cos(a) + y * math.sin(a)
+            tangent = d.cross(radial)
+            c = p1 + d * (length * t) + radial * (radius + 0.09)
+            box(bm, c, length / cols * 0.44, radius * math.pi / rows * 0.42, 0.035,
+                d, tangent, radial)
+
+
+def equipment_row(bm, start, direction, lateral, count, spacing, s_lo, s_hi, seed, lateral_axis=None):
+    """A deliberately arranged row of machinery boxes (not noise)."""
+    rng = random.Random(seed)
+    start = Vector(start)
+    direction = Vector(direction).normalized()
+    lateral = Vector(lateral).normalized()
+    ax = lateral_axis if lateral_axis is not None else direction.cross(lateral).normalized()
+    for i in range(count):
+        t = (i - (count - 1) * 0.5) * spacing
+        base = start + direction * t
+        w = rng.uniform(s_lo, s_hi)
+        h = rng.uniform(s_lo, s_hi)
+        dep = rng.uniform(s_lo, s_hi * 1.3)
+        box(bm, base + lateral * (dep * 0.5), w, h, dep * 0.5, direction, ax, lateral)
+        if rng.random() < 0.4:
+            cyl(bm, base + lateral * dep * 0.3 - ax * w * 0.6,
+                base + lateral * (dep * 0.5) - ax * w * 0.6, w * 0.18, seg=6)
+
+
+def panel_bank(bm, p1, p2, radius, cols=16, rows=8, depth=0.05):
+    """Regular rectangular panel grid over a cylinder (machined surface look)."""
+    p1, p2 = Vector(p1), Vector(p2)
+    d = (p2 - p1).normalized()
+    x, y, _ = basis(d)
+    length = (p2 - p1).length
+    for i in range(cols):
+        t = (i + 0.5) / cols
+        for j in range(rows):
+            a = 2.0 * math.pi * (j + 0.5) / rows
+            radial = x * math.cos(a) + y * math.sin(a)
+            tangent = d.cross(radial)
+            c = p1 + d * (length * t) + radial * radius
+            box(bm, c, length / cols * 0.42, radius * math.pi / rows * 0.40, depth,
+                d, tangent, radial)
+
+
+# --------------------------------------------------------------- assembly
 
-def assign_variants(obj, clay_material, livery_material):
-    obj["object_id"] = obj.name
-    obj["clay_material"] = clay_material.name
-    obj["livery_material"] = livery_material.name
-    obj.data.materials.clear()
-    obj.data.materials.append(clay_material)
-    return obj
 
-
-def apply_material_mode(bpy, materials, mode):
-    if mode not in {"clay", "livery"}:
-        raise ValueError(f"unknown material mode: {mode}")
-    for obj in bpy.context.scene.objects:
-        material_name = obj.get(f"{mode}_material")
-        if not material_name or not obj.data or not hasattr(obj.data, "materials"):
-            continue
-        material = bpy.data.materials.get(material_name)
-        if material is None:
-            raise RuntimeError(f"missing material {material_name!r} for {obj.name}")
-        obj.data.materials.clear()
-        obj.data.materials.append(material)
-
-
-def add_beveled_cube(bpy, name, location, dimensions, clay_material, livery_material, bevel=0.04, rotation=None):
-    bpy.ops.mesh.primitive_cube_add(location=location, rotation=rotation or (0.0, 0.0, 0.0))
-    obj = bpy.context.object
-    obj.name = name
-    obj.data.name = name + ".mesh"
-    obj.dimensions = dimensions
-    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
-    if bevel:
-        modifier = obj.modifiers.new("Structural edge softening", "BEVEL")
-        modifier.width = bevel
-        modifier.segments = 3
-    return assign_variants(obj, clay_material, livery_material)
-
-
-def add_cylinder(bpy, name, location, radius, depth, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0), vertices=32):
-    bpy.ops.mesh.primitive_cylinder_add(
-        vertices=vertices,
-        radius=radius,
-        depth=depth,
-        location=location,
-        rotation=rotation,
-    )
-    obj = bpy.context.object
-    obj.name = name
-    obj.data.name = name + ".mesh"
-    return assign_variants(obj, clay_material, livery_material)
-
-
-def add_cone(bpy, name, location, radius1, radius2, depth, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0)):
-    bpy.ops.mesh.primitive_cone_add(
-        vertices=24,
-        radius1=radius1,
-        radius2=radius2,
-        depth=depth,
-        location=location,
-        rotation=rotation,
-    )
-    obj = bpy.context.object
-    obj.name = name
-    obj.data.name = name + ".mesh"
-    return assign_variants(obj, clay_material, livery_material)
-
-
-def add_torus(bpy, name, location, major_radius, minor_radius, clay_material, livery_material, *, rotation=(0.0, 0.0, 0.0), minor_segments=12):
-    bpy.ops.mesh.primitive_torus_add(
-        major_radius=major_radius,
-        minor_radius=minor_radius,
-        major_segments=64,
-        minor_segments=minor_segments,
-        location=location,
-        rotation=rotation,
-    )
-    obj = bpy.context.object
-    obj.name = name
-    obj.data.name = name + ".mesh"
-    return assign_variants(obj, clay_material, livery_material)
-
-
-def add_between(bpy, name, start, end, radius, clay_material, livery_material, vertices=20):
-    start_vec = Vector(start)
-    end_vec = Vector(end)
-    delta = end_vec - start_vec
-    obj = add_cylinder(
-        bpy,
-        name,
-        (start_vec + end_vec) / 2.0,
-        radius,
-        delta.length,
-        clay_material,
-        livery_material,
-        vertices=vertices,
-    )
-    obj.rotation_euler = delta.to_track_quat("Z", "Y").to_euler()
-    return obj
+def clear_scene(bpy):
+    bpy.ops.wm.read_factory_settings(use_empty=True)
 
 
-def add_dish(bpy, name, base_x, center_y, center_z, radius, depth, clay_material, livery_material):
-    """Create a shallow open paraboloid whose boresight points along +X."""
-    segments = 64
-    rings = 9
-    vertices = [(base_x, center_y, center_z)]
-    for ring in range(1, rings + 1):
-        fraction = ring / rings
-        ring_radius = radius * fraction
-        ring_x = base_x + depth * fraction * fraction
-        for segment in range(segments):
-            angle = 2.0 * math.pi * segment / segments
-            vertices.append(
-                (
-                    ring_x,
-                    center_y + ring_radius * math.cos(angle),
-                    center_z + ring_radius * math.sin(angle),
-                )
-            )
-    faces = []
-    for segment in range(segments):
-        faces.append((0, 1 + segment, 1 + (segment + 1) % segments))
-    for ring in range(1, rings):
-        first = 1 + (ring - 1) * segments
-        next_first = first + segments
-        for segment in range(segments):
-            current = first + segment
-            following = first + (segment + 1) % segments
-            next_current = next_first + segment
-            next_following = next_first + (segment + 1) % segments
-            faces.append((current, next_current, next_following, following))
-    mesh = bpy.data.meshes.new(name + ".mesh")
-    mesh.from_pydata(vertices, [], faces)
-    mesh.update()
+def build_object(bpy, name, material, builder):
+    bm = bmesh.new()
+    builder(bm)
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
+    mesh = bpy.data.meshes.new(name)
+    bm.to_mesh(mesh)
+    bm.free()
     obj = bpy.data.objects.new(name, mesh)
     bpy.context.collection.objects.link(obj)
-    assign_variants(obj, clay_material, livery_material)
-    solidify = obj.modifiers.new("Reflector thickness", "SOLIDIFY")
-    solidify.thickness = 0.012
-    return obj
-
-
-
-
-def merge_details(bpy, master, extras):
-    """Join detail meshes into the master object so the exported GLB keeps
-    exactly the contract object names while carrying real secondary detail."""
-    if not extras:
-        return master
-    for obj in bpy.context.selected_objects:
-        obj.select_set(False)
-    for extra in extras:
-        extra.select_set(True)
-    master.select_set(True)
-    bpy.context.view_layer.objects.active = master
-    bpy.ops.object.join()
-    return master
-
-
-def detail_torus(bpy, name, location, major_radius, minor_radius, rotation=(0.0, 0.0, 0.0), minor_segments=10):
-    bpy.ops.mesh.primitive_torus_add(
-        major_radius=major_radius,
-        minor_radius=minor_radius,
-        major_segments=48,
-        minor_segments=minor_segments,
-        location=location,
-        rotation=rotation,
-    )
-    obj = bpy.context.object
-    obj.name = name
-    return obj
-
-
-def detail_cube(bpy, name, location, dimensions, rotation=(0.0, 0.0, 0.0)):
-    bpy.ops.mesh.primitive_cube_add(location=location, rotation=rotation)
-    obj = bpy.context.object
-    obj.name = name
-    obj.dimensions = dimensions
-    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
-    return obj
-
-
-def detail_cylinder(bpy, name, location, radius, depth, rotation=(0.0, 0.0, 0.0), vertices=20):
-    bpy.ops.mesh.primitive_cylinder_add(
-        vertices=vertices,
-        radius=radius,
-        depth=depth,
-        location=location,
-        rotation=rotation,
-    )
-    obj = bpy.context.object
-    obj.name = name
+    obj.data.materials.append(material)
     return obj
 
 
-def build_details(bpy, object_id, master, materials):
-    """Secondary engineering detail per contract object (joined back into the
-    master mesh before export). Names below never reach the GLB as objects."""
-    clay = None
-    details = []
-
-    if object_id == "starship.keel.spine":
-        # Reinforcement rings along the spine + twin conduit lines + equipment
-        # blocks riding the top ridge.
-        for index in range(14):
-            x = -5.2 + index * 0.72
-            details.append(detail_torus(
-                bpy,
-                f"{master.name}.detail.ring.{index:02d}",
-                (x, 0.0, 0.0),
-                0.40,
-                0.028,
-                rotation=(0.0, math.pi / 2.0, 0.0),
-            ))
-        details.append(detail_cylinder(bpy, master.name + ".detail.conduit.0", (-0.8, 0.30, 0.10), 0.035, 9.4, rotation=(0.0, math.pi / 2.0, 0.0)))
-        details.append(detail_cylinder(bpy, master.name + ".detail.conduit.1", (-0.8, -0.30, 0.10), 0.035, 9.4, rotation=(0.0, math.pi / 2.0, 0.0)))
-        for index, x in enumerate((-3.9, -1.9, 0.6, 2.9)):
-            details.append(detail_cube(bpy, f"{master.name}.detail.box.{index:02d}", (x, 0.0, 0.30), (0.5, 0.30, 0.16)))
-    elif object_id == "starship.hab.torus":
-        # Outer panel ribs every 15 degrees, inner twin conduits, and two
-        # comm masts riding the ring.
-        for index in range(24):
-            angle = 2.0 * math.pi * index / 24.0
-            y = HAB_RADIUS * math.cos(angle)
-            z = HAB_RADIUS * math.sin(angle)
-            rotation = (angle, 0.0, 0.0)
-            details.append(detail_cube(
-                bpy,
-                f"{master.name}.detail.rib.{index:02d}",
-                (HAB_X + 0.06, y, z),
-                (0.10, 0.08, 0.09),
-                rotation=rotation,
-            ))
-        for offset in (-0.10, 0.10):
-            details.append(detail_torus(
-                bpy,
-                f"{master.name}.detail.conduit.{offset:+.2f}",
-                (HAB_X + offset, 0.0, 0.0),
-                HAB_RADIUS - HAB_MINOR - 0.04,
-                0.020,
-                rotation=(0.0, math.pi / 2.0, 0.0),
-                minor_segments=8,
-            ))
-        details.append(detail_cylinder(bpy, master.name + ".detail.mast.0", (HAB_X - 0.02, HAB_RADIUS + HAB_MINOR, 0.0), 0.02, 0.5, rotation=(0.0, math.pi / 2.0, 0.0)))
-        details.append(detail_cylinder(bpy, master.name + ".detail.mast.1", (HAB_X + 0.02, 0.0, -(HAB_RADIUS + HAB_MINOR)), 0.02, 0.5))
-    elif object_id == "starship.hub.core":
-        for offset, radius in ((-0.74, 0.40), (0.74, 0.40)):
-            details.append(detail_cylinder(bpy, f"{master.name}.detail.flange.{offset:+.2f}", (HAB_X + offset, 0.0, 0.0), radius, 0.06, rotation=(0.0, math.pi / 2.0, 0.0)))
-        details.append(detail_torus(bpy, master.name + ".detail.bearing", (HAB_X, 0.0, 0.0), 0.34, 0.035, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
-    elif object_id == "starship.core.pressure":
-        for index in range(4):
-            x = -4.05 + index * 0.42
-            details.append(detail_torus(bpy, f"{master.name}.detail.band.{index:02d}", (x, 0.0, 0.0), 0.58, 0.030, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
-        for offset in (-0.92, 0.92):
-            details.append(detail_cylinder(bpy, f"{master.name}.detail.flange.{offset:+.2f}", (-3.4 + offset, 0.0, 0.0), 0.60, 0.07, rotation=(0.0, math.pi / 2.0, 0.0)))
-    elif object_id == "starship.shadow.collar":
-        for index in range(8):
-            angle = 2.0 * math.pi * index / 8.0
-            y = 0.86 * math.cos(angle)
-            z = 0.86 * math.sin(angle)
-            details.append(detail_cube(bpy, f"{master.name}.detail.rib.{index:02d}", (-1.35, y, z), (0.34, 0.10, 0.10), rotation=(angle, 0.0, 0.0)))
-    elif object_id == "starship.storm.cellar":
-        details.append(detail_cube(bpy, master.name + ".detail.doorframe", (-0.55, 0.0, 0.30), (0.66, 0.52, 0.05)))
-        details.append(detail_cylinder(bpy, master.name + ".detail.hinge", (-0.55, -0.32, 0.0), 0.035, 0.5))
-    elif object_id == "starship.nozzle.magnetic":
-        # Coil grooves down the bell + coolant lines hugging the cone.
-        for index in range(5):
-            fraction = 0.25 + index * 0.14
-            x = -6.35 + 2.2 * fraction
-            radius = 1.15 - 0.55 * fraction
-            details.append(detail_torus(bpy, f"{master.name}.detail.coil.{index:02d}", (x, 0.0, 0.0), radius, 0.034, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=10))
-        for index in range(4):
-            angle = 2.0 * math.pi * index / 4.0 + math.pi / 4.0
-            y = 0.95 * math.cos(angle)
-            z = 0.95 * math.sin(angle)
-            details.append(detail_cylinder(bpy, f"{master.name}.detail.coolant.{index:02d}", (-5.35, y, z), 0.028, 2.5, rotation=(0.0, math.pi / 2.0, 0.0)))
-    elif object_id == "starship.power.truss":
-        for index in range(6):
-            t = index / 5.0
-            x = -1.2 + t * 5.1
-            details.append(detail_cylinder(bpy, f"{master.name}.detail.diagonal.{index:02d}", (x, 0.0, 0.34), 0.022, 0.34, rotation=(0.0, math.pi / 2.0, 0.0), vertices=8))
-        details.append(detail_torus(bpy, master.name + ".detail.hoop", (1.6, 0.0, 0.34), 0.40, 0.028, rotation=(math.pi / 2.0, 0.0, 0.0), minor_segments=10))
-    elif object_id.startswith("starship.radiator."):
-        index = int(object_id.rsplit(".", 1)[-1])
-        angle = 2.0 * math.pi * index / 6.0 + math.pi / 6.0
-        y = 0.95 * math.cos(angle)
-        z = 0.95 * math.sin(angle)
-        details.append(detail_cube(bpy, master.name + ".detail.backbone", (-3.6, y, z), (1.5, 0.05, 0.06)))
-        for rib in (-0.45, 0.0, 0.45):
-            details.append(detail_cube(bpy, f"{master.name}.detail.stiff.{rib:+.2f}", (-3.6 + rib, y, z), (0.05, 0.06, 0.40)))
-    elif object_id.startswith("starship.cargo.pod."):
-        index = int(object_id.rsplit(".", 1)[-1])
-        y = (-0.62, 0.62)[index]
-        for offset in (-0.5, 0.0, 0.5):
-            details.append(detail_cube(bpy, f"{master.name}.detail.rib.{offset:+.2f}", (0.35 + offset, y, 0.0), (0.05, 0.26, 0.32)))
-        details.append(detail_cylinder(bpy, master.name + ".detail.endcap", (0.97, y, 0.0), 0.10, 0.05, rotation=(0.0, math.pi / 2.0, 0.0)))
-    elif object_id == "starship.nose.cone":
-        details.append(detail_torus(bpy, master.name + ".detail.seam.0", (4.45, 0.0, 0.0), 0.26, 0.02, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=8))
-        details.append(detail_torus(bpy, master.name + ".detail.seam.1", (4.75, 0.0, 0.0), 0.16, 0.018, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=8))
-    elif object_id == "starship.comm.dish":
-        # Mounting mast rising from the keel deck + gimbal block under the
-        # dish base, so the dish reads as bolted hardware instead of floating.
-        details.append(detail_cylinder(bpy, master.name + ".detail.post", (3.40, 0.0, 0.37), 0.045, 0.30, vertices=12))
-        details.append(detail_cube(bpy, master.name + ".detail.gimbal", (3.40, 0.0, 0.46), (0.16, 0.16, 0.10)))
-        details.append(detail_cube(bpy, master.name + ".detail.baseplate", (3.40, 0.0, 0.24), (0.26, 0.26, 0.05)))
-    elif object_id.startswith("starship.spoke."):
-        index = int(object_id.rsplit(".", 1)[-1])
-        angle = 2.0 * math.pi * index / SPOKE_COUNT
-        end_y = HAB_RADIUS * math.cos(angle)
-        end_z = HAB_RADIUS * math.sin(angle)
-        # Collar at the ring end and a hinge ring at the hub end.
-        details.append(detail_torus(bpy, master.name + ".detail.cuff", (HAB_X, end_y * 0.92, end_z * 0.92), 0.16, 0.045, rotation=(angle, 0.0, 0.0), minor_segments=12))
-        details.append(detail_torus(bpy, master.name + ".detail.root", (HAB_X + 0.06, 0.0, 0.0), 0.40, 0.045, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=12))
-    else:
-        return []
-
-    _ = clay
-    return details
-
-
-# ---------------------------------------------------------------------------
-# Starship layout (units are display metres, unscaled示意 dimensions).
-#
-#   nose +X  : forward docking / sensor section
-#   -X       : reactor + nozzle (the ship accelerates toward -X)
-#
-#   habitat  : torus in the Y-Z plane at x=+1.2 (far from reactor at x<-3)
-#   shadow   : water-shadow collar at x=-1.2, storm cellar hugs the keel
-#   reactor  : fusion pressure vessel x in [-4.2, -2.6], nozzle to x=-5.6
-# ---------------------------------------------------------------------------
-
-HAB_X = 1.2
-HAB_RADIUS = 1.7
-HAB_MINOR = 0.30
-SPOKE_COUNT = 6
+# Geometry constants shared across steps (units: 1 = 2 m).
+# Scale philosophy: few large elements, not many small ones. The hull core
+# is a continuous 16 m-diameter pressure body; everything else hangs off it.
+HULL_P1 = (0.0, -4.0, 0.0)
+HULL_P2 = (0.0, 42.0, 0.0)
+HULL_R = 4.0                       # 16 m diameter
+NODE_C = (0.0, 44.6, 0.0)
+CENTRIFUGE_CENTER = (0.0, 6.0, 0.0)
+CENTRIFUGE_R = 14.0                # 56 m ring
+SPINE_P1 = (0.0, -34.0, 0.0)
+SPINE_P2 = (0.0, 20.0, 0.0)
+SPINE_R = 1.2
+HAB_A = ((5.6, 12.0, 0.0), (5.6, 30.0, 0.0), 2.6)   # side-mounted lab module
+HAB_B = ((-5.6, 12.0, 0.0), (-5.6, 30.0, 0.0), 2.6)  # side-mounted hab module
+TANK_X = 7.6
+TANK_R = 2.5                       # 10 m diameter tanks
+REACTOR_C = (0.0, -30.5, 0.0)
+NOZZLE_MOUNT_Y = -40.5
+
+
+# --------------------------------------------------------------- builders
+
+
+def b_hull_core(bm):
+    """Continuous 16 m-diameter pressure hull — the ship's body."""
+    p1, p2 = Vector(HULL_P1), Vector(HULL_P2)
+    r = HULL_R
+    seg = 56
+    cyl(bm, p1, p2, r, seg=seg, cap1=False, cap2=False)
+    dome(bm, p1, (0.0, -1.0, 0.0), r, seg=seg)
+    dome(bm, p2, (0.0, 1.0, 0.0), r, seg=seg)
+    frames = 24
+    for i in range(1, frames):
+        t = i / frames
+        torus(bm, p1.lerp(p2, t), r, 0.115, axis=(0, 1, 0), seg=seg, rseg=7)
+    for k in range(8):
+        a = 2.0 * math.pi * k / 8 + math.pi / 8
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        cyl(bm, p1 + radial * r, p2 + radial * r, 0.10, seg=7)
+    for band_t, count in ((0.18, 22), (0.46, 26), (0.74, 22)):
+        c0 = p1.lerp(p2, band_t)
+        for k in range(count):
+            a = 2.0 * math.pi * k / count
+            radial = Vector((math.cos(a), 0.0, math.sin(a)))
+            wc = c0 + radial * r
+            cyl(bm, wc - radial * 0.12, wc + radial * 0.18, 0.22, seg=12, cap1=False)
+            torus(bm, wc + radial * 0.18, 0.245, 0.05, axis=radial, seg=14, rseg=5)
+    panel_bank(bm, p1 + Vector((0.0, 3.5, 0.0)), p2 - Vector((0.0, 3.5, 0.0)),
+               r + 0.035, cols=72, rows=18, depth=0.05)
+    for (t0, count, seed) in ((0.10, 26, 601), (0.60, 30, 602), (0.90, 22, 603)):
+        base = p1.lerp(p2, t0)
+        equipment_row(bm, base + Vector((0.0, 0.0, r + 0.12)), (0, 1, 0), (0, 0, 1), count, 1.35, 0.14, 0.34, seed=seed)
+        equipment_row(bm, base + Vector((0.0, 0.0, -r - 0.12)), (0, 1, 0), (0, 0, -1), count, 1.35, 0.14, 0.34, seed=seed + 50)
+
+
+def b_spine(bm):
+    """Outrigger trusses carrying tanks, arrays and radiators."""
+    for sx in (-1.0, 1.0):
+        x0 = sx * (HULL_R + 1.6)
+        truss(bm, (x0, -34.0, 0.0), (x0, 20.0, 0.0), 0.85, bays=36, chord_r=0.085, strut_r=0.05,
+              angles=[0.0, 120.0, 240.0] if sx > 0 else [180.0, 60.0, 300.0])
+        for st in (-30.0, -22.0, -14.0, -6.0, 2.0, 10.0):
+            cyl(bm, Vector((sx * HULL_R, st, 0.0)), Vector((x0, st, 0.0)), 0.10, seg=7)
+
+
+def b_node(bm):
+    c = Vector(NODE_C)
+    cyl(bm, c - Vector((0, 1.3, 0)), c + Vector((0, 1.3, 0)), 2.6, seg=24)
+    torus(bm, c - Vector((0, 1.3, 0)), 2.63, 0.09, axis=(0, 1, 0), seg=28, rseg=6)
+    torus(bm, c + Vector((0, 1.3, 0)), 2.63, 0.09, axis=(0, 1, 0), seg=28, rseg=6)
+    for dirv in ((0, 1, 0), (1, 0, 0), (-1, 0, 0), (0, 0, 1), (0, 0, -1)):
+        d = Vector(dirv)
+        x, y, _ = basis(d)
+        base = c + d * 1.25
+        cyl(bm, base, base + d * 0.65, 1.05, seg=18)
+        torus(bm, base + d * 0.65, 1.12, 0.085, axis=d, seg=20, rseg=6)
+        for k in range(10):
+            a = 2.0 * math.pi * k / 10
+            radial = x * math.cos(a) + y * math.sin(a)
+            cyl(bm, base + d * 0.65 + radial * 1.12, base + d * 0.80 + radial * 1.22, 0.055, seg=6)
+
+
+def b_hab_a(bm):
+    p1, p2, r = HAB_A
+    hab_module(bm, p1, p2, r, ribs=9, windows=12, seg=32)
+    panel_bank(bm, p1, p2, r + 0.02, cols=30, rows=18, depth=0.04)
+    equipment_row(bm, (6.6 + r + 0.12, 14.0, 0.0), (0, 1, 0), (1, 0, 0), 12, 1.25, 0.12, 0.28, seed=201)
+    equipment_row(bm, (6.6, 14.5, r + 0.12), (0, 1, 0), (0, 0, 1), 10, 1.4, 0.10, 0.26, seed=203)
+
+
+def b_hab_b(bm):
+    p1, p2, r = HAB_B
+    hab_module(bm, p1, p2, r, ribs=9, windows=12, seg=32)
+    panel_bank(bm, p1, p2, r + 0.02, cols=30, rows=18, depth=0.04)
+    equipment_row(bm, (-6.6 - r - 0.12, 15.0, 0.0), (0, 1, 0), (-1, 0, 0), 12, 1.25, 0.12, 0.28, seed=211)
+    equipment_row(bm, (-6.6, 15.5, r + 0.12), (0, 1, 0), (0, 0, 1), 10, 1.4, 0.10, 0.26, seed=213)
+
+
+def b_whipple(bm):
+    p1, p2 = Vector(HULL_P1), Vector(HULL_P2)
+    whipple_panels(bm, p1 + Vector((0, 3.0, 0)), p2 - Vector((0, 3.0, 0)), HULL_R, rows=14, cols=30)
+
+
+def b_waterwall(bm):
+    """Water tanks ringed around the forward hull as radiation shielding."""
+    for k in range(14):
+        a = 2.0 * math.pi * k / 14
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        p1 = Vector((0.0, 22.0, 0.0)) + radial * (HULL_R + 1.15)
+        p2 = Vector((0.0, 38.0, 0.0)) + radial * (HULL_R + 1.15)
+        pressure_vessel(bm, p1, p2, 1.15, rings=3, seg=16, ports=False)
+        mli_bands(bm, p1, p2, 1.18, bands=7, seg=18, wobble=0.02)
+        for t in (0.25, 0.75):
+            cco = p1.lerp(p2, t)
+            cyl(bm, cco - radial * 1.1, cco - radial * 0.4, 0.08, seg=6)
+
+
+def b_centrifuge(bm):
+    centrifuge_ring(bm, CENTRIFUGE_CENTER, CENTRIFUGE_R, axis=(0, 1, 0), cars=8, seg=72)
+    hub = Vector(CENTRIFUGE_CENTER)
+    cyl(bm, hub - Vector((0, 2.2, 0)), hub + Vector((0, 2.2, 0)), 1.9, seg=24)
+    torus(bm, hub + Vector((0, 2.2, 0)), 1.93, 0.09, axis=(0, 1, 0), seg=28, rseg=6)
+    torus(bm, hub - Vector((0, 2.2, 0)), 1.93, 0.09, axis=(0, 1, 0), seg=28, rseg=6)
+    for k in range(8):
+        a = 2.0 * math.pi * k / 8
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        cyl(bm, hub + radial * 1.9, hub + radial * 3.0, 0.11, seg=7)
+    for k in range(32):
+        a = 2.0 * math.pi * k / 32
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        c = Vector(CENTRIFUGE_CENTER) + radial * (CENTRIFUGE_R - 1.9)
+        cyl(bm, c - Vector((0, 1.1, 0)), c + Vector((0, 1.1, 0)), 0.62, seg=16)
+        torus(bm, c - Vector((0, 1.1, 0)), 0.64, 0.055, axis=(0, 1, 0), seg=16, rseg=5)
+        torus(bm, c + Vector((0, 1.1, 0)), 0.64, 0.055, axis=(0, 1, 0), seg=16, rseg=5)
+    for k in range(28):
+        a = 2.0 * math.pi * k / 28 + 0.22
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        c = Vector(CENTRIFUGE_CENTER) + radial * (CENTRIFUGE_R + 0.4)
+        box(bm, c, 0.38, 0.62, 0.38, radial, Vector((0, 1, 0)), Vector((-math.sin(a), 0.0, math.cos(a))))
+
+
+def b_prop_tank(bm):
+    for sx in (-1.0, 1.0):
+        for yc in (-14.0, -23.0):
+            x0 = sx * TANK_X
+            p1 = (x0, yc - 4.5, 0.0)
+            p2 = (x0, yc + 4.5, 0.0)
+            pressure_vessel(bm, p1, p2, TANK_R, rings=5, seg=30)
+            mli_bands(bm, p1, p2, TANK_R + 0.05, bands=13, seg=30, wobble=0.03)
+            panel_bank(bm, Vector(p1) + Vector((0, 1.4, 0)), Vector(p2) - Vector((0, 1.4, 0)),
+                       TANK_R + 0.05, cols=22, rows=16, depth=0.035)
+            for st in (yc - 3.0, yc, yc + 3.0):
+                cyl(bm, Vector((sx * (HULL_R + 1.6), st, 0.0)), Vector((x0, st, 0.0)), 0.16, seg=8)
+                cyl(bm, Vector((sx * (HULL_R + 1.6), st - 0.5, 0.0)), Vector((x0, st, 0.6)), 0.07, seg=6)
+                torus(bm, Vector((x0, st, 0.0)), TANK_R + 0.07, 0.06, axis=(0, 1, 0), seg=24, rseg=5)
+
+
+def b_reactor(bm):
+    base = Vector(REACTOR_C)
+    cyl(bm, base - Vector((0, 1.8, 0)), base + Vector((0, 1.8, 0)), 2.1, seg=26)
+    for yy in (-1.8, 1.8):
+        torus(bm, base + Vector((0, yy, 0)), 2.13, 0.09, axis=(0, 1, 0), seg=28, rseg=6)
+    for k in range(14):
+        a = 2.0 * math.pi * k / 14
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        cyl(bm, base + radial * 2.0 - Vector((0, 1.5, 0)), base + radial * 2.0 + Vector((0, 1.5, 0)), 0.11, seg=6)
+    for k in range(8):
+        a = 2.0 * math.pi * k / 8
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        cyl(bm, base + radial * 2.1, base + radial * 3.1 - Vector((0, 3.4, 0)), 0.10, seg=7)
+
+
+def b_thrust_cone(bm):
+    thrust_cone(bm, (0.0, -33.5, 0.0), (0, -1, 0), 3.6, 2.9, 1.8, struts=14)
+    shadow_shield(bm, (0.0, -35.6, 0.0), (0, -1, 0), 4.4, seg=36, ribs=12)
+
+
+def b_nozzle_cluster(bm):
+    for ex in (-2.4, 2.4):
+        mount = Vector((ex, NOZZLE_MOUNT_Y, 0.0))
+        gimbal(bm, mount, (0, -1, 0), radius=0.55, s=2.0)
+        ntp_engine(bm, mount, (0, -1, 0), scale=2.0)
+
+
+def b_solar(bm):
+    for sx in (-1.0, 1.0):
+        for yy in (24.0, -18.0):
+            root = Vector((sx * (HULL_R + 2.4), yy, 0.0))
+            solar_array(bm, root, (sx, 0, 0), 30.0, 13.0, cells=84, rows=18)
+            d = Vector((sx, 0, 0))
+            x, _, _ = basis(d)
+            for k in range(16):
+                t = (k + 0.5) / 16
+                c = root + d * (30.0 * t)
+                cyl(bm, c - x * 6.5, c + x * 6.5, 0.05, seg=6)
+            for side in (-1.0, 1.0):
+                off = x * 6.5 * side
+                cyl(bm, root + off, root + d * 30.0 + off, 0.07, seg=6)
+            cyl(bm, root, root + Vector((sx * 2.4, 0, 0)), 0.20, seg=10)
+            for k in range(4):
+                a = 2.0 * math.pi * k / 4
+                cyl(bm, Vector((sx * (HULL_R + 0.4), yy, 0.0)),
+                    root + Vector((sx * 1.2, 0, 0)) + x * 0.8 * math.cos(a), 0.06, seg=6)
+
+
+def b_radiator(bm):
+    for sx in (-1.0, 1.0):
+        for yy in (-32.0, -12.0, 32.0):
+            p1 = Vector((sx * (HULL_R + 3.4), yy - 6.0, 0.0))
+            p2 = Vector((sx * (HULL_R + 3.4), yy + 6.0, 0.0))
+            fin_radiator(bm, p1, p2, 3.4, fins=64, fin_h=0.55)
+            mid = p1.lerp(p2, 0.5)
+            cyl(bm, Vector((sx * (HULL_R + 0.6), mid.y, 0.0)), mid, 0.11, seg=8)
+            torus(bm, mid, 1.7, 0.06, axis=(1, 0, 0), seg=20, rseg=5)
+
+
+def b_airlock(bm):
+    p1 = Vector((0.0, 16.0, HULL_R - 0.5))
+    p2 = Vector((0.0, 16.0, HULL_R + 4.6))
+    cyl(bm, p1, p2, 1.6, seg=22)
+    for zz in (HULL_R - 0.5, HULL_R + 4.6):
+        torus(bm, Vector((0.0, 16.0, zz)), 1.63, 0.08, axis=(0, 0, 1), seg=24, rseg=6)
+    hatch = Vector((0.0, 16.0, HULL_R + 4.6 + 0.4))
+    cyl(bm, hatch - Vector((0, 0, 0.4)), hatch + Vector((0, 0, 0.25)), 1.0, seg=18)
+    torus(bm, hatch + Vector((0, 0, 0.25)), 1.06, 0.075, axis=(0, 0, 1), seg=20, rseg=6)
+    for k in range(8):
+        a = 2.0 * math.pi * k / 8
+        off = Vector((math.cos(a), math.sin(a), 0.0)) * 1.06
+        cyl(bm, hatch + off + Vector((0, 0, 0.25)), hatch + off + Vector((0, 0, 0.42)), 0.055, seg=6)
+    equipment_row(bm, (1.9, 16.0, HULL_R + 2.4), (0, 0, 1), (1, 0, 0), 8, 0.5, 0.10, 0.22, seed=401)
+
+
+def b_orion(bm):
+    """Orion-class shuttle docked forward — the human-scale reference."""
+    base = Vector((0.0, 47.6, 0.0))
+    cyl(bm, base, base + Vector((0, 5.4, 0)), 1.5, seg=20)
+    for t in (0.3, 0.62):
+        torus(bm, base + Vector((0, 5.4 * t, 0)), 1.53, 0.065, axis=(0, 1, 0), seg=22, rseg=5)
+    cyl(bm, base + Vector((0, 5.4, 0)), base + Vector((0, 7.8, 0)), 1.5, 0.55, seg=20)
+    torus(bm, base + Vector((0, 5.4, 0)), 1.53, 0.08, axis=(0, 1, 0), seg=22, rseg=6)
+    cyl(bm, base + Vector((0, 7.8, 0)), base + Vector((0, 8.5, 0)), 0.55, seg=14)
+    torus(bm, base + Vector((0, 8.5, 0)), 0.65, 0.07, axis=(0, 1, 0), seg=16, rseg=6)
+    for k in range(8):
+        a = 2.0 * math.pi * k / 8
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        c = base + Vector((0, 6.9, 0)) + radial * 1.06
+        cyl(bm, c - radial * 0.05, c + radial * 0.11, 0.13, seg=10, cap1=False)
+    for k in range(4):
+        a = 2.0 * math.pi * k / 4 + math.pi / 4
+        radial = Vector((math.cos(a), 0.0, math.sin(a)))
+        root = base + Vector((0, 5.4, 0)) + radial * 1.5
+        solar_array(bm, root, radial, 4.6, 2.0, cells=22, rows=8)
+    bell(bm, base - Vector((0, 0.6, 0)), (0, -1, 0), 1.5, 0.22, 0.68, seg=22, layers=9)
+
+
+def b_greeble(bm):
+    """Organised machinery, cable looms, nav lights, hatch plates."""
+    p1, p2 = Vector(HULL_P1), Vector(HULL_P2)
+    r = HULL_R
+    for rx, (yy, ang) in ((0, (28.0, 0.9)), (0, (36.0, 2.5)), (0, (10.0, 4.2))):
+        radial = Vector((math.cos(ang), 0.0, math.sin(ang)))
+        base = Vector((0.0, yy, 0.0)) + radial * r
+        cyl(bm, base - radial * 0.05, base + radial * 0.13, 0.55, seg=14)
+        torus(bm, base + radial * 0.13, 0.60, 0.055, axis=radial, seg=16, rseg=5)
+    for sx in (-1.0, 1.0):
+        x0 = sx * (HULL_R + 1.6)
+        for dz in (0.95, -0.95):
+            pipe_run(bm, [(x0, -34.0, dz), (x0, 20.0, dz)], 0.055)
+    for (pos, dirv, rad) in (((-4.0, 40.0, 0.0), (-1, 0, 0), 0.20),
+                             ((4.0, 40.0, 0.0), (1, 0, 0), 0.20),
+                             ((0.0, 40.0, 4.0), (0, 0, 1), 0.20),
+                             ((-4.0, -2.0, 0.0), (-1, 0, 0), 0.16),
+                             ((4.0, -2.0, 0.0), (1, 0, 0), 0.16)):
+        d = Vector(dirv)
+        cyl(bm, Vector(pos), Vector(pos) + d * 0.15, rad, seg=10)
+        cyl(bm, Vector(pos) + d * 0.15, Vector(pos) + d * 0.34, rad * 0.7, seg=10)
+    equipment_row(bm, (0.0, 34.0, r + 0.15), (0, 1, 0), (0, 0, 1), 12, 1.0, 0.10, 0.24, seed=501)
+    equipment_row(bm, (0.0, 6.0, -r - 0.15), (0, 1, 0), (0, 0, -1), 14, 1.0, 0.10, 0.24, seed=502)
+
+
+def b_antenna(bm):
+    antenna_dish(bm, (0.0, 30.0, HULL_R + 1.4), (0.0, 0.3, 1.0), 2.6, depth=0.7, ribs=12)
+    antenna_dish(bm, (HULL_R + 1.2, 38.0, 0.0), (1.0, 0.25, 0.1), 1.4, depth=0.4, ribs=9)
+    for (bx, by, bz, ll) in ((0.0, 42.5, 3.0, 2.2), (0.0, 8.0, -3.0, 2.0), (3.0, 41.0, 0.0, 1.6)):
+        cyl(bm, Vector((bx, by, bz)), Vector((bx, by + 0.2, bz + ll)), 0.055, seg=6)
+        torus(bm, Vector((bx, by + 0.2, bz + ll)), 0.4, 0.045, axis=(0, 0, 1), seg=16, rseg=5)
+
+
+BUILDERS = {
+    "hnx02.hull.core": b_hull_core,
+    "hnx02.spine.truss": b_spine,
+    "hnx02.node.forward": b_node,
+    "hnx02.hab.a": b_hab_a,
+    "hnx02.hab.b": b_hab_b,
+    "hnx02.hab.whipple": b_whipple,
+    "hnx02.rad.waterwall": b_waterwall,
+    "hnx02.centrifuge.ring": b_centrifuge,
+    "hnx02.prop.tank": b_prop_tank,
+    "hnx02.reactor.core": b_reactor,
+    "hnx02.thrust.cone": b_thrust_cone,
+    "hnx02.nozzle.cluster": b_nozzle_cluster,
+    "hnx02.power.solar": b_solar,
+    "hnx02.power.radiator": b_radiator,
+    "hnx02.cabin.airlock": b_airlock,
+    "hnx02.shuttle.orion": b_orion,
+    "hnx02.detail.greeble": b_greeble,
+    "hnx02.detail.antenna": b_antenna,
+}
 
 
 def build_geometry(bpy, materials, step_id):
-    """Build every object of the cumulative step, in STEP_OBJECTS order."""
-    clay_body = materials["clay_body"]
-    clay_structure = materials["clay_structure"]
-    clay_dark = materials["clay_dark"]
-    clay_white = materials["clay_white"]
-    clay_glass = materials["clay_glass"]
-    livery_hull = materials["livery_hull"]
-    livery_structure = materials["livery_structure"]
-    livery_dark = materials["livery_dark"]
-    livery_ceramic = materials["livery_ceramic"]
-    livery_amber = materials["livery_amber"]
-    livery_white = materials["livery_white"]
-    livery_glass = materials["livery_glass"]
-    livery_nozzle = materials["livery_nozzle"]
-
-    def spoke_end(index):
-        angle = 2.0 * math.pi * index / SPOKE_COUNT
-        return (HAB_X, HAB_RADIUS * math.cos(angle), HAB_RADIUS * math.sin(angle))
-
-    objects = {}
+    objects = []
     for object_id in STEP_OBJECTS[step_id]:
-        if object_id == "starship.keel.spine":
-            objects[object_id] = add_beveled_cube(bpy, object_id, (-0.8, 0.0, 0.0), (10.0, 0.46, 0.42), clay_structure, livery_structure, bevel=0.05)
-        elif object_id == "starship.nose.cone":
-            objects[object_id] = add_cone(bpy, object_id, (4.6, 0.0, 0.0), 0.42, 0.08, 1.0, clay_body, livery_hull, rotation=(0.0, -math.pi / 2.0, 0.0))
-        elif object_id == "starship.dock.ring":
-            objects[object_id] = add_torus(bpy, object_id, (4.1, 0.0, 0.0), 0.44, 0.06, clay_structure, livery_amber, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id == "starship.hab.torus":
-            objects[object_id] = add_torus(bpy, object_id, (HAB_X, 0.0, 0.0), HAB_RADIUS, HAB_MINOR, clay_body, livery_hull, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=18)
-        elif object_id == "starship.hub.core":
-            objects[object_id] = add_cylinder(bpy, object_id, (HAB_X, 0.0, 0.0), 0.34, 1.4, clay_structure, livery_structure, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id.startswith("starship.spoke."):
-            index = int(object_id.rsplit(".", 1)[-1])
-            end = spoke_end(index)
-            objects[object_id] = add_between(bpy, object_id, (HAB_X, 0.0, 0.0), end, 0.11, clay_structure, livery_structure, vertices=16)
-        elif object_id == "starship.shadow.collar":
-            objects[object_id] = add_torus(bpy, object_id, (-1.35, 0.0, 0.0), 0.78, 0.24, clay_dark, livery_ceramic, rotation=(0.0, math.pi / 2.0, 0.0), minor_segments=16)
-        elif object_id == "starship.storm.cellar":
-            objects[object_id] = add_beveled_cube(bpy, object_id, (-0.55, 0.0, 0.0), (1.1, 0.62, 0.58), clay_dark, livery_ceramic, bevel=0.06)
-        elif object_id == "starship.core.pressure":
-            objects[object_id] = add_cylinder(bpy, object_id, (-3.4, 0.0, 0.0), 0.56, 1.7, clay_structure, livery_nozzle, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id == "starship.core.shield.plug":
-            objects[object_id] = add_cylinder(bpy, object_id, (-2.45, 0.0, 0.0), 0.60, 0.5, clay_dark, livery_ceramic, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id == "starship.nozzle.magnetic":
-            objects[object_id] = add_cone(bpy, object_id, (-5.35, 0.0, 0.0), 1.15, 0.60, 2.4, clay_structure, livery_nozzle, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id.startswith("starship.radiator."):
-            index = int(object_id.rsplit(".", 1)[-1])
-            angle = 2.0 * math.pi * index / 6.0 + math.pi / 6.0
-            y = 0.95 * math.cos(angle)
-            z = 0.95 * math.sin(angle)
-            objects[object_id] = add_beveled_cube(bpy, object_id, (-3.6, y, z), (1.5, 0.04, 0.42), clay_white, livery_white, bevel=0.02, rotation=(angle, 0.0, 0.0))
-        elif object_id == "starship.power.truss":
-            objects[object_id] = add_between(bpy, object_id, (-1.2, 0.0, 0.34), (3.9, 0.0, 0.34), 0.09, clay_structure, livery_structure, vertices=14)
-        elif object_id == "starship.capacitor.ring":
-            objects[object_id] = add_torus(bpy, object_id, (2.6, 0.0, 0.34), 0.42, 0.08, clay_structure, livery_amber, rotation=(math.pi / 2.0, 0.0, 0.0))
-        elif object_id == "starship.comm.dish":
-            objects[object_id] = add_dish(bpy, object_id, 3.4, 0.0, 0.50, 0.55, 0.10, clay_white, livery_white)
-        elif object_id == "starship.comm.feed":
-            objects[object_id] = add_cylinder(bpy, object_id, (3.72, 0.0, 0.50), 0.05, 0.09, clay_glass, livery_glass, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id.startswith("starship.window."):
-            index = int(object_id.rsplit(".", 1)[-1])
-            angle = 2.0 * math.pi * index / SPOKE_COUNT + math.pi / 6.0
-            y = (HAB_RADIUS + HAB_MINOR * 0.55) * math.cos(angle)
-            z = (HAB_RADIUS + HAB_MINOR * 0.55) * math.sin(angle)
-            objects[object_id] = add_cylinder(bpy, object_id, (HAB_X + 0.16, y, z), 0.14, 0.10, clay_glass, livery_glass, rotation=(angle, 0.0, 0.0), vertices=18)
-        elif object_id == "starship.airlock.ring":
-            objects[object_id] = add_torus(bpy, object_id, (4.1, 0.0, 0.0), 0.30, 0.05, clay_structure, livery_amber, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id == "starship.airlock.tunnel":
-            objects[object_id] = add_cylinder(bpy, object_id, (4.55, 0.0, 0.0), 0.26, 0.9, clay_body, livery_hull, rotation=(0.0, math.pi / 2.0, 0.0))
-        elif object_id.startswith("starship.cargo.pod."):
-            index = int(object_id.rsplit(".", 1)[-1])
-            y = (-0.62, 0.62)[index]
-            objects[object_id] = add_beveled_cube(bpy, object_id, (0.35, y, 0.0), (1.2, 0.24, 0.30), clay_body, livery_hull, bevel=0.03)
-        else:
-            fail("unknown object id: " + object_id, 4)
-
-    # Secondary engineering detail is generated per contract object and
-    # merged into the master mesh, keeping the GLB object contract intact.
-    for object_id in list(STEP_OBJECTS[step_id]):
-        master = objects[object_id]
-        merge_details(bpy, master, build_details(bpy, object_id, master, materials))
-
-    ordered = [objects[object_id] for object_id in STEP_OBJECTS[step_id]]
-    for obj, object_id in zip(ordered, STEP_OBJECTS[step_id]):
-        if obj.get("object_id") != object_id:
-            fail("source object custom property verification failed", 4)
-    return ordered
+        material = materials[OBJECT_MATERIAL[object_id]]
+        objects.append(build_object(bpy, object_id, material, BUILDERS[object_id]))
+    return objects
 
 
-def add_render_setup(bpy):
-    from mathutils import Vector
+# ------------------------------------------------------------ render / io
+
 
+def add_render_setup(bpy):
     scene = bpy.context.scene
-    scene.render.resolution_x = 512
-    scene.render.resolution_y = 512
+    scene.render.resolution_x = 1280
+    scene.render.resolution_y = 860
     scene.render.resolution_percentage = 100
     scene.render.image_settings.file_format = "PNG"
     if scene.world is None:
-        scene.world = bpy.data.worlds.new("ship.world")
-    scene.world.color = (0.025, 0.035, 0.045)
+        scene.world = bpy.data.worlds.new("hnx02.world")
+    scene.world.color = (0.02, 0.03, 0.04)
 
-    camera_data = bpy.data.cameras.new("ship.camera")
+    camera_data = bpy.data.cameras.new("hnx02.camera")
     camera_data.type = "ORTHO"
-    camera_data.ortho_scale = 13.5
-    camera = bpy.data.objects.new("ship.camera", camera_data)
+    camera_data.ortho_scale = 118.0
+    camera = bpy.data.objects.new("hnx02.camera", camera_data)
     bpy.context.collection.objects.link(camera)
-    camera.location = (7.0, -13.5, 7.5)
-    camera.rotation_euler = (Vector((-0.5, 0.0, 0.0)) - camera.location).to_track_quat("-Z", "Y").to_euler()
+    camera.location = (52.0, -66.0, 40.0)
+    camera.rotation_euler = (Vector((0.0, 2.0, 0.0)) - camera.location).to_track_quat("-Z", "Y").to_euler()
     scene.camera = camera
 
     def add_light(name, location, energy, size, color=(1.0, 1.0, 1.0)):
@@ -703,12 +1057,12 @@ def add_render_setup(bpy):
         light = bpy.data.objects.new(name, light_data)
         bpy.context.collection.objects.link(light)
         light.location = location
-        light.rotation_euler = (Vector((-0.5, 0.0, 0.0)) - Vector(location)).to_track_quat("-Z", "Y").to_euler()
+        light.rotation_euler = (Vector((0.0, 2.0, 0.0)) - Vector(location)).to_track_quat("-Z", "Y").to_euler()
         return light
 
-    add_light("ship.key", (5.0, -6.0, 9.0), 1400, 6.0, (1.0, 0.98, 0.94))
-    add_light("ship.fill", (-4.0, -9.0, 2.0), 420, 8.0, (0.72, 0.82, 1.0))
-    add_light("ship.rim", (-7.5, 5.0, -3.0), 900, 3.0, (1.0, 0.86, 0.62))
+    add_light("hnx02.key", (34.0, -30.0, 40.0), 16000, 26.0, (1.0, 0.97, 0.92))
+    add_light("hnx02.fill", (-30.0, -42.0, 10.0), 5200, 30.0, (0.68, 0.79, 1.0))
+    add_light("hnx02.rim", (-36.0, 26.0, -16.0), 9000, 16.0, (1.0, 0.85, 0.58))
 
 
 def export_glb(bpy, objects, output):
@@ -717,7 +1071,17 @@ def export_glb(bpy, objects, output):
     for obj in objects:
         obj.select_set(True)
     bpy.context.view_layer.objects.active = objects[-1]
-    result = bpy.ops.export_scene.gltf(filepath=output, export_format="GLB", use_selection=True, export_apply=True)
+    result = bpy.ops.export_scene.gltf(
+        filepath=output,
+        export_format="GLB",
+        use_selection=True,
+        export_apply=True,
+        export_draco_mesh_compression_enable=True,
+        export_draco_mesh_compression_level=6,
+        export_draco_position_quantization=14,
+        export_draco_normal_quantization=10,
+        export_draco_texcoord_quantization=12,
+    )
     if "FINISHED" not in result or not os.path.isfile(output) or os.path.getsize(output) <= 0:
         fail("GLB export failed", 4)
 
@@ -738,11 +1102,9 @@ def verify_reimport(bpy, output, expected):
     result = bpy.ops.import_scene.gltf(filepath=output)
     if "FINISHED" not in result:
         fail("GLB reimport failed", 4)
-
     names = [obj.name for obj in bpy.context.scene.objects if obj.type == "MESH"]
     if len(names) != len(expected) or set(names) != set(expected):
         fail("GLB reimport object IDs did not match", 4)
-
     return [object_id for object_id in expected if object_id in names]
 
 
@@ -754,61 +1116,40 @@ def main():
     parser.add_argument("--result-output", required=True)
     args = parser.parse_args()
 
-    if args.step_id not in STEP_OBJECTS:
-        fail("unknown step id", 2)
-    if bool(args.render_output) and os.path.abspath(args.render_output) == os.path.abspath(args.output):
-        fail("render output must differ from GLB output", 2)
-
-    try:
-        import bpy
-    except Exception as exc:
-        fail("bpy is unavailable: " + str(exc), 3)
-
-    if tuple(bpy.app.version) < (3, 0, 0):
-        fail("bpy version is unsupported", 3)
-
-    output = os.path.abspath(args.output)
-    result_output = os.path.abspath(args.result_output)
-    os.makedirs(os.path.dirname(output), exist_ok=True)
-
-    try:
-        clear_scene(bpy)
-        materials = build_materials(bpy)
-        objects = build_geometry(bpy, materials, args.step_id)
-        apply_material_mode(bpy, materials, "livery" if args.step_id in LIVERY_STEPS else "clay")
-        export_glb(bpy, objects, output)
-        exported_at = utc_now()
-        glb_bytes = os.path.getsize(output)
-
-        rendered_at = None
-        if args.render_output:
-            render_output = os.path.abspath(args.render_output)
-            os.makedirs(os.path.dirname(render_output), exist_ok=True)
-            add_render_setup(bpy)
-            bpy.context.scene.render.filepath = render_output
-            result = bpy.ops.render.render(write_still=True)
-            if "FINISHED" not in result or not os.path.isfile(render_output) or os.path.getsize(render_output) <= 0:
-                fail("PNG render failed", 4)
-            rendered_at = utc_now()
-
-        verified = verify_reimport(bpy, output, STEP_OBJECTS[args.step_id])
-        response = {
-            "ok": True,
-            "blenderVersion": ".".join(str(part) for part in bpy.app.version),
-            "exportedAt": exported_at,
-            "objectIds": STEP_OBJECTS[args.step_id],
-            "verifiedObjectIds": verified,
-            "glbBytes": glb_bytes,
-        }
-        if args.render_output:
-            response["renderPath"] = os.path.abspath(args.render_output)
-            response["renderedAt"] = rendered_at
-        write_result(result_output, response)
-        print("starship result written: " + result_output)
-    except SystemExit:
-        raise
-    except Exception as exc:
-        fail("starship failed: " + str(exc), 4)
+    step_id = args.step_id
+    if step_id not in STEP_OBJECTS:
+        fail("unknown step id: " + step_id, 3)
+
+    clear_scene(bpy)
+    materials = build_materials(bpy)
+    objects = build_geometry(bpy, materials, step_id)
+
+    render_path = None
+    if args.render_output:
+        add_render_setup(bpy)
+        scene = bpy.context.scene
+        scene.render.filepath = args.render_output
+        bpy.ops.render.render(write_still=True)
+        if os.path.isfile(args.render_output):
+            render_path = os.path.abspath(args.render_output)
+
+    exported_at = utc_now()
+    export_glb(bpy, objects, args.output)
+    reimported = verify_reimport(bpy, args.output, STEP_OBJECTS[step_id])
+
+    response = {
+        "ok": True,
+        "blenderVersion": ".".join(str(part) for part in bpy.app.version),
+        "exportedAt": exported_at,
+        "objectIds": STEP_OBJECTS[step_id],
+        "verifiedObjectIds": reimported,
+        "glbBytes": os.path.getsize(args.output),
+    }
+    if render_path is not None:
+        response["renderPath"] = render_path
+        response["renderedAt"] = utc_now()
+    write_result(args.result_output, response)
+    print("hnx02 result written: " + args.result_output)
 
 
 if __name__ == "__main__":