ShiboSoftwareDev/linux-gameboy-advance

scripts/verify.mjs

import assert from "node:assert/strict"
import fs from "node:fs"

const circuitPath = "dist/index/circuit.json"
const circuit = JSON.parse(fs.readFileSync(circuitPath, "utf8"))
const of = (type) => circuit.filter((record) => record.type === type)
const nearly = (actual, expected, tolerance = 1e-6) =>
  Math.abs(actual - expected) <= tolerance
const pointToSegmentDistance = (point, start, end) => {
  const dx = end.x - start.x
  const dy = end.y - start.y
  const lengthSquared = dx * dx + dy * dy
  const position = lengthSquared === 0 ? 0 : Math.max(0, Math.min(1,
    ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSquared))
  return Math.hypot(point.x - (start.x + position * dx), point.y - (start.y + position * dy))
}

const readGlbJson = (path) => {
  const bytes = fs.readFileSync(path)
  assert.equal(bytes.toString("ascii", 0, 4), "glTF", `${path} is a binary glTF file`)
  assert.equal(bytes.readUInt32LE(4), 2, `${path} uses glTF 2.0`)
  assert.equal(bytes.readUInt32LE(8), bytes.length, `${path} has a valid declared length`)
  let offset = 12
  while (offset + 8 <= bytes.length) {
    const length = bytes.readUInt32LE(offset)
    const type = bytes.readUInt32LE(offset + 4)
    const start = offset + 8
    if (type === 0x4e4f534a) {
      return JSON.parse(bytes.toString("utf8", start, start + length).trimEnd())
    }
    offset = start + length
  }
  throw new Error(`${path} has no JSON chunk`)
}

const errors = circuit.filter((record) => record.type.endsWith("_error"))
assert.equal(errors.length, 0, `expected zero emitted DRC/electrical errors; got ${errors.length}`)
for (const warningType of [
  "schematic_sheet_styling_warning",
  "schematic_element_outside_sheet_warning",
]) assert.equal(of(warningType).length, 0, `${warningType} count is zero`)

const board = of("pcb_board")[0]
assert.ok(board, "PCB board exists")
assert.equal(board.num_layers, 4, "four copper layers")
assert.ok(board.outline?.length >= 4, "custom board outline is present")
assert.ok(nearly(board.width, 144.5) && nearly(board.height, 84.27), "144.5 x 84.27 mm envelope")
assert.ok(nearly(board.min_via_hole_diameter, 0.3), "board via drill rule is 0.30 mm")
assert.ok(nearly(board.min_via_pad_diameter, 0.45), "board via pad rule is 0.45 mm")
assert.ok(nearly(board.min_via_hole_edge_to_via_hole_edge_clearance, 0.2), "finished-hole spacing rule is 0.20 mm")

const cutouts = of("pcb_cutout")
assert.equal(cutouts.length, 1, "one battery-cable edge cutout exists")
const batteryCableCutout = cutouts[0]
assert.equal(batteryCableCutout.shape, "polygon", "battery-cable cutout uses fabrication-safe outline geometry")
assert.ok(batteryCableCutout.points.length >= 15, "battery-cable cutout has a rounded closed end")
const cutoutXs = batteryCableCutout.points.map(({ x }) => x)
const cutoutYs = batteryCableCutout.points.map(({ y }) => y)
const cutoutBounds = {
  minX: Math.min(...cutoutXs), maxX: Math.max(...cutoutXs),
  minY: Math.min(...cutoutYs), maxY: Math.max(...cutoutYs),
}
assert.ok(nearly(cutoutBounds.maxX - cutoutBounds.minX, 5), "battery-cable cutout is 5 mm wide")
assert.ok(nearly(cutoutBounds.maxY - cutoutBounds.minY, 11), "battery-cable cutout is 11 mm long")
const boardBottomY = Math.min(...board.outline.map(({ y }) => y))
const boardTopY = Math.max(...board.outline.map(({ y }) => y))
assert.ok(cutoutBounds.minY < boardBottomY && nearly(cutoutBounds.maxY - boardBottomY, 9.5),
  "battery-cable cutout opens through the bottom edge and extends 9.5 mm into the PCB")

const vias = of("pcb_via")
assert.ok(vias.length > 0, "routed board contains vias")
for (const via of vias) {
  assert.ok(nearly(via.hole_diameter, 0.3), `${via.pcb_via_id}: drill is exactly 0.30 mm`)
  assert.ok(nearly(via.outer_diameter, 0.45), `${via.pcb_via_id}: pad is exactly 0.45 mm`)
  assert.deepEqual([...via.layers].sort(), ["bottom", "inner1", "inner2", "top"],
    `${via.pcb_via_id}: physical via is a four-layer through-via`)
}

let minimumFinishedHoleGap = Infinity
let closestViaPair = []
for (let index = 0; index < vias.length; index++) {
  for (let other = index + 1; other < vias.length; other++) {
    const a = vias[index]
    const b = vias[other]
    const centerDistance = Math.hypot(a.x - b.x, a.y - b.y)
    const gap = centerDistance - a.hole_diameter / 2 - b.hole_diameter / 2
    if (gap < minimumFinishedHoleGap) {
      minimumFinishedHoleGap = gap
      closestViaPair = [a.pcb_via_id, b.pcb_via_id]
    }
  }
}
assert.ok(minimumFinishedHoleGap >= 0.2 - 1e-6,
  `minimum via finished-hole gap ${minimumFinishedHoleGap.toFixed(6)} mm is at least 0.20 mm`)

// Regression for the fabrication review's exact failure: the former via at
// (8.399, 11.013) had only 0.177 mm from its finished-hole edge to an inner2
// module trace. Its repaired position must retain JLCPCB's 0.20 mm minimum.
// IDs are allocation-order dependent and change whenever another routed branch
// gains or loses a via. Identify the repaired transition by its stable route
// suffix and reviewed coordinate instead of pinning the check to a stale ID.
const reviewedVia = vias.find((via) =>
  via.pcb_trace_id?.endsWith("source_net_6_mst40_0") &&
  nearly(via.x, 8.399) && nearly(via.y, 10.65))
assert.ok(reviewedVia, "reviewed V3V3 transition via exists")
let reviewedViaCopperGap = Infinity
let reviewedViaNearestTrace = null
for (const trace of of("pcb_trace")) {
  if (trace.pcb_trace_id === reviewedVia.pcb_trace_id ||
      trace.subcircuit_connectivity_map_key === reviewedVia.subcircuit_connectivity_map_key) continue
  for (let index = 1; index < (trace.route?.length ?? 0); index++) {
    const start = trace.route[index - 1]
    const end = trace.route[index]
    if (start.route_type !== "wire" || end.route_type !== "wire") continue
    const gap = pointToSegmentDistance(reviewedVia, start, end) -
      reviewedVia.hole_diameter / 2 - Math.max(start.width, end.width) / 2
    if (gap < reviewedViaCopperGap) {
      reviewedViaCopperGap = gap
      reviewedViaNearestTrace = trace.pcb_trace_id
    }
  }
}
assert.ok(reviewedViaCopperGap >= 0.2 - 1e-6,
  `reviewed via finished-hole-to-copper gap ${reviewedViaCopperGap.toFixed(3)} mm is at least 0.20 mm`)

const sourceComponents = of("source_component")
const sourceById = new Map(sourceComponents.map((component) => [component.source_component_id, component]))
const pcbComponents = of("pcb_component")
const missingCourtyardWarnings = of("pcb_component_missing_courtyard_warning")
assert.deepEqual(missingCourtyardWarnings, [],
  `every PCB component has courtyard geometry: ${missingCourtyardWarnings.map((warning) => warning.message).join(", ")}`)
const courtyardComponentIds = new Set([
  ...of("pcb_courtyard_rect"),
  ...of("pcb_courtyard_outline"),
].map((courtyard) => courtyard.pcb_component_id))
const fitted = pcbComponents
  .map((pcb) => ({ pcb, source: sourceById.get(pcb.source_component_id) }))
  .filter(({ pcb, source }) => source && !pcb.do_not_place && source.ftype !== "simple_test_point")
const missingJlcpcb = fitted
  .filter(({ source }) => !source.supplier_part_numbers?.jlcpcb?.some((id) => /^C\d+$/.test(id)))
  .map(({ source }) => source.name)
