@tscircuit/3d-viewer 0.0.599 → 0.0.601

package/README.md

@@ -146,6 +146,106 @@ Each component has specific props for defining its characteristics and position
 
 ## Advanced Usage
 
+### Non-blocking renderer comparison diagnostics
+
+The `Diagnostics/Renderer Parity` stories compare the actual viewer with
+`circuit-json-to-gltf` using the same Circuit JSON and local model assets:
+
+```bash
+bun run storybook:comparisons
+```
+
+This opens `Diagnostics/Renderer Parity / X Rotation` directly instead of
+restoring an unrelated story. The ordinary `bun run storybook` entry point is
+unchanged.
+
+Each comparison story automatically displays **both oblique and side geometry**
+once its model geometry loads. Both panels remain visible, with the exact
+unlit/no-texture PNGs, edge maps, red/cyan overlays, and metrics used by the
+browser tests. There are no comparison buttons. Click an image to download its
+full-resolution PNG. Bottom-layer fixtures use cameras below the PCB.
+
+circuit-json-to-gltf is a development-only dependency. A Bun preparation step generates
+GLBs and records circuit-json-to-gltf failures; it is not imported into the viewer's
+production bundle or the browser story. Model files are local, not fetched from
+ModelCDN during the tests.
+
+`build-storybook` also prepares the fixture data, so the existing `vercel-build`
+entry point publishes working comparison stories. Vercel hosts those static
+stories; Playwright diagnostics run separately in GitHub Actions.
+
+The browser suite has two separate roles:
+
+```bash
+# Blocking tests of the matcher itself and deliberate browser mutations
+bun test ./tests/geometry-edge-*.test.ts ./tests/renderer-diagnostic-result.test.ts ./tests/renderer-comparison-*.test.ts ./tests/renderer-usb-mounting.test.ts
+bun run test:renderer-calibration
+
+# Diagnostic comparisons: failures are reported but do not gate a completed run
+bun run test:renderer-comparisons
+bunx --no-install playwright show-report
+```
+
+Install the test browser with `bunx playwright install chromium` if Playwright
+reports that its Chromium executable is missing.
+
+CI uses Ubuntu, Node 22, Bun 1.3.14 and the Chromium version paired with the
+pinned Playwright dependency. `playwright install --with-deps chromium`
+installs the Linux browser libraries; captures use software WebGL and require
+no physical GPU. Playwright executes under Node even when launched by a Bun
+package script.
+
+A local Node 26 `module.register()` deprecation warning is not a test failure;
+Node 22 is the CI runtime. Vite messages about missing dependency source maps
+(for example `manifold-3d/lib/wasm.js.map`) concern debugger metadata, not a
+missing JavaScript or WebAssembly module. A run ending in `passed` completed
+successfully. Runtime/model-loading errors are still surfaced normally; the
+harness does not blanket-suppress logs.
+
+Actual comparisons are ordinary failing Playwright assertions, not skipped or
+automatically approved baselines. The runner retains those failures and their
+artifacts but returns success after a completed diagnostic report, making it
+non-blocking for local gate runners too. Missing reports, global runner errors,
+and interrupted runs still fail. For strict exit behavior, invoke
+`bunx playwright test --project=diagnostics` directly.
+
+The CI comparison step additionally has `continue-on-error: true`.
+Dependency setup, matcher/runner unit tests, and browser calibration remain blocking.
+The workflow always uploads the HTML report, geometry images, edge maps, diff
+overlays, metadata, and failure traces.
+
+The geometry pass isolates the studied CAD component, preserves its actual
+world placement, and uses neutral unlit surfaces rather than textures/shadows.
+The exported GLB receives only the fixed frame conversion back to project
+coordinates: `P = (-G.x, G.z, G.y)`. Both sides use the same orthographic camera
+and viewport. There is no recentering, image registration, or per-renderer fit.
+
+The matcher checks edge coverage in both directions with a 1.5-pixel tolerance
+and at most 1% unmatched edges on each side. It does not average differences
+over the whole PCB image. Browser calibration requires identical geometry to
+match and deliberate X-sign, rotation-order, and 0.2248885 mm origin errors to
+be rejected. Pixel agreement is not a substitute for the existing numerical
+placement tests, and it is not a test of material or normal appearance.
+The calibration case has no exported GLB and compares viewer geometry only, so
+browser-side exporter failures remain in the non-blocking diagnostic stage.
+Diff overlays show unmatched viewer edges in red, unmatched exporter edges in
+cyan, and covered edges in gray.
+
+Cases keep rotation, origin inference, format dispatch, and the physical USB
+mounting example separate. Explicit-origin zero/Z cases are controls; missing-origin
+cases retain their original alignment tags. Generated output lives in ignored
+directories, never committed PNG baselines. See
+[`tests/fixtures/renderer-parity/README.md`](tests/fixtures/renderer-parity/README.md)
+for source provenance and the common-board adaptation.
+
+Nonzero angle probes use oblique values (for example X=37, Y=30, Z=47, and
+mixed 23/31/47), not quarter turns that can conceal symmetry and axis mistakes.
+Zero angles and the renderer's implicit bottom-layer fallback remain deliberate
+controls. The physical USB mounting fixture is a documented exception: its
+native Z-up mesh requires Z=270 degrees to fit the footprint. Actual tab/hole
+and contact/pad geometry is checked separately. The original USB missing-origin
+input remains a distinct diagnostic, not the mounted pose's zero-angle control.
+
 ### Custom Component Models
 
 You can define custom 3D models for components using the `cadModel` prop:

package/dist/index.js

@@ -26343,6 +26343,292 @@ var FootprintPlatedHole = ({
   }
   throw new Error("Shape not supported: " + hole.shape);
 };
