diff --git a/nhf/parts/box.py b/nhf/parts/box.py
new file mode 100644
index 0000000..a95f512
--- /dev/null
+++ b/nhf/parts/box.py
@@ -0,0 +1,110 @@
+import cadquery as Cq
+from dataclasses import dataclass, field
+from typing import Tuple, Optional, Union
+import nhf.utils
+
+def box_with_centre_holes(
+        length: float,
+        width: float,
+        height: float,
+        hole_loc: list[float],
+        hole_diam: float = 6.0,
+        ) -> Cq.Workplane:
+    """
+    Creates a box with holes along the X axis, marked `conn0, conn1, ...`. The
+    box's y axis is centred
+    """
+    result = (
+        Cq.Workplane('XY')
+        .box(length, width, height, centered=(False, True, False))
+        .faces(">Z")
+        .workplane()
+    )
+    plane = result
+    for i, x in enumerate(hole_loc):
+        result = result.moveTo(x, 0).hole(hole_diam)
+        plane.moveTo(x, 0).tagPlane(f"conn{i}")
+    return result
+
+@dataclass
+class Hole:
+    x: float
+    y: float = 0.0
+    diam: Optional[float] = None
+    tag: Optional[str] = None
+
+@dataclass
+class MountingBox:
+    """
+    Create a box with marked holes
+    """
+    length: float = 100.0
+    width: float = 60.0
+    thickness: float = 1.0
+
+    # List of (x, y), diam
+    holes: list[Hole] = field(default_factory=lambda: [
+        Hole(x=5, y=5, diam=3),
+        Hole(x=20, y=10, diam=5),
+    ])
+    hole_diam: Optional[float] = None
+
+    centred: Tuple[bool, bool] = (False, True)
+
+    generate_side_tags: bool = True
+
+    def profile(self) -> Cq.Sketch:
+        bx, by = 0, 0
+        if not self.centred[0]:
+            bx = self.length / 2
+        if not self.centred[1]:
+            by = self.width / 2
+        result = (
+            Cq.Sketch()
+            .push([(bx, by)])
+            .rect(self.length, self.width)
+        )
+        for hole in self.holes:
+            diam = hole.diam if hole.diam else self.hole_diam
+            result.push([(hole.x, hole.y)]).circle(diam / 2, mode='s')
+        return result
+
+    def generate(self) -> Cq.Workplane:
+        """
+        Creates box shape with markers
+        """
+        result = (
+            Cq.Workplane('XY')
+            .placeSketch(self.profile())
+            .extrude(self.thickness)
+        )
+        plane = result.copyWorkplane(Cq.Workplane('XY')).workplane(offset=self.thickness)
+        for i, hole in enumerate(self.holes):
+            tag = hole.tag if hole.tag else f"conn{i}"
+            plane.moveTo(hole.x, hole.y).tagPlane(tag)
+
+        if self.generate_side_tags:
+            result.faces("<Y").workplane(origin=result.vertices("<X and <Y and >Z").val().Center()).tagPlane("left")
+            result.faces(">Y").workplane(origin=result.vertices("<X and >Y and >Z").val().Center()).tagPlane("right")
+            result.faces("<X").workplane(origin=result.vertices("<X and <Y and >Z").val().Center()).tagPlane("bot")
+            result.faces(">X").workplane(origin=result.vertices(">X and <Y and >Z").val().Center()).tagPlane("top")
+            result.faces(">Z").tag("dir")
+        return result
+
+    def marked_assembly(self) -> Cq.Assembly:
+        result = (
+            Cq.Assembly()
+            .add(self.generate(), name="box")
+        )
+        for i in range(len(self.holes)):
+            result.markPlane(f"box?conn{i}")
+        if self.generate_side_tags:
+            (
+                result
+                .markPlane("box?left")
+                .markPlane("box?right")
+                .markPlane("box?dir")
+                .markPlane("box?top")
+                .markPlane("box?bot")
+            )
+        return result.solve()
diff --git a/nhf/parts/joints.py b/nhf/parts/joints.py
index bb1c449..9867b4f 100644
--- a/nhf/parts/joints.py
+++ b/nhf/parts/joints.py
@@ -105,6 +105,18 @@ class HirthJoint:
         )
         return result
 
+    def add_constraints(self,
+                        assembly: Cq.Assembly,
+                        parent: str,
+                        child: str,
+                        angle: int = 0):
+        (
+            assembly
+            .constrain(f"{parent}?mate", f"{child}?mate", "Plane")
+            .constrain(f"{parent}?dir", f"{child}?dir",
+                       "Axis", param=angle * self.tooth_angle)
+        )
+
     def assembly(self, offset: int = 1):
         """
         Generate an example assembly
diff --git a/nhf/touhou/houjuu_nue/__init__.py b/nhf/touhou/houjuu_nue/__init__.py
index 844ce48..4e57fae 100644
--- a/nhf/touhou/houjuu_nue/__init__.py
+++ b/nhf/touhou/houjuu_nue/__init__.py
@@ -62,7 +62,11 @@ class Parameters(Model):
     ))
 
     wing_profile: MW.WingProfile = field(default_factory=lambda: MW.WingProfile(
-        shoulder_height=100.0,
+        shoulder_joint=MJ.ShoulderJoint(
+            height=100.0,
+        ),
+        elbow_joint=MJ.ElbowJoint(),
+        wrist_joint=MJ.ElbowJoint(),
         elbow_height=110.0,
     ))
 
@@ -70,14 +74,6 @@ class Parameters(Model):
     wing_root_radius: float = 40
     wing_root_wall_thickness: float = 8
 
-    shoulder_joint: MJ.ShoulderJoint = field(default_factory=lambda: MJ.ShoulderJoint(
-        shoulder_height=100.0,
-    ))
-    elbow_joint: MJ.ElbowJoint = field(default_factory=lambda: MJ.ElbowJoint(
-    ))
-    wrist_joint: MJ.ElbowJoint = field(default_factory=lambda: MJ.ElbowJoint(
-    ))
-
     """
     Heights for various wing joints, where the numbers start from the first
     joint.
@@ -109,6 +105,7 @@ class Parameters(Model):
     def __post_init__(self):
         super().__init__(name="houjuu-nue")
         self.harness.hs_hirth_joint = self.hs_hirth_joint
+        self.wing_profile.base_joint = self.hs_hirth_joint
         assert self.wing_root_radius > self.hs_hirth_joint.radius, \
             "Wing root must be large enough to accomodate joint"
         assert self.wing_s1_shoulder_spacer_hole_dist > self.wing_s1_spacer_hole_diam, \
@@ -145,309 +142,20 @@ class Parameters(Model):
     def harness_assembly(self) -> Cq.Assembly:
         return self.harness.assembly()
 
-    #@target(name="wing/joining-plate", kind=TargetKind.DXF)
-    #def joining_plate(self) -> Cq.Workplane:
-    #    return self.wing_joining_plate.plate()
-
-    @target(name="wing/root")
-    def wing_root(self) -> Cq.Assembly:
-        """
-        Generate the wing root which contains a Hirth joint at its base and a
-        rectangular opening on its side, with the necessary interfaces.
-        """
-        return MW.wing_root(
-            joint=self.hs_hirth_joint,
-            shoulder_attach_dist=self.shoulder_joint.attach_dist,
-            shoulder_attach_diam=self.shoulder_joint.attach_diam,
-            wall_thickness=self.wing_root_wall_thickness,
-            conn_height=self.wing_profile.shoulder_height,
-            conn_thickness=self.wing_s0_thickness,
-        )
-
     @target(name="wing/proto-shoulder-joint-parent", prototype=True)
     def proto_shoulder_joint_parent(self):
-        return self.shoulder_joint.torsion_joint.track()
+        return self.wing_profile.shoulder_joint.torsion_joint.track()
     @target(name="wing/proto-shoulder-joint-child", prototype=True)
     def proto_shoulder_joint_child(self):