assert.deepEqual(missingJlcpcb, [], `all fitted parts have explicit JLCPCB/LCSC IDs: ${missingJlcpcb.join(", ")}`)

const uniqueJlcpcbParts = new Set(fitted.flatMap(({ source }) => source.supplier_part_numbers.jlcpcb))
const componentByName = new Map(sourceComponents.map((component) => [component.name, component]))
const pcbByName = new Map(pcbComponents.map((pcb) => [sourceById.get(pcb.source_component_id)?.name, pcb]))
const cadByName = new Map(of("cad_component").map((cad) => [sourceById.get(cad.source_component_id)?.name, cad]))
const schematicByName = new Map(of("schematic_component")
  .map((schematic) => [sourceById.get(schematic.source_component_id)?.name, schematic]))
for (const name of ["C_TV_REF", "Y1", "FB_SPK_POS", "FB_SPK_NEG", "J_SPK", "CASE_SCREEN_WINDOW"])
  assert.ok(courtyardComponentIds.has(pcbByName.get(name)?.pcb_component_id),
    `${name} has explicit courtyard geometry`)
for (const name of [
  "U1", "J_LCD", "J_SD", "U_FLASH", "U_IO", "J_USB", "J_BAT",
  "U_BUCK_3V3", "L_BUCK_3V3", "Q_BAT_IDEAL", "U_2V5", "U_1V2", "U_2V8", "U_SPK_AMP", "J_SPK",
  "J_UART", "J_I2C", "J_SPI", "R_UART_RX_SER", "R_UART_TX_SER", "JP_BOOT",
  "U_LCD_BL", "L_LCD_BL", "D_LCD_BL", "C_LCD_BL_IN", "C_LCD_BL_OUT",
  "R_LCD_BL_SET_A", "R_LCD_BL_SET_B",
  "D_STATUS", "R_STATUS_R", "R_STATUS_G", "R_STATUS_B",
]) assert.ok(componentByName.has(name), `critical component ${name} exists`)

assert.equal(componentByName.get("D_STATUS").manufacturer_part_number,
  "F.1615.00026/P4-1615G2B2R4TS2-06T-001-24",
  "status indicator uses the exact low-forward-voltage common-anode RGB LED")
assert.deepEqual(componentByName.get("D_STATUS").supplier_part_numbers.jlcpcb, ["C7496855"],
  "status RGB LED has an explicit JLCPCB part")
assert.ok(nearly(pcbByName.get("D_STATUS").center.x, -6.5) && nearly(pcbByName.get("D_STATUS").center.y, -18.5),
  "status LED stays centered between the display and Start/Select")
for (const [name, resistance, jlc] of [
  ["R_STATUS_R", 330, "C23138"],
  ["R_STATUS_G", 100, "C22775"],
  ["R_STATUS_B", 100, "C22775"],
]) {
  assert.ok(nearly(componentByName.get(name).resistance, resistance), `${name} has the intended current limit`)
  assert.deepEqual(componentByName.get(name).supplier_part_numbers.jlcpcb, [jlc],
    `${name} uses the audited JLCPCB resistor`)
}
for (const traceName of [
  "STATUS_RED_IO", "STATUS_GREEN_IO", "STATUS_BLUE_IO",
  "STATUS_LED_CA", "STATUS_RED_LIMIT", "STATUS_GREEN_LIMIT", "STATUS_BLUE_LIMIT",
]) assert.ok(of("source_trace").some((trace) => trace.name === traceName),
  `${traceName} is present in the final source netlist`)

assert.equal(componentByName.get("U_BUCK_3V3").manufacturer_part_number, "TPS63020DSJR",
  "two-AA input uses a true buck-boost regulator")
assert.deepEqual(componentByName.get("U_BUCK_3V3").supplier_part_numbers.jlcpcb, ["C15483"],
  "TPS63020 has an explicit JLCPCB part")
assert.equal(componentByName.get("L_BUCK_3V3").manufacturer_part_number, "YHNR4020-1R5M",
  "buck-boost uses the datasheet-class 1.5 uH inductor")
assert.deepEqual(componentByName.get("L_BUCK_3V3").supplier_part_numbers.jlcpcb, ["C18199423"],
  "buck-boost inductor has an explicit JLCPCB part")
assert.equal(componentByName.get("Q_BAT_IDEAL").manufacturer_part_number, "AO3401A",
  "battery source selection avoids a low-voltage Schottky drop")

assert.equal(componentByName.get("J_USB").manufacturer_part_number, "TYPE-C-31-M-12",
  "the original USB-C receptacle remains the USB2/FEL data port")
assert.equal(componentByName.get("J_USB").ftype, "simple_connector",
  "the USB2/FEL port uses the standard USB-C connector schematic symbol")
assert.ok(nearly(schematicByName.get("J_USB")?.size.width, 1.575),
  "J_USB uses the schematic analyzer's accepted standard USB-C box width")
assert.equal(sourceComponents.filter((component) => component.name?.startsWith("J_USB")).length, 1,
  "the handheld has exactly one USB-C receptacle")
for (const removedName of [
  "J_USB_PD", "U_PD", "R_PD_VDD", "R_PD_VBUS", "C_PD_VDD",
  "D_PD_TVS", "C_PD_BULK", "C_PD_HF", "D_PD_OR",
]) assert.equal(componentByName.has(removedName), false, `${removedName} was removed with the PD island`)
assert.equal(pcbByName.get("JP_BOOT").do_not_place, true,
  "JP_BOOT is a copper-only DNP solder bridge")
assert.equal(cadByName.has("JP_BOOT"), false,
  "JP_BOOT has no 3D model")
for (const name of ["R_UART_RX_SER", "R_UART_TX_SER"]) {
  assert.ok(nearly(componentByName.get(name).resistance, 100), `${name} is 100 ohms`)
  assert.deepEqual(componentByName.get(name).supplier_part_numbers.jlcpcb, ["C25076"],
    `${name} uses the audited JLCPCB resistor`)
}
for (const traceName of [
  "UART_JST_RX", "UART_JST_TX",
  "UART_RX_SER_MCU", "UART_TX_SER_MCU",
]) assert.ok(of("source_trace").some((trace) => trace.name === traceName),
  `${traceName} is present in the final source netlist`)
assert.equal(of("source_trace").filter((trace) => trace.name?.startsWith("PD_")).length, 0,
  "no obsolete USB-PD traces remain")

const sheetNames = new Set(of("schematic_sheet").map((sheet) => sheet.name))
for (const name of [
  "soc_interfaces", "soc_power", "soc_support", "display", "storage", "controls_service", "usb_power",
  "secondary_rails", "audio", "backlight", "status",
]) assert.ok(sheetNames.has(name), `schematic sheet ${name} exists`)
for (const name of ["R_FLASH_WP", "R_FLASH_HOLD", "R_FLASH_CS"])
  assert.equal(schematicByName.get(name)?.symbol_name, "boxresistor_up",
    `${name} pull-up symbol faces the positive rail`)

const hasRenderableCad = (cad) => Boolean(cad && (
  cad.model_step_url || cad.model_obj_url || cad.model_glb_url ||
  cad.model_gltf_url || cad.model_stl_url || cad.jscad || cad.footprinter_string
)) && !cad.show_as_bounding_box
const missingCadModels = fitted
  .filter(({ source }) => !hasRenderableCad(cadByName.get(source.name)))
  .map(({ source }) => source.name)
assert.deepEqual(missingCadModels, [],
  `every fitted PCB part has a renderable non-placeholder 3D model: ${missingCadModels.join(", ")}`)

assert.equal(componentByName.get("U_LCD_BL").manufacturer_part_number, "AP3031KTR-G1",
  "LCD uses a regulated AP3031 boost/current driver")
assert.deepEqual(componentByName.get("U_LCD_BL").supplier_part_numbers.jlcpcb, ["C82636"],
  "LCD current driver has an explicit JLCPCB part")
assert.deepEqual(componentByName.get("L_LCD_BL").supplier_part_numbers.jlcpcb, ["C2997603"],
  "LCD boost inductor has an explicit JLCPCB part")
assert.deepEqual(componentByName.get("D_LCD_BL").supplier_part_numbers.jlcpcb, ["C2909920"],
  "LCD boost diode has an explicit JLCPCB part")
