### Complete ESP OLED Sensor Box Assembly (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

An example demonstrating the integration of multiple JL_SCAD modules to create a complete enclosure for an ESP32-based project. This example includes mounting for a D1 Mini, DHT22 sensor, and a Grove OLED display, along with features like screw clamps, wall mounting, and ventilation slots.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>
include <jl_scad/utils.scad>

$fs = $preview ? 0.5 : 0.25;
$fa = 1;
$slop = 0.1;

pc_pad = 1;
sensor_ofs = -12;
box_sz = [82, 46, 19];

box_make(print=true, explode=0.1)
box_shell_base_lid(box_sz, rsides=4, rtop_inside=1, rbot_inside=1,
                   rtop=1, wall_sides=1.6, base_height=4, rim_height=5)
{
    // Mount D1 Mini microcontroller
    M(pcb_pad, pcb_pad) position(FRONT + LEFT)
        d1mini(anchor=FRONT + LEFT);

    // Mount DHT22 sensor on the right side
    X(sensor_ofs) {
        position(RIGHT) dht22();

        // Isolating wall between sensor and electronics
        X(-8 - 3) {
            box_part(CENTER, RIGHT)
                box_wall(width=5, gap=0.1, anchor=BOTTOM + RIGHT);
            M(0.5, 3, $box_half_height) box_part(BOT, RIGHT + FRONT)
                box_cut() cube([6, 4, 4], anchor=TOP + RIGHT + FRONT);
        }
    }

    // Mount OLED display in center
    position(CENTER) grove_oled_066();

    // Screw clamps at corners
    for(a = [BACK + LEFT, FRONT + RIGHT])
        M(a * -0.5) position(a)
            box_screw_clamp(anchor=a, gap=0.1);

    // Wall mounting keyhole
    Y(-3) box_part(BOT, BACK)
        box_cutout(keyhole(3.5, 7.5), anchor=BACK);

    // Ventilation slots at corners
    box_cut()
        box_part(TOP, [BACK + LEFT, FRONT + LEFT, BACK + RIGHT, FRONT + RIGHT])
            X(sensor_ofs * $box_anchor.x) xcopies(3.5, 5)
                cuboid([1.5, 4, 15], rounding=0.75, anchor=CENTER);
}
```

--------------------------------

### Basic Box Creation with JL_SCAD

Source: https://github.com/lijon/jl_scad/blob/main/README.md

Demonstrates the fundamental usage of JL_SCAD to create a simple box enclosure with a cube as a component. It includes necessary includes and shows how to place a part on the base of the box.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=30)
box_shell_base_lid([20,20,20])
{
    box_part(BOT, CENTER) cube(5,anchor=BOTTOM); // add a cube in the center of the base.
}
```

--------------------------------

### Previewing Geometry with JL_SCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Shows how to use the `box_preview()` function in JL_SCAD to visualize component fit and clearances without affecting the final STL output. This aids in design validation.

```openscad
include <JL_SCAD/JL_SCAD.scad>

$slop = 0.15;

box_make( "BoxWithPreview" ) {
    box_shell_base_lid( "base", "lid" ) {
        // Add components as usual
        box_part( "internal_component", "base", [0, 0, 5] ) {
            cube([20, 20, 10]);
        }
    }
    
    // Preview the internal component within the base
    box_preview( "internal_component", "base" );
}
```

--------------------------------

### Display Preview Geometry with box_preview (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

The `box_preview` module allows for the visualization of geometry that will not be part of the final render, such as PCBs or components. It takes a color string as an argument and wraps the geometry to be previewed. This is useful for checking fit and placement during the design process.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=20)
box_shell_base_lid([60, 40, 25])
{
    // Preview a battery with custom color
    box_part(BOT, LEFT)
        box_preview("#aaa8")
            cuboid([45, 25, 17], rounding=2, anchor=BOTTOM + LEFT);

    // Preview a PCB
    box_part(BOT, CENTER)
        box_preview("#44ba")
            cube([30, 20, 1.6], anchor=BOTTOM);

    // Preview LED indicator
    box_part(TOP, FRONT + RIGHT)
        box_preview("#f00a")
            cyl(d=3, h=5, anchor=BOTTOM);
}
```

--------------------------------

### Creating Screw Mounts with JL_SCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Illustrates the use of JL_SCAD's `box_screw_clamp()` to automatically generate matching screw mounting features in both halves of the enclosure. This simplifies assembly.

```openscad
include <JL_SCAD/JL_SCAD.scad>