-        return self.shoulder_joint.torsion_joint.rider()
-    @assembly()
-    def shoulder_assembly(self):
-        return self.shoulder_joint.assembly(
-            wing_root_wall_thickness=self.wing_root_wall_thickness,
-            lip_height=self.wing_s1_thickness,
-            hole_dist=self.wing_s1_shoulder_spacer_hole_dist,
-            spacer_hole_diam=self.wing_s1_spacer_hole_diam,
-        )
-    @assembly()
-    def elbow_assembly(self):
-        return self.elbow_joint.assembly()
-    @assembly()
-    def wrist_assembly(self):
-        return self.wrist_joint.assembly()
-
-
-    @target(name="wing/s1-spacer", kind=TargetKind.DXF)
-    def wing_s1_spacer(self) -> Cq.Workplane:
-        result = (
-            Cq.Workplane('XZ')
-            .sketch()
-            .rect(self.wing_s1_spacer_width, self.wing_s1_thickness)
-            .finalize()
-            .extrude(self.wing_s1_spacer_thickness)
-        )
-        result.faces("<Z").tag("weld1")
-        result.faces(">Z").tag("weld2")
-        result.faces(">Y").tag("dir")
-        return result
-
-    @target(name="wing/s1-shoulder-spacer", kind=TargetKind.DXF)
-    def wing_s1_shoulder_spacer(self) -> Cq.Workplane:
-        """
-        Creates a rectangular spacer. This could be cut from acrylic.
-
-        There are two holes on the top of the spacer. With the holes
-        """
-        dx = self.wing_s1_shoulder_spacer_hole_dist
-        h = self.wing_s1_spacer_thickness
-        length = self.wing_s1_shoulder_spacer_width
-        hole_diam = self.wing_s1_spacer_hole_diam
-        assert dx + hole_diam < length / 2
-        result = (
-            Cq.Workplane('XY')
-            .sketch()
-            .rect(length, self.wing_s1_thickness)
-            .push([
-                (0, 0),
-                (dx, 0),
-            ])
-            .circle(hole_diam / 2, mode='s')
-            .finalize()
-            .extrude(h)
-        )
-        # Tag the mating surfaces to be glued
-        result.faces("<Y").workplane().moveTo(length / 2, h).tagPlane("left")
-        result.faces(">Y").workplane().moveTo(-length / 2, h).tagPlane("right")
-
-        # Tag the directrix
-        result.faces(">Z").tag("dir")
-
-        # Tag the holes
-        plane = result.faces(">Z").workplane()
-        # Side closer to the parent is 0
-        plane.moveTo(dx, 0).tagPlane("conn0")
-        plane.tagPlane("conn1")
-        return result
-    def assembly_insert_shoulder_spacer(
-            self,
-            assembly,
-            spacer,
-            point_tag: str,
-            front_tag: str = "panel_front",
-            back_tag: str = "panel_back",
-            flipped: bool = False,
-            ):
-        """
-        For a child joint facing up, front panel should be on the right, back
-        panel on the left
-        """
-        site_front, site_back = "right", "left"
-        if flipped:
-            site_front, site_back = site_back, site_front
-        angle = 0
-        (
-            assembly
-            .add(spacer,
-                 name=f"{point_tag}_spacer",
-                 color=self.material_bracket.color)
-            .constrain(f"{front_tag}?{point_tag}",
-                       f"{point_tag}_spacer?{site_front}", "Plane")
-            .constrain(f"{back_tag}?{point_tag}",
-                       f"{point_tag}_spacer?{site_back}", "Plane")
-            .constrain(f"{point_tag}_spacer?dir", f"{front_tag}?{point_tag}_dir",
-                       "Axis", param=angle)
-        )
-
-    @target(name="wing/r1s1", kind=TargetKind.DXF)
-    def wing_r1s1_profile(self) -> Cq.Sketch:
-        """
-        FIXME: Output individual segment profiles
-        """
-        return self.wing_profile.profile()
-
-    def wing_r1s1_panel(self, front=True) -> Cq.Workplane:
-        return self.wing_profile.surface_s1(
-            thickness=self.panel_thickness,
-            shoulder_joint_child_height=self.shoulder_joint.child_height,
-            front=front,
-        )
-    def wing_r1s2_panel(self, front=True) -> Cq.Workplane:
-        return self.wing_profile.surface_s2(
-            thickness=self.panel_thickness,
-            front=front,
-        )
-    def wing_r1s3_panel(self, front=True) -> Cq.Workplane:
-        return self.wing_profile.surface_s3(
-            thickness=self.panel_thickness,
-            front=front,
-        )
-
-    @assembly()
-    def wing_r1s1_assembly(self) -> Cq.Assembly:
-        result = (
-            Cq.Assembly()
-            .add(self.wing_r1s1_panel(front=True), name="panel_front",
-                 color=self.material_panel.color)
-            .constrain("panel_front", "Fixed")
-            .add(self.wing_r1s1_panel(front=False), name="panel_back",
-                 color=self.material_panel.color)
-            .constrain("panel_front@faces@>Z", "panel_back@faces@<Z", "Point",
-                       param=self.wing_s1_thickness)
-        )
-        for t in ["shoulder_bot", "shoulder_top", "elbow_bot", "elbow_top"]:
-            is_top = t.endswith("_top")
-            is_parent = t.startswith("shoulder")
-            self.assembly_insert_shoulder_spacer(
-                result,
-                self.wing_s1_shoulder_spacer(),
-                point_tag=t,
-                flipped=is_top == is_parent,
-            )
-        return result.solve()
-    @assembly()
-    def wing_r1s2_assembly(self) -> Cq.Assembly:
-        result = (
-            Cq.Assembly()
-            .add(self.wing_r1s2_panel(front=True), name="panel_front",
-                 color=self.material_panel.color)
-            .constrain("panel_front", "Fixed")
-            .add(self.wing_r1s2_panel(front=False), name="panel_back",
-                 color=self.material_panel.color)
-            # FIXME: Use s2 thickness
-            .constrain("panel_front@faces@>Z", "panel_back@faces@<Z", "Point",
-                       param=self.wing_s1_thickness)
-        )
-        for t in ["elbow_bot", "elbow_top", "wrist_bot", "wrist_top"]:
-            is_top = t.endswith("_top")
-            is_parent = t.startswith("elbow")
-            self.assembly_insert_shoulder_spacer(
-                result,
-                self.wing_s1_shoulder_spacer(),
-                point_tag=t,
-                flipped=is_top == is_parent,
-            )
-        return result.solve()
-    @assembly()
-    def wing_r1s3_assembly(self) -> Cq.Assembly:
-        result = (
-            Cq.Assembly()
-            .add(self.wing_r1s3_panel(front=True), name="panel_front",
-                 color=self.material_panel.color)
-            .constrain("panel_front", "Fixed")
-            .add(self.wing_r1s3_panel(front=False), name="panel_back",
-                 color=self.material_panel.color)
-            # FIXME: Use s2 thickness
-            .constrain("panel_front@faces@>Z", "panel_back@faces@<Z", "Point",
-                       param=self.wing_s1_thickness)
-        )
-        for t in ["wrist_bot", "wrist_top"]:
-            self.assembly_insert_shoulder_spacer(
-                result,
-                self.wing_s1_shoulder_spacer(),
-                point_tag=t
-            )
-        return result.solve()
+        return self.wing_profile.shoulder_joint.torsion_joint.rider()
 
 
     @assembly()