+function LGA(p) {
+  for (const k of [
+    "bodyWidth",
+    "bodyLength",
+    "bodyHeight",
+    "pitch",
+    "landWidth",
+    "landLength",
+    "landThickness"
+  ])
+    if (!Number.isFinite(p[k]) || p[k] <= 0)
+      throw new Error(`${k} must be finite and positive`);
+  for (const k of ["landsPerSideX", "landsPerSideY"])
+    if (!Number.isInteger(p[k]) || p[k] < 0)
+      throw new Error(`${k} must be a nonnegative integer`);
+  if (!Number.isFinite(p.edgeInset) || p.edgeInset < 0 || p.landThickness >= p.bodyHeight || p.landWidth >= p.pitch || p.landsPerSideX + p.landsPerSideY < 1)
+    throw new Error("Invalid land layout or thickness");
+  const layouts = [
+    {
+      count: p.landsPerSideX,
+      across: p.bodyWidth,
+      along: p.bodyLength,
+      horizontal: true
+    },
+    {
+      count: p.landsPerSideY,
+      across: p.bodyLength,
+      along: p.bodyWidth,
+      horizontal: false
+    }
+  ];
+  for (const l of layouts) {
+    if (l.count === 0) continue;
+    const row = (l.count - 1) * p.pitch + p.landWidth;
+    if (row >= l.along - 2 * p.edgeInset || 2 * (p.edgeInset + p.landLength) >= l.across)
+      throw new Error(
+        "Lands must fit below the body without opposite-row overlap"
+      );
+    const other = l.horizontal ? p.landsPerSideY : p.landsPerSideX;
+    if (other > 0 && row >= l.along - 2 * (p.edgeInset + p.landLength) && (other - 1) * p.pitch + p.landWidth >= l.across - 2 * (p.edgeInset + p.landLength))
+      throw new Error("Adjacent land rows overlap at corners");
+  }
+  const r = Math.min(p.bodyWidth, p.bodyLength) * 0.035;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#353535", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      /* @__PURE__ */ jsx2(Translate, { z: (p.bodyHeight + p.landThickness / 2) / 2, children: /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [
+            p.bodyWidth,
+            p.bodyLength,
+            p.bodyHeight - p.landThickness / 2
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx2(
+        Translate,
+        {
+          offset: [
+            -p.bodyWidth / 2 + 2 * r,
+            p.bodyLength / 2 - 2 * r,
+            p.bodyHeight
+          ],
+          children: /* @__PURE__ */ jsx2(Cylinder, { radius: r, height: Math.min(0.04, p.bodyHeight / 10) })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#c5b987", children: layouts.flatMap(
+      (l) => [-1, 1].flatMap(
+        (sign) => Array.from({ length: l.count }, (_, i) => {
+          const across = sign * (l.across / 2 - p.edgeInset - p.landLength / 2), along = ((l.count - 1) / 2 - i) * p.pitch;
+          return /* @__PURE__ */ jsx2(
+            Translate,
+            {
+              offset: [
+                l.horizontal ? across : along,
+                l.horizontal ? along : across,
+                p.landThickness / 2
+              ],
+              children: /* @__PURE__ */ jsx2(
+                Cuboid,
+                {
+                  size: l.horizontal ? [p.landLength, p.landWidth, p.landThickness] : [p.landWidth, p.landLength, p.landThickness]
+                }
+              )
+            },
+            `${l.horizontal}-${sign}-${i}`
+          );
+        })
+      )
+    ) })
+  ] });
+}
+function createDualRowGullWing(p) {
+  const {
+    pinCount,
+    pitch,
+    bodyWidth,
+    bodyLength: bodyLength10,
+    bodyHeight,
+    standoff,
+    leadSpan,
+    leadWidth,
+    leadThickness,
+    contactLength,
+    taperInset,
+    exposedPadWidth = 0,
+    exposedPadLength = 0
+  } = p;
+  for (const key of [
+    "pitch",
+    "bodyWidth",
+    "bodyLength",
+    "bodyHeight",
+    "leadSpan",
+    "leadWidth",
+    "leadThickness",
+    "contactLength"
+  ])
+    if (!Number.isFinite(p[key]) || p[key] <= 0)
+      throw new Error(`${key} must be finite and positive`);
+  for (const [name, value] of Object.entries({
+    standoff,
+    taperInset,
+    exposedPadWidth,
+    exposedPadLength
+  }))
+    if (!Number.isFinite(value) || value < 0)
+      throw new Error(`${name} must be finite and nonnegative`);
+  if (!Number.isInteger(pinCount) || pinCount < 4 || pinCount % 2)
+    throw new Error("pinCount must be even and at least 4");
+  const moldHeight = bodyHeight - standoff;
+  const reach = (leadSpan - bodyWidth) / 2;
+  const rowLength = (pinCount / 2 - 1) * pitch + leadWidth;
+  if (moldHeight <= leadThickness * 2 || leadWidth >= pitch || rowLength >= bodyLength10 - 2 * taperInset || taperInset * 2 >= Math.min(bodyWidth, bodyLength10) || contactLength >= reach)
+    throw new Error("Invalid mold, lead spacing, or terminal reach");
+  if (exposedPadWidth === 0 !== (exposedPadLength === 0) || exposedPadWidth >= bodyWidth - 2 * taperInset || exposedPadLength >= bodyLength10 - 2 * taperInset)
+    throw new Error("Exposed pad must fit inside the bottom mold face");
+  const midZ = standoff + moldHeight / 2;
+  const slice = Math.min(2e-3, moldHeight / 100);
+  const body = /* @__PURE__ */ jsxs(Hull, { children: [
+    /* @__PURE__ */ jsx2(Translate, { z: standoff + slice / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          bodyWidth - 2 * taperInset,
+          bodyLength10 - 2 * taperInset,
+          slice
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx2(Translate, { z: midZ, children: /* @__PURE__ */ jsx2(Cuboid, { size: [bodyWidth, bodyLength10, slice] }) }),
+    /* @__PURE__ */ jsx2(Translate, { z: bodyHeight - slice / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          bodyWidth - 2 * taperInset,
+          bodyLength10 - 2 * taperInset,
+          slice
+        ]
+      }
+    ) })
+  ] });
+  const dimpleRadius = Math.min(bodyWidth, bodyLength10) * 0.045;
+  const dimpleDepth = Math.min(0.04, moldHeight / 10);
+  const lead = (side, y) => {
+    const outer = leadSpan / 2;
+    const root = bodyWidth / 2 - Math.min(bodyWidth / 8, 0.15);
+    const bendStart = outer - contactLength;
+    const bendEnd = bodyWidth / 2 + Math.min(0.08, (reach - contactLength) / 4);
+    const points = [
+      [outer - slice / 2, leadThickness / 2],
+      [bendStart, leadThickness / 2]
+    ];
+    for (let i = 1; i <= 12; i++) {
+      const t = i / 12;
+      points.push([
+        bendStart + (bendEnd - bendStart) * t,
+        leadThickness / 2 + (midZ - leadThickness / 2) * t * t * (3 - 2 * t)
+      ]);
+    }
+    points.push([root, midZ]);
+    const section = ([x, z22]) => /* @__PURE__ */ jsx2(Translate, { offset: { x: side * x, y, z: z22 }, children: /* @__PURE__ */ jsx2(Cuboid, { size: [slice, leadWidth, leadThickness] }) });
+    return /* @__PURE__ */ jsx2(Union, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs(Hull, { children: [
+      section(points[i]),
+      section(point)
+    ] }, i)) });
+  };
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#353535", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      body,
+      /* @__PURE__ */ jsx2(
+        Translate,
+        {
+          offset: {
+            x: -bodyWidth / 2 + taperInset + dimpleRadius * 2,
+            y: bodyLength10 / 2 - taperInset - dimpleRadius * 2,
+            z: bodyHeight
+          },
+          children: /* @__PURE__ */ jsx2(Cylinder, { radius: dimpleRadius, height: dimpleDepth * 2 })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#bfc1c4", children: Array.from(
+      { length: pinCount },
+      (_, i) => lead(
+        i < pinCount / 2 ? -1 : 1,
+        ((pinCount / 2 - 1) / 2 - i % (pinCount / 2)) * pitch
+      )
+    ) }),
+    exposedPadWidth > 0 && /* @__PURE__ */ jsx2(Colorize, { color: "#bfc1c4", children: /* @__PURE__ */ jsx2(Translate, { z: (standoff + leadThickness) / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          exposedPadWidth,
+          exposedPadLength,
+          standoff + leadThickness
+        ]
+      }
+    ) }) })
+  ] });
+}
+var SSOP = (props) => createDualRowGullWing(props);
+function renderFootprinterBodyModel(p) {
+  if (p.bodywidth === void 0 && p.bodyheight === void 0 && p.bodythickness === void 0)
+    return null;
+  if (p.fn === "ssop") {
+    const bodyWidth = p.bodywidth ?? p.w * 0.55;
+    const bodyLength10 = p.bodyheight ?? (p.num_pins / 2 - 1) * p.p + p.pw + 0.4;
+    const thickness = p.bodythickness ?? 1;
+    const leadWidth = Math.min(p.pw, p.p * 0.5);
+    const rowLength = (p.num_pins / 2 - 1) * p.p + leadWidth;
+    if (bodyLength10 <= rowLength)
+      throw new Error("SSOP bodyheight must contain the lead row");
+    const leadSpan = Math.max(p.w + 0.2 + p.pl / 2, bodyWidth + p.p);
+    const standoff = Math.min(0.1, thickness / 10);
+    return /* @__PURE__ */ jsx2(
+      SSOP,
+      {
+        pinCount: p.num_pins,
+        pitch: p.p,
+        bodyWidth,
+        bodyLength: bodyLength10,
+        bodyHeight: thickness + standoff,
+        standoff,
+        leadSpan,
+        leadWidth,
+        leadThickness: Math.min(0.15, thickness / 4),
+        contactLength: Math.min(p.pl / 2, (leadSpan - bodyWidth) / 4),
+        taperInset: Math.min(0.12, (bodyLength10 - rowLength) / 4, bodyWidth / 8)
+      }
+    );
+  }
+  if (p.fn === "lga") {
+    const bodyWidth = p.bodywidth ?? p.w;
+    const bodyLength10 = p.bodyheight ?? p.h;
+    const thickness = p.bodythickness ?? 1;
+    const grid2 = p.grid;
+    const landWidth = Math.min(p.pw, p.p / 2);
+    const roomX = bodyWidth - ((grid2.y - 1) * p.p + landWidth);
+    const roomY = bodyLength10 - ((grid2.x - 1) * p.p + landWidth);
+    const landLength = Math.min(
+      p.pl / 2,
+      bodyWidth / 8,
+      bodyLength10 / 8,
+      roomX / 4,
+      roomY / 4
+    );
+    return /* @__PURE__ */ jsx2(
+      LGA,
+      {
+        bodyWidth,
+        bodyLength: bodyLength10,
+        bodyHeight: thickness,
+        landsPerSideX: grid2.x,
+        landsPerSideY: grid2.y,
+        pitch: p.p,
+        landWidth,
+        landLength,
+        edgeInset: 0,
+        landThickness: Math.min(0.015, thickness / 10)
+      }
+    );
+  }
+  return null;
+}
 var ChipBody = ({
   center,
   width: width10,
@@ -26591,7 +26877,7 @@ var SmdChipLead = (props) => {
   const polygon2 = getExpandedStroke(points, thickness);
   return /* @__PURE__ */ jsx2(Colorize, { color: "#fff", children: /* @__PURE__ */ jsx2(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx2(Rotate, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx2(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx2(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx2(Polygon, { points: polygon2.map((p) => [p.x, p.y]) }) }) }) }) }) });
 };