$slop = 0.15;

box_make( "BoxWithScrewMounts" ) {
    box_shell_base_lid( "base", "lid" ) {
        // Add screw mounts to the base
        box_screw_clamp( "mount1", "base", [10, 10, 0] );
        box_screw_clamp( "mount2", "base", [40, 10, 0] );
        
        // The corresponding mounts in the lid are created automatically
    }
}
```

--------------------------------

### Mount QAPASS 16x2 LCD with qapass_1602a_led (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

Provides a pre-built mounting solution for a QAPASS 16x2 character LCD display. This module includes standoffs and a cutout tailored for the LCD, simplifying its integration into project enclosures. The module is designed for easy placement using standard positioning commands.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([90, 50, 25])
{
    // Mount 16x2 LCD display
    position(CENTER) qapass_1602a_led();
}
```

--------------------------------

### Mount D1 Mini Board with d1mini (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

Provides a pre-built mounting solution for a D1 Mini ESP8266 board. This module includes integrated standoffs and a USB cutout, simplifying the process of incorporating the D1 Mini into a custom enclosure. The `pcb_zofs` parameter allows for vertical adjustment.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([40, 45, 20])
{
    // Mount D1 Mini at front-left corner
    M(1, 1) position(FRONT + LEFT)
        d1mini(pcb_zofs=3, anchor=FRONT + LEFT);
}
```

--------------------------------

### JL_SCAD: Create and Render Box Enclosures with box_make

Source: https://context7.com/lijon/jl_scad/llms.txt

The `box_make` module is the primary entry point for generating box enclosures. It controls the rendering mode (assembled, exploded, or print layout), specifies which box halves to generate, and manages visibility options for the box and its parts. It requires the `jl_scad/box.scad` and `jl_scad/parts.scad` includes.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

// Render all halves with exploded view
box_make(explode=30)
box_shell_base_lid([50, 40, 20])
{
    box_part(BOT, CENTER) cube(5, anchor=BOTTOM);
}

// Render only the bottom half, laid out for printing
box_make(halves=[BOT], print=true)
box_shell_base_lid([50, 40, 20])
{
    box_part(BOT) standoff(h=5);
}

// Full options
box_make(
    halves=BOX_ALL,      // Which halves: BOX_ALL, [BOT], [TOP], [BOT, TOP]
    print=false,         // true=print layout, false=assembled view
    top_pos=BACK,        // Position of top piece in print layout
    explode=30,          // Explode distance in assembled view
    spread=5,            // Spacing in print layout
    hide_box=false,      // Hide the box shell
    hide_parts=false,    // Hide attached parts
    hide_previews=false  // Hide preview elements
)
box_shell_base_lid([80, 60, 30])
{
    // Parts go here
}
```

--------------------------------

### Mount ESP32-WROOM-32 Board with esp32_wroom_32 (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

A pre-built mounting module specifically designed for the ESP32-WROOM-32 development board. It simplifies the integration of this popular microcontroller into enclosures by providing accurate standoffs and positioning. The `pcb_zofs` parameter controls the board's height.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([45, 65, 25])
{
    // Mount ESP32 board
    M(2, 2) position(FRONT + LEFT)
        esp32_wroom_32(pcb_zofs=5, anchor=FRONT + LEFT);
}
```

--------------------------------

### Mount DHT22 Sensor with dht22 (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

A pre-built mounting module for the DHT22 temperature and humidity sensor. This module simplifies the integration of the DHT22 into enclosures by providing appropriate standoffs and a cutout for the sensor. The `depth` parameter can be adjusted.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([30, 35, 20])
{
    // Mount DHT22 sensor
    position(CENTER) dht22(depth=3);
}
```

--------------------------------

### Adding Components with JL_SCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Demonstrates how to add electronic components, such as PCBs or sensors, to an enclosure designed with JL_SCAD. Components are positioned relative to the box.