-    def wing_r1_assembly(
-            self,
-            parts=["s0", "shoulder", "s1", "elbow", "s2", "wrist", "s3"],
-    ) -> Cq.Assembly:
-        result = (
-            Cq.Assembly()
-        )
-        if "s0" in parts:
-            (
-                result
-                .add(self.wing_root(), name="s0")
-                .constrain("s0/scaffold", "Fixed")
-            )
-        if "shoulder" in parts:
-            result.add(self.shoulder_assembly(), name="shoulder")
-
-        if "s0" in parts and "shoulder" in parts:
-            (
-                result
-                .constrain("s0/scaffold?conn_top0", "shoulder/parent_top?conn0", "Plane")
-                .constrain("s0/scaffold?conn_top1", "shoulder/parent_top?conn1", "Plane")
-                .constrain("s0/scaffold?conn_bot0", "shoulder/parent_bot?conn0", "Plane")
-                .constrain("s0/scaffold?conn_bot1", "shoulder/parent_bot?conn1", "Plane")
-            )
-
-        if "s1" in parts:
-            result.add(self.wing_r1s1_assembly(), name="s1")
-
-        if "s1" in parts and "shoulder" in parts:
-            (
-                result
-                .constrain("shoulder/child/lip_bot?conn0",
-                           "s1/shoulder_bot_spacer?conn0",
-                           "Plane")
-                .constrain("shoulder/child/lip_bot?conn1",
-                           "s1/shoulder_bot_spacer?conn1",
-                           "Plane")
-                .constrain("shoulder/child/lip_top?conn0",
-                           "s1/shoulder_top_spacer?conn0",
-                           "Plane")
-                .constrain("shoulder/child/lip_top?conn1",
-                           "s1/shoulder_top_spacer?conn1",
-                           "Plane")
-            )
-        if "elbow" in parts:
-            result.add(self.elbow_assembly(), name="elbow")
-
-        if "s2" in parts:
-            result.add(self.wing_r1s2_assembly(), name="s2")
-
-        if "s1" in parts and "elbow" in parts:
-            (
-                result
-                .constrain("elbow/parent_upper/top?conn1",
-                           "s1/elbow_top_spacer?conn1",
-                           "Plane")
-                .constrain("elbow/parent_upper/top?conn0",
-                           "s1/elbow_top_spacer?conn0",
-                           "Plane")
-                .constrain("elbow/parent_upper/bot?conn1",
-                           "s1/elbow_bot_spacer?conn1",
-                           "Plane")
-                .constrain("elbow/parent_upper/bot?conn0",
-                           "s1/elbow_bot_spacer?conn0",
-                           "Plane")
-            )
-
-        if "s2" in parts and "elbow" in parts:
-            (
-                result
-                .constrain("elbow/child/bot?conn0",
-                           "s2/elbow_bot_spacer?conn0",
-                           "Plane")
-                .constrain("elbow/child/bot?conn1",
-                           "s2/elbow_bot_spacer?conn1",
-                           "Plane")
-                .constrain("elbow/child/top?conn0",
-                           "s2/elbow_top_spacer?conn0",
-                           "Plane")
-                .constrain("elbow/child/top?conn1",
-                           "s2/elbow_top_spacer?conn1",
-                           "Plane")
-            )
-        if len(parts) > 1:
-            result.solve()
-        return result
+    def wing_r1_assembly(self) -> Cq.Assembly:
+        return self.wing_profile.assembly()
 
     @assembly()
-    def wings_assembly(self) -> Cq.Assembly:
+    def wings_harness_assembly(self) -> Cq.Assembly:
         """
         Assembly of harness with all the wings
         """
@@ -456,18 +164,14 @@ class Parameters(Model):
         result = (
             Cq.Assembly()
             .add(self.harness_assembly(), name="harness", loc=Cq.Location((0, 0, 0)))
-            .add(self.wing_root(), name="w0_r1")
-            .add(self.wing_root(), name="w0_l1")
-            .constrain("harness/base", "Fixed")
-            .constrain("w0_r1/joint?mate", "harness/r1?mate", "Plane")
-            .constrain("w0_r1/joint?dir", "harness/r1?dir",
-                       "Axis", param=7 * a_tooth)
-            .constrain("w0_l1/joint?mate", "harness/l1?mate", "Plane")
-            .constrain("w0_l1/joint?dir", "harness/l1?dir",
-                       "Axis", param=-1 * a_tooth)
-            .solve()
+            .add(self.wing_r1_assembly(), name="wing_r1")
+            .add(self.wing_r1_assembly(), name="wing_r2")
+            .add(self.wing_r1_assembly(), name="wing_r3")
         )
-        return result
+        self.hs_hirth_joint.add_constraints(result, "harness/r1", "wing_r1/s0/hs", angle=9)
+        self.hs_hirth_joint.add_constraints(result, "harness/r2", "wing_r2/s0/hs", angle=8)
+        self.hs_hirth_joint.add_constraints(result, "harness/r3", "wing_r3/s0/hs", angle=7)
+        return result.solve()
 
     @assembly(collision_check=False)
     def trident_assembly(self) -> Cq.Assembly:
diff --git a/nhf/touhou/houjuu_nue/joints.py b/nhf/touhou/houjuu_nue/joints.py
index dfd5207..d25c22c 100644
--- a/nhf/touhou/houjuu_nue/joints.py
+++ b/nhf/touhou/houjuu_nue/joints.py
@@ -5,6 +5,7 @@ from nhf import Role
 from nhf.build import Model, target, assembly
 import nhf.parts.springs as springs
 from nhf.parts.joints import TorsionJoint
+from nhf.parts.box import box_with_centre_holes
 import nhf.utils
 
 TOL = 1e-6
@@ -12,7 +13,7 @@ TOL = 1e-6
 @dataclass
 class ShoulderJoint(Model):
 
-    shoulder_height: float = 100.0
+    height: float = 100.0
     torsion_joint: TorsionJoint = field(default_factory=lambda: TorsionJoint(
         radius_track=18,
         radius_rider=18,
@@ -27,47 +28,67 @@ class ShoulderJoint(Model):
         spring_thickness=1.3,
         spring_height=7.5,
     ))
-    # Two holes on each side (top and bottom) are used to attach the shoulder
-    # joint. This governs the distance between these two holes
-    attach_dist: float = 25
-    attach_diam: float = 8
+
+    # On the parent side, drill vertical holes
+
+    parent_conn_hole_diam: float = 6.0
+    # Position of the holes relative
+    parent_conn_hole_pos: list[float] = field(default_factory=lambda: [20, 30])
+
+    parent_lip_length: float = 40.0
+    parent_lip_width: float = 20.0
+    parent_lip_thickness: float = 8.0
+    parent_lip_ext: float = 40.0
+    parent_lip_guard_height: float = 10.0
+
+    # Measured from centre of axle
+    child_lip_length: float = 45.0
+    child_lip_width: float = 20.0
+    child_conn_hole_diam: float = 6.0
+    # Measured from centre of axle
+    child_conn_hole_pos: list[float] = field(default_factory=lambda: [25, 35])
+    child_core_thickness: float = 3.0
 
 
     @target(name="shoulder-joint/parent")
     def parent(self,
-               wing_root_wall_thickness: float = 5.0) -> Cq.Workplane:
+               root_wall_thickness: float = 25.4 / 16) -> Cq.Assembly:
         joint = self.torsion_joint
         # Thickness of the lip connecting this joint to the wing root
-        lip_thickness = 10
-        lip_width = 25
-        lip_guard_ext = 40
-        lip_guard_height = wing_root_wall_thickness + lip_thickness
-        assert lip_guard_ext > joint.radius_track
+        dz = root_wall_thickness
+        assert self.parent_lip_width <= joint.radius_track * 2
+        assert self.parent_lip_ext > joint.radius_track
 
         lip_guard = (
-            Cq.Solid.makeBox(lip_guard_ext, lip_width, lip_guard_height)
-            .located(Cq.Location((0, -lip_width/2 , 0)))
-            .cut(Cq.Solid.makeCylinder(joint.radius_track, lip_guard_height))
+            Cq.Solid.makeBox(
+                self.parent_lip_ext,
+                self.parent_lip_width,
+                self.parent_lip_guard_height)
+            .located(Cq.Location((0, -self.parent_lip_width/2 , dz)))
+            .cut(Cq.Solid.makeCylinder(joint.radius_track, self.parent_lip_guard_height + dz))
         )