-var Tssop = ({
+var LegacyTssop = ({
   pinCount,
   leadLength,
   leadWidth,
@@ -26669,7 +26955,8 @@ var Tssop = ({
     )
   ] });
 };
-var MSOP = ({
+var Tssop = (props) => "leadSpan" in props ? createDualRowGullWing(props) : LegacyTssop(props);
+var LegacyMSOP = ({
   pinCount,
   padContactLength = 0.4,
   leadWidth = 0.2,
@@ -26727,6 +27014,7 @@ var MSOP = ({
     )
   ] });
 };
+var MSOP = (props) => "leadSpan" in props ? createDualRowGullWing(props) : LegacyMSOP(props);
 var fullLength = 1;
 var width = 0.5;
 var height = 0.5;
@@ -27105,6 +27393,103 @@ var PinRow = ({
     );
   }) });
 };
+function createPhysicalQfn(p) {
+  const {
+    num_pins,
+    bodyWidth,
+    bodyLength: bodyLength10,
+    bodyHeight,
+    standoff,
+    terminalSpanX,
+    terminalSpanY,
+    terminalThickness,
+    padWidth,
+    padLength,
+    pitch,
+    exposedPadWidth,
+    exposedPadLength
+  } = p;
+  for (const key of [
+    "bodyWidth",
+    "bodyLength",
+    "bodyHeight",
+    "terminalSpanX",
+    "terminalSpanY",
+    "terminalThickness",
+    "padWidth",
+    "padLength",
+    "pitch",
+    "exposedPadWidth",
+    "exposedPadLength"
+  ])
+    if (!Number.isFinite(p[key]) || p[key] <= 0)
+      throw new Error(`${key} must be finite and positive`);
+  if (!Number.isInteger(num_pins) || num_pins < 8 || num_pins % 4)
+    throw new Error("num_pins must be divisible by four and at least eight");
+  if (!Number.isFinite(standoff) || standoff < 0)
+    throw new Error("standoff must be finite and nonnegative");
+  const rowLength = (num_pins / 4 - 1) * pitch + padWidth;
+  if (terminalThickness <= standoff || terminalThickness >= bodyHeight || padWidth >= pitch || rowLength >= Math.min(bodyWidth, bodyLength10))
+    throw new Error("Invalid mold, terminal thickness or spacing");
+  if (terminalSpanX < bodyWidth || terminalSpanY < bodyLength10 || terminalSpanX / 2 - padLength >= bodyWidth / 2 || terminalSpanY / 2 - padLength >= bodyLength10 / 2 || exposedPadWidth >= Math.min(bodyWidth, terminalSpanX - 2 * padLength) || exposedPadLength >= Math.min(bodyLength10, terminalSpanY - 2 * padLength) || rowLength >= Math.min(terminalSpanX, terminalSpanY) - 2 * padLength)
+    throw new Error(
+      "Terminals must enter the mold and clear the exposed pad and corners"
+    );
+  const body = /* @__PURE__ */ jsx2(Translate, { z: (bodyHeight + standoff) / 2, children: /* @__PURE__ */ jsx2(Cuboid, { size: [bodyWidth, bodyLength10, bodyHeight - standoff] }) });
+  const radius = Math.min(bodyWidth, bodyLength10) * 0.035;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#353535", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      body,
+      /* @__PURE__ */ jsx2(
+        Translate,
+        {
+          offset: {
+            x: -bodyWidth / 2 + radius * 2,
+            y: bodyLength10 / 2 - radius * 2,
+            z: bodyHeight
+          },
+          children: /* @__PURE__ */ jsx2(
+            Cylinder,
+            {
+              radius,
+              height: Math.min(0.06, (bodyHeight - standoff) / 5)
+            }
+          )
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#bfc1c4", children: Array.from({ length: num_pins }, (_, i) => {
+      const side = Math.floor(i / (num_pins / 4));
+      const along = ((num_pins / 4 - 1) / 2 - i % (num_pins / 4)) * pitch;
+      const horizontal = side % 2 === 0;
+      const sign = side < 2 ? -1 : 1;
+      const across = ((horizontal ? terminalSpanX : terminalSpanY) - padLength) / 2 * sign;
+      return /* @__PURE__ */ jsx2(
+        Translate,
+        {
+          offset: {
+            x: horizontal ? across : along,
+            y: horizontal ? along : across,
+            z: terminalThickness / 2
+          },
+          children: /* @__PURE__ */ jsx2(
+            Cuboid,
+            {
+              size: horizontal ? [padLength, padWidth, terminalThickness] : [padWidth, padLength, terminalThickness]
+            }
+          )
+        },
+        i
+      );
+    }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#bfc1c4", children: /* @__PURE__ */ jsx2(Translate, { z: terminalThickness / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [exposedPadWidth, exposedPadLength, terminalThickness]
+      }
+    ) }) })
+  ] });
+}
 var getQuadCoords2 = (params) => {
   const SIDES_CCW2 = ["left", "bottom", "right", "top"];
   const { pin_count, pn, w, h: h2, p, pl, legsoutside } = params;
@@ -27188,7 +27573,7 @@ var getQuadPinMap2 = ({
   }
   return pin_map;
 };
-var QFN = ({
+var LegacyQFN = ({
   num_pins = 16,
   bodyWidth = 9,
   bodyLength: bodyLength10 = 9,
@@ -27258,6 +27643,7 @@ var QFN = ({
     )
   ] });
 };
+var QFN = (props) => "bodyHeight" in props ? createPhysicalQfn(props) : LegacyQFN(props);
 var qfn_default = QFN;
 var SOT235 = () => {
   const fullWidth = 2.8;
@@ -28002,7 +28388,7 @@ var PushButtonLeg = (props) => {
     }
   ) });
 };
