maker-safety-practices

name	maker-safety-practices
description	Implements makerspace safety protocols with PPE selection by hazard type, machine-specific safe operating procedures (3D printers, laser cutters, CNC, soldering), and emergency response.
license	MIT
compatibility	opencode
metadata	{"version":"1.0.0","domain":"maker","triggers":"maker safety, makerspace safety, 3d printer safety, laser cutter safety, PPE selection, fume extraction, how do i work safely with tools","archetypes":["educational"],"anti_triggers":["brainstorming","vague ideation"],"response_profile":{"verbosity":"low","directive_strength":"high","abstraction_level":"operational"},"role":"implementation","scope":"implementation","output-format":"code","content-types":["code","guidance","config","examples","do-dont"],"related-skills":"rapid-prototyping-workflow, digital-fabrication"}

Maker Safety Practices

Implements comprehensive safety protocols for makerspace operations covering hazard assessment, PPE selection by hazard type, machine-specific safe operating procedures for 3D printers/laser cutters/CNC mills/electronics workstations, electrical safety for power tools and battery handling, fume extraction requirements, and emergency response procedures. Safety is not optional — every operation requires a documented risk assessment before the first tool is touched.

TL;DR Checklist

• Complete hazard assessment: identify ALL hazard types (thermal, mechanical, chemical, electrical, particulate) present in the workspace
• Verify PPE matches each identified hazard: ANSI Z87.1 eye protection, N95/respirator for particulates/chemicals, appropriate gloves
• Confirm emergency stop is accessible and functional — within arm's reach, unobstructed, tested before each session
• Ensure fire extinguisher of correct class (ABC general, D for metal fires) is present and inspected within last 12 months
• Verify fume extraction/ventilation is active and functioning BEFORE starting any operation that generates smoke, fumes, or particulates
• Inspect machine safety features: interlocks on laser cutters, chip guards on CNC, thermal run protection on 3D printers, E-stop wiring intact
• Maintain a 36-inch clear workspace perimeter around every operating machine; no flammable materials within that radius
• Confirm first aid kit is accessible within 30 seconds and contains burn dressings, eye wash solution, and trauma supplies
• Wear NO loose clothing, jewelry, or unrestrained long hair near rotating machinery (CNC mills, drill presses, lathes)
• Never leave an active laser cutter, CNC mill, or soldering station unattended — 3D printers may run unattended ONLY if thermal runaway protection is confirmed active and room ventilation is adequate

---

When to Use

Use this skill when:

• Setting up a new workspace, makerspace bay, or electronics bench before any fabrication begins
• Operating any machine tool (CNC mill, lathe, drill press, saw) for the first time or after maintenance
• Working with materials that generate fumes, smoke, or dust (3D printing ABS, soldering lead-free alloys, cutting composites, sanding wood)
• Handling lithium-polymer (LiPo) batteries for charging, discharging, storage, or disposal
• Performing electrical work involving mains voltage (120V/240V AC) or high-current DC systems
• Conducting soldering operations with any heated tool above 200°C (soldering iron, hot air rework station)
• Preparing for a safety audit or onboarding new makerspace users who need structured safety training
• An incident, near-miss, or unsafe condition has been observed and needs formal documentation

---

When NOT to Use

Avoid this skill for:

• Situations requiring professional safety officer judgment — industrial-scale chemical storage, radiation equipment, high-voltage (>1000V) systems, confined space entry
• Emergency situations already in progress where immediate action is needed — call emergency services (911 or local equivalent) first, then document using this skill's protocols after the situation is controlled
• Legal compliance documentation for regulated industries (medical device manufacturing, aviation maintenance) — these require certified safety programs and licensed professionals

---

Core Workflow

Step 1: Assess Hazard Type

Identify every hazard category present in your operation. A single task may involve multiple hazards simultaneously.

Hazard categories and common sources:

