bare/claude-opus-4-7 / tier-3-butt-hinge

```openscad
// Small butt hinge - 180° open state
// Pin axis along Y, leaves on Z=0 plane

$fn = 64;

// Parameters
leaf_w = 25;       // leaf width (in X direction from knuckle)
leaf_h = 30;       // leaf height (along Y, hinge axis)
leaf_t = 2;        // leaf thickness
knuckle_od = 8;    // knuckle outer diameter
knuckle_id = 4.6;  // knuckle inner diameter (pin + clearance)
pin_d = 4;         // pin diameter
pin_len = 32;      // pin length
seg = 6;           // each knuckle segment length (30/5)

// Screw hole parameters
screw_through_d = 3.2;
screw_csk_d = 6;
screw_csk_depth = 1;
screw_pitch = 8;

// ---------- Leaf with knuckles ----------
// side: "left" -> x<0, knuckles at segments 0,2,4
// side: "right" -> x>0, knuckles at segments 1,3
module leaf(side="left") {
    sign = (side=="left") ? -1 : 1;
    knuckle_segs = (side=="left") ? [0,2,4] : [1,3];
    
    difference() {
        union() {
            // Flat plate part - extends from knuckle edge outward
            // Plate runs from x = sign * (knuckle_od/2) outward by leaf_w? 
            // Actually leaf is 25mm wide; we connect plate to knuckle.
            // Plate top surface at z = leaf_t/2, bottom at z = -leaf_t/2
            // Plate extends from x near knuckle tangent to x = sign*(leaf_w + something)
            // Let's place plate from x=0 (overlapping knuckle) to x = sign*leaf_w
            if (side=="left") {
                translate([-leaf_w, 0, -leaf_t/2])
                    cube([leaf_w, leaf_h, leaf_t]);
            } else {
                translate([0, 0, -leaf_t/2])
                    cube([leaf_w, leaf_h, leaf_t]);
            }
            
            // Knuckles
            for (i = knuckle_segs) {
                translate([0, i*seg, 0])
                    rotate([-90,0,0])
                        cylinder(d=knuckle_od, h=seg);
            }
        }
        
        // Pin hole through knuckles (full length to be safe)
        translate([0, -1, 0])
            rotate([-90,0,0])
                cylinder(d=knuckle_id, h=leaf_h+2);
        
        // Cut plate where it would overlap knuckle cylinder area on opposite side
        // Remove the half of plate that's under the knuckle on wrong side
        // Plate currently extends from x=0; knuckle is centered at x=0.
        // We want plate to merge cleanly - remove plate portion inside knuckle radius on the opposite side
        if (side=="left") {
            // remove anything with x > 0 (already none, but ensure)
            translate([0, -1, -leaf_t])
                cube([knuckle_od, leaf_h+2, leaf_t*2]);
        } else {
            translate([-knuckle_od, -1, -leaf_t])
                cube([knuckle_od, leaf_h+2, leaf_t*2]);
        }
        
        // Screw holes - 3 holes along Y, centered, at far end of leaf
        // Hole X position: at distance from knuckle, near far edge
        hole_x = sign * (leaf_w - 5);  // 5mm from outer edge
        y_center = leaf_h/2;
        for (i = [-1,0,1]) {
            y = y_center + i*screw_pitch;
            // Through hole
            translate([hole_x, y, -leaf_t-0.1])
                cylinder(d=screw_through_d, h=leaf_t+0.2);
            // Countersink (taper) on top surface
            translate([hole_x, y, leaf_t/2 - screw_csk_depth])
                cylinder(d1=screw_through_d, d2=screw_csk_d, h=screw_csk_depth+0.01);
        }
    }
}

// ---------- Pin ----------
module pin() {
    translate([0, -1, 0])
        rotate([-90,0,0])
            cylinder(d=pin_d, h=pin_len);
}

// ---------- Assembly (180° open) ----------
leaf(side="left");
leaf(side="right");
pin();
```