```openscad
include <JL_SCAD/JL_SCAD.scad>

$slop = 0.15;

box_make( "EnclosureWithParts" ) {
    box_shell_base_lid( "base", "lid" ) {
        // Example: Add a PCB mount
        box_part( "pcb_mount", "base", [0, 0, 10] ) {
            // PCB geometry definition
            cube([50, 30, 2]); 
        }
        
        // Example: Add a sensor cutout
        box_part( "sensor_cutout", "lid", [20, 15, 5] ) {
            // Sensor geometry definition
            cylinder(h=5, r=5);
        }
    }
}
```

--------------------------------

### Create Box Snap Fits with OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Designs interlocking snap-fit clips for tool-less assembly of box base and lid. Supports customizable snap dimensions, protrusion depth, spring length and direction, spring slot width, and options for through holes. Also includes parameters for tolerance gap and anchor point.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([50, 50, 20], rim_height=3)
{
    // Snap fits on sides
    up($box_rim_height)
        box_part([LEFT, RIGHT])
            box_snap_fit(
                size=[5, 2],         // Width and depth of snap
                depth=0.6,           // Snap protrusion height
                spring_len=4,        // Length of flexible spring section
                spring_dir=FRONT,    // Direction of spring flex slot
                spring_slot=0.5,     // Width of spring slot
                thru_hole=false,     // Cut through instead of recess
                gap=0.1,             // Tolerance gap
                anchor=BOT + BACK
            );

    // Simple snap fits on all sides (no spring)
    up($box_rim_height / 2)
        box_part([LEFT, RIGHT, FRONT, BACK])
            box_snap_fit(size=[5, 1], depth=0.4, anchor=BOT);
}
```

--------------------------------

### Convenience Wrapper for Positioning Parts - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The box_part function is a convenience wrapper that combines box_half and box_pos, allowing specification of half and side in a single vector. This is the recommended method for placing most parts. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=20)
box_shell_base_lid([60, 50, 25])
{
    // Part in bottom half, centered
    box_part(BOT, CENTER)
        standoff(h=5);

    // Part on front side of bottom half
    box_part(BOT + FRONT, CENTER)
        box_cutout(rect([10, 5]), chamfer=0.5);

    // Part on left side (applies to all halves that have a left)
    box_part(LEFT)
        box_cutout(rect([8, 4]), rounding=0.5);

    // Part at multiple positions
    box_part([TOP + BACK + LEFT, TOP + BACK + RIGHT, TOP + FRONT + LEFT, TOP + FRONT + RIGHT])
        box_hole(3, chamfer=0.5);

    // Part on outside of top
    box_part(TOP, CENTER, inside=false)
        box_cut() text3d("MY BOX", h=0.5, size=6, anchor=BOTTOM);
}
```

--------------------------------

### Create Box Standoff Clamps with OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Creates matching standoffs in the base and lid of a box to clamp a PCB or similar component. The base includes a pin and the lid has a corresponding hole. Allows configuration of height, diameters, pin height, gap for PCB thickness, fillet, and inner hole rounding.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;  // Set tolerance for fit

box_make(explode=25)
box_shell_base_lid([60, 50, 25])
{
    // Single clamp standoff at center
    position(CENTER)
        box_standoff_clamp(h=5, od=5, id=2.25, pin_h=2, gap=1.7, fillet=2);

    // Multiple clamp standoffs for PCB mounting
    position(CENTER)
        grid_copies([45, 35], [2, 2])
            box_standoff_clamp(
                h=5,           // Height of base standoff
                od=5,          // Outer diameter
                id=2.25,       // Inner hole diameter
                pin_h=2,       // Pin height (false to disable)
                gap=1.7,       // Gap for PCB thickness
                fillet=2,      // Base fillet radius
                iround=0.5     // Inner hole rounding
            );
}
```

--------------------------------

### JL_SCAD: Define Box Shell with box_shell_base_lid

Source: https://context7.com/lijon/jl_scad/llms.txt

The `box_shell_base_lid` module constructs a two-piece box shell (base and lid) with customizable features. It allows configuration of wall thicknesses, corner rounding, alignment rims, and optional snap-fit mechanisms. This module is typically used within `box_make` and requires `jl_scad/box.scad` and `jl_scad/parts.scad` includes.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=10)
box_shell_base_lid(
    size=[80, 60, 30],       // Inner dimensions (or outer if walls_outside=false)
    base_height=12,          // Height of base (default: half of total)
    wall_sides=2,            // Side wall thickness
    wall_top=1.5,            // Top wall thickness
    wall_bot=2,              // Bottom wall thickness
    walls_outside=true,      // true=walls added outside size
    rim_height=3,            // Height of alignment rim
    rim_gap=0,               // Gap between rim and lid
    rsides=5,                // Outside corner rounding
    rbot=2,                  // Bottom edge rounding
    rtop=1,                  // Top edge rounding
    rsides_inside=2,         // Inside corner rounding
    rbot_inside=1,           // Inside bottom rounding
    rtop_inside=1,           // Inside top rounding
    k=0.92,                  // Rounding smoothness (0-1)
    rim_snap=true,           // Enable snap ridge on rim
    rim_snap_ofs=1,          // Snap ridge position
    rim_snap_depth=0.2,      // Snap ridge protrusion
    rim_snap_gap=0.1,        // Gap for snap fit tolerance
    rim_snap_height=0.2      // Snap ridge height
)
{
    // Add parts to the box
    box_part(BOT, CENTER) standoff(h=8);
}
```