for (const name of ["R_LCD_BL_SET_A", "R_LCD_BL_SET_B"]) {
  assert.ok(nearly(componentByName.get(name).resistance, 1), `${name} is 1 ohm`)
  assert.deepEqual(componentByName.get(name).supplier_part_numbers.jlcpcb, ["C137355"],
    `${name} has an explicit JLCPCB part`)
  assert.equal(pcbByName.get(name).layer, "top", `${name} is on the top side`)
}
for (const name of [
  "U_LCD_BL", "L_LCD_BL", "D_LCD_BL", "C_LCD_BL_IN", "C_LCD_BL_OUT",
  "R_LCD_BL_SET_A", "R_LCD_BL_SET_B",
]) assert.equal(pcbByName.get(name).layer, "top", `${name} is on the top side`)
const lcdBacklightCurrentMa = 0.2 / (1 + 1) * 1000
assert.ok(nearly(lcdBacklightCurrentMa, 100), "AP3031 sense network regulates the LCD backlight to 100 mA")

const expectedButtons = ["UP", "DOWN", "LEFT", "RIGHT", "A", "B", "X", "Y", "SELECT", "START", "L", "R"]
for (const label of expectedButtons)
  assert.ok(componentByName.has(`SW_${label}`), `${label} control exists`)
assert.equal(sourceComponents.filter((component) => component.name?.startsWith("SW_")).length, 13,
  "twelve game controls plus reset switch")

const placement = (name, x, y, rotation) => {
  const pcb = pcbByName.get(name)
  assert.ok(pcb, `${name} has a PCB placement`)
  // Imported footprints can have an asymmetric copper centroid. Their
  // display offset is the component origin set by pcbX/pcbY; fall back to the
  // geometric center for symmetric/native footprints.
  const placedX = pcb.display_offset_x ?? pcb.center.x
  const placedY = pcb.display_offset_y ?? pcb.center.y
  assert.ok(nearly(placedX, x) && nearly(placedY, y), `${name} placement is ${x}, ${y}`)
  assert.ok(nearly(pcb.rotation, rotation), `${name} rotation is ${rotation} degrees`)
}

placement("SW_SELECT", -14, -26, 0)
placement("SW_START", 1, -26, 0)
for (const name of ["SW_SELECT", "SW_START"])
  assert.deepEqual(componentByName.get(name).supplier_part_numbers.jlcpcb, ["C18186519"],
    `${name} uses the same long-plunger JLC button as the reference Game Boy`)
placement("SW_L", -45, 39.32595785, 0)
placement("SW_R", 45, 39.32595785, 0)
for (const name of ["SW_L", "SW_R"]) {
  assert.deepEqual(componentByName.get(name).supplier_part_numbers.jlcpcb, ["C33543618"],
    `${name} is the mid-length variant of the original low-profile shoulder-switch family`)
  assert.match(cadByName.get(name)?.model_step_url ?? "", /C33543618\.step/,
    `${name} has the real JLC 3D model`)
}
const shoulderBoardEdgeY = 43.27
const shoulderBodyEdgeY = 39.32595785 + 3.94404215
const shoulderActuatorTipY = 39.32595785 + 6.97499875
assert.ok(Math.abs(shoulderBodyEdgeY - shoulderBoardEdgeY) < 0.01,
  "shoulder switch housings finish flush with the top board edge")
assert.ok(shoulderActuatorTipY - shoulderBoardEdgeY >= 3.03,
  "mid-length shoulder actuators project about 3.03 mm beyond the top board edge")

const volumePlacement = { x: -63.1291306297, y: 26.0729869550 }
const volumeRotationDeg = 46.7780905471
placement("RV_VOLUME", volumePlacement.x, volumePlacement.y, volumeRotationDeg)
const volumeCad = cadByName.get("RV_VOLUME")
assert.ok(volumeCad, "volume control has its real C231765 CAD model")
assert.ok(nearly(volumeCad.rotation.z, volumeRotationDeg),
  "volume wheel faces diagonally toward the upper-left corner")
const volumeRotationRad = volumeRotationDeg * Math.PI / 180
const volumeOutward = {
  x: -Math.sin(volumeRotationRad),
  y: Math.cos(volumeRotationRad),
}
const volumeInward = { x: -volumeOutward.x, y: -volumeOutward.y }
assert.ok(volumeOutward.x < -0.70 && volumeOutward.y > 0.65,
  "volume wheel points outward along the rounded-corner bisector")
// The wheel points at the vertex joining the two upper-left edge segments.
// Project the real CAD extents and placement onto that same corner bisector.
const volumeCorner = { x: -70.5, y: 33 }
const volumeCenterInsetMm =
  (volumePlacement.x - volumeCorner.x) * volumeInward.x +
  (volumePlacement.y - volumeCorner.y) * volumeInward.y
const volumeModelOriginY = -2.8229947
const volumeWheelMaxY = 7
const volumeHousingMaxY = 5.066803
const volumeCadOffsetAlongOutward =
  (volumeCad.position.x - volumePlacement.x) * volumeOutward.x +
  (volumeCad.position.y - volumePlacement.y) * volumeOutward.y
const volumeWheelReachMm = volumeCadOffsetAlongOutward + volumeWheelMaxY - volumeModelOriginY
const volumeHousingReachMm = volumeCadOffsetAlongOutward + volumeHousingMaxY - volumeModelOriginY
const volumeWheelProtrusionMm = volumeWheelReachMm - volumeCenterInsetMm
const volumeHousingCornerProtrusionMm = volumeHousingReachMm - volumeCenterInsetMm
assert.ok(volumeWheelProtrusionMm >= 0.89,
  "volume thumbwheel remains exposed at least 0.89 mm through the corner aperture")
const volumePcb = pcbByName.get("RV_VOLUME")
const volumeMountingSlots = of("pcb_plated_hole")
  .filter((hole) => hole.pcb_component_id === volumePcb.pcb_component_id && hole.shape === "pill")
assert.equal(volumeMountingSlots.length, 2, "volume control has both plated mounting slots")
const boardEdges = board.outline.map((start, index) => ({
  start,
  end: board.outline[(index + 1) % board.outline.length],
}))
for (const point of board.outline) {
  assert.ok(board.outline.some((candidate) => nearly(candidate.x, -point.x) && nearly(candidate.y, point.y)),
    `board outline point (${point.x}, ${point.y}) has a mirrored counterpart`)
}
const slotCopperEdgeClearance = (slot) => {
  const rotation = (slot.ccw_rotation ?? 0) * Math.PI / 180
  const longAxis = { x: -Math.sin(rotation), y: Math.cos(rotation) }
  const radius = slot.outer_width / 2
  const halfStraight = (slot.outer_height - slot.outer_width) / 2
  return Math.min(...boardEdges.map(({ start, end }) => {
    const dx = end.x - start.x
    const dy = end.y - start.y
    const length = Math.hypot(dx, dy)
    const inward = { x: -dy / length, y: dx / length }
    const centerDistance = (slot.x - start.x) * inward.x + (slot.y - start.y) * inward.y
    const copperSupport = radius + halfStraight * Math.abs(
      inward.x * longAxis.x + inward.y * longAxis.y)
    return centerDistance - copperSupport
  }))
}
const volumeSlotCopperClearances = volumeMountingSlots.map(slotCopperEdgeClearance)
const volumeMountingSlotEdgeClearanceMm = Math.min(...volumeSlotCopperClearances)
assert.ok(volumeMountingSlotEdgeClearanceMm >= 0.549,
  "both volume-control mounting-slot copper features retain 0.55 mm board-edge clearance")

placement("J_LCD", 40.8, 15, 270)
placement("J_SD", 62.74868915, 22, 90)
placement("JP_BOOT", -49.27, 18, 0)
placement("J_BAT", -40, -37.4, 270)
placement("J_PWR_SW", -68.983, -24, 180)
placement("J_UART", -18, 37, 180)
placement("J_I2C", -28, 37, 180)
placement("J_SPI", 22, 37, 180)
for (const name of ["J_UART", "J_I2C", "J_SPI"])
  assert.equal(pcbByName.get(name).layer, "top", `${name} stays at its intentional rear-edge position on the top side`)