-var SOIC = ({
+var LegacySOIC = ({
   pinCount,
   leadLength,
   leadWidth,
@@ -28062,6 +28448,7 @@ var SOIC = ({
     )
   ] });
 };
+var SOIC = (props) => "leadSpan" in props ? createDualRowGullWing(props) : LegacySOIC(props);
 var VSSOP = ({
   pinCount,
   pitch,
@@ -29110,7 +29497,140 @@ var SOT323 = () => {
     )
   ] });
 };
-var LQFP = ({
+function createPhysicalLqfp(p) {
+  const {
+    pinCount,
+    pitch,
+    bodyWidth,
+    bodyLength: bodyLength10,
+    bodyHeight,
+    standoff,
+    leadSpanX,
+    leadSpanY,
+    leadWidth,
+    leadThickness,
+    contactLength,
+    taperInset
+  } = p;
+  for (const key of [
+    "pitch",
+    "bodyWidth",
+    "bodyLength",
+    "bodyHeight",
+    "leadSpanX",
+    "leadSpanY",
+    "leadWidth",
+    "leadThickness",
+    "contactLength"
+  ])
+    if (!Number.isFinite(p[key]) || p[key] <= 0)
+      throw new Error(`${key} must be finite and positive`);
+  for (const [name, value] of Object.entries({
+    standoff,
+    taperInset
+  }))
+    if (!Number.isFinite(value) || value < 0)
+      throw new Error(`${name} must be finite and nonnegative`);
+  if (!Number.isInteger(pinCount) || pinCount < 8 || pinCount % 4)
+    throw new Error("pinCount must be divisible by four and at least eight");
+  const moldHeight = bodyHeight - standoff;
+  const reach = Math.min(leadSpanX - bodyWidth, leadSpanY - bodyLength10) / 2;
+  const rowLength = (pinCount / 4 - 1) * pitch + leadWidth;
+  if (moldHeight <= leadThickness * 2 || leadWidth >= pitch || rowLength >= Math.min(bodyWidth, bodyLength10) - 2 * taperInset || taperInset * 2 >= Math.min(bodyWidth, bodyLength10) || contactLength >= reach)
+    throw new Error("Invalid mold, lead spacing, or terminal reach");
+  const midZ = standoff + moldHeight / 2;
+  const slice = Math.min(2e-3, moldHeight / 100);
+  const body = /* @__PURE__ */ jsxs(Hull, { children: [
+    /* @__PURE__ */ jsx2(Translate, { z: standoff + slice / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          bodyWidth - 2 * taperInset,
+          bodyLength10 - 2 * taperInset,
+          slice
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx2(Translate, { z: midZ, children: /* @__PURE__ */ jsx2(Cuboid, { size: [bodyWidth, bodyLength10, slice] }) }),
+    /* @__PURE__ */ jsx2(Translate, { z: bodyHeight - slice / 2, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          bodyWidth - 2 * taperInset,
+          bodyLength10 - 2 * taperInset,
+          slice
+        ]
+      }
+    ) })
+  ] });
+  const dimpleRadius = Math.min(bodyWidth, bodyLength10) * 0.045;
+  const dimpleDepth = Math.min(0.04, moldHeight / 10);
+  const lead = (side, along) => {
+    const horizontal = side % 2 === 0;
+    const sign = side < 2 ? -1 : 1;
+    const width10 = horizontal ? bodyWidth : bodyLength10;
+    const outer = (horizontal ? leadSpanX : leadSpanY) / 2;
+    const root = width10 / 2 - Math.min(width10 / 8, 0.15);
+    const bendStart = outer - contactLength;
+    const bendEnd = width10 / 2 + Math.min(0.08, (reach - contactLength) / 4);
+    const points = [
+      [outer - slice / 2, leadThickness / 2],
+      [bendStart, leadThickness / 2]
+    ];
+    for (let i = 1; i <= 12; i++) {
+      const t = i / 12;
+      points.push([
+        bendStart + (bendEnd - bendStart) * t,
+        leadThickness / 2 + (midZ - leadThickness / 2) * t * t * (3 - 2 * t)
+      ]);
+    }
+    points.push([root, midZ]);
+    const section = ([x, z22]) => /* @__PURE__ */ jsx2(
+      Translate,
+      {
+        offset: {
+          x: horizontal ? sign * x : along,
+          y: horizontal ? along : sign * x,
+          z: z22
+        },
+        children: /* @__PURE__ */ jsx2(
+          Cuboid,
+          {
+            size: horizontal ? [slice, leadWidth, leadThickness] : [leadWidth, slice, leadThickness]
+          }
+        )
+      }
+    );
+    return /* @__PURE__ */ jsx2(Union, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs(Hull, { children: [
+      section(points[i]),
+      section(point)
+    ] }, i)) });
+  };
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#353535", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      body,
+      /* @__PURE__ */ jsx2(
+        Translate,
+        {
+          offset: {
+            x: -bodyWidth / 2 + taperInset + dimpleRadius * 2,
+            y: bodyLength10 / 2 - taperInset - dimpleRadius * 2,
+            z: bodyHeight
+          },
+          children: /* @__PURE__ */ jsx2(Cylinder, { radius: dimpleRadius, height: dimpleDepth * 2 })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#bfc1c4", children: Array.from(
+      { length: pinCount },
+      (_, i) => lead(
+        Math.floor(i / (pinCount / 4)),
+        ((pinCount / 4 - 1) / 2 - i % (pinCount / 4)) * pitch
+      )
+    ) })
+  ] });
+}
+var LegacyLQFP = ({
   pinCount,
   pitch,
   leadWidth,
@@ -29220,6 +29740,7 @@ var LQFP = ({
     )
   ] });
 };