--------------------------------

### Creating Compound Parts with JL_SCAD

Source: https://github.com/lijon/jl_scad/blob/main/README.md

Illustrates how to define a compound part in JL_SCAD that spans both the base and lid of a box. The `attachable()` module is used to ensure correct positioning and orientation within the enclosure system.

```openscad
module my_compound_part(size, anchor=CENTER, spin=0, orient=UP) {
    inside_height = $parent_size.z;
    attachable(anchor, spin, orient, size=[size.x,size.y,inside_height]) {
        union() {
            box_part(BOT) cube(size, anchor=BOTTOM);
            box_part(TOP) cube([size.x, size.y, inside_height - size.z], anchor=BOTTOM);
        }
        children();
    }
}
```

--------------------------------

### Create Standoffs with OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Generates a cylindrical standoff with optional screw hole and fillet at the base. Supports customization of height, outer diameter, inner diameter, depth, fillet radius, and rounding for inner holes. Can be used to create basic standoffs, those with screw holes, or protruding pins.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([60, 50, 25])
{
    // Basic standoff
    box_part(BOT, FRONT + LEFT)
        standoff(h=8);

    // Standoff with screw hole
    box_part(BOT, FRONT + RIGHT)
        standoff(h=10, od=6, id=2.5, depth=8, fillet=1.5);

    // Standoff with protruding pin (negative depth)
    box_part(BOT, BACK + LEFT)
        standoff(h=5, od=5, id=2, depth=-3, fillet=1);

    // Multiple standoffs at PCB mounting positions
    box_part(BOT, CENTER)
        grid_copies([40, 30], [2, 2])
            standoff(h=6, od=5, id=2.5, depth=5, fillet=1.5, iround=0.5);
}
```

--------------------------------

### Create Box Screw Clamps with OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Generates matching standoffs in the base and lid of a box with a screw hole for fastening. This part is designed for securing box halves together. It allows detailed control over standoff heights, diameters, screw hole sizes, screw head dimensions, gap, fillet, and rounding.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=20)
box_shell_base_lid([70, 50, 30])
{
    // Screw clamps at corners
    for(a = [BACK + LEFT, FRONT + RIGHT, BACK + RIGHT, FRONT + LEFT])
        M(a * -0.5) position(a)
            box_screw_clamp(
                h=2,            // Base standoff height
                od=8,           // Outer diameter
                od2=8,          // Lid standoff outer diameter
                id=3,           // Screw hole diameter
                id2=2.5,        // Lid hole diameter (for self-tapping)
                head_d=6,       // Screw head diameter
                head_depth=3,   // Screw head recess depth
                gap=0.1,        // Gap between base and lid
                fillet=1.5,     // Base fillet
                rounding=0.5,   // Head recess rounding
                anchor=a
            );
}
```

--------------------------------

### JL_SCAD: Control Part Placement with box_half

Source: https://context7.com/lijon/jl_scad/llms.txt