+        lip = box_with_centre_holes(
+            length=self.parent_lip_length - dz,
+            width=self.parent_lip_width,
+            height=self.parent_lip_thickness,
+            hole_loc=[
+                self.height / 2 - dz - x
+                for x in self.parent_conn_hole_pos
+            ],
+            hole_diam=self.parent_conn_hole_diam,
+        )
+        # Flip so the lip's holes point to -X
+        loc_axis = Cq.Location((0,0,0), (0, 1, 0), -90)
+        # so they point to +X
+        loc_dir = Cq.Location((0,0,0), (0, 0, 1), 180)
+        loc_pos = Cq.Location((self.parent_lip_ext - self.parent_lip_thickness, 0, dz))
+
         result = (
-            joint.track()
-            .union(lip_guard, tol=1e-6)
-
-            # Extrude the handle
-            .copyWorkplane(Cq.Workplane(
-                'YZ', origin=Cq.Vector((88, 0, wing_root_wall_thickness))))
-            .rect(lip_width, lip_thickness, centered=(True, False))
-            .extrude("next")
-
-            # Connector holes on the lip
-            .copyWorkplane(Cq.Workplane(
-                'YX', origin=Cq.Vector((57, 0, wing_root_wall_thickness))))
-            .hole(self.attach_diam)
-            .moveTo(0, self.attach_dist)
-            .hole(self.attach_diam)
+            Cq.Assembly()
+            .add(joint.track(), name="track")
+            .add(lip_guard, name="lip_guard")
+            .add(lip, name="lip", loc=loc_pos * loc_dir * loc_axis)
         )
-        result.moveTo(0, 0).tagPlane('conn0')
-        result.moveTo(0, self.attach_dist).tagPlane('conn1')
         return result
 
     @property
@@ -77,32 +98,32 @@ class ShoulderJoint(Model):
         of the shoulder joint.
         """
         joint = self.torsion_joint
-        return self.shoulder_height - 2 * joint.total_height + 2 * joint.rider_disk_height
+        return self.height - 2 * joint.total_height + 2 * joint.rider_disk_height
 
     @target(name="shoulder-joint/child")
-    def child(self,
-              lip_height: float = 20.0,
-              hole_dist: float = 10.0,
-              spacer_hole_diam: float = 8.0) -> Cq.Assembly:
+    def child(self) -> Cq.Assembly:
         """
         Creates the top/bottom shoulder child joint
         """
 
         joint = self.torsion_joint
+        assert all(r > joint.radius_rider for r in self.child_conn_hole_pos)
+        assert all(r < self.child_lip_length for r in self.child_conn_hole_pos)
+
         # Half of the height of the bridging cylinder
-        dh = self.shoulder_height / 2 - joint.total_height
+        dh = self.height / 2 - joint.total_height
         core_start_angle = 30
         core_end_angle1 = 90
         core_end_angle2 = 180
-        core_thickness = 2
 
+        radius_core_inner = joint.radius_rider - self.child_core_thickness
         core_profile1 = (
             Cq.Sketch()
             .arc((0, 0), joint.radius_rider, core_start_angle, core_end_angle1-core_start_angle)
             .segment((0, 0))
             .close()
             .assemble()
-            .circle(joint.radius_rider - core_thickness, mode='s')
+            .circle(radius_core_inner, mode='s')
         )
         core_profile2 = (
             Cq.Sketch()
@@ -110,7 +131,7 @@ class ShoulderJoint(Model):
             .segment((0, 0))
             .close()
             .assemble()
-            .circle(joint.radius_rider - core_thickness, mode='s')
+            .circle(radius_core_inner, mode='s')
         )
         core = (
             Cq.Workplane('XY')
@@ -123,33 +144,24 @@ class ShoulderJoint(Model):
             .extrude(dh * 2)
             .translate(Cq.Vector(0, 0, -dh))
         )
-        # Create the upper and lower lips
+        assert self.child_lip_width / 2 <= joint.radius_rider
         lip_thickness = joint.rider_disk_height
-        lip_ext = 40 + joint.radius_rider
-        assert lip_height / 2 <= joint.radius_rider
-        lip = (
-            Cq.Workplane('XY')
-            .box(lip_ext, lip_height, lip_thickness,
-                 centered=(False, True, False))
-            .copyWorkplane(Cq.Workplane('XY'))
-            .cylinder(radius=joint.radius_rider, height=lip_thickness,
-                      centered=(True, True, False),
-                      combine='cut')
-            .faces(">Z")
-            .workplane()
+        lip = box_with_centre_holes(
+            length=self.child_lip_length,
+            width=self.child_lip_width,
+            height=lip_thickness,
+            hole_loc=self.child_conn_hole_pos,
+            hole_diam=self.child_conn_hole_diam,
+        )
+        lip = (
+            lip
+            .copyWorkplane(Cq.Workplane('XY'))
+            .cylinder(
+                radius=joint.radius_rider,
+                height=lip_thickness,
+                centered=(True, True, False),
+                combine='cut')
         )
-        hole_x = lip_ext - hole_dist / 2
-        for i in range(2):
-            x = hole_x - i * hole_dist
-            lip = lip.moveTo(x, 0).hole(spacer_hole_diam)
-        for i in range(2):
-            x = hole_x - i * hole_dist
-            (
-                lip
-                .moveTo(x, 0)
-                .tagPlane(f"conn{1 - i}")
-            )
-
         loc_rotate = Cq.Location((0, 0, 0), (1, 0, 0), 180)
         result = (
             Cq.Assembly()
@@ -167,18 +179,12 @@ class ShoulderJoint(Model):
 
     @assembly()
     def assembly(self,
-                 wing_root_wall_thickness: float = 5.0,
-                 lip_height: float = 5.0,
-                 hole_dist: float = 10.0,
-                 spacer_hole_diam: float = 8.0
+                 wing_root_wall_thickness: float = 25.4/16,
                  ) -> Cq.Assembly:
         directrix = 0
         result = (
             Cq.Assembly()
-            .add(self.child(lip_height=lip_height,
-                            hole_dist=hole_dist,
-                            spacer_hole_diam=spacer_hole_diam),
-                 name="child",
+            .add(self.child(), name="child",
                  color=Role.CHILD.color)
             .constrain("child/core", "Fixed")
             .add(self.torsion_joint.spring(), name="spring_top",
@@ -194,12 +200,12 @@ class ShoulderJoint(Model):
         )
         TorsionJoint.add_constraints(result,
                                      rider="child/rider_top",
-                                     track="parent_top",
+                                     track="parent_top/track",
                                      spring="spring_top",
                                      directrix=directrix)
         TorsionJoint.add_constraints(result,
                                      rider="child/rider_bot",
-                                     track="parent_bot",
+                                     track="parent_bot/track",
                                      spring="spring_bot",
                                      directrix=directrix)
         return result.solve()
@@ -565,15 +571,31 @@ class ElbowJoint:
         assert self.disk_joint.movement_angle < self.parent_arm_angle < 360 - self.parent_arm_span
         assert self.parent_binding_hole_radius - self.hole_diam / 2 > self.disk_joint.radius_housing
 
+    def child_hole_pos(self) -> list[float]:
+        """
+        List of hole positions measured from axle
+        """
+        dx = self.child_beam.hole_dist / 2
+        r = self.child_arm_radius
+        return [r - dx, r + dx]
+    def parent_hole_pos(self) -> list[float]:
+        """
+        List of hole positions measured from axle
+        """
+        dx = self.parent_beam.hole_dist / 2
+        r = self.parent_arm_radius
+        return [r - dx, r + dx]
+
     def child_joint(self) -> Cq.Assembly:
         angle = -self.disk_joint.tongue_span / 2
         dz = self.disk_joint.disk_thickness / 2
         # We need to ensure the disk is on the "other" side so
-        flip = Cq.Location((0, 0, 0), (0, 0, 1), 180)
+        flip_x = Cq.Location((0, 0, 0), (1, 0, 0), 180)
+        flip_z = Cq.Location((0, 0, 0), (0, 0, 1), 180)
         result = (
             self.child_beam.beam()
             .add(self.disk_joint.disk(), name="disk",
-                 loc=flip * Cq.Location((-self.child_arm_radius, 0, -dz), (0, 0, 1), angle))
+                 loc=flip_x * flip_z * Cq.Location((-self.child_arm_radius, 0, -dz), (0, 0, 1), angle))
             #.constrain("disk", "Fixed")
             #.constrain("top", "Fixed")
             #.constrain("bot", "Fixed")
diff --git a/nhf/touhou/houjuu_nue/wing.py b/nhf/touhou/houjuu_nue/wing.py
index 46fd676..b832dff 100644
--- a/nhf/touhou/houjuu_nue/wing.py
+++ b/nhf/touhou/houjuu_nue/wing.py
@@ -4,341 +4,46 @@ This file describes the shapes of the wing shells. The joints are defined in
 """
 import math
 from enum import Enum