Hazard Type	Sources	Primary Risk
Thermal	Laser cutter optics, soldering iron (300-450°C), 3D printer hot end (200-260°C), heated bed (60-110°C), CNC spindle friction	Burns, fires from ignition of nearby materials, thermal runaway in printers
Mechanical	CNC mill rotating tool, drill press chuck, table saw blade, belt drives, conveyor belts	Lacerations, amputation, eye injury from flying debris, entanglement
Chemical	ABS printer fumes (styrene), solder flux fumes, acetone/Isopropyl alcohol for cleaning, resin printers (uncured photopolymer), spray adhesives	Respiratory irritation, chemical burns, long-term carcinogenic exposure, skin sensitization
Electrical	Mains-powered tools, LiPo batteries (fire/explosion risk), laser tube high voltage (10-30kV DC), soldering station ground loops	Electric shock, electrocution, arc flash burns, LiPo fire and toxic gas release
Particulate	Wood dust from CNC/laser cutting, sanding dust, metal shavings from milling, 3D printer ultrafine particles (UFPs)	Respiratory disease (asthma, silicosis from silica-containing materials), eye irritation, surface contamination

Checkpoint: List ALL hazard categories applicable to your specific task. If you can name only one category, you are under-assessing — every operation has at least two hazards.

---

Step 2: Select Required PPE

Match personal protective equipment to each identified hazard. No single piece of PPE covers all hazards; layer protection appropriately.

Eye and face protection:

Hazard	Required Protection	Standard	Notes
General workshop work (3D printer, soldering bench)	ANSI Z87.1 safety glasses with side shields	ANSI/ANSI Z87.1-2020	Must have "Z87" or "Z87+" etched into lens
CNC milling (flying chips), table saw	Full face shield OVER safety glasses	ANSI Z87.1-2020 + Z87 side shields	Face shield alone is NOT sufficient — secondary eyewear required underneath
Laser cutter operation	Interlock enclosure OR laser-rated goggles matched to wavelength	EN 207/EN 206 or equivalent	Goggles must have optical density rating for specific laser wavelength (e.g., OD5+ at 1064nm for fiber lasers)
Chemical handling (resin, acetone)	Splash-proof safety goggles (sealed)	ANSI Z87.1-2020	Regular safety glasses do NOT prevent splash exposure to eyes

Hand protection:

Hazard	Required Protection	Notes
Chemical handling (resin, acetone, solvents)	Nitrile gloves (minimum 4 mil thickness)	Replace immediately if torn or saturated; latex causes allergic reactions in many people
Sharp edges (laser-cut sheet metal, raw stock)	Cut-resistant gloves (ANSI Level A3+)	Must be removed before approaching any rotating machinery — loose material can get caught
Hot surfaces (removing prints, handling heated parts)	Heat-resistant gloves (Kevlar or leather, rated to task temperature)	Do NOT use fabric work gloves near rotating tools
Electrical work	Class 0 insulated gloves (rated for voltage level)	Must be inspected before each use; rubber inspection certificate required
General workshop tasks	NO GLOVES near CNC mill, lathe, drill press, or any rotating tool	Glove entanglement causes severe finger/hand amputation — this is the #1 rule of machine safety

Respiratory protection:

Exposure	Required Protection	Notes
Wood dust, sanding, general particulates	N95 respirator (NIOSH-approved)	Must fit-seal check performed each wear; replace when breathing becomes difficult or after 8 hours continuous use
Solder fumes, light chemical vapors	Activated carbon mask (respirator with organic vapor cartridge)	P100 + OV combination for best protection against both particulates and organics
ABS printing fumes (styrene), resin vapor, solvent cleaning	Half-face respirator with P100 + OV cartridges	Nuisance masks and cloth masks provide ZERO protection against chemical vapors
Unknown or high-concentration airborne hazards	Supplied-air respirator (SCBA) or immediate evacuation	Do not enter area — call safety officer or emergency services

Hearing protection:

Noise Level	Required Protection	Notes
< 75 dB(A)	None required	Normal conversation level
75–85 dB(A)	Recommended but not mandatory	Long-exposure monitoring recommended
85–100 dB(A)	Earplugs (NRR 25+) or earmuffs	CNC milling, table saws, router tables typically in this range
> 100 dB(A)	Double protection: earplugs + earmuffs	Chain saws, large industrial saws; limit exposure to < 2 hours/day

Checkpoint: Every identified hazard must have a corresponding PPE requirement listed. If a hazard exists without matched PPE, stop and procure the correct protection before proceeding.

---

Step 3: Verify Machine Safety Features

Test all safety mechanisms before beginning any fabrication session. A machine with disabled or broken safety features is as dangerous as no machine at all.

Pre-session safety checklist (repeat for every machine):