The `box_half` module is used to specify which box half (bottom or top) a part belongs to and whether it should be placed on the inside or outside surface of that half. It is used within the `box_make` context and requires `jl_scad/box.scad` and `jl_scad/parts.scad` includes.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=20)
box_shell_base_lid([50, 40, 20])
{
    // Part only in the bottom half, inside
    box_half(BOT, inside=true)
        box_pos(CENTER)
            standoff(h=5);

    // Part only in the top half, inside
    box_half(TOP, inside=true)
        box_pos(CENTER)
            standoff(h=3);

    // Part in both halves
    box_half(BOX_ALL)
        box_pos(CENTER, side=LEFT)
            cube([5, 5, 10], anchor=BOTTOM);

    // Part on the outside of the lid
    box_half(TOP, inside=false)
        box_pos(CENTER)
            box_cut() text3d("LABEL", h=0.5, size=5, anchor=BOTTOM);
}
```

--------------------------------

### Mount Grove OLED 0.66" Display with grove_oled_066 (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

This module provides a pre-built mounting solution for a 0.66-inch Grove OLED display. It includes necessary standoffs and a cutout for the display itself, streamlining the enclosure design process for projects utilizing this small display.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=15)
box_shell_base_lid([35, 35, 20])
{
    // Mount OLED display at center
    position(CENTER) grove_oled_066();
}
```

--------------------------------

### Inspect Model Internals with cut_inspect (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

The `cut_inspect` utility module facilitates design inspection by cutting away a portion of the model. It accepts a face (e.g., `BACK`, `LEFT`) and an optional offset (`ofs`) to define the cutting plane. This is invaluable for examining internal structures without altering the final geometry.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>
include <jl_scad/utils.scad>

// Cut from back to inspect interior
cut_inspect(BACK, ofs=0, s=100, color="#58c7")
box_make(explode=0)
box_shell_base_lid([50, 40, 20])
{
    position(CENTER) box_standoff_clamp();
}

// Cut at specific offset
cut_inspect(LEFT, ofs=-10)
box_make()
box_shell_base_lid([60, 40, 25])
{
    box_part(BOT) standoff(h=8);
}
```

--------------------------------

### Basic Box Structure with JL_SCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Defines the basic structure of an enclosure using JL_SCAD, including the shell and lid. This function sets up the primary container for electronic components.

```openscad
include <JL_SCAD/JL_SCAD.scad>

// Set printer tolerance
$slop = 0.15;

// Define the main box structure
box_make( "MyProjectBox" ) {
    box_shell_base_lid( "base", "lid" ) {
        // Add internal components here
    }
}
```

--------------------------------

### Flip Part Orientation with box_flip (OpenSCAD)

Source: https://context7.com/lijon/jl_scad/llms.txt

The `box_flip` module is used to invert the orientation of a part, making it suitable for compound parts that require different alignments. It's typically used within a `box_make` context to modify the positioning of child elements. The `$slop` variable can be adjusted to control tolerances.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

$slop = 0.1;

box_make(explode=20)
box_shell_base_lid([60, 50, 30])
{
    // Normal screw clamp (screw from bottom)
    position(FRONT + LEFT)
        box_screw_clamp(anchor=FRONT + LEFT);

    // Flipped screw clamp (screw from top)
    position(FRONT + RIGHT)
        box_flip() box_screw_clamp(anchor=FRONT + RIGHT);
}
```

--------------------------------

### Generate Keyhole Path for Mounting - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The keyhole function generates a 2D keyhole path suitable for wall-mounting cutouts. It allows customization of screw shaft diameter, screw head diameter, and corner radius. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=10)
box_shell_base_lid([60, 40, 20])
{
    // Standard keyhole for wall mounting
    box_part(BOT, BACK)
        box_cutout(keyhole(), anchor=BACK);

    // Custom sized keyhole
    // d1=screw shaft diameter, d2=screw head diameter, r=corner radius
    box_part(BOT, BACK + LEFT)
        box_cutout(keyhole(d1=4, d2=8, r=1), anchor=BACK);

    // Multiple keyholes
    box_part(BOT, BACK)
        xcopies(25, 2) box_cutout(keyhole(d1=3.5, d2=7.5), anchor=BACK);
}
```

--------------------------------

### Create Internal Box Walls with OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

Generates an internal dividing wall within a box. Allows specification of wall direction, width, fillet radius, and gap. Can create full-height walls, partial walls with custom length and height, or walls positioned in specific halves of the box for alignment.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([80, 60, 30])
{
    // Full-height wall dividing box front-to-back
    box_part(CENTER, RIGHT)
        box_wall(dir=RIGHT, width=2, fillet=1.5, gap=0.5);

    // Partial wall with custom length
    box_part(BOT, FRONT)
        box_wall(dir=BACK, length=30, width=1.5, height=15, fillet=1);

    // Wall in both halves for alignment
    Y(10) box_part([TOP, BOT], FRONT)
        box_wall(RIGHT, width=1, fillet=1.5, gap=0.5);
}
```