const boardRightX = Math.max(...board.outline.map(({ x }) => x))
const microSd = pcbByName.get("J_SD")
const microSdCad = cadByName.get("J_SD")
assert.ok(microSdCad, "microSD socket has its real C91145 CAD model")
assert.ok(nearly(microSdCad.rotation.z, 90), "microSD card mouth faces the right edge")
// Exact bounds measured from the C91145 OBJ used by the board. At 90 degrees,
// the model's minimum local Y becomes the rightmost card-entry face and its
// local X bounds become the installed vertical housing bounds.
const microSdModelMinY = -4.4
const microSdModelMinX = -8.052222
const microSdModelMaxX = 8.047777
const microSdEntryFaceX = microSd.center.x + microSdCad.model_origin_position.y - microSdModelMinY
const microSdHousingMinY = microSd.center.y + microSdModelMinX - microSdCad.model_origin_position.x
const microSdHousingMaxY = microSd.center.y + microSdModelMaxX - microSdCad.model_origin_position.x
assert.ok(nearly(microSdEntryFaceX, boardRightX),
  "microSD card-entry face finishes exactly flush with the uninterrupted right PCB edge")
const straightRightEdgeYs = board.outline
  .filter(({ x }) => nearly(x, boardRightX))
  .map(({ y }) => y)
assert.ok(Math.min(...straightRightEdgeYs) <= microSdHousingMinY &&
  Math.max(...straightRightEdgeYs) >= microSdHousingMaxY,
  "the full rigid microSD housing is backed by the straight PCB edge")
assert.ok(!board.outline.some(({ x, y }) => nearly(x, 65) && (nearly(y, 12) || nearly(y, 30))),
  "the former microSD access recess is removed")

// The component's 180-degree PCB rotation plus the CAD model's 90-degree
// offset points the real C136720 actuator toward global -X. The housing is
// deliberately inset from the straight left edge; only the actuator projects.
const powerSwitch = pcbByName.get("J_PWR_SW")
const powerSwitchCad = cadByName.get("J_PWR_SW")
assert.ok(powerSwitchCad, "power switch has its real C136720 CAD model")
assert.ok(nearly(powerSwitchCad.rotation.z, 270), "power-switch CAD actuator faces global -X")
const powerCadOriginY = powerSwitchCad.model_origin_position.y
const boardLeftX = Math.min(...board.outline.map(({ x }) => x))
const powerActuatorTipX = powerSwitch.center.x - 7.4 - powerCadOriginY
const powerBodyLeftX = powerSwitch.center.x - 2.4 - powerCadOriginY
const powerActuatorProtrusionMm = boardLeftX - powerActuatorTipX
const powerBodyInsetMm = powerBodyLeftX - boardLeftX
assert.ok(powerActuatorProtrusionMm >= 4.49,
  "real power-switch CAD actuator extends at least 4.49 mm beyond the left PCB edge")
assert.ok(powerBodyInsetMm >= 0.49,
  "real power-switch CAD housing face remains at least 0.49 mm inside the left PCB edge")
const powerHousingMinY = powerSwitch.center.y - 6.45
const powerHousingMaxY = powerSwitch.center.y + 6.45
const straightLeftEdgeYs = board.outline
  .filter(({ x }) => nearly(x, boardLeftX))
  .map(({ y }) => y)
assert.ok(Math.min(...straightLeftEdgeYs) <= powerHousingMinY &&
  Math.max(...straightLeftEdgeYs) >= powerHousingMaxY,
  "the power-switch housing is centered on the straight left edge, not a rounded corner")
assert.ok(Math.abs(pcbByName.get("J_BAT").center.y - boardBottomY) < 5,
  "battery connector is beside the bottom cable cutout")
const landscapePanelHalfWidthMm = 84.96 / 2
const bootJumperRightEdge = pcbByName.get("JP_BOOT").center.x + pcbByName.get("JP_BOOT").width / 2
assert.ok(bootJumperRightEdge < -landscapePanelHalfWidthMm,
  "boot solder bridge is fully outside the landscape LCD module envelope")
const batteryConnectorCourtyardRightX = pcbByName.get("J_BAT").center.x + 6.5492
const batteryCableBendCorridorMm = cutoutBounds.minX - batteryConnectorCourtyardRightX
assert.ok(batteryCableBendCorridorMm >= 5.9,
  "battery connector leaves at least 5.9 mm for the cable to bend before the cutout")

assert.match(cadByName.get("U1")?.model_step_url ?? "", /C1511928\.step/,
  "F1C100S uses the real JLC 3D model")
assert.match(cadByName.get("U_FLASH")?.model_step_url ?? "", /C97521\.step/,
  "SPI flash uses the real JLC 3D model")
assert.equal(cadByName.get("U1")?.show_as_bounding_box, undefined, "F1C100S is not a placeholder box")
assert.equal(cadByName.get("U_FLASH")?.show_as_bounding_box, undefined, "SPI flash is not a placeholder box")

const screenComponent = componentByName.get("ER_TFT035IPS_6")
const screenCad = cadByName.get("ER_TFT035IPS_6")
const screenModelFile = "er-tft035ips-6-oem-installed-v5.glb"
assert.ok(screenComponent, "ER-TFT035IPS-6 assembly screen exists")
assert.ok(screenCad, "ER-TFT035IPS-6 has a 3D assembly model")
assert.match(screenCad.model_glb_url ?? "", new RegExp(`${screenModelFile}$`),
  "screen uses the OEM STEP-derived GLB assembly rather than a generic slab")
assert.ok(nearly(screenCad.position.x, 40.8) && nearly(screenCad.position.y, 15),
  "screen 3D model is anchored to J_LCD")
assert.ok(nearly(screenCad.rotation.z, 90),
  "screen 3D model extends left from the right-side J_LCD cable-entry axis")
const screenGlb = readGlbJson(`assets/${screenModelFile}`)
const screenNode = screenGlb.nodes?.find(({ name }) => name === "ER-TFT035-6-OEM-installed")
assert.ok(screenNode, "screen GLB contains the named OEM node")
const screenMesh = screenGlb.meshes?.[screenNode.mesh]
assert.ok(screenMesh, "screen GLB OEM node references its exported mesh")
assert.equal(screenNode.extras?.source, "ER-TFT035-6.step",
  "screen GLB identifies the manufacturer STEP source")
assert.equal(screenNode.extras?.rigidGeometry, "OEM STEP, unscaled",
  "screen GLB records unscaled rigid OEM geometry")
assert.ok(nearly(screenNode.extras?.rigidPanelWidthMm, 84.96) &&
  nearly(screenNode.extras?.rigidPanelHeightMm, 56.54),
  "screen GLB records the exact 84.96 x 56.54 mm rigid outline")
assert.ok(nearly(screenNode.extras?.flexPathLengthMm, 30),
  "screen GLB records an exact 30 mm installed FPC path")
assert.ok(screenNode.extras?.minimumInstalledBendRadiusMm >= 2.0,
  `installed display flex bend radius is too small: ${screenNode.extras?.minimumInstalledBendRadiusMm}`)
assert.ok(screenNode.extras?.bendRadiusToThicknessRatio >= 10,
  `installed display flex bend ratio is too small: ${screenNode.extras?.bendRadiusToThicknessRatio}`)
const screenPositionAccessors = screenMesh.primitives
  .map(({ attributes }) => screenGlb.accessors[attributes.POSITION])
const screenModelMinLocalX = Math.min(...screenPositionAccessors.map(({ min }) => min[0]))
const screenModelMaxLocalX = Math.max(...screenPositionAccessors.map(({ max }) => max[0]))
const screenInstalledLateralOffsetMm = screenNode.extras.installedPanelLateralOffsetMm
assert.ok(nearly(screenInstalledLateralOffsetMm, 0),
  "screen GLB keeps the OEM panel and FPC on the same centerline")
assert.ok(nearly(screenModelMinLocalX, -28.27) && nearly(screenModelMaxLocalX, 28.27),
  "screen GLB exported X bounds match the centered 56.54 mm rigid panel")
const previousScreenTopOverhangMm = screenCad.position.y + screenModelMaxLocalX - 41
// Positive 90-degree Z rotation extends the model's positive local Y to the
// left of J_LCD, and maps local X onto PCB Y.
const screenTopEdgeY = screenCad.position.y + screenModelMaxLocalX
assert.ok(nearly(screenTopEdgeY, boardTopY),
  "screen top edge is exactly flush with the PCB top edge")