-from dataclasses import dataclass
-from typing import Mapping, Tuple
+from dataclasses import dataclass, field
+from typing import Mapping, Tuple, Optional
 import cadquery as Cq
 from nhf import Material, Role
+from nhf.build import Model, target, assembly
+from nhf.parts.box import box_with_centre_holes, MountingBox, Hole
 from nhf.parts.joints import HirthJoint
+from nhf.touhou.houjuu_nue.joints import ShoulderJoint, ElbowJoint
 import nhf.utils
 
-
-def wing_root_profiles(
-        base_sweep=150,
-        wall_thickness=8,
-        base_radius=40,
-        middle_offset=30,
-        middle_height=80,
-        conn_thickness=40,
-        conn_height=100) -> tuple[Cq.Wire, Cq.Wire]:
-    assert base_sweep < 180
-    assert middle_offset > 0
-    theta = math.pi * base_sweep / 180
-    c, s = math.cos(theta), math.sin(theta)
-    c_1, s_1 = math.cos(theta * 0.75), math.sin(theta * 0.75)
-    c_2, s_2 = math.cos(theta / 2), math.sin(theta / 2)
-    r1 = base_radius
-    r2 = base_radius - wall_thickness
-    base = (
-        Cq.Sketch()
-        .arc(
-            (c * r1, s * r1),
-            (c_1 * r1, s_1 * r1),
-            (c_2 * r1, s_2 * r1),
-        )
-        .arc(
-            (c_2 * r1, s_2 * r1),
-            (r1, 0),
-            (c_2 * r1, -s_2 * r1),
-        )
-        .arc(
-            (c_2 * r1, -s_2 * r1),
-            (c_1 * r1, -s_1 * r1),
-            (c * r1, -s * r1),
-        )
-        .segment(
-            (c * r1, -s * r1),
-            (c * r2, -s * r2),
-        )
-        .arc(
-            (c * r2, -s * r2),
-            (c_1 * r2, -s_1 * r2),
-            (c_2 * r2, -s_2 * r2),
-        )
-        .arc(
-            (c_2 * r2, -s_2 * r2),
-            (r2, 0),
-            (c_2 * r2, s_2 * r2),
-        )
-        .arc(
-            (c_2 * r2, s_2 * r2),
-            (c_1 * r2, s_1 * r2),
-            (c * r2, s * r2),
-        )
-        .segment(
-            (c * r2, s * r2),
-            (c * r1, s * r1),
-        )
-        .assemble(tag="wire")
-        .wires().val()
-    )
-    assert isinstance(base, Cq.Wire)
-
-    # The interior sweep is given by theta, but the exterior sweep exceeds the
-    # interior sweep so the wall does not become thinner towards the edges.
-    # If the exterior sweep is theta', it has to satisfy
-    #
-    # sin(theta) * r2 + wall_thickness = sin(theta') * r1
-    x, y = conn_thickness / 2, middle_height / 2
-    t = wall_thickness
-    dx = middle_offset
-    middle = (
-        Cq.Sketch()
-        # Interior arc, top point
-        .arc(
-            (x - t, y - t),
-            (x - t + dx, 0),
-            (x - t, -y + t),
-        )
-        .segment(
-            (x - t, -y + t),
-            (-x, -y+t)
-        )
-        .segment((-x, -y))
-        .segment((x, -y))
-        # Outer arc, bottom point
-        .arc(
-            (x, -y),
-            (x + dx, 0),
-            (x, y),
-        )
-        .segment(
-            (x, y),
-            (-x, y)
-        )
-        .segment((-x, y-t))
-        #.segment((x2, a))
-        .close()
-        .assemble(tag="wire")
-        .wires().val()
-    )
-    assert isinstance(middle, Cq.Wire)
-
-    x, y = conn_thickness / 2, conn_height / 2
-    t = wall_thickness
-    tip = (
-        Cq.Sketch()
-        .segment((-x, y), (x, y))
-        .segment((x, -y))
-        .segment((-x, -y))
-        .segment((-x, -y+t))
-        .segment((x-t, -y+t))
-        .segment((x-t, y-t))
-        .segment((-x, y-t))
-        .close()
-        .assemble(tag="wire")
-        .wires().val()
-    )
-    return base, middle, tip
-
-
-def wing_root(joint: HirthJoint,
-              bolt_diam: int = 12,
-              union_tol=1e-4,
-              shoulder_attach_diam=8,
-              shoulder_attach_dist=25,
-              conn_thickness=40,
-              conn_height=100,
-              wall_thickness=8) -> Cq.Assembly:
-    """
-    Generate the contiguous components of the root wing segment
-    """
-    tip_centre = Cq.Vector((-150, 0, -80))
-    attach_theta = math.radians(5)
-    c, s = math.cos(attach_theta), math.sin(attach_theta)
-    attach_points = [
-        (15, 4),
-        (15 + shoulder_attach_dist * c, 4 + shoulder_attach_dist * s),
-    ]
-    root_profile, middle_profile, tip_profile = wing_root_profiles(
-        conn_thickness=conn_thickness,
-        conn_height=conn_height,
-        wall_thickness=8,
-    )
-    middle_profile = middle_profile.located(Cq.Location(
-        (-40, 0, -40), (0, 1, 0), 30
-    ))
-    antetip_profile = tip_profile.located(Cq.Location(
-        (-95, 0, -75), (0, 1, 0), 60
-    ))
-    tip_profile = tip_profile.located(Cq.Location(
-        tip_centre, (0, 1, 0), 90
-    ))
-    profiles = [
-        root_profile,
-        middle_profile,
-        antetip_profile,
-        tip_profile,
-    ]
-    result = None
-    for p1, p2 in zip(profiles[:-1], profiles[1:]):
-        seg = (
-            Cq.Workplane('XY')
-            .add(p1)
-            .toPending()
-            .workplane() # This call is necessary
-            .add(p2)
-            .toPending()
-            .loft()
-        )
-        if result:
-            result = result.union(seg, tol=union_tol)
-        else:
-            result = seg
-    result = (
-        result
-        # Create connector holes
-        .copyWorkplane(
-            Cq.Workplane('bottom', origin=tip_centre + Cq.Vector((0, -50, 0)))
-        )
-        .pushPoints(attach_points)
-        .hole(shoulder_attach_diam)
-    )
-    # Generate attach point tags
-
-    for sign in [False, True]:
-        y = conn_height / 2 - wall_thickness
-        side = "bottom" if sign else "top"
-        y = -y if sign else y
-        plane = (
-            result
-            # Create connector holes
-            .copyWorkplane(
-                Cq.Workplane(side, origin=tip_centre +
-                             Cq.Vector((0, y, 0)))
-            )
-        )
-        if side == "bottom":
-            side = "bot"
-        for i, (px, py) in enumerate(attach_points):
-            tag = f"conn_{side}{i}"
-            plane.moveTo(px, -py if side == "top" else py).tagPlane(tag, "-Z")
-
-    result.faces("<Z").tag("base")
-    result.faces(">X").tag("conn")
-
-    j = (
-        joint.generate(is_mated=True)
-        .faces("<Z")
-        .hole(bolt_diam)
-    )
-
-    color = Material.PLASTIC_PLA.color
-    result = (
-        Cq.Assembly()
-        .add(result, name="scaffold", color=color)
-        .add(j, name="joint", color=Role.CHILD.color,
-             loc=Cq.Location((0, 0, -joint.total_height)))
-    )
-    return result
-
 @dataclass
-class WingRoot:
-    """
-    Generator for the wing root profile and model
-    """
+class WingProfile(Model):
+
+    name: str = "wing"
+
+    base_joint: HirthJoint = field(default_factory=lambda: HirthJoint())
+    root_width: float = 80.0
+    hs_joint_corner_dx: float = 30.0
+    hs_joint_corner_hole_diam: float = 6.0
 
     panel_thickness: float = 25.4 / 16
     spacer_thickness: float = 25.4 / 8