+var LQFP = (props) => "leadSpanX" in props ? createPhysicalLqfp(props) : LegacyLQFP(props);
 var SOT723 = () => {
   const bodyWidth = 0.85;
   const bodyLength10 = 1.2;
@@ -29292,8 +29813,41 @@ var DFN = ({
   padWidth = bodyLength10 / 5.3 * 0.6,
   padLength = bodyLength10 / 5.3 * 1,
   pitch = 0.5,
-  thermalPadThickness = 0.2
+  thermalPadThickness = 0.2,
+  bodyStyle = "chamfered",
+  standoff = 0,
+  terminalInset = 0,
+  terminalThickness = thermalPadThickness,
+  pin1TerminalChamfer = 0,
+  pin1MarkWidth = 0
 }) => {
+  if (bodyStyle === "rectangular") {
+    if (!Number.isInteger(num_pins) || num_pins < 2 || num_pins % 2 !== 0)
+      throw new Error("DFN requires an even pin count of at least two");
+    for (const value of [
+      bodyWidth,
+      bodyLength10,
+      bodyThickness,
+      padWidth,
+      padLength,
+      pitch,
+      terminalThickness
+    ])
+      if (!Number.isFinite(value) || value <= 0)
+        throw new Error("DFN dimensions must be finite and positive");
+    for (const value of [
+      standoff,
+      terminalInset,
+      pin1TerminalChamfer,
+      pin1MarkWidth
+    ])
+      if (!Number.isFinite(value) || value < 0)
+        throw new Error("DFN offsets must be finite and nonnegative");
+    if (terminalThickness <= standoff || terminalThickness > standoff + bodyThickness || terminalInset + padLength >= bodyWidth / 2 || (num_pins / 2 - 1) * pitch + padWidth > bodyLength10 || num_pins > 2 && padWidth >= pitch || pin1TerminalChamfer >= Math.min(padLength, padWidth / 2) || pin1MarkWidth >= bodyWidth / 4)
+      throw new Error(
+        "DFN dimensions leave disconnected or overlapping terminals"
+      );
+  }
   const pinPositions = [];
   const pinsPerSide = Math.floor(num_pins / 2);
   const pinSpan = pitch * (pinsPerSide - 1);
@@ -29303,10 +29857,88 @@ var DFN = ({
     const y = pinSpan / 2 - indexOnSide * pitch;
     const padSizeX = padLength;
     const padSizeY = padWidth;
-    const x = side === "left" ? -bodyWidth / 2 + padSizeX / 2 : bodyWidth / 2 - padSizeX / 2;
+    const x = side === "left" ? -bodyWidth / 2 + padSizeX / 2 + terminalInset : bodyWidth / 2 - padSizeX / 2 - terminalInset;
     const pinNumber = i + 1;
     pinPositions.push({ pinNumber, x, y, padSizeX, padSizeY });
   }
+  if (bodyStyle === "rectangular") {
+    const top = standoff + bodyThickness;
+    const inkThickness = Math.min(bodyThickness, bodyLength10) / 100;
+    const stripe = /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [pin1MarkWidth, bodyLength10 * 0.8, inkThickness],
+        center: [
+          -bodyWidth / 2 + pin1MarkWidth * 1.5,
+          0,
+          top - inkThickness / 2
+        ]
+      }
+    );
+    const body = /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [bodyWidth, bodyLength10, bodyThickness],
+        center: [0, 0, standoff + bodyThickness / 2]
+      }
+    );
+    return /* @__PURE__ */ jsxs(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(Colorize, { color: "#25272a", children: pin1MarkWidth > 0 ? /* @__PURE__ */ jsxs(Subtract, { children: [
+        body,
+        stripe
+      ] }) : body }),
+      /* @__PURE__ */ jsx2(Colorize, { color: "#c7c9cd", children: pinPositions.map(
+        (p) => p.pinNumber === 1 && pin1TerminalChamfer > 0 ? /* @__PURE__ */ jsxs(Hull, { children: [
+          /* @__PURE__ */ jsx2(
+            Cuboid,
+            {
+              size: [
+                padLength - pin1TerminalChamfer,
+                padWidth,
+                terminalThickness
+              ],
+              center: [
+                p.x + pin1TerminalChamfer / 2,
+                p.y,
+                terminalThickness / 2
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Cuboid,
+            {
+              size: [
+                padLength,
+                padWidth - 2 * pin1TerminalChamfer,
+                terminalThickness
+              ],
+              center: [p.x, p.y, terminalThickness / 2]
+            }
+          )
+        ] }, p.pinNumber) : /* @__PURE__ */ jsx2(
+          Cuboid,
+          {
+            size: [p.padSizeX, p.padSizeY, terminalThickness],
+            center: [p.x, p.y, terminalThickness / 2]
+          },
+          p.pinNumber
+        )
+      ) }),
+      thermalPadSize && /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          color: "#c7c9cd",
+          size: [
+            thermalPadSize.width,
+            thermalPadSize.length,
+            thermalPadThickness
+          ],
+          center: [0, 0, thermalPadThickness / 2]
+        }
+      ),
+      pin1MarkWidth > 0 && /* @__PURE__ */ jsx2(Colorize, { color: "#969997", children: stripe })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     /* @__PURE__ */ jsx2(
       ChipBody,
@@ -29483,36 +30115,50 @@ var MicroMELF = ({
 var MINIMELF = ({
   bodyLength: bodyLength10 = 3.5,
   bodyDiameter = 1.5,
-  color = "#3a3a3aff",
-  contactColor = "#c6c6c6"
+  color = "#202020",
+  contactColor = "#c6c6c6",
+  bandColor = "#f2f2f2"
 }) => {
-  const padLength = 0.5;
+  const contactLength = 0.4;
+  const glassLength = bodyLength10 - 2 * contactLength + 0.04;
+  const contactOffset = (bodyLength10 - contactLength) / 2;
+  const contactRadius = bodyDiameter / 2 + 0.02;
+  const bandLength = 0.14;
+  const bandOffset = -bodyLength10 / 2 + contactLength + 0.35;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     /* @__PURE__ */ jsx2(Colorize, { color, children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx2(
       RoundedCylinder,
       {
-        height: bodyLength10,
+        height: glassLength,
         radius: bodyDiameter / 2,
-        roundRadius: 0.3,
+        roundRadius: 0.05,
         center: [-bodyDiameter / 2, 0, 0]
       }
     ) }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: bandColor, children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx2(
+      Cylinder,
+      {
+        height: bandLength,
+        radius: bodyDiameter / 2 + 2e-3,
+        center: [-bodyDiameter / 2, 0, bandOffset]
+      }
+    ) }) }),
     /* @__PURE__ */ jsx2(Colorize, { color: contactColor, children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx2(
       RoundedCylinder,
       {
-        height: padLength,
-        radius: bodyDiameter / 2,
-        roundRadius: 0.2,
-        center: [-bodyDiameter / 2, 0, -bodyLength10 / 2]
+        height: contactLength,
+        radius: contactRadius,
+        roundRadius: 0.04,
+        center: [-bodyDiameter / 2, 0, -contactOffset]
       }
     ) }) }),
     /* @__PURE__ */ jsx2(Colorize, { color: contactColor, children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, "90deg", 0], children: /* @__PURE__ */ jsx2(
       RoundedCylinder,
       {
-        height: padLength,
-        radius: bodyDiameter / 2,
-        roundRadius: 0.2,
-        center: [-bodyDiameter / 2, 0, bodyLength10 / 2]
+        height: contactLength,
+        radius: contactRadius,
+        roundRadius: 0.04,
+        center: [-bodyDiameter / 2, 0, contactOffset]
       }
     ) }) })
   ] });