const printedPartNames = [
  "GBA_CASE_BASE", "GBA_CASE_LID", "GBA_BATTERY_DOOR",
  "LCD_CARRIER", "SPK_RETAINER", "DPAD_CAP", "BUTTON_CAP_A", "BUTTON_CAP_B",
  "BUTTON_CAP_X", "BUTTON_CAP_Y", "BUTTON_CAP_SELECT", "BUTTON_CAP_START",
  "SHOULDER_PADDLE_L", "SHOULDER_PADDLE_R",
]
const printedPartCad = new Map()
for (const name of printedPartNames) {
  const source = componentByName.get(name)
  assert.ok(source, `native printed part ${name} exists`)
  assert.equal(source.ftype, "printedpart", `${name} uses the native printed-part API`)
  assert.equal(source.material, "petg", `${name} has its intended printable material`)
  const models = of("cad_component").filter((cad) =>
    cad.source_component_id === source.source_component_id)
  assert.equal(models.length, 1, `${name} emits exactly one printable solid`)
  assert.equal(models[0].model_jscad?.type, "rotate", `${name} has native JSCAD geometry`)
  assert.ok(models[0].model_jscad?.shape, `${name} has a nonempty authored shape`)
  printedPartCad.set(name, models[0])
}

const baseShape = printedPartCad.get("GBA_CASE_BASE").model_jscad.shape
const lidShape = printedPartCad.get("GBA_CASE_LID").model_jscad.shape
const batteryDoorShape = printedPartCad.get("GBA_BATTERY_DOOR").model_jscad.shape
const carrierShape = printedPartCad.get("LCD_CARRIER").model_jscad.shape
const dpadShape = printedPartCad.get("DPAD_CAP").model_jscad.shape
assert.equal(baseShape.type, "subtract", "base is a printable shell with authored openings")
assert.equal(lidShape.type, "subtract", "lid is a printable bezel with authored openings")
assert.equal(batteryDoorShape.type, "subtract", "battery door has an authored panel, tongue, integral latch, and thumb dimple")
assert.equal(carrierShape.type, "subtract", "LCD carrier includes blind screw pilots")
const baseOuterPrism = baseShape.shapes[0].shapes[0].shapes[0]
const baseInnerPrism = baseShape.shapes[0].shapes[0].shapes[1]
assert.equal(baseOuterPrism.type, "translate", "base exterior is an extruded board-profile polygon")
assert.equal(baseInnerPrism.type, "translate", "base cavity uses an independent inset profile")
assert.equal(baseOuterPrism.shape.shape.points.length, board.outline.length,
  "manual enclosure preserves every rounded/chamfered board-outline segment")
assert.ok(nearly(baseOuterPrism.shape.options.height, 29),
  "continuous base wall reaches the authored lid datum from the two-AA depth")
assert.ok(nearly(baseInnerPrism.shape.options.height, 27.8),
  "continuous base has a 1.6 mm rear floor")
const bottomOuterY = Math.min(...baseOuterPrism.shape.shape.points.map(([, y]) => y))
const bottomInnerY = Math.min(...baseInnerPrism.shape.shape.points.map(([, y]) => y))
assert.ok(nearly(bottomInnerY - bottomOuterY, 1.4),
  "continuous base keeps a 1.4 mm wall after adding 0.8 mm PCB assembly clearance")
const batteryCradleShape = baseShape.shapes[0].shapes.find((shape) =>
  shape.type === "union" && shape.shapes?.length === 9 &&
  shape.shapes[0]?.shape?.size?.[1] === 58.1)
const batteryDoorOpening = baseShape.shapes.find((shape) =>
  shape.type === "union" && shape.shapes?.[1]?.shape?.size?.[0] === 33.6)
const batteryDoorRebate = baseShape.shapes.find((shape) =>
  shape.type === "union" && shape.shapes?.[1]?.shape?.size?.[0] === 37)
assert.equal(batteryCradleShape.type, "union", "base includes an integrated two-AA cradle")
assert.equal(batteryCradleShape.shapes.length, 9,
  "two-AA cradle has side rails, center rib, contact bulkheads, shelves, and two wire clips")
assert.deepEqual(batteryCradleShape.shapes[0].shape.size, [1.6, 58.1, 6],
  "two-AA cradle side rails overlap the 57.7 mm inside-wall contact layout")
assert.deepEqual(batteryCradleShape.shapes[2].shape.size, [1.2, 58.1, 2.4],
  "two-AA cradle has a low center separator joined to both contact bulkheads")
assert.ok(nearly(batteryCradleShape.shapes[3].shape.size[1], 1.65) &&
  nearly(batteryCradleShape.shapes[4].shape.size[1], 1.65),
  "battery contact bulkheads stay inside Keystone's 1.52-1.78 mm snap-on wall range")
const batteryInsideWallLengthMm =
  (batteryCradleShape.shapes[4].vector[1] - batteryCradleShape.shapes[4].shape.size[1] / 2) -
  (batteryCradleShape.shapes[3].vector[1] + batteryCradleShape.shapes[3].shape.size[1] / 2)
assert.ok(nearly(batteryInsideWallLengthMm, 57.7),
  "209/210 two-cell series contact bulkheads use the specified 57.7 mm inside-wall spacing")
assert.equal(batteryDoorOpening.type, "union", "base has a rounded removable-door opening")
assert.equal(batteryDoorRebate.type, "union", "base has a shallow flush-door rebate")
assert.deepEqual(batteryDoorOpening.shapes[1].shape.size, [33.6, 49.6, 2.4],
  "battery door opening is 33.6 x 56 mm with rounded corners")
assert.deepEqual(batteryDoorRebate.shapes[1].shape.size, [37, 51.4, 1.25],
  "battery door rebate is 37 x 59.4 mm and 1.25 mm deep")
const batteryDoorPanel = batteryDoorShape.shapes[0].shapes[0]
assert.equal(batteryDoorPanel.type, "union", "battery door starts with a rounded exterior panel")
assert.deepEqual(batteryDoorPanel.shapes[1].shape.size, [36.4, 51.4, 0.9],
  "battery door perimeter flange is 36.4 x 58.8 mm and 0.9 mm thick")
const batteryDoorReinforcement = batteryDoorShape.shapes[0].shapes[1]
assert.equal(batteryDoorReinforcement.type, "union", "battery door has an inner central reinforcement")
assert.ok(batteryDoorReinforcement.shapes[1].shape.size.every((value, index) =>
  nearly(value, [31.6, 49.6, 0.32][index])),
"battery door central doubler restores a 1.2 mm section inside the through-opening")
const batteryDoorUnionMembers = batteryDoorShape.shapes[0].shapes
const batteryLatchBeam = batteryDoorUnionMembers.find((shape) =>
  shape.shape?.type === "cuboid" && shape.shape.size?.[0] === 7.2 && shape.shape.size?.[1] === 11.2)
const batteryLatchHook = batteryDoorUnionMembers.find((shape) =>
  shape.shape?.type === "cuboid" && shape.shape.size?.[0] === 8.2 && shape.shape.size?.[1] === 2.0)
assert.ok(batteryLatchBeam && batteryLatchHook,
  "battery door has an integral cantilever beam and positive retaining hook")
assert.equal(batteryDoorShape.shapes.filter((shape) =>
  shape.shape?.type === "cuboid" && shape.shape.size?.[0] === 0.8 && shape.shape.size?.[1] === 11.2).length, 2,
"battery-door latch is released by two parallel compliance slots, not a loose printed part")
const findBaseCutoutAt = (x, y, z) => baseShape.shapes.find((shape) =>
  shape.vector && nearly(shape.vector[0], x) && nearly(shape.vector[1], y) && nearly(shape.vector[2], z))
const powerSwitchOpening = findBaseCutoutAt(-72, -24, 4.28)
const findRoundedShoulderOpening = (x) => baseShape.shapes.find((shape) =>
  shape.type === "translate" && shape.shape?.type === "roundedCuboid" &&
  nearly(shape.vector[0], x) && nearly(shape.vector[1], 44.67) && nearly(shape.vector[2], 4.98))
const shoulderOpenings = [findRoundedShoulderOpening(-45), findRoundedShoulderOpening(45)]
assert.deepEqual(powerSwitchOpening.shape.size, [9, 6.8, 4.2],
  "power-slider opening retains controlled side and vertical clearance")
assert.deepEqual(powerSwitchOpening.vector, [-72, -24, 4.28],
  "power-slider opening is centered on the measured actuator height")