-    height: float = 100.0
+
+    shoulder_joint: ShoulderJoint = field(default_factory=lambda: ShoulderJoint())
     shoulder_width: float = 30.0
-    root_width: float = 80.0
+    shoulder_tip_x: float = -200.0
+    shoulder_tip_y: float = 160.0
 
-    tip_x: float = -200.0
-    tip_y: float = 160.0
-
-    def outer_spline(self) -> list[Tuple[float, float]]:
-        """
-        Generate outer wing shape spline
-        """
-
-    def profile(self) -> Cq.Sketch:
-        sketch = (
-            Cq.Sketch()
-            .segment((-self.root_width, 0), (0, 0))
-            .spline([
-                (0, 0),
-                (-30.0, 80.0),
-                (self.tip_x, self.tip_y)
-            ])
-            .segment(
-                (self.tip_x, self.tip_y),
-                (self.tip_x, self.tip_y - self.shoulder_width)
-            )
-            .segment(
-                (self.tip_x, self.tip_y - self.shoulder_width),
-                (-self.root_width, 0)
-            )
-            .assemble()
-        )
-        return sketch
-
-    def spacer(self) -> Cq.Workplane:
-        """
-        Creates a rectangular spacer. This could be cut from acrylic.
-
-        There are two holes on the top of the spacer. With the holes
-        """
-        length = self.height
-        width = 10.0
-        h = self.spacer_thickness
-        result = (
-            Cq.Workplane('XY')
-            .sketch()
-            .rect(length, width)
-            .finalize()
-            .extrude(h)
-        )
-        # Tag the mating surfaces to be glued
-        result.faces("<X").workplane().tagPlane("left")
-        result.faces(">X").workplane().tagPlane("right")
-
-        # Tag the directrix
-        result.faces(">Z").tag("dir")
-        return result
-
-    def surface(self, top: bool = False) -> Cq.Workplane:
-        tags = [
-            ("shoulder", (self.tip_x, self.tip_y + 30), 0),
-            ("base", (-self.root_width,  0), 90),
-        ]
-        return nhf.utils.extrude_with_markers(
-            self.profile(),
-            self.panel_thickness,
-            tags,
-            reverse=not top,
-        )
-
-    def assembly(self) -> Cq.Assembly:
-        result = (
-            Cq.Assembly()
-            .add(self.surface(top=True), name="bot")
-            .add(self.surface(top=False), name="top")
-            .constrain("bot@faces@>Z", "top@faces@<Z", "Point",
-                       param=self.height)
-        )
-        for t in ["shoulder", "base"]:
-            name = f"{t}_spacer"
-            (
-                result
-                .add(self.spacer(), name=name)
-                .constrain(f"{name}?left", f"bot?{t}", "Plane")
-                .constrain(f"{name}?right", f"top?{t}", "Plane")
-                .constrain(f"{name}?dir", f"top?{t}_dir", "Axis")
-            )
-        return result.solve()
-
-
-@dataclass
-class WingProfile:
-
-    shoulder_height: float = 100
+    s1_thickness: float = 25.0
 
+    elbow_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint())
     elbow_height: float = 100
     elbow_x: float = 240
     elbow_y: float = 30
     # Tilt of elbow w.r.t. shoulder
     elbow_angle: float = 20
 
+    s2_thickness: float = 25.0
+
+    wrist_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint())
     wrist_height: float = 70
     # Bottom point of the wrist
     wrist_x: float = 400
@@ -347,6 +52,8 @@ class WingProfile:
     # Tile of wrist w.r.t. shoulder
     wrist_angle: float = 40
 
+    s3_thickness: float = 25.0
+
     # Extends from the wrist to the tip of the arrow
     arrow_height: float = 300
     arrow_angle: float = 7
@@ -356,7 +63,11 @@ class WingProfile:
     ring_y: float = 20
     ring_radius_inner: float = 22
 
+    material_panel: Material = Material.ACRYLIC_TRANSPARENT
+    material_bracket: Material = Material.ACRYLIC_TRANSPARENT
+
     def __post_init__(self):
+        super().__init__(name=self.name)
         assert self.ring_radius > self.ring_radius_inner
 
         self.elbow_theta = math.radians(self.elbow_angle)
@@ -377,6 +88,145 @@ class WingProfile:
         self.ring_abs_x = self.wrist_top_x + self.wrist_c * self.ring_x - self.wrist_s * self.ring_y
         self.ring_abs_y = self.wrist_top_y + self.wrist_s * self.ring_x + self.wrist_c * self.ring_y
 
+    @property
+    def root_height(self) -> float:
+        return self.shoulder_joint.height
+
+    def profile_s0(self) -> Cq.Sketch:
+        tip_x = self.shoulder_tip_x
+        tip_y = self.shoulder_tip_y
+        sketch = (
+            Cq.Sketch()
+            .segment((-self.root_width, 0), (0, 0))
+            .spline([
+                (0, 0),
+                (-30.0, 80.0),
+                (tip_x, tip_y)
+            ])
+            .segment(
+                (tip_x, tip_y),
+                (tip_x, tip_y - self.shoulder_width)
+            )
+            .segment(
+                (tip_x, tip_y - self.shoulder_width),
+                (-self.root_width, 0)
+            )
+            .assemble()
+        )
+        return sketch
+
+    def spacer_s0_shoulder(self) -> MountingBox:
+        """
+        Should be cut
+        """
+        holes = [
+            hole
+            for i, x in enumerate(self.shoulder_joint.parent_conn_hole_pos)
+            for hole in [
+                Hole(x=x, tag=f"conn_top{i}"),
+                Hole(x=-x, tag=f"conn_bot{i}"),
+            ]
+        ]
+        return MountingBox(
+            length=self.shoulder_joint.height,
+            width=self.shoulder_width,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.shoulder_joint.parent_conn_hole_diam,
+            centred=(True, True),
+        )
+    def spacer_s0_base(self) -> MountingBox:
+        """
+        Should be cut
+        """
+        dx = self.hs_joint_corner_dx
+        holes = [
+            Hole(x=-dx, y=-dx),
+            Hole(x=dx, y=-dx),
+            Hole(x=dx, y=dx),
+            Hole(x=-dx, y=dx),
+        ]
+        return MountingBox(
+            length=self.root_height,
+            width=self.root_width,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.hs_joint_corner_hole_diam,
+            centred=(True, True),
+        )
+
+    def surface_s0(self, top: bool = False) -> Cq.Workplane:
+        tags = [
+            ("shoulder", (self.shoulder_tip_x, self.shoulder_tip_y - self.shoulder_width), 0),
+            ("base", (0,  0), 90),
+        ]
+        return nhf.utils.extrude_with_markers(
+            self.profile_s0(),
+            self.panel_thickness,
+            tags,
+            reverse=not top,
+        )
+
+    def assembly_s0(self) -> Cq.Assembly:
+        result = (
+            Cq.Assembly()
+            .add(self.surface_s0(top=True), name="bot", color=self.material_panel.color)
+            .add(self.surface_s0(top=False), name="top", color=self.material_panel.color)
+            .constrain("bot@faces@>Z", "top@faces@<Z", "Point",
+                       param=self.shoulder_joint.height)
+        )
+        for o, tag in [
+                (self.spacer_s0_shoulder().generate(), "shoulder"),
+                (self.spacer_s0_base().generate(), "base")
+        ]:
+            (
+                result
+                .add(o, name=tag, color=self.material_bracket.color)
+                .constrain(f"{tag}?bot", f"bot?{tag}", "Plane")
+                .constrain(f"{tag}?top", f"top?{tag}", "Plane")
+                .constrain(f"{tag}?dir", f"top?{tag}_dir", "Axis")
+            )
+        hirth = self.base_joint.generate()
+        (
+            result
+            .add(hirth, name="hs", color=Role.CHILD.color)
+            .constrain("hs@faces@<Z", "base?dir", "Plane")
+        )
+        return result.solve()
+
+
+    ### s1, s2, s3 ###
+
+    def _assembly_insert_spacer(
+            self,
+            a: Cq.Assembly,
+            spacer: Cq.Workplane,
+            point_tag: str,
+            front_tag: str = "front",
+            back_tag: str = "back",
+            flipped: bool = False,
+            ):
+        """
+        For a child joint facing up, front panel should be on the right, back
+        panel on the left
+        """
+        site_front, site_back = "right", "left"
+        if flipped:
+            site_front, site_back = site_back, site_front
+        angle = 0
+        (
+            a
+            .add(spacer,
+                 name=point_tag,
+                 color=self.material_bracket.color)
+            .constrain(f"{front_tag}?{point_tag}",
+                       f"{point_tag}?{site_front}", "Plane")
+            .constrain(f"{back_tag}?{point_tag}",
+                       f"{point_tag}?{site_back}", "Plane")
+            .constrain(f"{point_tag}?dir", f"{front_tag}?{point_tag}_dir",
+                       "Axis", param=angle)
+        )
+
     @property
     def ring_radius(self) -> float:
         dx = self.ring_x