Check	Action	Pass Criteria
Emergency stop	Press the E-stop button, verify machine powers down immediately	Machine stops within 1 second of E-stop actuation; must be physically reset to resume operation
E-stop accessibility	Walk from your normal standing position to the E-stop without moving feet	Path is clear, no cables/tools blocking reach, E-stop is clearly visible and colored red on yellow background
Enclosure/interlock (laser)	Open the laser cutter door while a job is running (if safe to test) or verify interlock engages when door opens	Laser tube immediately ceases emission; status indicator changes from "LASER ON" to "LASER OFF"
Ventilation/fume extraction	Verify exhaust fan is running with airflow indicator active; feel for suction at work zone	Airflow gauge shows adequate flow, or paper strip placed near extraction port is drawn toward it
Machine guards (CNC)	Inspect chip guard is in place, spindle guard intact, axis travel limits functional	Guard covers all exposed rotating tool; limit switches respond when axes reach physical endpoints
Thermal runaway protection (3D printer)	Verify firmware setting is enabled and heater thermistor reads ambient temperature correctly on cold start	Marlin/Motion/RepRapFirmware: "THERMAL RUNWAY PROTECTION" is defined in Configuration.h; hot end does not exceed 50°C without command
Grounding	Inspect power cord grounding pin intact, equipment connected to grounded outlet (no adapters)	Outlet tester shows correct wiring (GROUNDED); no cracked or damaged cords visible
Fire suppression readiness	Fire extinguisher present in room, correct class for hazards, pressure gauge in green zone, inspection tag current	Extinguisher within 30 feet of machine, inspected within last 12 months, type matches workspace hazards (ABC for general)

---

Step 4: Set Up Safe Work Environment

Configure the physical workspace before activating any equipment.

Workspace layout requirements:

• 36-inch clearance zone: Maintain a minimum 36-inch (91cm) clear perimeter around every operating machine. No stools, bins, cables, or materials within this zone. This provides escape space and E-stop access.
• Flammable material buffer zone: Keep all paper, cardboard, solvents, aerosol cans, and fabric at least 10 feet from laser cutters, soldering stations, and 3D printers with active hot ends.
• Fire extinguisher placement: Class ABC fire extinguisher must be visible and accessible within 30 seconds (approximately 75 feet) of any fabrication station. Class D extinguisher required for any metalworking area.
• First aid kit: Must be stocked within arm's reach (within 30 seconds walking time) and contain: burn gel/dressings, sterile gauze pads, adhesive bandages, trauma shears, eye wash solution, nitrile gloves, and CPR mask.
• Lighting: Minimum 500 lux at the work surface without glare on reflective surfaces (polished metal, laser beam path, mirror-finish prints). Task lamp required for precision soldering or detail sanding.
• Housekeeping: Floor free of tripping hazards (cables routed and taped down), spills cleaned immediately, waste bins with lids for chemical-contaminated materials (acetone-soaked rags stored in sealed metal container to prevent spontaneous combustion).

---

Step 5: Execute Machine-Specific Safety Protocol

Follow the startup, operation, and shutdown sequence for each machine type. Do not deviate from these sequences.

General startup sequence:

1. Verify workspace is clear (36-inch perimeter, no flammable materials nearby)
2. Confirm PPE is donned correctly for identified hazards
3. Verify ventilation/fume extraction is ACTIVE before powering on the machine
4. Power on machine, allow warm-up period if specified by manufacturer
5. Run a dry cycle or self-test (no material/workpiece loaded) to confirm normal operation
6. Load material/workpiece using appropriate handling tools — not bare hands when hot or sharp
7. Start fabrication — stay within sight of the machine for the first 10 minutes

General shutdown sequence:

1. Allow complete cycle finish — do not abort mid-operation unless an emergency condition exists
2. Wait for all heating elements to cool below safe touch temperature (<50°C)
3. Remove workpiece using appropriate tools (tweezers, pliers, brush — never bare hands on hot parts)
4. Turn off machine power, then disconnect extraction/ventilation after 2 minutes to purge remaining fumes
5. Clean workspace: remove debris, wipe surfaces with appropriate cleaner, store tools in designated locations
6. Log any abnormalities, near-misses, or unusual behavior in the shared incident log

---

Machine-Specific Protocols

3D Printer Safety

Thermal hazards:

• Hot ends operate at 200–260°C for PLA/PETG/ABS; up to 300°C for Nylon/PC. Contact causes immediate severe burns.
• Heated beds operate at 60–110°C. Contact above 55°C causes second-degree burns within seconds.
• Rule: Never touch a hot end or heated bed without confirming temperature via display or reading <40°C with IR thermometer.