for (const [index, opening] of shoulderOpenings.entries()) {
  assert.ok(opening, `rounded shoulder guide ${index + 1} exists`)
  assert.deepEqual(opening.shape.size, [21.6, 2.4, 6.4],
    `shoulder guide ${index + 1} preserves 0.30 mm lateral/vertical running clearance`)
  assert.ok(nearly(opening.shape.roundRadius, 1.0),
    `shoulder guide ${index + 1} uses a matched radiused profile`)
}
const lidPlatePrism = lidShape.shapes[0].shapes[0]
assert.equal(lidPlatePrism.type, "translate", "lid follows the same rounded board profile")
assert.ok(nearly(lidPlatePrism.shape.options.height, 1.6), "lid is 1.6 mm thick")
const lidRegistrationKeys = lidShape.shapes[0].shapes.slice(1, 5)
assert.deepEqual(lidRegistrationKeys.map((key) => key.shape.size), [
  [20, 0.8, 1.8], [20, 0.8, 1.8], [0.8, 12, 1.8], [0.8, 12, 1.8],
], "four broad internal registration keys locate the butt seam without entering the LCD envelope")
assert.ok(lidRegistrationKeys.every((key) => nearly(key.vector[2], 10.7)),
  "all registration keys engage the rear shell by 1.8 mm below the lid")
const enclosureOuterPoints = baseOuterPrism.shape.shape.points
const enclosureOutsideWidthMm = Math.max(...enclosureOuterPoints.map(([x]) => x)) -
  Math.min(...enclosureOuterPoints.map(([x]) => x))
const enclosureOutsideHeightMm = Math.max(...enclosureOuterPoints.map(([, y]) => y)) -
  Math.min(...enclosureOuterPoints.map(([, y]) => y))
const enclosureBottomZ = -17.4
const enclosureTopZ = 13.2

const mechanicalHoles = of("pcb_hole").filter((hole) => hole.pcb_component_id == null)
const expectedPcbMountHoles = [
  [-59.5, -34], [55.5, -38], [-66, 14], [62, 34.5],
]
const expectedScreenHoles = [
  [-48.75, 32.75], [51, 33], [-49, -35.5], [66, -31],
]
const findMechanicalHole = (x, y, diameter) => mechanicalHoles.find((hole) =>
  nearly(hole.x, x) && nearly(hole.y, y) && nearly(hole.hole_diameter, diameter))
for (const [x, y] of expectedPcbMountHoles)
  assert.ok(findMechanicalHole(x, y, 3.3), `M3 PCB support hole exists at ${x}, ${y}`)
const batteryPocketBounds = { minX: -40, maxX: -8, minY: -22.25, maxY: 32.25 }
const rigidScreenBounds = { minX: -45.16, maxX: 39.8, minY: -13.27, maxY: 43.27 }
const circleToRectGap = (x, y, rectangle) => Math.hypot(
  Math.max(rectangle.minX - x, 0, x - rectangle.maxX),
  Math.max(rectangle.minY - y, 0, y - rectangle.maxY),
)
for (const [x, y] of expectedPcbMountHoles) {
  assert.ok(circleToRectGap(x, y, batteryPocketBounds) >= 3.2,
    `PCB boss at ${x}, ${y} stays outside the battery-holder pocket`)
  assert.ok(circleToRectGap(x, y, rigidScreenBounds) >= 3.2,
    `PCB boss at ${x}, ${y} stays outside the rigid LCD footprint`)
}
for (const [x, y] of expectedScreenHoles) {
  const hole = findMechanicalHole(x, y, 2.7)
  assert.ok(hole, `dedicated M2.5 LCD-carrier hole exists at ${x}, ${y}`)
  let minimumTraceGap = Infinity
  for (const trace of of("pcb_trace")) {
    for (let index = 1; index < (trace.route?.length ?? 0); index++) {
      const start = trace.route[index - 1]
      const end = trace.route[index]
      if (start.route_type !== "wire" || end.route_type !== "wire") continue
      minimumTraceGap = Math.min(minimumTraceGap,
        pointToSegmentDistance(hole, start, end) - 2.7 / 2 - Math.max(start.width, end.width) / 2)
    }
  }
  assert.ok(minimumTraceGap >= 0.2 - 1e-6,
    `LCD hole at ${x}, ${y} has at least 0.20 mm finished-hole-to-trace clearance`)
}
assert.equal(mechanicalHoles.filter((hole) => nearly(hole.hole_diameter, 3.3)).length, 4,
  "exactly four PCB-to-base support holes are present")
assert.equal(mechanicalHoles.filter((hole) => nearly(hole.hole_diameter, 2.7)).length, 4,
  "exactly four independent LCD-carrier holes are present")

// Guard every previously observed carrier collision.  These are the tall
// controls/connectors whose actual 3D bodies reach the carrier's Z envelope.
const carrierMembers = carrierShape.shapes[0].shapes
const carrierStandoffs = carrierMembers.filter((member) => member.shape?.type === "cylinder")
const carrierBeams = carrierMembers.filter((member) => member.type === "translate" &&
  (member.shape?.type === "roundedCuboid" || member.shape?.shape?.type === "roundedCuboid"))
assert.equal(carrierStandoffs.length, 4, "LCD carrier has four independent screw standoffs")
assert.ok(carrierStandoffs.every((standoff) => standoff.shape.radius >= 3.6),
  "every LCD-carrier standoff has a reinforced 7.2 mm body")
assert.equal(carrierBeams.length, 14,
  "LCD carrier has two bezel rails and twelve joined rounded load-path beams")
const carrierLoadBeams = carrierBeams
assert.ok(carrierLoadBeams.every((beam) => nearly(beam.shape.shape.size[2], 1.8)),
  "LCD-carrier perimeter arms and ledges are 1.8 mm thick")
assert.ok(carrierLoadBeams.every((beam) =>
  nearly(beam.vector[2] + beam.shape.shape.size[2] / 2, 8.2)),
  "LCD-carrier perimeter has one planar Z=8.20 mm gasket bearing surface")
assert.ok(carrierLoadBeams.every((beam) => beam.shape.shape.size[1] >= 4),
  "every LCD-carrier rail or bridge is at least 4 mm wide")
// The carrier includes rotated and diagonal beams; source-level axis-aligned
// rectangles are not a safe collision approximation. export-3d-assembly.mjs
// checks every fitted GLB body against every boss and beam capsule instead.

assert.equal(dpadShape.type, "union", "D-pad combines a hidden socket carrier with a visible crown")
const dpadSocketCarrier = dpadShape.shapes.find((shape) => shape.type === "subtract")
const dpadVisibleCrown = dpadShape.shapes.find((shape) => shape.type === "union")
assert.ok(dpadSocketCarrier, "D-pad has a subtractive socket/pivot carrier")
assert.ok(dpadVisibleCrown && dpadVisibleCrown.shapes.length === 2,
  "D-pad has a complete two-arm visible cross independent of its actuator sockets")
const dpadCarrierMembers = dpadSocketCarrier.shapes[0].shapes
const dpadCaptureRings = dpadCarrierMembers.filter((shape) => shape.type === "subtract" &&
  shape.shapes?.every((member) => member.shape?.type === "cylinder"))
const dpadCaptureRoof = dpadCarrierMembers.find((shape) => shape.shape?.type === "cylinder" &&
  nearly(shape.shape.radius, 3.4) && nearly(shape.shape.height, 0.35))
assert.equal(dpadCaptureRings.length, 2,
  "D-pad has two concentric retention rings around the silicone pivot")
assert.ok(dpadCaptureRoof, "D-pad pivot recess has an integral retaining roof")
for (const name of ["DPAD_PIVOT_PAD", "BAT_CONTACT_COMMON_210", "BAT_CONTACT_NEG_209",
  "BAT_CONTACT_POS_228", "BAT_WIRE_NEG", "BAT_WIRE_POS", "SPK_WIRE_NEG", "SPK_WIRE_POS"]) {
  const source = componentByName.get(name)
  assert.ok(source, `${name} exists in the complete mechanical assembly`)
  assert.ok(of("cad_component").some((cad) => cad.source_component_id === source.source_component_id),
    `${name} has authored 3D geometry`)
}
const enclosureApertureMarkers = [
  "CASE_SCREEN_WINDOW",
]
assert.equal(componentByName.has("CASE_RESET_ACCESS"), false,
  "reset is an internal service control with no front-panel aperture")