@@ -31311,6 +31957,103 @@ var JSTXH2_5mm = ({
     })()
   ] });
 };
+function isJstShFootprint(footprint) {
+  const p = fp.string(footprint).json();
+  if (p.fn !== "jst") return false;
+  return Boolean(
+    p.sh || p.smd && Math.abs(mm(p.p) - 1) < 0.01 && Math.abs(mm(p.mpx ?? 0) - (p.num_pins - 1 + 2.6)) < 0.15 && Math.abs(mm(p.mpy ?? 0) - 2.525) < 0.15
+  );
+}
+var JstSh = ({ footprint = "jst6_sh" }) => {
+  if (!isJstShFootprint(footprint))
+    throw new Error(
+      "JstSh requires a named SH or matching 1mm SH top-entry footprint"
+    );
+  const canonical = footprint.replace(/_pin1location\([^)]*\)/g, "");
+  const params = fp.string(canonical).json();
+  const pads = fp.string(canonical).circuitJson().filter((e) => e.type === "pcb_smtpad" && e.shape === "rect");
+  const target = fp.string(footprint).circuitJson().filter(
+    (e) => e.type === "pcb_smtpad" && (e.shape === "rect" || e.shape === "rotated_rect")
+  );
+  const n = params.num_pins;
+  if (!Number.isInteger(n) || n < 2 || n > 20 || pads.length !== n + 2)
+    throw new Error("JstSh requires 2\u201320 contacts and two hold-down pads");
+  const signals = pads.slice(0, n), mounts = pads.slice(n);
+  const angle = Math.atan2(target[1].y - target[0].y, target[1].x - target[0].x) - Math.atan2(pads[1].y - pads[0].y, pads[1].x - pads[0].x);
+  const x = signals.reduce((sum, p) => sum + p.x, 0) / n, rowY = signals[0].y;
+  const direction = mounts[0].y > rowY ? 1 : -1;
+  const y = rowY + direction * 1.8, width10 = n + 2, depth = 2.9, height10 = 4.2;
+  const pinY = y - direction * 0.25;
+  return /* @__PURE__ */ jsxs(Rotate, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#e4e1d6", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [width10, depth, height10],
+          center: [x, y, height10 / 2 + 0.05]
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [width10 - 1.3, 1.8, height10],
+          center: [x, y, height10 / 2 + 0.8]
+        }
+      ),
+      mounts.map((pad2, i) => /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [0.7, pad2.height * 0.8, 1.5],
+          center: [pad2.x, pad2.y, 0.75]
+        },
+        `recess-${i}`
+      )),
+      [-1, 1].map((side) => /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [0.55, 0.6, 1],
+          center: [
+            x + side * (width10 / 2 - 0.9),
+            y + direction * depth / 2,
+            4
+          ]
+        },
+        side
+      ))
+    ] }) }),
+    /* @__PURE__ */ jsxs(Colorize, { color: "#c6c7c9", children: [
+      signals.map((pad2, i) => {
+        const tailY = pad2.y - direction * pad2.height * 0.4;
+        return /* @__PURE__ */ jsxs(Union, { children: [
+          /* @__PURE__ */ jsx2(
+            Cuboid,
+            {
+              size: [0.2, Math.abs(pinY - tailY) + 0.1, 0.2],
+              center: [pad2.x, (pinY + tailY) / 2, 0.1]
+            }
+          ),
+          /* @__PURE__ */ jsx2(Cuboid, { size: [0.2, 0.2, 3.45], center: [pad2.x, pinY, 1.725] })
+        ] }, i);
+      }),
+      mounts.map((pad2, i) => /* @__PURE__ */ jsxs(Union, { children: [
+        /* @__PURE__ */ jsx2(
+          Cuboid,
+          {
+            size: [0.7, pad2.height * 0.75, 0.2],
+            center: [pad2.x, pad2.y, 0.1]
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          Cuboid,
+          {
+            size: [0.2, pad2.height * 0.6, 1.35],
+            center: [pad2.x, pad2.y, 0.675]
+          }
+        )
+      ] }, `mount-${i}`))
+    ] })
+  ] });
+};
 var getTerminalPoints = ([centerX, centerY], width10, length64, chamfer, isPinOne) => {
   const xDirection = Math.sign(centerX);
   const yDirection = Math.sign(centerY);
@@ -32486,6 +33229,81 @@ var SmdPushButton = ({
     )
   ] });
 };
+var SmdSlideSwitch = ({
+  footprint = "smdslideswitch7",
+  position = 0
+}) => {
+  const canonical = footprint.replace(/_pin1location\([^)]*\)/g, "");
+  const params = fp.string(canonical).json();
+  const elements = fp.string(canonical).circuitJson();
+  const pads = elements.filter(
+    (e) => e.type === "pcb_smtpad" && e.shape === "rect"
+  );
+  const target = fp.string(footprint).circuitJson().filter(
+    (e) => e.type === "pcb_smtpad" && (e.shape === "rect" || e.shape === "rotated_rect")
+  );
+  if (pads.length < 7 || !Number.isFinite(params.mpx) || params.mpx < 3)
+    throw new Error("SmdSlideSwitch needs signal pads and four mounting pads");
+  const angle = Math.atan2(target[1].y - target[0].y, target[1].x - target[0].x) - Math.atan2(pads[1].y - pads[0].y, pads[1].x - pads[0].x);
+  const width10 = params.mpx - 0.5, depth = 2.7, height10 = params.mpx > 6 ? 1.5 : 1.4, y = params.mounty;
+  return /* @__PURE__ */ jsxs(Rotate, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#aeb4ba", children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      /* @__PURE__ */ jsx2(Cuboid, { size: [width10, depth, height10], center: [0, y, height10 / 2] }),
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [width10 - 0.3, depth - 0.3, height10],
+          center: [0, y, height10 / 2 - 0.15]
+        }
+      ),
+      /* @__PURE__ */ jsx2(Cuboid, { size: [2.7, 0.5, 0.9], center: [0, y - depth / 2, 0.65] })
+    ] }) }),
+    /* @__PURE__ */ jsxs(Colorize, { color: "#28292c", children: [
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [width10 - 0.32, depth - 0.32, 0.35],
+          center: [0, y, 0.175]
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [1, 2.25, 0.65],
+          center: [position === 0 ? -0.5 : 0.5, y - 1.5, 0.65]
+        }
+      ),
+      elements.filter((e) => e.type === "pcb_hole").map(
+        (hole, i) => "hole_diameter" in hole && "x" in hole ? /* @__PURE__ */ jsx2(
+          Cylinder,
+          {
+            radius: hole.hole_diameter * 0.42,
+            height: 0.6,
+            center: [hole.x, hole.y, -0.2]
+          },
+          i
+        ) : null
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#c6c7c9", children: pads.map((pad2, i) => {
+      const signal = i < pads.length - 4;
+      const outerY = pad2.y + pad2.height * 0.4;
+      const innerY = Math.min(pad2.y - pad2.height * 0.4, y + depth / 2 - 0.2);
+      return /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [
+            pad2.width * 0.8,
+            signal ? outerY - innerY : pad2.height * 0.8,
+            0.18
+          ],
+          center: [pad2.x, signal ? (outerY + innerY) / 2 : pad2.y, 0.09]
+        },
+        i
+      );
+    }) })
+  ] });
+};
 var SOT563 = ({ fullWidth = 1.94, fullLength: fullLength10 = 1.6 }) => {
   const bodyWidth = 1.2;
   const bodyLength10 = 1.6;
@@ -32566,6 +33384,154 @@ var BGA = ({
     })
   ] });
 };