Fume hazards by material:

Material	Fumes Generated	Ventilation Requirement
PLA	Minimal (lactide — low toxicity)	Basic room ventilation adequate
PETG	Glycol-based fumes (low risk)	Room ventilation adequate
ABS	Styrene (carcinogenic, CNS depressant)	Mandatory: active extraction or outdoor venting. Never run in unventilated bedroom/home office.
Nylon	Caprolactam fumes (respiratory irritant)	Active extraction required
Resin (SLA/DLP)	Uncured photopolymer vapor + UV exposure	Mandatory: fume extractor, nitrile gloves for handling. Never handle uncured resin with bare skin.

Thermal runaway protection:

• Must be enabled in printer firmware. Verify before each print session.
• If the hot end temperature exceeds 15°C above the setpoint for more than 10 seconds, thermal runaway should trigger an automatic shutdown and heater disable.
• Test quarterly: disconnect thermistor and verify printer shuts down heaters and alarms within 30 seconds.

---

Laser Cutter Safety

CRITICAL — Material Incompatibility List:

Never cut or engrave the following materials in ANY laser cutter under any circumstances:

Material	Hazard	Why Forbidden
PVC, vinyl, pleather, "faux leather"	Chlorine gas release	Produces hydrogen chloride gas — corrodes machine optics, creates toxic cloud, can kill people
Polycarbonate (Lexan)	Melts, ignites	Does not cut cleanly; catches fire inside enclosure
HDPE / PP plastics	Melts through, ignites	Low melting point causes material to drip and ignite
Fiberglass	Silica dust, toxic fumes	Destroys laser mirror and optics with conductive dust
Carbon fiber	Toxic fumes, electrical conductivity	Carbon dust is conductive — can short laser tube electronics
Materials with halogenated flame retardants	Unknown toxic gas release	Chemical composition varies by batch — unpredictable hazard
Reflective metals (bare copper, brass, aluminum)	Laser reflection back into tube	Reflected beam can destroy laser source and create fire

Interlock integrity:

• The enclosure interlock must prevent laser emission whenever the door is open. Test before every session.
• Never bypass or disable an interlock — "I'll just prop it open for this one quick cut" has caused multiple permanent eye injuries in maker spaces.

Ventilation requirements:

• CO2 laser cutters (10.6µm wavelength): Active exhaust fan must move minimum 5 CFM per square foot of bed area, with carbon filter stage for odor removal.
• Fiber lasers (1.06µm): Same airflow requirements PLUS spark extraction for metal cutting operations.

---

CNC Mill Safety

Tool speed and feed rate verification:

• Before starting any cut, confirm the displayed RPM matches your calculated requirement (see digital-fabrication skill toolpath calculator). Running a small end mill at excessive RPM causes catastrophic tool failure — the tool shatters at high velocity.
• Verify the tool is properly seated in the collet with correct clamping length and torque. A loose tool becomes a high-speed projectile.

Workholding security:

• Vises must be tightened to manufacturer-specified torque before cutting begins.
• Clamps must clear the tool path — verify by jogging the axis manually (low speed) through the full cutting range with the spindle OFF but the light ON for visibility.
• Soft jaws should be used for irregular stock shapes; never rely on friction alone to hold material.

Chip guard and containment:

• The chip guard must enclose all exposed rotating tool surfaces during operation.
• Coolant/minimum quantity lubrication (MQL) systems require splash guards — coolant can create slippery floor hazards.

---

Electronics / Soldering Station Safety

LiPo battery handling protocol:

Operation	Requirement
Charging	Charge on non-flammable surface (concrete floor, metal tray). Never charge on wood, fabric, or plastic table top. Use a LiPo fireproof bag or sandbox charging station. Maximum charge current: 1C (where C = battery capacity in Ah).
Storage	Store at 3.8V per cell (storage voltage). Keep in fireproof container away from flammable materials. Maximum 5 batteries per container in a makerspace environment.
Inspection	Check every battery before use: no swelling, punctures, or casing damage. A swollen LiPo is CRITICAL — do not charge, do not use. Place in sand bucket and arrange for proper disposal.
Disposal	Deactivate by submerging in salt water solution (10% NaCl by weight) for 48 hours until voltage reads <1V per cell. Then dispose as electronic waste at certified facility. Never place a LiPo in regular trash or recycling.
Fire response	A burning LiPo releases toxic gas (HF, CO). Evacuate the area immediately. Use a Class D fire extinguisher if available; otherwise use copious amounts of sand to smother. Do NOT use water on a lithium fire — it can intensify the reaction. Call fire department even for small fires.