assert.equal(componentByName.has("CASE_BAT_CABLE_EXIT"), false,
  "internal battery lead has no exterior enclosure aperture")
for (const name of ["CASE_UART_ACCESS", "CASE_I2C_ACCESS", "CASE_SPI_ACCESS"])
  assert.equal(componentByName.has(name), false,
    `${name} is absent because programming connectors are internal to the enclosure`)
for (const name of enclosureApertureMarkers) {
  assert.ok(componentByName.has(name), `${name} aperture marker exists`)
  assert.equal(pcbByName.get(name)?.do_not_place, true, `${name} is excluded from PCB assembly`)
  assert.equal(pcbByName.get(name)?.obstructs_within_bounds, false,
    `${name} cannot perturb PCB placement or routing`)
}

for (const traceName of ["SPK_POS_OUT", "SPK_NEG_OUT"])
  assert.ok(of("source_trace").some((trace) => trace.name === traceName),
    `J_SPK carries ${traceName} from the PAM8403 bridge output`)

const traces = of("pcb_trace")
assert.ok(traces.length >= 250, "dense routed design contains its expected copper traces")
assert.ok(!circuit.some((record) => /unrouted|trace_missing/i.test(record.type)), "no unrouted/missing-trace records")

const traceEndingWith = (suffix) => {
  const matches = traces.filter((trace) => trace.pcb_trace_id.endsWith(suffix))
  assert.equal(matches.length, 1, `one PCB trace ends with ${suffix}`)
  return matches[0]
}
const assertMinimumWireWidth = (trace, width, label) => {
  assert.ok(trace, `${label} has generated PCB copper`)
  const wireWidths = trace.route.filter((point) => point.route_type === "wire").map((point) => point.width)
  assert.ok(wireWidths.length > 0 && wireWidths.every((actual) => actual >= width - 1e-6),
    `${label} is physically routed at least ${width.toFixed(2)} mm wide`)
}
const traceById = (id) => {
  const found = traces.find((trace) => trace.pcb_trace_id === id)
  assert.ok(found, `${id} exists`)
  return found
}
for (const [id, label] of [
  ["twoaa_battery_path_0", "two-AA battery path"],
  ["twoaa_sys_sources_0", "USB/battery selected SYS_IN path"],
  ["twoaa_sys_input_0", "SYS_IN input-capacitor trunk"],
  ["twoaa_v3v3_trunk_0", "3V3 distribution trunk"],
]) assertMinimumWireWidth(traceById(id), 0.5, label)
for (const [id, label] of [
  ["twoaa_input_cap_a_0", "buck-boost input capacitor A link"],
  ["twoaa_input_cap_b_0", "buck-boost input capacitor B link"],
  ["twoaa_l1_0", "buck-boost L1 switching link"],
  ["twoaa_l2_0", "buck-boost L2 switching link"],
  ["twoaa_output_cap_a_0", "buck-boost output capacitor A link"],
  ["twoaa_output_cap_b_0", "buck-boost output capacitor B link"],
  ["twoaa_output_cap_c_0", "buck-boost output capacitor C link"],
]) {
  const widths = traceById(id).route.filter((point) => point.route_type === "wire").map((point) => point.width)
  assert.ok(Math.max(...widths) >= 0.5 - 1e-6, `${label} widens to 0.50 mm after the DSJ-package escape`)
  assert.ok(Math.min(...widths) >= 0.12 - 1e-6, `${label} never falls below the 0.12 mm fabrication minimum`)
}
const sourceTraceIdsByName = (name) => new Set(of("source_trace")
  .filter((trace) => trace.name === name)
  .map((trace) => trace.source_trace_id))
const pcbTracesForSourceName = (name) => {
  const ids = sourceTraceIdsByName(name)
  return traces.filter((trace) => ids.has(trace.source_trace_id))
}
const assertSourceNameWireWidth = (name, width, label = name) => {
  const matches = pcbTracesForSourceName(name)
  assert.ok(matches.length > 0, `${label} has generated PCB copper`)
  for (const trace of matches) assertMinimumWireWidth(trace, width, label)
}
for (const name of [
  "LCD_BL_VIN", "LCD_BL_INPUT_L", "LCD_BL_INPUT_CAP", "LCD_BL_SWITCH_L", "LCD_BL_SWITCH_D",
  "LCD_BL_OUTPUT_CAP",
]) assertSourceNameWireWidth(name, 0.5, `${name} backlight power link`)
assertSourceNameWireWidth("I2C_JST_3V3", 0.5, "I2C/SPI JST 3V3 branch")
// The panel string is regulated to 100 mA. Its board-spanning LED+ feed uses
// the 0.12 mm fabrication minimum so it can follow the already-verified LCD
// fanout corridor; even at 60 mm on 1 oz copper this is about 0.25 ohm / 25 mV.
// The high-di/dt boost input, switch node, diode and local capacitor links
// remain 0.50 mm above, where width and loop area materially affect EMI.
assertSourceNameWireWidth("LCD_BL_OUTPUT", 0.12, "LCD_BL_OUTPUT regulated 100 mA feed")
const usbVbusChainPorts = new Set([
  "pcb_port_424", "pcb_port_425", "pcb_port_434", "pcb_port_436", "pcb_port_450",
])
const usbVbusChainTraces = traces.filter((trace) => {
  const endpoints = (trace.connectsTo ?? []).filter((id) => id?.startsWith("pcb_port_"))
  return endpoints.length === 2 && endpoints.every((id) => usbVbusChainPorts.has(id))
})
assert.equal(usbVbusChainTraces.length, 4,
  "the complete USB-C VBUS chain has four routed branches")
const usbVbusMain = traceEndingWith("source_net_1_mst1_0")
const usbVbusDiode = traceEndingWith("source_net_1_mst3_0")
assertMinimumWireWidth(usbVbusMain, 0.2, "USB-C VBUS dual-pad escape")
assert.ok(Math.max(...usbVbusMain.route.filter((point) => point.route_type === "wire")
  .map((point) => point.width)) >= 0.5,
"USB-C VBUS connector-to-capacitor path reaches 0.50 mm trunk width")
assert.ok(usbVbusMain.route.some((point) => point.route_type === "wire" &&
  Math.abs(point.x + 10) < 1e-6 && Math.abs(point.y + 31.825) < 1e-6),
"USB-C VBUS 0.50 mm trunk passes through the input-capacitor pad")
assertMinimumWireWidth(usbVbusDiode, 0.5, "USB-C VBUS capacitor-to-diode trunk")
for (const suffix of ["source_net_1_mst0_0", "source_net_1_mst2_0"])
  assertMinimumWireWidth(traceEndingWith(suffix), 0.12, "USB ESD VBUS reference stub")

const batteryRangeText = of("pcb_silkscreen_text").find((text) => text.text === "2xAA 1.8-3.2V • NO CHARGE")
assert.ok(batteryRangeText, "battery silkscreen states the two-AA range and explicitly forbids charging")