@@ -401,10 +251,10 @@ class WingProfile:
             Cq.Sketch()
             .segment(
                 (0, 0),
-                (0, self.shoulder_height),
+                (0, self.shoulder_joint.height),
                 tag="shoulder")
             .arc(
-                (0, self.shoulder_height),
+                (0, self.shoulder_joint.height),
                 (self.elbow_top_x, self.elbow_top_y),
                 (self.wrist_top_x, self.wrist_top_y),
                 tag="s1_top")
@@ -475,31 +325,74 @@ class WingProfile:
         )
         return profile
     def surface_s1(self,
-                   thickness: float = 25.4/16,
-                   shoulder_mount_inset: float = 20,
-                   shoulder_joint_child_height: float = 80,
-                   elbow_mount_inset: float = 20,
-                   elbow_joint_parent_height: float = 60,
+                   shoulder_mount_inset: float = 0,
+                   elbow_mount_inset: float = 0,
                    front: bool = True) -> Cq.Workplane:
-        assert shoulder_joint_child_height < self.shoulder_height
-        assert elbow_joint_parent_height < self.elbow_height
-        h = (self.shoulder_height - shoulder_joint_child_height) / 2
+        shoulder_h = self.shoulder_joint.child_height
+        h = (self.shoulder_joint.height - shoulder_h) / 2
         tags_shoulder = [
             ("shoulder_bot", (shoulder_mount_inset, h), 90),
-            ("shoulder_top", (shoulder_mount_inset, h + shoulder_joint_child_height), 270),
+            ("shoulder_top", (shoulder_mount_inset, h + shoulder_h), 270),
         ]
-        h = (self.elbow_height - elbow_joint_parent_height) / 2
+        elbow_h = self.elbow_joint.parent_beam.total_height
+        h = (self.elbow_height - elbow_h) / 2
         tags_elbow = [
             ("elbow_bot",
              self.elbow_to_abs(-elbow_mount_inset, h),
              self.elbow_angle + 90),
             ("elbow_top",
-             self.elbow_to_abs(-elbow_mount_inset, h + elbow_joint_parent_height),
+             self.elbow_to_abs(-elbow_mount_inset, h + elbow_h),
              self.elbow_angle + 270),
         ]
         profile = self.profile_s1()
         tags = tags_shoulder + tags_elbow
-        return nhf.utils.extrude_with_markers(profile, thickness, tags, reverse=front)
+        return nhf.utils.extrude_with_markers(profile, self.panel_thickness, tags, reverse=front)
+    def spacer_s1_shoulder(self) -> MountingBox:
+        holes = [
+            Hole(x)
+            for x in self.shoulder_joint.child_conn_hole_pos
+        ]
+        return MountingBox(
+            length=50.0, # FIXME: magic
+            width=self.s1_thickness,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.shoulder_joint.child_conn_hole_diam,
+        )
+    def spacer_s1_elbow(self) -> MountingBox:
+        holes = [
+            Hole(x)
+            for x in self.elbow_joint.parent_hole_pos()
+        ]
+        return MountingBox(
+            length=70.0, # FIXME: magic
+            width=self.s1_thickness,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.elbow_joint.hole_diam,
+        )
+    def assembly_s1(self) -> Cq.Assembly:
+        result = (
+            Cq.Assembly()
+            .add(self.surface_s1(front=True), name="front",
+                 color=self.material_panel.color)
+            .constrain("front", "Fixed")
+            .add(self.surface_s1(front=False), name="back",
+                 color=self.material_panel.color)
+            .constrain("front@faces@>Z", "back@faces@<Z", "Point",
+                       param=self.s1_thickness)
+        )
+        for t in ["shoulder_bot", "shoulder_top", "elbow_bot", "elbow_top"]:
+            is_top = t.endswith("_top")
+            is_parent = t.startswith("shoulder")
+            o = self.spacer_s1_shoulder().generate() if is_parent else self.spacer_s1_elbow().generate()
+            self._assembly_insert_spacer(
+                result,
+                o,
+                point_tag=t,
+                flipped=is_top != is_parent,
+            )
+        return result.solve()
 
 
     def profile_s2(self) -> Cq.Sketch:
@@ -513,33 +406,78 @@ class WingProfile:
         return profile
     def surface_s2(self,
                    thickness: float = 25.4/16,
-                   elbow_mount_inset: float = 20,
-                   elbow_joint_child_height: float = 80,
-                   wrist_mount_inset: float = 20,
-                   wrist_joint_parent_height: float = 60,
+                   elbow_mount_inset: float = 0,
+                   wrist_mount_inset: float = 0,
                    front: bool = True) -> Cq.Workplane:
-        assert elbow_joint_child_height < self.elbow_height
-        h = (self.elbow_height - elbow_joint_child_height) / 2
+        elbow_h = self.elbow_joint.child_beam.total_height
+        h = (self.elbow_height - elbow_h) / 2
         tags_elbow = [
             ("elbow_bot",
              self.elbow_to_abs(elbow_mount_inset, h),
              self.elbow_angle + 90),
             ("elbow_top",
-             self.elbow_to_abs(elbow_mount_inset, h + elbow_joint_child_height),
+             self.elbow_to_abs(elbow_mount_inset, h + elbow_h),
              self.elbow_angle - 90),
         ]
-        h = (self.wrist_height - wrist_joint_parent_height) / 2
+        wrist_h = self.wrist_joint.parent_beam.total_height
+        h = (self.wrist_height - wrist_h) / 2
         tags_wrist = [
             ("wrist_bot",
              self.wrist_to_abs(-wrist_mount_inset, h),
              self.wrist_angle + 90),
             ("wrist_top",
-             self.wrist_to_abs(-wrist_mount_inset, h + wrist_joint_parent_height),
+             self.wrist_to_abs(-wrist_mount_inset, h + wrist_h),
              self.wrist_angle - 90),
         ]
         profile = self.profile_s2()
         tags = tags_elbow + tags_wrist
         return nhf.utils.extrude_with_markers(profile, thickness, tags, reverse=front)
+    def spacer_s2_elbow(self) -> MountingBox:
+        holes = [
+            Hole(x)
+            for x in self.elbow_joint.child_hole_pos()
+        ]
+        return MountingBox(
+            length=50.0, # FIXME: magic
+            width=self.s2_thickness,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.elbow_joint.hole_diam,
+        )
+    def spacer_s2_wrist(self) -> MountingBox:
+        holes = [
+            Hole(x)
+            for x in self.wrist_joint.parent_hole_pos()
+        ]
+        return MountingBox(
+            length=70.0, # FIXME: magic
+            width=self.s1_thickness,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.wrist_joint.hole_diam,
+        )
+    def assembly_s2(self) -> Cq.Assembly:
+        result = (
+            Cq.Assembly()
+            .add(self.surface_s2(front=True), name="front",
+                 color=self.material_panel.color)
+            .constrain("front", "Fixed")
+            .add(self.surface_s2(front=False), name="back",
+                 color=self.material_panel.color)
+            .constrain("front@faces@>Z", "back@faces@<Z", "Point",
+                       param=self.s1_thickness)
+        )
+        for t in ["elbow_bot", "elbow_top", "wrist_bot", "wrist_top"]:
+            is_top = t.endswith("_top")
+            is_parent = t.startswith("elbow")
+            o = self.spacer_s2_elbow() if is_parent else self.spacer_s2_wrist()
+            self._assembly_insert_spacer(
+                result,
+                o.generate(),
+                point_tag=t,
+                flipped=is_top != is_parent,
+            )
+        return result.solve()
 
     def profile_s3(self) -> Cq.Sketch:
         profile = (
@@ -549,61 +487,127 @@ class WingProfile:
         )
         return profile
     def surface_s3(self,
-                   thickness: float = 25.4/16,
-                   wrist_mount_inset: float = 20,
-                   wrist_joint_child_height: float = 80,
                    front: bool = True) -> Cq.Workplane:
-        assert wrist_joint_child_height < self.wrist_height
-        h = (self.wrist_height - wrist_joint_child_height) / 2
+        wrist_mount_inset = 0
+        wrist_h = self.wrist_joint.child_beam.total_height
+        h = (self.wrist_height - wrist_h) / 2
         tags = [
             ("wrist_bot",
-             self.elbow_to_abs(wrist_mount_inset, h),
-             self.elbow_angle + 90),
+             self.wrist_to_abs(wrist_mount_inset, h),
+             self.wrist_angle + 90),
             ("wrist_top",
-             self.elbow_to_abs(wrist_mount_inset, h + wrist_joint_child_height),
-             self.elbow_angle - 90),
+             self.wrist_to_abs(wrist_mount_inset, h + wrist_h),
+             self.wrist_angle - 90),
         ]
         profile = self.profile_s3()
-        return nhf.utils.extrude_with_markers(profile, thickness, tags, reverse=front)
-
-
-    def wing_r1s1_profile(self) -> Cq.Sketch:
-        """
-        Generates the first wing segment profile, with the wing root pointing in
-        the positive x axis.
-        """
-
-
-        w = 270
-        # Depression of the wing middle, measured
-        h = 0
-        # spline curve easing extension
-        theta = math.radians(30)
-        c_th, s_th = math.cos(theta), math.sin(theta)
-        bend = 30
-        ext = 40
-        ext_dh = -5
-        assert ext * 2 < w
-
-        factor = 0.7
-
-        result = (
-            Cq.Sketch()
-            .segment((0, 0), (0, self.shoulder_height))
-            .spline([
-                (0, self.shoulder_height),
-                ((w - s_th * self.elbow_height) / 2, self.shoulder_height / 2 + (self.elbow_height * c_th - h) / 2 - bend),
-                (w - s_th * self.elbow_height, self.elbow_height * c_th - h),
-            ])
-            .segment(
-                (w - s_th * self.elbow_height, self.elbow_height * c_th -h),
-                (w, -h),
-            )
-            .spline([
-                (0, 0),
-                (w / 2, -h / 2 - bend),
-                (w, -h),
-            ])
-            .assemble()
+        return nhf.utils.extrude_with_markers(profile, self.panel_thickness, tags, reverse=front)
+    def spacer_s3_wrist(self) -> MountingBox:
+        holes = [
+            Hole(x)
+            for x in self.wrist_joint.child_hole_pos()
+        ]
+        return MountingBox(
+            length=70.0, # FIXME: magic
+            width=self.s1_thickness,
+            thickness=self.spacer_thickness,
+            holes=holes,
+            hole_diam=self.wrist_joint.hole_diam
         )
-        return result
+    def assembly_s3(self) -> Cq.Assembly:
+        result = (
+            Cq.Assembly()
+            .add(self.surface_s3(front=True), name="front",
+                 color=self.material_panel.color)
+            .constrain("front", "Fixed")
+            .add(self.surface_s3(front=False), name="back",
+                 color=self.material_panel.color)
+            .constrain("front@faces@>Z", "back@faces@<Z", "Point",
+                       param=self.s1_thickness)
+        )
+        for t in ["wrist_bot", "wrist_top"]:
+            is_top = t.endswith("_top")
+            is_parent = True
+            o = self.spacer_s3_wrist()
+            self._assembly_insert_spacer(
+                result,
+                o.generate(),
+                point_tag=t,
+                flipped=is_top != is_parent,
+            )
+        return result.solve()
+
+    def assembly(self,
+                 parts: Optional[list[str]] = None
+                 ) -> Cq.Assembly():
+        if parts is None:
+            parts = ["s0", "shoulder", "s1", "elbow", "s2", "wrist", "s3"]
+        result = (
+            Cq.Assembly()
+        )
+        if "s0" in parts:
+            result.add(self.assembly_s0(), name="s0")
+        if "shoulder" in parts:
+            result.add(self.shoulder_joint.assembly(), name="shoulder")
+        if "s0" in parts and "shoulder" in parts:
+            (
+                result
+                .constrain("s0/shoulder?conn_top0", "shoulder/parent_top/lip?conn0", "Plane")
+                .constrain("s0/shoulder?conn_top1", "shoulder/parent_top/lip?conn1", "Plane")
+                .constrain("s0/shoulder?conn_bot0", "shoulder/parent_bot/lip?conn0", "Plane")
+                .constrain("s0/shoulder?conn_bot1", "shoulder/parent_bot/lip?conn1", "Plane")
+            )
+        if "s1" in parts:
+            result.add(self.assembly_s1(), name="s1")
+        if "s1" in parts and "shoulder" in parts:
+            (
+                result
+                .constrain("s1/shoulder_top?conn0", "shoulder/child/lip_top?conn0", "Plane")
+                .constrain("s1/shoulder_top?conn1", "shoulder/child/lip_top?conn1", "Plane")
+                .constrain("s1/shoulder_bot?conn0", "shoulder/child/lip_bot?conn0", "Plane")
+                .constrain("s1/shoulder_bot?conn1", "shoulder/child/lip_bot?conn1", "Plane")
+            )
+        if "elbow" in parts:
+            result.add(self.elbow_joint.assembly(), name="elbow")
+        if "s1" in parts and "elbow" in parts:
+            (
+                result
+                .constrain("s1/elbow_top?conn0", "elbow/parent_upper/top?conn0", "Plane")
+                .constrain("s1/elbow_top?conn1", "elbow/parent_upper/top?conn1", "Plane")
+                .constrain("s1/elbow_bot?conn0", "elbow/parent_upper/bot?conn0", "Plane")
+                .constrain("s1/elbow_bot?conn1", "elbow/parent_upper/bot?conn1", "Plane")
+            )
+        if "s2" in parts:
+            result.add(self.assembly_s2(), name="s2")
+        if "s2" in parts and "elbow" in parts:
+            (
+                result
+                .constrain("s2/elbow_top?conn0", "elbow/child/top?conn0", "Plane")
+                .constrain("s2/elbow_top?conn1", "elbow/child/top?conn1", "Plane")
+                .constrain("s2/elbow_bot?conn0", "elbow/child/bot?conn0", "Plane")
+                .constrain("s2/elbow_bot?conn1", "elbow/child/bot?conn1", "Plane")
+            )
+        if "wrist" in parts:
+            result.add(self.wrist_joint.assembly(), name="wrist")
+        if "s2" in parts and "wrist" in parts:
+            (
+                result
+                .constrain("s2/wrist_top?conn0", "wrist/parent_upper/top?conn0", "Plane")
+                .constrain("s2/wrist_top?conn1", "wrist/parent_upper/top?conn1", "Plane")
+                .constrain("s2/wrist_bot?conn0", "wrist/parent_upper/bot?conn0", "Plane")
+                .constrain("s2/wrist_bot?conn1", "wrist/parent_upper/bot?conn1", "Plane")
+            )
+        if "s3" in parts:
+            result.add(self.assembly_s3(), name="s3")
+        if "s3" in parts and "wrist" in parts:
+            (
+                result
+                .constrain("s3/wrist_top?conn0", "wrist/child/top?conn0", "Plane")
+                .constrain("s3/wrist_top?conn1", "wrist/child/top?conn1", "Plane")
+                .constrain("s3/wrist_bot?conn0", "wrist/child/bot?conn0", "Plane")
+                .constrain("s3/wrist_bot?conn1", "wrist/child/bot?conn1", "Plane")
+            )
+
+        return result.solve()
+
+
+