ESD protection:

• Wear an ESD wrist strap connected to a common ground point when handling sensitive components (CMOS ICs, FPGA modules, OLED displays).
• Use an ESD-safe mat on the workbench with resistance between 10^6 and 10^9 ohms.
• Store unmounted SMD components in conductive foam or metal containers — antistatic bags are not sufficient for long-term storage.

Fume extraction during soldering:

• Active fume extractor with HEPA + activated carbon filter required within 12 inches of soldering iron tip.
• Soldering in a shared workspace without personal fume extraction is unacceptable — flux fumes affect everyone in the room.
• Lead-free solder (SAC305) produces different fume characteristics than leaded solder (63/37 Sn/Pb) — both require extraction; lead requires additional glove and hand-washing protocols.

---

Implementation Patterns

Pattern 1: Safety Checklist Generator (Printable Per Machine)

"""
Machine-specific safety checklist generator.

Generates a printable, machine-type-appropriate safety checklist
that can be used for daily pre-session verification or new-user onboarding.
Supports output in plain text, CSV for logging, and structured JSON for digital tracking.
"""

from __future__ import annotations

import json
import csv
import io
from dataclasses import dataclass, field, asdict
from enum import Enum
from typing import Optional


class MachineType(Enum):
    FDM_3D_PRINTER = "fdm_3d_printer"
    SLA_RESIN_PRINTER = "sla_resin_printer"
    CO2_LASER_CUTTER = "co2_laser_cutter"
    FIBER_LASER = "fiber_laser"
    CNC_MILL = "cnc_mill"
    DRILL_PRESS = "drill_press"
    TABLE_SAW = "table_saw"
    SOLDERING_STATION = "soldering_station"
    BENCH_GRINDER = "bench_grinder"


@dataclass
class ChecklistItem:
    """A single safety verification item."""
    id: str                          # Unique identifier, e.g., "3DP-01"
    category: str                    # Hazard type: thermal, mechanical, chemical, electrical, particulate
    description: str                 # Human-readable check description
    pass_criteria: str               # What constitutes a passing result
    is_critical: bool = False        


MACHINE_CHECKLISTS: [MachineType, [ChecklistItem]] = {
    MachineType.FDM_3D_PRINTER: [
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
    ],
    MachineType.SLA_RESIN_PRINTER: [
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
    ],
    MachineType.CO2_LASER_CUTTER: [
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
    ],
    MachineType.CNC_MILL: [
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
    ],
    MachineType.SOLDERING_STATION: [
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
        ChecklistItem(, , ,
                      , ),
    ],
}


 () -> :
    
     datetime

     session_date  :
        session_date = datetime.date.today().isoformat()

    items = MACHINE_CHECKLISTS.get(machine, [])
    lines = [
         * ,
        ,
        ,
        ,
        ,
         * ,
        ,
        ,
         * ,
    ]

     item  items:
        crit =   item.is_critical  
        lines.append()

    lines.extend([
        ,
         * ,
        ,
        ,
        ,
        ,
        ,
        ,
         * ,
    ])

     .join(lines)


 () -> :
    
    items = MACHINE_CHECKLISTS.get(machine, [])

    
    ppe_required: [] = ()
     item  items:
           item.category:
            ppe_required.add()
            ppe_required.add()
           item.category:
            ppe_required.add()
            ppe_required.add()
           item.category:
            ppe_required.add()
            ppe_required.add()
           item.category:
            ppe_required.add()
           item.category:
            ppe_required.add()

    output = {
        : machine.value,
        : [asdict(item)  item  items],
        : (ppe_required),
        : (items),
        : (  item  items  item.is_critical),
    }

     json.dumps(output, indent=)


 __name__ == :
     sys

    machine_name = sys.argv[]  (sys.argv) >   
    operator = sys.argv[]  (sys.argv) >   

    
    machine_map = {m.value: m  m  MachineType}
     machine_name   machine_map:
        available = .join((machine_map.keys()))
        ()
        ()
        sys.exit()

    machine = machine_map[machine_name]

    
    text = generate_checklist(machine, operator)
    (text)

    
    json_out = generate_checklist_json(machine)
     (, )  f:
        f.write(json_out)
    ()

    
    ppe_data = json.loads(json_out)
    ()
     p  ppe_data[]:
        ()