+var Capsule = ({
+  width: width10,
+  height: height10,
+  depth
+}) => /* @__PURE__ */ jsx2(Hull, { children: [-1, 1].map((side) => /* @__PURE__ */ jsx2(Translate, { offset: [side * (width10 - height10) / 2, 0, 0], children: /* @__PURE__ */ jsx2(Rotate, { rotation: [Math.PI / 2, 0, 0], children: /* @__PURE__ */ jsx2(Cylinder, { radius: height10 / 2, height: depth }) }) }, side)) });
+var UsbCMidmount = ({
+  footprint = "usbcmidmount16"
+}) => {
+  const canonical = footprint.replace(/_pin1location\([^)]*\)/g, "");
+  const params = fp.string(canonical).json();
+  const elements = fp.string(canonical).circuitJson();
+  const pads = elements.filter(
+    (e) => e.type === "pcb_smtpad" && e.shape === "rect"
+  );
+  const slots = elements.filter((e) => e.type === "pcb_plated_hole");
+  const holes = elements.filter((e) => e.type === "pcb_hole");
+  const target = fp.string(footprint).circuitJson().find((e) => e.type === "pcb_plated_hole");
+  const first = slots[0];
+  const angle = first && target && "x" in target ? Math.atan2(target.y, target.x) - Math.atan2(first.y, first.x) : 0;
+  const width10 = 8.94, height10 = 3.2, wall = 0.22;
+  const back = params.rowy + 0.23, front = -params.bodybottom;
+  const depth = back - front, centerY = (back + front) / 2, centerZ = 1.65;
+  if (!Number.isFinite(depth) || depth < 3 || slots.length !== 4)
+    throw new Error(
+      "UsbCMidmount requires four mounting slots and a positive body depth"
+    );
+  const tabBottom = -0.9, tabTop = centerZ + 0.1;
+  return /* @__PURE__ */ jsxs(Rotate, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx2(Colorize, { color: "#b8bdc4", children: /* @__PURE__ */ jsx2(Translate, { offset: [0, centerY, centerZ], children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      /* @__PURE__ */ jsx2(Capsule, { width: width10, height: height10, depth }),
+      /* @__PURE__ */ jsx2(
+        Capsule,
+        {
+          width: width10 - wall * 2,
+          height: height10 - wall * 2,
+          depth: depth + 0.2
+        }
+      )
+    ] }) }) }),
+    /* @__PURE__ */ jsxs(Colorize, { color: "#242529", children: [
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [6.65, depth - 1.1, 0.7],
+          center: [0, centerY + 0.3, centerZ]
+        }
+      ),
+      /* @__PURE__ */ jsx2(Cuboid, { size: [7.6, 1, 2.45], center: [0, back - 0.65, centerZ] }),
+      holes.map(
+        (hole, i) => "x" in hole && "hole_diameter" in hole ? /* @__PURE__ */ jsx2(
+          Cylinder,
+          {
+            radius: hole.hole_diameter * 0.42,
+            height: 0.8,
+            center: [hole.x, hole.y, -0.3]
+          },
+          i
+        ) : null
+      )
+    ] }),
+    /* @__PURE__ */ jsxs(Colorize, { color: "#d3ad57", children: [
+      [-1, 1].flatMap(
+        (side) => [-2.75, -2.25, -1.25, -0.25, 0.25, 1.25, 2.25, 2.75].map((x) => /* @__PURE__ */ jsx2(
+          Cuboid,
+          {
+            size: [0.24, depth - 2, 0.04],
+            center: [x, centerY + 0.1, centerZ + side * 0.365]
+          },
+          `${side}-${x}`
+        ))
+      ),
+      pads.map((pad2, i) => /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [
+            Math.min(pad2.width * 0.7, 0.35),
+            pad2.height * 0.8 + 0.35,
+            0.15
+          ],
+          center: [pad2.x, pad2.y - 0.175, 0.075]
+        },
+        i
+      ))
+    ] }),
+    /* @__PURE__ */ jsx2(Colorize, { color: "#b8bdc4", children: slots.map((slot, i) => /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [
+          0.4,
+          "hole_height" in slot ? Math.max(0.3, slot.hole_height - 0.2) : 1,
+          tabTop - tabBottom
+        ],
+        center: [slot.x, slot.y, (tabTop + tabBottom) / 2]
+      },
+      i
+    )) })
+  ] });
+};
+var getPads = (footprint) => fp.string(footprint).circuitJson().filter(
+  (element) => element.type === "pcb_smtpad" && (element.shape === "rect" || element.shape === "rotated_rect")
+).map((pad2) => ({ x: pad2.x, y: pad2.y, pin: pad2.port_hints?.[0] }));
+var SOT143 = ({ footprint = "sot143" }) => {
+  const pads = getPads(footprint);
+  if (pads.length !== 4) throw new Error("SOT143 requires four signal pads");
+  const canonical = getPads("sot143");
+  const options = fp.string(footprint).json();
+  const origin = canonical[1];
+  const target = pads.find((pad2) => pad2.pin === "2");
+  const angle = options.pin1location ? Math.round(
+    (Math.atan2(target.y, target.x) - Math.atan2(origin.y, origin.x)) / (Math.PI / 2)
+  ) * (Math.PI / 2) : 0;
+  const local = pads.map((pad2) => ({
+    ...pad2,
+    x: pad2.x * Math.cos(angle) + pad2.y * Math.sin(angle),
+    y: -pad2.x * Math.sin(angle) + pad2.y * Math.cos(angle)
+  }));
+  return /* @__PURE__ */ jsxs(Rotate, { rotation: [0, 0, angle], children: [
+    /* @__PURE__ */ jsx2(
+      ChipBody,
+      {
+        width: 2.9,
+        length: 1.3,
+        height: 0.95,
+        heightAboveSurface: 0.05,
+        center: { x: 0, y: 0, z: 0 },
+        includeNotch: false,
+        taperRatio: 0.06
+      }
+    ),
+    local.map((pad2) => {
+      const side = pad2.y < 0 ? -1 : 1;
+      const leadWidth = pad2.pin === "1" ? 0.83 : 0.43;
+      return /* @__PURE__ */ jsx2(
+        SmdChipLead,
+        {
+          width: leadWidth,
+          thickness: 0.12,
+          height: 0.45,
+          padContactLength: 0.3,
+          bodyDistance: 0.6,
+          rotation: side < 0 ? Math.PI / 2 : -Math.PI / 2,
+          position: { x: pad2.x, y: side * 1.15, z: 0.06 }
+        },
+        pad2.pin
+      );
+    })
+  ] });
+};
 var DEFAULT_ASPECT_RATIO = 16 / 9;
 var DEFAULT_DIAGONAL = 40;
 var EPSILON = 1e-6;