const report = {
  circuitPath,
  generatedAt: new Date().toISOString(),
  board: {
    title: "F1C100S Linux Game Boy Advance",
    widthMm: board.width,
    heightMm: board.height,
    copperLayers: board.num_layers,
  },
  routing: {
    pcbTraces: traces.length,
    pcbVias: vias.length,
    viaHoleDiameterMm: 0.3,
    viaPadDiameterMm: 0.45,
    minimumFinishedHoleGapMm: Number(minimumFinishedHoleGap.toFixed(6)),
    closestViaPair,
    reviewedViaHoleToCopperGapMm: Number(reviewedViaCopperGap.toFixed(3)),
    reviewedViaNearestTrace,
    buckBoostPowerLinksMm: 0.5,
    buckBoostFinePitchNeckMm: 0.12,
    backlightSwitchingLinksMm: 0.5,
    backlightRegulatedFeedMm: 0.12,
    usbCToSystemPowerTrunkMm: 0.5,
    usbCConnectorEscapeNeckMm: 0.2,
  },
  mechanical: {
    batteryCableEdgeCut: {
      widthMm: Number((cutoutBounds.maxX - cutoutBounds.minX).toFixed(3)),
      overallLengthMm: Number((cutoutBounds.maxY - cutoutBounds.minY).toFixed(3)),
      depthIntoBoardMm: Number((cutoutBounds.maxY - boardBottomY).toFixed(3)),
      closedEnd: "rounded",
    },
    shoulderSwitches: "TS6695ZJ 022 low-profile right-angle housing, 9.5 mm switch height, 3.03 mm board-edge stem protrusion",
    volumeControl: {
      center: volumePlacement,
      rotationDeg: volumeRotationDeg,
      side: "upper-left rounded corner",
      wheelDirection: "upper-left corner bisector",
      wheelProtrusionMm: Number(volumeWheelProtrusionMm.toFixed(3)),
      housingCornerProtrusionMm: Number(volumeHousingCornerProtrusionMm.toFixed(3)),
      mountingSlotCopperToEdgeMm: Number(volumeMountingSlotEdgeClearanceMm.toFixed(3)),
      mountingSlotCopperClearancesMm: volumeSlotCopperClearances.map((clearance) => Number(clearance.toFixed(3))),
    },
    bootSolderJumper: {
      center: { x: -49.27, y: 18 },
      outsideLandscapeLcdEnvelope: true,
      normallyOpen: true,
      dnp: true,
      enclosureAccessHole: false,
    },
    startSelect: {
      select: { x: -14, y: -26 },
      start: { x: 1, y: -26 },
      arrangement: "central pair below display",
    },
    microSdEdge: "card-entry face flush with the PCB and recessed behind a 2.2 mm right-wall guard tunnel",
    microSdEntryFaceXmm: Number(microSdEntryFaceX.toFixed(3)),
    powerSwitchEdge: "straight left edge",
    powerSwitchBodyInsetMm: Number(powerBodyInsetMm.toFixed(3)),
    powerSwitchActuatorProtrusionMm: Number(powerActuatorProtrusionMm.toFixed(3)),
    batteryConnectorFacesCutout: true,
    batteryCableBendCorridorMm: Number(batteryCableBendCorridorMm.toFixed(3)),
    batteryHolder: {
      reference: "integrated two-AA bay using IEC/Energizer maximum cell envelope",
      maximumCellSizeMm: [14.5, 50.5],
      bayClearanceMm: [32, 57.7, 14.5],
      contactMountWallThicknessMm: 1.65,
      contactInsideWallSpacingMm: Number(batteryInsideWallLengthMm.toFixed(3)),
      installation: "two removable AA cells under the PCB; internal series contacts wire through the PCB slot to J_BAT",
      exteriorCableOpening: false,
      removableDoor: true,
    },
    powerSwitch: {
      center: { x: powerSwitch.center.x, y: powerSwitch.center.y },
      side: "straight lower-left side wall, clear of the rounded corner",
      actuatorDirection: "left",
      actuatorProtrusionMm: Number(powerActuatorProtrusionMm.toFixed(3)),
      bodyInsetMm: Number(powerBodyInsetMm.toFixed(3)),
      enclosureActuation: "direct-access protruding slider",
    },
    rearServiceConnectors: {
      uart: { center: { x: -18, y: 37 }, layer: "top", pinout: ["RX", "GND", "TX"] },
      i2c: { center: { x: -28, y: 37 }, layer: "top", pinout: ["GND", "3V3", "SDA", "SCL"] },
      spi: { center: { x: 22, y: 37 }, layer: "top", pinout: ["GND", "3V3", "SCLK", "MOSI", "MISO", "CS"] },
    },
  },
  display: {
    part: "ER-TFT035IPS-6",
    widthMm: 84.96,
    heightMm: 56.54,
    orientation: "landscape",
    fpcConnectorSide: "right",
    connectorRotationDeg: 270,
    connectorCenter: { x: 40.8, y: 15 },
    installedFlexLateralOffsetMm: screenInstalledLateralOffsetMm,
    boardTopEdgeYmm: boardTopY,
    panelTopEdgeYmm: Number(screenTopEdgeY.toFixed(3)),
    panelTopEdgeOffsetMm: Number((screenTopEdgeY - boardTopY).toFixed(3)),
    correctedPreviousTopOverhangMm: Number(previousScreenTopOverhangMm.toFixed(3)),
    assemblyModel: screenModelFile,
    backlightDriver: "AP3031KTR-G1",
    regulatedBacklightCurrentMa: lcdBacklightCurrentMa,
  },
  power: {
    labeledBatteryRangeV: [1.8, 3.2],
    batteryChemistry: "two removable alkaline or NiMH AA cells in series",
    batteryCharging: false,
    primaryRegulator: "TPS63020 buck-boost",
    usbPorts: ["J_USB (USB2 D+/D- plus default 5 V Type-C sink power)"],
  },
  models: {
    f1c100s: "C1511928",
    spiFlash: "C113767",
    shoulderSwitch: "C33543618",
    screen: screenModelFile,
    enclosure: "serviceable PETG shells with rear M3 closure, captive controls, two-AA door, sealed speaker, and four-point LCD carrier",
    fittedPartsWithRenderableModels: fitted.length - missingCadModels.length,
    missingRenderableModels: missingCadModels,
  },
  audio: {
    speakerConnector: "J_SPK",
    output: "PAM8403 mono bridge SPK+/SPK- for an internal 4-8 ohm speaker",
  },
  assembly: {
    fittedComponents: fitted.length,
    uniqueJlcpcbPartNumbers: uniqueJlcpcbParts.size,
    missingJlcpcbPartNumbers: missingJlcpcb,
    enclosure: {
      outsideWidthMm: Number(enclosureOutsideWidthMm.toFixed(3)),
      outsideHeightMm: Number(enclosureOutsideHeightMm.toFixed(3)),
      overallOutsideZMm: Number((enclosureTopZ - enclosureBottomZ).toFixed(3)),
      generalBodyOutsideZMm: Number((enclosureTopZ - enclosureBottomZ).toFixed(3)),
      enclosureBottomZmm: enclosureBottomZ,
      bodies: printedPartNames.length,
      printedParts: printedPartNames,
      wallThicknessMm: 1.4,
      floorThicknessMm: 1.6,
      lidThicknessMm: 1.6,
      boardClearanceMm: 0.8,
      generalPcbUnderbodyClearanceMm: 15,
      batteryHolderPocketDepthMm: 14.5,
      batteryDoorFlangeMm: [36.4, 58.8, 0.9],
      batteryDoorCentralPanelMm: [31.6, 53.8, 1.2],
      batteryDoorOpeningMm: [33.6, 56],
      batteryDoorRebateMm: [37, 59.4, 1.25],
      batteryDoorClosure: "insertion tongue plus integral cantilever latch with positive hook and exterior thumb dimple",
      topHeadroomMm: 10.8,
      closure: "four rear M3x24 screws through PCB into front-shell heat-set inserts and nylon washers",
      lidRegistration: "four broad 0.8 x 1.8 mm internal tongues in component-free edge regions",
      profileVertices: board.outline.length,
      pcbSupportHoles: expectedPcbMountHoles.length,
      lcdCarrierHoles: expectedScreenHoles.length,
      lcdCarrierHoleDiameterMm: 2.7,
      lcdCarrierFastener: "M2.5 thread-forming screw from PCB underside",
      lcdPerimeterSupportZmm: 8.2,
      lcdCarrierCenterOpen: true,
      lcdCarrierArmThicknessMm: 1.8,
      lcdCarrierMinimumRailWidthMm: 4,
      fullPanelPocketMm: [86.46, 57.04],
      displayGasketsMm: { front: 0.5, rear: 0.5 },
      speakerCradle: "Same Sky CMS-2004-18SP 20 mm x 4.2 mm speaker, real terminal pads, snap strain relief, foam gasket, printed retainer, two M2 screws, modeled harness and four 1.6 mm feet",
      faceControls: "six captive rear-flanged caps with 0.05 mm silicone anti-rattle preload plus one centrally pivoted D-pad with snap-captured silicone pad",
      shoulderControls: "two close-fit rounded sliding keys with twin guide rails, independent retaining tabs and blind TS6695 actuator pockets",
      apertureMarkers: enclosureApertureMarkers,
    },
  },
  controls: expectedButtons.length,
  schematic: {
    sheets: [...sheetNames],
    standardProgrammerUart: "RX-GND-TX with 100 ohm RX/TX series isolation",
  },
  errorsByType: {},
  emittedErrors: 0,
}

fs.writeFileSync("verification.json", `${JSON.stringify(report, null, 2)}\n`)
console.log(JSON.stringify(report, null, 2))