---

Pattern 2: Hazard Assessment Matrix with Automated PPE Recommendation

"""
Hazard assessment matrix for makerspace operations.

Analyzes the materials, tools, and processes involved in a planned operation
and produces an automated hazard classification with corresponding PPE,
engineering controls, and emergency procedures.
"""

from __future__ import annotations

import json
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional


class HazardCategory(Enum):
    THERMAL = "thermal"
    MECHANICAL = "mechanical"
    CHEMICAL = "chemical"
    ELECTRICAL = "electrical"
    PARTICULATE = "particulate"


class SeverityLevel(Enum):
    LOW = "low"        # Minimal injury risk; first aid sufficient
    MEDIUM = "medium"  # May require medical attention; time off expected
    HIGH = "high"      # Serious injury possible; potential hospitalization
    CRITICAL = "critical"  # Life-threatening; permanent disability or death possible


@dataclass
class HazardEntry:
    """Single identified hazard with severity and mitigation."""
    category: HazardCategory
    description: str
    severity: SeverityLevel
    engineering_controls: list[str] = field(default_factory=list)
    ppe_required: list[str] = field(default_factory=)
    emergency_procedure:  = 



 :
    
    operation_name: 
    materials_used: [] = field(default_factory=)
    tools_used: [] = field(default_factory=)
    hazards: [HazardEntry] = field(default_factory=)
    required_ppe: [] = field(default_factory=)
    engineering_controls: [] = field(default_factory=)
    emergency_contacts: [] = field(default_factory=)
    risk_level:  =   


 () -> OperationAssessment:
    
    assessment = OperationAssessment(
        operation_name=operation_name,
        materials_used=materials  [],
        tools_used=tools  [],
    )

    materials_lower = [m.lower()  m  (materials  [])]
    tools_lower = [t.lower()  t  (tools  [])]
    notes = process_notes  {}

    
     (t  [, , , , , ]  t  tools_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.MECHANICAL,
            description=,
            severity=SeverityLevel.HIGH,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))

     (  t  t  tools_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.THERMAL,
            description=,
            severity=SeverityLevel.CRITICAL,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.CHEMICAL,
            description=,
            severity=SeverityLevel.HIGH,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))

     (  t    t  t  tools_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.THERMAL,
            description=,
            severity=SeverityLevel.HIGH,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))

     (  t    t    t  t  tools_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.CHEMICAL,
            description=,
            severity=SeverityLevel.HIGH,
            engineering_controls=[,
                                   ],
            ppe_required=[, ,
                           ],
            emergency_procedure=,
        ))

     (  t  t  tools_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.THERMAL,
            description=,
            severity=SeverityLevel.MEDIUM,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.CHEMICAL,
            description=,
            severity=SeverityLevel.MEDIUM,
            engineering_controls=[,
                                   ],
            ppe_required=[],
            emergency_procedure=,
        ))

    
     material  materials_lower:
           material    material    material    material:
            assessment.hazards.append(HazardEntry(
                category=HazardCategory.PARTICULATE,
                description=,
                severity=SeverityLevel.MEDIUM,
                engineering_controls=[, ],
                ppe_required=[, ],
                emergency_procedure=,
            ))
           material:
            assessment.hazards.append(HazardEntry(
                category=HazardCategory.CHEMICAL,
                description=,
                severity=SeverityLevel.HIGH,
                engineering_controls=[,
                                       ],
                ppe_required=[],
                emergency_procedure=,
            ))
           material    material    material:
            assessment.hazards.append(HazardEntry(
                category=HazardCategory.PARTICULATE,
                description=,
                severity=SeverityLevel.MEDIUM,
                engineering_controls=[, ],
                ppe_required=[],
                emergency_procedure=,
            ))

    
     notes.get():
        voltage = notes[]
         voltage > :
            severity = SeverityLevel.CRITICAL
            desc = 
         voltage > :
            severity = SeverityLevel.HIGH
            desc = 
        :
            severity = SeverityLevel.MEDIUM
            desc = 

        assessment.hazards.append(HazardEntry(
            category=HazardCategory.ELECTRICAL,
            description=desc,
            severity=severity,
            engineering_controls=[,
                                   ],
            ppe_required=[, ],
            emergency_procedure=,
        ))

    
     (  m    m    m  m  materials_lower):
        assessment.hazards.append(HazardEntry(
            category=HazardCategory.CHEMICAL,
            description=,
            severity=SeverityLevel.CRITICAL,
            engineering_controls=[,
                                   ],
            ppe_required=[,
                           ],
            emergency_procedure=,
        ))

    
    all_ppe: [] = ()
    all_eng: [] = ()
     h  assessment.hazards:
        all_ppe.update(h.ppe_required)
        all_eng.update(h.engineering_controls)

    assessment.required_ppe = (all_ppe)
    assessment.engineering_controls = (all_eng)

    
    severity_scores = {: , : , : , : }
      assessment.hazards:
        assessment.risk_level = 
    :
        max_score = (severity_scores[h.severity.value]  h  assessment.hazards)
        
        elevated_count = (  h  assessment.hazards  severity_scores[h.severity.value] >= )
         max_score >=   elevated_count > (assessment.hazards) / :
            assessment.risk_level = 
         max_score == :
            assessment.risk_level = 
         max_score >= :
            assessment.risk_level = 
         max_score == :
            assessment.risk_level = 
        :
            assessment.risk_level = 

     assessment


 () -> :
    
    lines = [
         * ,
        ,
        ,
        ,
         * ,
        ,
        ,
    ]
     m  assessment.materials_used:
        lines.append()

    lines.extend([, ])
     t  assessment.tools_used:
        lines.append()

    lines.extend([,  * , ,  * ])
     i, h  (assessment.hazards, ):
        lines.extend([
            ,
            ,
            ,
            ,
            ,
        ])
         ctrl  h.engineering_controls:
            lines.append()
        lines.append()
         ppe  h.ppe_required:
            lines.append()
         h.emergency_procedure:
            lines.append()

    lines.extend([
        ,
         * ,
        ,
         * ,
    ])
     ppe  assessment.required_ppe:
        lines.append()

    lines.extend([
        ,
         * ,
        ,
         * ,
    ])
     ctrl  assessment.engineering_controls:
        lines.append()

     assessment.risk_level  (, ):
        lines.extend([
            ,
            ,
        ])

    lines.extend([,  * ])
     .join(lines)


 __name__ == :
    
    assessment = assess_operation(
        operation_name=,
        materials=[, ],
        tools=[, ],
        process_notes={},
    )

    report = format_assessment_report(assessment)
    (report)

    
    assessment_json = {
        : assessment.operation_name,
        : assessment.risk_level,
        : assessment.materials_used,
        : assessment.tools_used,
        : [
            {
                : h.category.value,
                : h.severity.value,
                : h.description,
                : h.engineering_controls,
                : h.ppe_required,
                : h.emergency_procedure,
            }
             h  assessment.hazards
        ],
        : assessment.required_ppe,
    }
     (, )  f:
        json.dump(assessment_json, f, indent=)
    ()