@@ -33138,6 +34104,8 @@ var Footprinter3d = ({ footprint }) => {
     const parsed = mm(value);
     return Number.isFinite(parsed) ? parsed : fallback;
   };
+  const bodyModel = renderFootprinterBodyModel(fpJson);
+  if (bodyModel) return bodyModel;
   switch (fpJson.fn) {
     case "crystal":
       return /* @__PURE__ */ jsx2(
@@ -33340,6 +34308,12 @@ var Footprinter3d = ({ footprint }) => {
     }
     case "sot457":
       return /* @__PURE__ */ jsx2(SOT457, {});
+    case "smdslideswitch":
+      return /* @__PURE__ */ jsx2(SmdSlideSwitch, { footprint: normalizedFootprint });
+    case "usbcmidmount":
+      return /* @__PURE__ */ jsx2(UsbCMidmount, { footprint: normalizedFootprint });
+    case "sot143":
+      return /* @__PURE__ */ jsx2(SOT143, { footprint: normalizedFootprint });
     case "sot223":
       return /* @__PURE__ */ jsx2(SOT223, {});
     case "sot23w":
@@ -33366,6 +34340,9 @@ var Footprinter3d = ({ footprint }) => {
         }
       );
     case "jst":
+      if (isJstShFootprint(normalizedFootprint)) {
+        return /* @__PURE__ */ jsx2(JstSh, { footprint: normalizedFootprint });
+      }
       if (fpJson.zh) {
         return /* @__PURE__ */ jsx2(JSTZH1_5mm, { numPins: fpJson.num_pins });
       }
@@ -33806,11 +34783,8 @@ function renderNode(node, colorCtx, renderCtx) {
     }));
   }
   if (type === Rotate) {
-    const rot = Array.isArray(props?.rotation) ? [
-      degToRad(props.rotation[0]),
-      degToRad(props.rotation[1]),
-      degToRad(props.rotation[2])
-    ] : [
+    const angles = props?.angles ?? props?.rotation;
+    const rot = Array.isArray(angles) ? [degToRad(angles[0]), degToRad(angles[1]), degToRad(angles[2])] : [
       degToRad(props?.x ?? 0),
       degToRad(props?.y ?? 0),
       degToRad(props?.z ?? 0)
@@ -35765,7 +36739,7 @@ import * as THREE23 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.598",
+  version: "0.0.600",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/3d-viewer"
@@ -35789,11 +36763,16 @@ var package_default = {
     prepublish: "npm run build",
     preview: "vite preview",
     storybook: "storybook dev -p 6006",
-    "build-storybook": "storybook build",
+    "build-storybook": "bun run prepare:renderer-comparisons && storybook build",
     "vercel-build": "bun run build-storybook",
     format: "biome format . --write",
     "format:check": "biome format .",
-    "test:node-bundle": "node ./scripts/load-bundle-in-node.js"
+    "test:node-bundle": "node ./scripts/load-bundle-in-node.js",
+    "prepare:renderer-comparisons": "bun scripts/prepare-renderer-comparisons.ts",
+    "storybook:comparisons": "bun run prepare:renderer-comparisons && bun run storybook --initial-path '/story/diagnostics-renderer-parity--x-rotation'",
+    "test:renderer-comparisons:serve": "bun run prepare:renderer-comparisons && vite --config playwright/vite.config.ts",
+    "test:renderer-calibration": "playwright test --project=calibration",
+    "test:renderer-comparisons": "bun scripts/run-renderer-comparisons.ts"
   },
   dependencies: {
     "@jscad/regl-renderer": "^2.6.12",
@@ -35817,6 +36796,8 @@ var package_default = {
     "@chromatic-com/storybook": "^1.9.0",
     "@jscad/modeling": "^2.12.5",
     "@napi-rs/canvas": "^1.0.9",
+    "@playwright/test": "1.58.2",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/alphabet": "^0.0.25",
@@ -35826,12 +36807,12 @@ var package_default = {
     "@types/react": "19",
     "@types/react-dom": "19",
     "@types/three": "^0.165.0",
-    "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@vitejs/plugin-react": "^4.3.4",
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
+    "circuit-json-to-gltf": "0.0.129",
     debug: "^4.4.0",
-    "jscad-electronics": "^0.0.159",
+    "jscad-electronics": "^0.0.178",
     "jscad-planner": "^0.0.13",
     jsdom: "^26.0.0",
     "manifold-3d": "^3.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.599",
+  "version": "0.0.601",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/3d-viewer"
@@ -24,11 +24,16 @@
     "prepublish": "npm run build",
     "preview": "vite preview",
     "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build",
+    "build-storybook": "bun run prepare:renderer-comparisons && storybook build",
     "vercel-build": "bun run build-storybook",
     "format": "biome format . --write",
     "format:check": "biome format .",
-    "test:node-bundle": "node ./scripts/load-bundle-in-node.js"
+    "test:node-bundle": "node ./scripts/load-bundle-in-node.js",
+    "prepare:renderer-comparisons": "bun scripts/prepare-renderer-comparisons.ts",
+    "storybook:comparisons": "bun run prepare:renderer-comparisons && bun run storybook --initial-path '/story/diagnostics-renderer-parity--x-rotation'",
+    "test:renderer-comparisons:serve": "bun run prepare:renderer-comparisons && vite --config playwright/vite.config.ts",
+    "test:renderer-calibration": "playwright test --project=calibration",
+    "test:renderer-comparisons": "bun scripts/run-renderer-comparisons.ts"
   },
   "dependencies": {
     "@jscad/regl-renderer": "^2.6.12",
@@ -52,6 +57,8 @@
     "@chromatic-com/storybook": "^1.9.0",
     "@jscad/modeling": "^2.12.5",
     "@napi-rs/canvas": "^1.0.9",
+    "@playwright/test": "1.58.2",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/alphabet": "^0.0.25",
@@ -61,12 +68,12 @@
     "@types/react": "19",
     "@types/react-dom": "19",
     "@types/three": "^0.165.0",
-    "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@vitejs/plugin-react": "^4.3.4",
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
+    "circuit-json-to-gltf": "0.0.129",
     "debug": "^4.4.0",
-    "jscad-electronics": "^0.0.159",
+    "jscad-electronics": "^0.0.178",
     "jscad-planner": "^0.0.13",
     "jsdom": "^26.0.0",
     "manifold-3d": "^3.2.1",