--------------------------------

### Create 2D Cutouts in Box Walls - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The box_cutout function creates a 2D cutout through a box wall from a 2D path, with optional edge rounding or chamfering. It can also specify depth and anchor points. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([70, 50, 30])
{
    // Rectangular cutout with rounded edge
    box_part(TOP, CENTER)
        box_cutout(rect([20, 15]), rounding=1);

    // Rectangular cutout with chamfered edge
    box_part(TOP, BACK + LEFT)
        box_cutout(rect([10, 8], rounding=2), chamfer=0.75);

    // Circular cutout
    box_part(FRONT, CENTER)
        box_cutout(circle(d=12), rounding=0.5);

    // Cutout with extra depth into the box
    box_part(BACK, CENTER)
        box_cutout(rect([15, 10]), depth=3, anchor=CENTER);

    // Custom path cutout (rounded square)
    box_part(LEFT, CENTER)
        box_cutout(rect([8, 8], rounding=1), chamfer=0.5, anchor=CENTER);
}
```

--------------------------------

### Tag Children for Removal (Diff) - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The box_cut function tags child objects for removal from the box using BOSL2's diff() mechanism, suitable for custom 3D cutout shapes. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([60, 50, 30])
{
    // Cut with a custom 3D shape
    box_part(TOP, CENTER)
        box_cut()
            cuboid([15, 10, 10], rounding=2, anchor=BOTTOM);

    // Ventilation slots
    box_part(TOP, BACK)
        xcopies(3, 5) box_cut()
            cuboid([1.5, 8, 8], rounding=0.75, anchor=CENTER);

    // Engraved text
    box_part(TOP, inside=false)
        box_cut()
            text3d("LABEL", h=0.5, size=8, anchor=BOTTOM);

    // Cut a corner for inspection
    box_half(BOX_ALL)
        position(CENTER) box_cut("#58c")
            cube(25, anchor=LEFT + BACK);
}
```

--------------------------------

### Position Parts Relative to Box Anchor - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The box_pos function positions and orients child objects relative to a box anchor point. It automatically adjusts orientation based on the part's facing side. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([60, 40, 25])
{
    // Place standoff at center of bottom
    box_half(BOT)
        box_pos(CENTER)
            standoff(h=8);

    // Place standoff at front-left corner
    box_half(BOT)
        box_pos(FRONT + LEFT)
            standoff(h=5);

    // Place on a specific side with multiple anchors
    box_half(BOT)
        box_pos([FRONT + LEFT, FRONT + RIGHT, BACK + LEFT, BACK + RIGHT], side=BOTTOM)
            standoff(h=6, od=6, id=3);

    // Part oriented toward LEFT side
    box_half(BOT)
        box_pos(CENTER, side=LEFT, spin=0, auto_anchor=true)
            cube([3, 10, 15], anchor=BOTTOM);
}
```

--------------------------------

### Create Circular Holes in Box Walls - OpenSCAD

Source: https://context7.com/lijon/jl_scad/llms.txt

The box_hole function creates a circular hole through a box wall, with options for rounding, chamfering, and a teardrop shape for improved 3D printing. Dependencies include jl_scad/box.scad and jl_scad/parts.scad.

```openscad
include <jl_scad/box.scad>
include <jl_scad/parts.scad>

box_make(explode=15)
box_shell_base_lid([60, 40, 25])
{
    // Simple hole with rounded edge
    box_part(TOP, CENTER)
        box_hole(d=8, rounding=0.5);

    // Hole with chamfered edge
    box_part(FRONT, CENTER)
        box_hole(d=6, chamfer=0.75);

    // Teardrop hole (better for printing horizontal holes)
    box_part(LEFT, CENTER)
        box_hole(d=5, teardrop=true, chamfer=0.5);

    // Multiple holes using xcopies from BOSL2
    box_part(BACK, CENTER)
        xcopies(8, 3) box_hole(d=4, rounding=0.3);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.