---

Pattern 3: Emergency Response Quick-Reference Card Generator

"""
Emergency response quick-reference card generator.

Creates printable one-page emergency reference cards tailored to the specific
machines and materials present in a workspace. Cards include step-by-step
procedures for common emergencies, contact numbers, and first aid instructions.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class EmergencyProcedure:
    """One emergency scenario with response steps."""
    scenario: str                # e.g., "Fire — burning LiPo battery"
    priority: int                # 1 = most urgent
    immediate_actions: list[str] = field(default_factory=list)
    medical_actions: list[str] = field(default_factory=list)
    equipment_needed: list[str] = field(default_factory=list)


@dataclass
class EmergencyResponseCard:
    """Complete emergency response card for a workspace."""
    facility_name: str
    address: str
    emergency_phone: str = "911"
    internal_safety_officer: str = ""
    safety_officer_phone: str = ""
    nearest_hospital: str = ""
    hospital_address: str = ""
    procedures: list[EmergencyProcedure] = field(default_factory=)

     () -> :
        
        lines = [
             * ,
            ,
            ,
             * ,
            ,
            ,
            ,
            ,
            ,
             * ,
        ]

        
        sorted_procedures = (.procedures, key= p: p.priority)

         proc  sorted_procedures:
            lines.extend([
                ,
                ,
                ,
            ])
             i, action  (proc.immediate_actions, ):
                lines.append()

             proc.medical_actions:
                lines.append()
                 i, action  (proc.medical_actions, ):
                    lines.append()

             proc.equipment_needed:
                lines.append()
                 eq  proc.equipment_needed:
                    lines.append()

            lines.extend([,  * ])

        lines.extend([
            ,
            ,
            ,
             * ,
        ])

         .join(lines)


 () -> EmergencyResponseCard:
    
     EmergencyResponseCard(
        facility_name=facility_name,
        address=address,
        nearest_hospital=,
        hospital_address=,
        procedures=[
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                    ,
                ],
                equipment_needed=[, , ],
            ),
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                    ,
                ],
                equipment_needed=[, ],
            ),
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                    ,
                ],
                equipment_needed=[, ],
            ),
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                    ,
                ],
                equipment_needed=[, ],
            ),
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                ],
                equipment_needed=[],
            ),
            EmergencyProcedure(
                scenario=,
                priority=,
                immediate_actions=[
                    ,
                    ,
                    ,
                ],
                medical_actions=[
                    ,
                    ,
                ],
                equipment_needed=[, ],
            ),
        ],
    )


 __name__ == :
    card = build_default_emergency_card(
        facility_name=,
        address=,
    )

    text = card.generate_card_text()
    (text)

    
     (, )  f:
        f.write(text)
    ()

---

Constraints

MUST DO

• Complete a written hazard assessment for every new operation or workspace setup — never assume safety requirements from a previous task apply to the current one
• Test emergency stop functionality at the start of every session, not just once when you arrive
• Keep fire extinguishers inspected annually and replace if pressure gauge reads outside the green zone
• Never bypass safety interlocks on laser cutters, CNC chip guards, or 3D printer thermal runaway protection — disabled safety is unacceptable risk
• Store all chemical solvents (acetone, Isopropyl alcohol, resin) in flame-rated containers with sealed caps when not in active use
• Wear ANSI Z87.1-rated eye protection in the entire workshop area — not just while operating a machine
• Perform a fit-seal check on any respirator each time it is worn; a leaking seal provides zero protection
• Immediately stop work and report to a safety officer if you observe: unusual odors, smoke without visible source, sparks from unexpected locations, structural cracks in machine components, or swollen/damaged batteries

MUST NOT DO

• Never cut PVC, vinyl, or any halogen-containing material in a laser cutter — chlorine gas destroys the machine and creates a health emergency
• Never wear loose clothing, jewelry, gloves, or unrestrained long hair near CNC mills, drill presses, lathes, or any rotating tool
• Never leave an active soldering iron unattended — place it in its holder immediately after use, even for "just one second"
• Never charge LiPo batteries on flammable surfaces (wooden tables, fabric-covered benches) or without a fireproof containment method
• Never use compressed air to clean yourself or clothing of metal dust — it embeds particles into skin and can cause long-term health effects
• Never mix food and drink areas with chemical storage, solvent handling, or battery charging zones
• Never operate machinery while fatigued, under the influence of medication that impairs judgment, or without having read this procedure at minimum once

---

Output Template

When this skill is active, produce:

1. Hazard Assessment Matrix — Tabulated list of all hazard types identified for the specific operation with corresponding risk level (Low/Medium/High/Critical)
2. PPE Selection Summary — Required PPE per hazard type with ANSI/NIOSH rating specifications and rationale
3. Pre-Session Machine Safety Checklist — Completed checklist for each machine to be operated, including E-stop test result and ventilation status
4. Workspace Configuration Verification — Confirmed clearances (36-inch perimeter), fire extinguisher placement, first aid kit location, fume extraction status
5. Machine-Specific Protocol Confirmation — Step-by-step startup/operation/shutdown sequence for the selected machine(s) with sign-off points
6. Emergency Response Quick Reference — Applicable emergency procedures, nearest exits, E-stop locations, and emergency contact numbers

---

Related Skills

Skill	Purpose
rapid-prototyping-workflow	Plan the overall prototype workflow — safety protocols apply at every stage from paper sketch to physical fabrication
digital-fabrication	Machine-specific fabrication methods (3D printing, laser cutting, CNC milling) each have unique safety requirements covered in this skill
maker-safety-practices	This skill — the comprehensive safety reference covering all makerspace operations and hazards

---

Live References

Authoritative documentation links for this skill's domain. The model follows markdown links to resolve external references and inline content.

• OSHA Electrical Safety Standards
• ANSI Z87.1 — Occupational Eye & Face Protection
• NFPA 45 — Standard for Fire Prevention in Labs
• Maker Safety Guidelines (Haxpress)
• NIOSH — Particulate Respirator Guide