circuit-json-to-tscircuit 0.0.91 → 0.0.93

package/dist/{chunk-TYZGD7TY.js → chunk-B7377FUZ.js}

@@ -1,19 +1,26 @@
-// lib/get-board-using-template.ts
-import { mmStr as mmStr9 } from "@tscircuit/mm";
-import { su as su21 } from "@tscircuit/soup-util";
-
 // lib/get-runtime-net-names.ts
 var getRuntimeNetNames = (circuitJson, sourceNetIdsRequiringSelector) => {
   const sourceNets = circuitJson.filter(
     (element) => element.type === "source_net"
   );
+  const canonicalSourceNetIdBySourceNetId = getCanonicalSourceNetIdBySourceNetId(circuitJson);
+  const sourceNetById = new Map(
+    sourceNets.map((sourceNet) => [sourceNet.source_net_id, sourceNet])
+  );
+  const canonicalSourceNets = sourceNets.filter(
+    (sourceNet) => canonicalSourceNetIdBySourceNetId.get(sourceNet.source_net_id) === sourceNet.source_net_id
+  );
   const sourceNetNamesRequiringSelector = /* @__PURE__ */ new Set();
-  for (const sourceNet of sourceNets) {
-    if (sourceNetIdsRequiringSelector.has(sourceNet.source_net_id)) {
-      sourceNetNamesRequiringSelector.add(sourceNet.name);
+  for (const sourceNetId of sourceNetIdsRequiringSelector) {
+    const canonicalSourceNetId = canonicalSourceNetIdBySourceNetId.get(sourceNetId) ?? sourceNetId;
+    const canonicalSourceNet = sourceNetById.get(canonicalSourceNetId);
+    if (canonicalSourceNet) {
+      sourceNetNamesRequiringSelector.add(canonicalSourceNet.name);
     }
   }
-  const sourceNetNames = [...new Set(sourceNets.map(({ name }) => name))];
+  const sourceNetNames = [
+    ...new Set(canonicalSourceNets.map(({ name }) => name))
+  ];
   const runtimeNameByOriginalName = /* @__PURE__ */ new Map();
   const usedRuntimeNetNames = /* @__PURE__ */ new Set();
   const namesThatRemainUnchanged = sourceNetNames.filter(
@@ -36,13 +43,74 @@ var getRuntimeNetNames = (circuitJson, sourceNetIdsRequiringSelector) => {
   }
   const runtimeNetNameBySourceNetId = /* @__PURE__ */ new Map();
   for (const sourceNet of sourceNets) {
+    const canonicalSourceNetId = canonicalSourceNetIdBySourceNetId.get(sourceNet.source_net_id) ?? sourceNet.source_net_id;
+    const canonicalSourceNet = sourceNetById.get(canonicalSourceNetId);
+    if (!canonicalSourceNet) continue;
     runtimeNetNameBySourceNetId.set(
       sourceNet.source_net_id,
-      runtimeNameByOriginalName.get(sourceNet.name)
+      runtimeNameByOriginalName.get(canonicalSourceNet.name)
     );
   }
   return runtimeNetNameBySourceNetId;
 };
+var getCanonicalSourceNetIdBySourceNetId = (circuitJson) => {
+  const parentSourceNetIdBySourceNetId = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type !== "source_net") continue;
+    parentSourceNetIdBySourceNetId.set(
+      element.source_net_id,
+      element.source_net_id
+    );
+  }
+  for (const element of circuitJson) {
+    if (element.type !== "source_trace") continue;
+    const sourceNetIds = element.connected_source_net_ids.filter(
+      (sourceNetId) => parentSourceNetIdBySourceNetId.has(sourceNetId)
+    );
+    const firstSourceNetId = sourceNetIds[0];
+    if (!firstSourceNetId) continue;
+    const canonicalSourceNetId = findCanonicalSourceNetId({
+      parentSourceNetIdBySourceNetId,
+      sourceNetId: firstSourceNetId
+    });
+    for (const sourceNetId of sourceNetIds.slice(1)) {
+      const aliasCanonicalSourceNetId = findCanonicalSourceNetId({
+        parentSourceNetIdBySourceNetId,
+        sourceNetId
+      });
+      if (aliasCanonicalSourceNetId === canonicalSourceNetId) continue;
+      parentSourceNetIdBySourceNetId.set(
+        aliasCanonicalSourceNetId,
+        canonicalSourceNetId
+      );
+    }
+  }
+  return new Map(
+    [...parentSourceNetIdBySourceNetId.keys()].map((sourceNetId) => [
+      sourceNetId,
+      findCanonicalSourceNetId({
+        parentSourceNetIdBySourceNetId,
+        sourceNetId
+      })
+    ])
+  );
+};
+var findCanonicalSourceNetId = ({
+  parentSourceNetIdBySourceNetId,
+  sourceNetId
+}) => {
+  let currentSourceNetId = sourceNetId;
+  const visitedSourceNetIds = /* @__PURE__ */ new Set();
+  while (!visitedSourceNetIds.has(currentSourceNetId)) {
+    visitedSourceNetIds.add(currentSourceNetId);
+    const parentSourceNetId = parentSourceNetIdBySourceNetId.get(currentSourceNetId);
+    if (!parentSourceNetId || parentSourceNetId === currentSourceNetId) {
+      return currentSourceNetId;
+    }
+    currentSourceNetId = parentSourceNetId;
+  }
+  return currentSourceNetId;
+};
 var getUniqueRuntimeNetName = (sourceNetName, usedRuntimeNetNames) => {
   const baseName = getRuntimeNetNameBase(sourceNetName);
   let candidate = baseName;
@@ -59,8 +127,11 @@ var getRuntimeNetNameBase = (sourceNetName) => {
 };
 
 // lib/board-conversion-context.ts
-var PCB_CHIP_NAME = "ImportedBoard";
-var createBoardConversionContext = (circuitJson) => {
+var DEFAULT_PCB_CHIP_NAME = "ImportedBoard";
+var createBoardConversionContext = ({
+  circuitJson,
+  pcbChipName = DEFAULT_PCB_CHIP_NAME
+}) => {
   const sourceNetIdsRequiringSelector = getSourceNetIdsRequiringSelector(circuitJson);
   const runtimeNetNameBySourceNetId = getRuntimeNetNames(
     circuitJson,
@@ -78,22 +149,29 @@ var createBoardConversionContext = (circuitJson) => {
     circuitJson,
     runtimeNetNameBySourceNetId
   });
+  const pcbPortSelectorsBySourcePortId = /* @__PURE__ */ new Map();
   const pcbPortSelectorsByRuntimeNetName = /* @__PURE__ */ new Map();
   for (const [pcbPortId, sourcePortId] of sourcePortIdByPcbPortId) {
     const portHint = portHintByPcbPortId.get(pcbPortId);
     if (!portHint) continue;
+    const selector = `.${pcbChipName} > .${portHint}`;
+    const sourcePortSelectors = pcbPortSelectorsBySourcePortId.get(sourcePortId) ?? [];
+    sourcePortSelectors.push(selector);
+    pcbPortSelectorsBySourcePortId.set(sourcePortId, sourcePortSelectors);
     for (const runtimeNetName of runtimeNetNamesBySourcePortId.get(
       sourcePortId
     ) ?? []) {
       const selectors = pcbPortSelectorsByRuntimeNetName.get(runtimeNetName) ?? [];
-      selectors.push(`.${PCB_CHIP_NAME} > .${portHint}`);
+      selectors.push(selector);
       pcbPortSelectorsByRuntimeNetName.set(runtimeNetName, selectors);
     }
   }
   return {
-    pcbChipName: PCB_CHIP_NAME,
+    pcbChipName,
+    pcbPortIdsWithUnambiguousComponentSelectors: /* @__PURE__ */ new Set(),
     portHintByPcbPortId,
     runtimeNetNameBySourceNetId,
+    pcbPortSelectorsBySourcePortId,
     pcbPortSelectorsByRuntimeNetName
   };
 };
@@ -140,6 +218,206 @@ var getRuntimeNetNamesBySourcePortId = ({
   return result;
 };
 
+// lib/board-converter/create-component-preserving-board-conversion-context.ts
+function createComponentPreservingBoardConversionContext({
+  circuitJson,
+  pcbChipName,
+  pcbComponentRuntimeNameByPcbComponentId
+}) {
+  const context = createBoardConversionContext({ circuitJson, pcbChipName });
+  const pcbComponentsById = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type === "pcb_component") {
+      pcbComponentsById.set(element.pcb_component_id, element);
+    }
+  }
+  const pcbPortSelectorsBySourcePortId = /* @__PURE__ */ new Map();
+  const pcbPortIdsWithUnambiguousComponentSelectors = new Set(
+    circuitJson.flatMap((element) => {
+      if (element.type !== "pcb_port") return [];
+      const pcbComponent = element.pcb_component_id ? pcbComponentsById.get(element.pcb_component_id) : void 0;
+      return pcbComponent && pcbComponentRuntimeNameByPcbComponentId.has(
+        pcbComponent.pcb_component_id
+      ) ? [element.pcb_port_id] : [];
+    })
+  );
+  for (const element of circuitJson) {
+    if (element.type !== "pcb_port") continue;
+    const pcbComponent = element.pcb_component_id ? pcbComponentsById.get(element.pcb_component_id) : void 0;
+    const portHint = context.portHintByPcbPortId.get(element.pcb_port_id);
+    if (!portHint) continue;
+    const componentName = pcbComponent ? pcbComponentRuntimeNameByPcbComponentId.get(
+      pcbComponent.pcb_component_id
+    ) : void 0;
+    const selectors = pcbPortSelectorsBySourcePortId.get(element.source_port_id) ?? [];
+    selectors.push(`.${componentName ?? context.pcbChipName} > .${portHint}`);
+    pcbPortSelectorsBySourcePortId.set(element.source_port_id, selectors);
+  }
+  const pcbPortSelectorsByRuntimeNetName = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type !== "source_trace") continue;
+    for (const sourceNetId of element.connected_source_net_ids) {
+      const runtimeNetName = context.runtimeNetNameBySourceNetId.get(sourceNetId);
+      if (!runtimeNetName) continue;
+      const selectors = pcbPortSelectorsByRuntimeNetName.get(runtimeNetName) ?? [];
+      for (const sourcePortId of element.connected_source_port_ids) {
+        for (const selector of pcbPortSelectorsBySourcePortId.get(
+          sourcePortId
+        ) ?? []) {
+          if (!selectors.includes(selector)) selectors.push(selector);
+        }
+      }
+      pcbPortSelectorsByRuntimeNetName.set(runtimeNetName, selectors);
+    }
+  }
+  return {
+    ...context,
+    pcbPortIdsWithUnambiguousComponentSelectors,
+    pcbPortSelectorsBySourcePortId,
+    pcbPortSelectorsByRuntimeNetName
+  };
+}
+
+// lib/generate-board-cad-models-tsx/get-cad-model-url.ts
+function getCadModelUrl(cadComponent) {
+  if (cadComponent.model_glb_url) {
+    return { format: "glb", url: cadComponent.model_glb_url };
+  }
+  if (cadComponent.model_gltf_url) {
+    return { format: "gltf", url: cadComponent.model_gltf_url };
+  }
+  if (cadComponent.model_obj_url) {
+    return { format: "obj", url: cadComponent.model_obj_url };
+  }
+  if (cadComponent.model_step_url) {
+    return { format: "step", url: cadComponent.model_step_url };
+  }
+  if (cadComponent.model_stl_url) {
+    return { format: "stl", url: cadComponent.model_stl_url };
+  }
+  if (cadComponent.model_wrl_url) {
+    return { format: "wrl", url: cadComponent.model_wrl_url };
+  }
+  return void 0;
+}
+
+// lib/generate-board-cad-models-tsx/has-cad-model-source.ts
+function hasCadModelSource(cadComponent) {
+  return cadComponent.model_jscad !== void 0 || getCadModelUrl(cadComponent) !== void 0;
+}
+
+// lib/generate-board-cad-models-tsx/get-cad-model-groups.ts
+function getCadModelGroups(circuitJson) {
+  const pcbComponentById = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type === "pcb_component") {
+      pcbComponentById.set(element.pcb_component_id, element);
+    }
+  }
+  const cadModelGroupByKey = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type !== "cad_component" || !hasCadModelSource(element))
+      continue;
+    const pcbComponent = element.pcb_component_id ? pcbComponentById.get(element.pcb_component_id) : void 0;
+    const layer = (element.layer ?? pcbComponent?.layer) === "bottom" ? "bottom" : "top";
+    let parentPlacement = {
+      center: element.position,
+      ccwRotationDegrees: 0,
+      layer
+    };
+    let cadModelGroupKey = element.cad_component_id;
+    if (pcbComponent !== void 0) {
+      parentPlacement = {
+        center: pcbComponent.center,
+        ccwRotationDegrees: pcbComponent.rotation,
+        layer
+      };
+      cadModelGroupKey = `${pcbComponent.pcb_component_id}:${layer}`;
+    }
+    const cadModelGroup = cadModelGroupByKey.get(cadModelGroupKey) ?? {
+      cadComponents: [],
+      parentPlacement
+    };
+    cadModelGroup.cadComponents.push(element);
+    cadModelGroupByKey.set(cadModelGroupKey, cadModelGroup);
+  }
+  return [...cadModelGroupByKey.values()];
+}
+
+// lib/board-converter/get-board-child-runtime-names.ts
+var getUnusedRuntimeName = ({
+  preferredRuntimeName,
+  usedRuntimeNames
+}) => {
+  if (!usedRuntimeNames.has(preferredRuntimeName)) return preferredRuntimeName;
+  let duplicateNumber = 2;
+  while (usedRuntimeNames.has(`${preferredRuntimeName}_${duplicateNumber}`)) {
+    duplicateNumber += 1;
+  }
+  return `${preferredRuntimeName}_${duplicateNumber}`;
+};
+var getBoardChildRuntimeNames = (circuitJson) => {
+  const sourceComponentBySourceComponentId = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type === "source_component" && !sourceComponentBySourceComponentId.has(element.source_component_id)) {
+      sourceComponentBySourceComponentId.set(
+        element.source_component_id,
+        element
+      );
+    }
+  }
+  const usedRuntimeNames = /* @__PURE__ */ new Set();
+  const pcbComponentRuntimeNameByPcbComponentId = /* @__PURE__ */ new Map();
+  const pcbComponents = circuitJson.filter(
+    (element) => element.type === "pcb_component"
+  );
+  for (const [pcbComponentIndex, pcbComponent] of pcbComponents.entries()) {
+    const sourceComponent = pcbComponent.source_component_id ? sourceComponentBySourceComponentId.get(pcbComponent.source_component_id) : void 0;
+    const preferredRuntimeName = sourceComponent?.name ?? `imported_component_${pcbComponentIndex + 1}`;
+    const runtimeName = getUnusedRuntimeName({
+      preferredRuntimeName,
+      usedRuntimeNames
+    });
+    usedRuntimeNames.add(runtimeName);
+    pcbComponentRuntimeNameByPcbComponentId.set(
+      pcbComponent.pcb_component_id,
+      runtimeName
+    );
+  }
+  const pcbChipName = getUnusedRuntimeName({
+    preferredRuntimeName: DEFAULT_PCB_CHIP_NAME,
+    usedRuntimeNames
+  });
+  usedRuntimeNames.add(pcbChipName);
+  const standaloneCadModelRuntimeNameByCadComponentId = /* @__PURE__ */ new Map();
+  const standaloneCadModelGroups = getCadModelGroups(circuitJson).filter(
+    (cadModelGroup) => cadModelGroup.cadComponents.every(
+      (cadComponent) => cadComponent.pcb_component_id === void 0
+    )
+  );
+  for (const [
+    groupIndex,
+    cadModelGroup
+  ] of standaloneCadModelGroups.entries()) {
+    const firstCadComponent = cadModelGroup.cadComponents[0];
+    if (!firstCadComponent) continue;
+    const runtimeName = getUnusedRuntimeName({
+      preferredRuntimeName: `ImportedCadModel${groupIndex + 1}`,
+      usedRuntimeNames
+    });
+    usedRuntimeNames.add(runtimeName);
+    standaloneCadModelRuntimeNameByCadComponentId.set(
+      firstCadComponent.cad_component_id,
+      runtimeName
+    );
+  }
+  return {
+    pcbChipName,
+    pcbComponentRuntimeNameByPcbComponentId,
+    standaloneCadModelRuntimeNameByCadComponentId
+  };
+};
+
 // lib/generate-board-cad-models-tsx/format-point-prop.ts
 function formatPointProp(point) {
   return `{ x: ${point.x}, y: ${point.y}, z: ${point.z} }`;
@@ -192,27 +470,44 @@ function getCadModelPlacement({
   };
 }
 
-// lib/generate-board-cad-models-tsx/get-cad-model-url.ts
-function getCadModelUrl(cadComponent) {
-  if (cadComponent.model_glb_url) {
-    return { format: "glb", url: cadComponent.model_glb_url };
-  }
-  if (cadComponent.model_gltf_url) {
-    return { format: "gltf", url: cadComponent.model_gltf_url };
-  }
-  if (cadComponent.model_obj_url) {
-    return { format: "obj", url: cadComponent.model_obj_url };
+// lib/generate-board-cad-models-tsx/get-cad-model-placement-attributes.ts
+function getCadModelPlacementAttributes({
+  cadComponent,
+  parentPlacement,
+  pcbBoard
+}) {
+  const placement = getCadModelPlacement({
+    cadComponent,
+    parentPlacement,
+    pcbBoard
+  });
+  const attributes = [
+    `positionOffset={${formatPointProp(placement.positionOffset)}}`,
+    `rotationOffset={${formatPointProp(placement.ccwRotationOffsetDegrees)}}`
+  ];
+  if (cadComponent.model_unit_to_mm_scale_factor !== void 0) {
+    attributes.push(
+      `modelUnitToMmScale={${cadComponent.model_unit_to_mm_scale_factor}}`
+    );
   }
-  if (cadComponent.model_step_url) {
-    return { format: "step", url: cadComponent.model_step_url };
+  if (cadComponent.model_board_normal_direction !== void 0) {
+    attributes.push(
+      `modelBoardNormalDirection={${JSON.stringify(cadComponent.model_board_normal_direction)}}`
+    );
   }
-  if (cadComponent.model_stl_url) {
-    return { format: "stl", url: cadComponent.model_stl_url };
+  const modelOriginPosition = getCadModelOriginPosition(cadComponent);
+  if (modelOriginPosition !== void 0) {
+    attributes.push(
+      `modelOriginPosition={${formatPointProp(modelOriginPosition)}}`
+    );
   }
-  if (cadComponent.model_wrl_url) {
-    return { format: "wrl", url: cadComponent.model_wrl_url };
+  if (cadComponent.size !== void 0) {
+    attributes.push(`size={${formatPointProp(cadComponent.size)}}`);
   }
-  return void 0;
+  attributes.push(
+    `showAsTranslucentModel={${cadComponent.show_as_translucent_model === true}}`
+  );
+  return attributes;
 }
 
 // lib/generate-board-cad-models-tsx/get-model-url-with-format-hint.ts
@@ -233,141 +528,571 @@ function generateCadModelTsx({
 }) {
   const modelUrl = getCadModelUrl(cadComponent);
   if (!modelUrl) return void 0;
+  const attributes = [
+    `modelUrl={${JSON.stringify(getModelUrlWithFormatHint(modelUrl))}}`,
+    ...getCadModelPlacementAttributes({
+      cadComponent,
+      parentPlacement,
+      pcbBoard
+    })
+  ];
+  return `<cadmodel ${attributes.join(" ")} />`;
+}
+
+// lib/generate-board-cad-models-tsx/get-jscad-operation-fit-scale-factors.ts
+import jscad2 from "@jscad/modeling";
+
+// lib/generate-board-cad-models-tsx/execute-jscad-operation.ts
+import jscad from "@jscad/modeling";
+import { executeJscadOperations } from "jscad-planner";
+function executeJscadOperation(operation) {
+  return executeJscadOperations(jscad, operation);
+}
+
+// lib/generate-board-cad-models-tsx/get-jscad-operation-fit-scale-factors.ts
+var identityScaleFactors = { x: 1, y: 1, z: 1 };
+function getSafeScaleFactor({
+  sourceLength,
+  targetLength
+}) {
+  return sourceLength > 0 ? targetLength / sourceLength : 1;
+}
+function getJscadOperationFitScaleFactors({
+  cadComponent,
+  operation
+}) {
+  if (cadComponent.size === void 0) return identityScaleFactors;
+  const geometry = executeJscadOperation(operation);
+  if (!jscad2.geometries.geom3.isA(geometry)) return identityScaleFactors;
+  const [minimumPoint, maximumPoint] = jscad2.measurements.measureBoundingBox(geometry);
+  const modelUnitToMmScaleFactor = cadComponent.model_unit_to_mm_scale_factor ?? 1;
+  const axisScaleFactors = {
+    x: getSafeScaleFactor({
+      sourceLength: maximumPoint[0] - minimumPoint[0],
+      targetLength: cadComponent.size.x * modelUnitToMmScaleFactor
+    }),
+    y: getSafeScaleFactor({
+      sourceLength: maximumPoint[1] - minimumPoint[1],
+      targetLength: cadComponent.size.y * modelUnitToMmScaleFactor
+    }),
+    z: getSafeScaleFactor({
+      sourceLength: maximumPoint[2] - minimumPoint[2],
+      targetLength: cadComponent.size.z * modelUnitToMmScaleFactor
+    })
+  };
+  if (cadComponent.model_object_fit === "fill_bounds") {
+    return axisScaleFactors;
+  }
+  const uniformScaleFactor = Math.min(
+    axisScaleFactors.x,
+    axisScaleFactors.y,
+    axisScaleFactors.z
+  );
+  return {
+    x: uniformScaleFactor,
+    y: uniformScaleFactor,
+    z: uniformScaleFactor
+  };
+}
+
+// lib/generate-board-cad-models-tsx/get-jscad-operation-in-base-model-frame.ts
+var degreesToRadians = (angleDegrees) => angleDegrees * Math.PI / 180;
+var getCadComponentRotation = (cadComponent) => cadComponent.rotation ?? { x: 0, y: 0, z: 0 };
+var getModelOriginPosition = (cadComponent) => cadComponent.model_origin_position ?? { x: 0, y: 0, z: 0 };
+var getBoardNormalRotation = (cadComponent) => {
+  switch (cadComponent.model_board_normal_direction ?? "z+") {
+    case "x+":
+      return { x: 0, y: -90, z: 0 };
+    case "x-":
+      return { x: 0, y: 90, z: 0 };
+    case "y+":
+      return { x: 90, y: 0, z: 0 };
+    case "y-":
+      return { x: -90, y: 0, z: 0 };
+    case "z-":
+      return { x: 180, y: 0, z: 0 };
+    case "z+":
+      return { x: 0, y: 0, z: 0 };
+  }
+};
+var rotateOperation = ({
+  operation,
+  rotationDegrees
+}) => {
+  let rotatedOperation = operation;
+  for (const [axis, angleDegrees] of [
+    ["Z", rotationDegrees.z],
+    ["Y", rotationDegrees.y],
+    ["X", rotationDegrees.x]
+  ]) {
+    if (angleDegrees === 0) continue;
+    rotatedOperation = {
+      type: `rotate${axis}`,
+      angle: degreesToRadians(angleDegrees),
+      shape: rotatedOperation
+    };
+  }
+  return rotatedOperation;
+};
+var rotateOperationByInverse = ({
+  operation,
+  rotationDegrees
+}) => {
+  let rotatedOperation = operation;
+  for (const [axis, angleDegrees] of [
+    ["X", rotationDegrees.x],
+    ["Y", rotationDegrees.y],
+    ["Z", rotationDegrees.z]
+  ]) {
+    if (angleDegrees === 0) continue;
+    rotatedOperation = {
+      type: `rotate${axis}`,
+      angle: degreesToRadians(-angleDegrees),
+      shape: rotatedOperation
+    };
+  }
+  return rotatedOperation;
+};
+var translateOperation = ({
+  operation,
+  translation
+}) => {
+  if (translation.x === 0 && translation.y === 0 && translation.z === 0) {
+    return operation;
+  }
+  return {
+    type: "translate",
+    vector: [translation.x, translation.y, translation.z],
+    shape: operation
+  };
+};
+var scaleOperation = ({
+  operation,
+  scaleFactors
+}) => {
+  if (scaleFactors.x === 1 && scaleFactors.y === 1 && scaleFactors.z === 1) {
+    return operation;
+  }
+  return {
+    type: "scale",
+    factors: [scaleFactors.x, scaleFactors.y, scaleFactors.z],
+    shape: operation
+  };
+};
+function getJscadOperationInBaseModelFrame({
+  baseCadComponent,
+  basePositionOffset,
+  cadComponent,
+  positionOffset
+}) {
+  if (cadComponent.model_jscad === void 0) return void 0;
+  const modelOriginPosition = getModelOriginPosition(cadComponent);
+  const cadRotationDegrees = getCadComponentRotation(cadComponent);
+  const baseCadRotationDegrees = getCadComponentRotation(baseCadComponent);
+  const modelUnitToMmScaleFactor = cadComponent.model_unit_to_mm_scale_factor ?? 1;
+  let operation = cadComponent.model_jscad;
+  operation = scaleOperation({
+    operation,
+    scaleFactors: {
+      x: modelUnitToMmScaleFactor,
+      y: modelUnitToMmScaleFactor,
+      z: modelUnitToMmScaleFactor
+    }
+  });
+  operation = translateOperation({
+    operation,
+    translation: {
+      x: -modelOriginPosition.x,
+      y: -modelOriginPosition.y,
+      z: -modelOriginPosition.z
+    }
+  });
+  operation = rotateOperation({
+    operation,
+    rotationDegrees: getBoardNormalRotation(cadComponent)
+  });
+  operation = scaleOperation({
+    operation,
+    scaleFactors: getJscadOperationFitScaleFactors({
+      cadComponent,
+      operation
+    })
+  });
+  operation = rotateOperation({
+    operation,
+    rotationDegrees: cadRotationDegrees
+  });
+  operation = translateOperation({
+    operation,
+    translation: {
+      x: positionOffset.x - basePositionOffset.x,
+      y: positionOffset.y - basePositionOffset.y,
+      z: positionOffset.z - basePositionOffset.z
+    }
+  });
+  return rotateOperationByInverse({
+    operation,
+    rotationDegrees: baseCadRotationDegrees
+  });
+}
+
+// lib/generate-board-cad-models-tsx/pack-jscad-operations.ts
+import jscad3 from "@jscad/modeling";
+import "jscad-planner";
+var copyPolygon = ({
+  polygon,
+  geometryColor
+}) => ({
+  vertices: polygon.vertices.map(([x, y, z]) => [x, y, z]),
+  color: polygon.color ?? geometryColor
+});
+var getPackedJscadSize = (polygons) => {
+  const vertices = polygons.flatMap((polygon) => polygon.vertices);
+  if (vertices.length === 0) return void 0;
+  const [firstVertex, ...remainingVertices] = vertices;
+  let minX = firstVertex[0];
+  let minY = firstVertex[1];
+  let minZ = firstVertex[2];
+  let maxX = firstVertex[0];
+  let maxY = firstVertex[1];
+  let maxZ = firstVertex[2];
+  for (const [x, y, z] of remainingVertices) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    minZ = Math.min(minZ, z);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+    maxZ = Math.max(maxZ, z);
+  }
+  return { x: maxX - minX, y: maxY - minY, z: maxZ - minZ };
+};
+var packJscadOperations = (operations) => {
+  const polygons = [];
+  for (const operation of operations) {
+    const geometry = executeJscadOperation(operation);
+    if (!jscad3.geometries.geom3.isA(geometry)) return void 0;
+    polygons.push(
+      ...jscad3.geometries.geom3.toPolygons(geometry).map(
+        (polygon) => copyPolygon({
+          polygon,
+          geometryColor: geometry.color
+        })
+      )
+    );
+  }
+  return {
+    jscad: { type: "createGeom3", polygons },
+    size: getPackedJscadSize(polygons)
+  };
+};
+
+// lib/generate-board-cad-models-tsx/generate-jscad-cad-model-prop-tsx.ts
+function generateSingleJscadCadModelPropTsx({
+  cadComponent,
+  parentPlacement,
+  pcbBoard
+}) {
   const placement = getCadModelPlacement({
     cadComponent,
     parentPlacement,
     pcbBoard
   });
-  const attributes = [
-    `modelUrl={${JSON.stringify(getModelUrlWithFormatHint(modelUrl))}}`,
-    `positionOffset={${formatPointProp(placement.positionOffset)}}`,
-    `rotationOffset={${formatPointProp(placement.ccwRotationOffsetDegrees)}}`
+  const properties = [
+    `jscad: ${JSON.stringify(cadComponent.model_jscad)}`,
+    `positionOffset: ${formatPointProp(placement.positionOffset)}`,
+    `rotationOffset: ${formatPointProp(placement.ccwRotationOffsetDegrees)}`
   ];
-  if (cadComponent.model_unit_to_mm_scale_factor !== void 0) {
-    attributes.push(
-      `modelUnitToMmScale={${cadComponent.model_unit_to_mm_scale_factor}}`
+  const modelOriginPosition = getCadModelOriginPosition(cadComponent);
+  if (modelOriginPosition !== void 0) {
+    properties.push(
+      `modelOriginPosition: ${formatPointProp(modelOriginPosition)}`
     );
   }
-  if (cadComponent.model_board_normal_direction !== void 0) {
-    attributes.push(
-      `modelBoardNormalDirection={${JSON.stringify(cadComponent.model_board_normal_direction)}}`
+  if (cadComponent.model_unit_to_mm_scale_factor !== void 0) {
+    properties.push(
+      `modelUnitToMmScale: ${cadComponent.model_unit_to_mm_scale_factor}`
     );
   }
-  const modelOriginPosition = getCadModelOriginPosition(cadComponent);
-  if (modelOriginPosition !== void 0) {
-    attributes.push(
-      `modelOriginPosition={${formatPointProp(modelOriginPosition)}}`
+  if (cadComponent.model_board_normal_direction !== void 0) {
+    properties.push(
+      `modelBoardNormalDirection: ${JSON.stringify(cadComponent.model_board_normal_direction)}`
     );
   }
   if (cadComponent.size !== void 0) {
-    attributes.push(`size={${formatPointProp(cadComponent.size)}}`);
-  }
-  if (cadComponent.show_as_translucent_model === true) {
-    attributes.push("showAsTranslucentModel");
+    properties.push(`size: ${formatPointProp(cadComponent.size)}`);
   }
-  return `<cadmodel ${attributes.join(" ")} />`;
+  return `{ ${properties.join(", ")} }`;
 }
-
-// lib/generate-board-cad-models-tsx/generate-cad-model-group-tsx.ts
-function generateCadModelGroupTsx({
-  cadModelGroup,
-  groupIndex,
+function generateJscadCadModelPropTsx({
+  cadComponents,
+  parentPlacement,
   pcbBoard
 }) {
-  const { cadComponents, parentPlacement } = cadModelGroup;
-  const modelElements = cadComponents.flatMap((cadComponent) => {
-    const modelElement = generateCadModelTsx({
+  const baseCadComponent = cadComponents[0];
+  if (!baseCadComponent || baseCadComponent.model_jscad === void 0) {
+    return void 0;
+  }
+  if (cadComponents.length === 1) {
+    return generateSingleJscadCadModelPropTsx({
+      cadComponent: baseCadComponent,
+      parentPlacement,
+      pcbBoard
+    });
+  }
+  const basePlacement = getCadModelPlacement({
+    cadComponent: baseCadComponent,
+    parentPlacement,
+    pcbBoard
+  });
+  const shapes = cadComponents.flatMap((cadComponent) => {
+    const placement = getCadModelPlacement({
       cadComponent,
       parentPlacement,
       pcbBoard
     });
-    return modelElement ? [modelElement] : [];
+    const operation = getJscadOperationInBaseModelFrame({
+      baseCadComponent,
+      basePositionOffset: basePlacement.positionOffset,
+      cadComponent,
+      positionOffset: placement.positionOffset
+    });
+    return operation ? [operation] : [];
+  });
+  if (shapes.length === 0) return void 0;
+  const packedJscadOperations = packJscadOperations(shapes);
+  const jscad4 = packedJscadOperations?.jscad ?? {
+    type: "union",
+    shapes
+  };
+  const properties = [
+    `jscad: ${JSON.stringify(jscad4)}`,
+    `positionOffset: ${formatPointProp(basePlacement.positionOffset)}`,
+    `rotationOffset: ${formatPointProp(basePlacement.ccwRotationOffsetDegrees)}`,
+    `modelOriginPosition: ${formatPointProp({ x: 0, y: 0, z: 0 })}`,
+    "modelUnitToMmScale: 1",
+    'modelBoardNormalDirection: "z+"'
+  ];
+  if (packedJscadOperations?.size !== void 0) {
+    properties.push(`size: ${formatPointProp(packedJscadOperations.size)}`);
+  }
+  return `{ ${properties.join(", ")} }`;
+}
+
+// lib/generate-board-cad-models-tsx/generate-cad-model-group-model-tsx.ts
+var generateUrlCadModelElementsTsx = ({
+  cadModelGroup,
+  pcbBoard
+}) => cadModelGroup.cadComponents.flatMap((cadComponent) => {
+  if (getCadModelUrl(cadComponent) === void 0) return [];
+  const modelElement = generateCadModelTsx({
+    cadComponent,
+    parentPlacement: cadModelGroup.parentPlacement,
+    pcbBoard
   });
-  if (modelElements.length === 0) return void 0;
-  let cadModelTsx = modelElements[0];
-  if (modelElements.length > 1) {
-    cadModelTsx = `<cadassembly>${modelElements.join("\n")}</cadassembly>`;
+  return modelElement ? [modelElement] : [];
+});
+var getJscadCadComponents = (cadModelGroup) => cadModelGroup.cadComponents.filter(
+  (cadComponent) => cadComponent.model_jscad !== void 0
+);
+function generateCadModelGroupModelTsx({
+  cadModelGroup,
+  pcbBoard
+}) {
+  const jscadCadComponents = getJscadCadComponents(cadModelGroup);
+  if (jscadCadComponents.length > 0) {
+    return generateJscadCadModelPropTsx({
+      cadComponents: jscadCadComponents,
+      parentPlacement: cadModelGroup.parentPlacement,
+      pcbBoard
+    });
   }
+  const urlCadModelElementsTsx = generateUrlCadModelElementsTsx({
+    cadModelGroup,
+    pcbBoard
+  });
+  if (urlCadModelElementsTsx.length === 0) return void 0;
+  if (urlCadModelElementsTsx.length === 1) return urlCadModelElementsTsx[0];
+  return `<cadassembly>${urlCadModelElementsTsx.join("\n")}</cadassembly>`;
+}
+function generateCadModelGroupChildrenTsx({
+  cadModelGroup,
+  pcbBoard
+}) {
+  if (getJscadCadComponents(cadModelGroup).length === 0) return [];
+  return generateUrlCadModelElementsTsx({ cadModelGroup, pcbBoard });
+}
+
+// lib/generate-board-cad-models-tsx/is-jscad-cad-model-group-translucent.ts
+function isJscadCadModelGroupTranslucent(cadModelGroup) {
+  const jscadCadComponents = cadModelGroup.cadComponents.filter(
+    (cadComponent) => cadComponent.model_jscad !== void 0
+  );
+  return jscadCadComponents.length > 0 && jscadCadComponents.every(
+    (cadComponent) => cadComponent.show_as_translucent_model === true
+  );
+}
+
+// lib/generate-board-cad-models-tsx/generate-cad-model-group-tsx.ts
+function generateCadModelGroupTsx({
+  cadModelGroup,
+  pcbBoard,
+  runtimeName
+}) {
+  const { parentPlacement } = cadModelGroup;
+  const cadModelTsx = generateCadModelGroupModelTsx({
+    cadModelGroup,
+    pcbBoard
+  });
   if (!cadModelTsx) return void 0;
   const attributes = [
-    `name={${JSON.stringify(`ImportedCadModel${groupIndex + 1}`)}}`,
+    `name={${JSON.stringify(runtimeName)}}`,
     `pcbX={${parentPlacement.center.x}}`,
     `pcbY={${parentPlacement.center.y}}`,
     `pcbRotation="${parentPlacement.ccwRotationDegrees}deg"`,
     `layer="${parentPlacement.layer}"`,
     "noSchematicRepresentation",
-    "obstructsWithinBounds={false}",
-    "footprint={<footprint />}",
-    `cadModel={${cadModelTsx}}`
-  ];
-  return `<chip ${attributes.join(" ")} />`;
-}
-
-// lib/generate-board-cad-models-tsx/get-cad-model-groups.ts
-function getCadModelGroups(circuitJson) {
-  const pcbComponentById = /* @__PURE__ */ new Map();
-  for (const element of circuitJson) {
-    if (element.type === "pcb_component") {
-      pcbComponentById.set(element.pcb_component_id, element);
-    }
-  }
-  const cadModelGroupByKey = /* @__PURE__ */ new Map();
-  for (const element of circuitJson) {
-    if (element.type !== "cad_component" || !getCadModelUrl(element)) continue;
-    const pcbComponent = element.pcb_component_id ? pcbComponentById.get(element.pcb_component_id) : void 0;
-    const layer = (element.layer ?? pcbComponent?.layer) === "bottom" ? "bottom" : "top";
-    let parentPlacement = {
-      center: element.position,
-      ccwRotationDegrees: 0,
-      layer
-    };
-    let cadModelGroupKey = element.cad_component_id;
-    if (pcbComponent !== void 0) {
-      parentPlacement = {
-        center: pcbComponent.center,
-        ccwRotationDegrees: pcbComponent.rotation,
-        layer
-      };
-      cadModelGroupKey = `${pcbComponent.pcb_component_id}:${layer}`;
-    }
-    const cadModelGroup = cadModelGroupByKey.get(cadModelGroupKey) ?? {
-      cadComponents: [],
-      parentPlacement
-    };
-    cadModelGroup.cadComponents.push(element);
-    cadModelGroupByKey.set(cadModelGroupKey, cadModelGroup);
+    "obstructsWithinBounds={false}",
+    "footprint={<footprint />}",
+    `cadModel={${cadModelTsx}}`
+  ];
+  if (isJscadCadModelGroupTranslucent(cadModelGroup)) {
+    attributes.push("showAsTranslucentModel");
   }
-  return [...cadModelGroupByKey.values()];
+  const childModelElementsTsx = generateCadModelGroupChildrenTsx({
+    cadModelGroup,
+    pcbBoard
+  });
+  if (childModelElementsTsx.length === 0) {
+    return `<chip ${attributes.join(" ")} />`;
+  }
+  return `<chip ${attributes.join(" ")}>${childModelElementsTsx.join("\n")}</chip>`;
 }
 
-// lib/generate-board-cad-models-tsx.ts
-function generateBoardCadModelsTsx({
+// lib/board-converter/stages/convert-board-cad-models.ts
+var convertBoardCadModels = ({
   circuitJson,
-  pcbBoard
-}) {
-  if (!pcbBoard) return [];
-  return getCadModelGroups(circuitJson).flatMap((cadModelGroup, groupIndex) => {
+  pcbBoard,
+  boardChildren,
+  standaloneCadModelRuntimeNameByCadComponentId
+}) => {
+  const standaloneCadModelGroups = getCadModelGroups(circuitJson).filter(
+    (cadModelGroup) => cadModelGroup.cadComponents.every(
+      (cadComponent) => cadComponent.pcb_component_id === void 0
+    )
+  );
+  for (const cadModelGroup of standaloneCadModelGroups) {
+    const firstCadComponent = cadModelGroup.cadComponents[0];
+    if (!firstCadComponent) continue;
+    const runtimeName = standaloneCadModelRuntimeNameByCadComponentId.get(
+      firstCadComponent.cad_component_id
+    );
+    if (!runtimeName) {
+      throw new Error(
+        `Missing runtime name for standalone CAD model ${firstCadComponent.cad_component_id}`
+      );
+    }
     const cadModelGroupTsx = generateCadModelGroupTsx({
       cadModelGroup,
-      groupIndex,
-      pcbBoard
+      pcbBoard,
+      runtimeName
     });
-    return cadModelGroupTsx ? [cadModelGroupTsx] : [];
-  });
-}
+    if (cadModelGroupTsx) boardChildren.push(cadModelGroupTsx);
+  }
+};
 
 // lib/generate-board-nets-tsx.ts
-var generateBoardNetsTsx = (context) => {
-  const runtimeNetNames = new Set(context.runtimeNetNameBySourceNetId.values());
-  return [...runtimeNetNames].map((runtimeNetName) => {
+var generateBoardNetsTsx = (circuitJson, context) => {
+  const runtimeNetNames = getRuntimeNetNamesInTraceOrder(circuitJson, context);
+  return runtimeNetNames.map((runtimeNetName) => {
     const selectors = context.pcbPortSelectorsByRuntimeNetName.get(runtimeNetName) ?? [];
     const connectsTo = selectors.length ? ` connectsTo={${JSON.stringify(selectors)}}` : "";
     return `<net name={${JSON.stringify(runtimeNetName)}}${connectsTo} />`;
   });
 };
+var getRuntimeNetNamesInTraceOrder = (circuitJson, context) => {
+  const orderedNames = [];
+  const addedNames = /* @__PURE__ */ new Set();
+  for (const element of circuitJson) {
+    if (element.type !== "source_trace") continue;
+    for (const sourceNetId of element.connected_source_net_ids) {
+      const runtimeNetName = context.runtimeNetNameBySourceNetId.get(sourceNetId);
+      if (!runtimeNetName || addedNames.has(runtimeNetName)) continue;
+      orderedNames.push(runtimeNetName);
+      addedNames.add(runtimeNetName);
+    }
+  }
+  for (const runtimeNetName of context.runtimeNetNameBySourceNetId.values()) {
+    if (addedNames.has(runtimeNetName)) continue;
+    orderedNames.push(runtimeNetName);
+    addedNames.add(runtimeNetName);
+  }
+  return orderedNames;
+};
 
-// lib/generate-board-schematic-sheet-tsx.ts
+// lib/board-converter/stages/convert-board-nets.ts
+var convertBoardNets = ({
+  boardChildren,
+  boardProps,
+  circuitJson,
+  footprintConversionContext
+}) => {
+  boardChildren.push(
+    ...generateBoardNetsTsx(circuitJson, footprintConversionContext)
+  );
+  if (circuitJson.some((element) => element.type === "pcb_trace") && !boardProps.includes("routingDisabled")) {
+    boardProps.push("routingDisabled");
+  }
+};
+
+// lib/board-converter/stages/convert-board-properties.ts
 import { mmStr } from "@tscircuit/mm";
+var convertBoardProperties = ({
+  pcbBoard,
+  boardProps
+}) => {
+  if (pcbBoard.center.x !== 0) {
+    boardProps.push(`pcbX={${pcbBoard.center.x}}`);
+  }
+  if (pcbBoard.center.y !== 0) {
+    boardProps.push(`pcbY={${pcbBoard.center.y}}`);
+  }
+  if (pcbBoard.width !== void 0) {
+    boardProps.push(`width="${mmStr(pcbBoard.width)}"`);
+  }
+  if (pcbBoard.height !== void 0) {
+    boardProps.push(`height="${mmStr(pcbBoard.height)}"`);
+  }
+  if (pcbBoard.outline && pcbBoard.outline.length > 0) {
+    const points = pcbBoard.outline.map((point) => `{ x: ${point.x}, y: ${point.y} }`).join(", ");
+    boardProps.push(`outline={[${points}]}`);
+  }
+  if (pcbBoard.thickness !== void 0) {
+    boardProps.push(`thickness="${mmStr(pcbBoard.thickness)}"`);
+  }
+  if (pcbBoard.num_layers !== void 0) {
+    boardProps.push(`layers={${pcbBoard.num_layers}}`);
+  }
+  if (pcbBoard.material !== void 0) {
+    boardProps.push(`material="${pcbBoard.material}"`);
+  }
+  if (pcbBoard.solder_mask_color !== void 0) {
+    boardProps.push(`solderMaskColor="${pcbBoard.solder_mask_color}"`);
+  }
+  if (pcbBoard.silkscreen_color !== void 0) {
+    boardProps.push(`silkscreenColor="${pcbBoard.silkscreen_color}"`);
+  }
+  if (pcbBoard.anchor_position !== void 0) {
+    boardProps.push(
+      `boardAnchorPosition={{ x: ${pcbBoard.anchor_position.x}, y: ${pcbBoard.anchor_position.y} }}`
+    );
+  }
+  if (pcbBoard.anchor_alignment !== void 0) {
+    boardProps.push(`boardAnchorAlignment="${pcbBoard.anchor_alignment}"`);
+  }
+};
+
+// lib/generate-board-schematic-sheet-tsx.ts
+import { mmStr as mmStr2 } from "@tscircuit/mm";
 var DEFAULT_SHEET_DIMENSIONS_MM = {
   a4: { width: 297, height: 210 },
   ansi_b: { width: 431.8, height: 279.4 }
@@ -391,8 +1116,8 @@ var generateBoardSchematicSheetTsx = ({
   const defaultDimensions = DEFAULT_SHEET_DIMENSIONS_MM[sheet.sheet_size ?? "a4"];
   const sheetWidth = sheet.sheet_width ?? defaultDimensions.width;
   const sheetHeight = sheet.sheet_height ?? defaultDimensions.height;
-  attrs.push(`sheetWidth="${mmStr(sheetWidth)}"`);
-  attrs.push(`sheetHeight="${mmStr(sheetHeight)}"`);
+  attrs.push(`sheetWidth="${mmStr2(sheetWidth)}"`);
+  attrs.push(`sheetHeight="${mmStr2(sheetHeight)}"`);
   return `<schematicsheet ${attrs.join(" ")}>
 ${schematicElements.join("\n")}
 </schematicsheet>`;
@@ -1589,6 +2314,51 @@ var generateBoardSchematicElements = (circuitJson) => {
   ];
 };
 
+// lib/board-converter/stages/convert-board-schematic.ts
+var convertBoardSchematic = ({
+  boardChildren,
+  circuitJson
+}) => {
+  const schematicElements = generateBoardSchematicElements(circuitJson);
+  boardChildren.push(
+    generateBoardSchematicSheetTsx({
+      circuitJson,
+      schematicElements
+    })
+  );
+};
+
+// lib/generate-board-traces-tsx.ts
+function generateBoardTracesTsx(circuitJson, context) {
+  return circuitJson.flatMap((element) => {
+    if (element.type !== "source_trace") return [];
+    const portSelectors = element.connected_source_port_ids.flatMap(
+      (sourcePortId) => context.pcbPortSelectorsBySourcePortId.get(sourcePortId) ?? []
+    );
+    const netSelectors = [
+      ...new Set(
+        element.connected_source_net_ids.flatMap((sourceNetId) => {
+          const runtimeNetName = context.runtimeNetNameBySourceNetId.get(sourceNetId);
+          return runtimeNetName ? [`net.${runtimeNetName}`] : [];
+        })
+      )
+    ];
+    const path = [...portSelectors, ...netSelectors];
+    return path.length >= 2 ? [`<trace path={${JSON.stringify(path)}} />`] : [];
+  });
+}
+
+// lib/board-converter/stages/convert-board-traces.ts
+var convertBoardTraces = ({
+  boardChildren,
+  circuitJson,
+  footprintConversionContext
+}) => {
+  boardChildren.push(
+    ...generateBoardTracesTsx(circuitJson, footprintConversionContext)
+  );
+};
+
 // lib/generate-copper-pours-tsx.ts
 import { su as su6 } from "@tscircuit/soup-util";
 
@@ -1798,6 +2568,26 @@ var getUnassignedCopperPourNetName = ({
   return name;
 };
 
+// lib/board-converter/stages/convert-copper-pours.ts
+var convertCopperPours = ({
+  boardChildren,
+  circuitJson,
+  footprintConversionContext
+}) => {
+  boardChildren.push(
+    ...generateCopperPoursTsx(circuitJson, footprintConversionContext)
+  );
+};
+
+// lib/format-jsx-string-attribute.ts
+var formatJsxStringAttribute = (text) => {
+  const stringText = String(text ?? "");
+  if (!/["\\\r\n\t{}<&>]/.test(stringText)) {
+    return `"${stringText}"`;
+  }
+  return `{${JSON.stringify(stringText)}}`;
+};
+
 // lib/generate-footprint-tsx/convert-copper-text.ts
 import { su as su7 } from "@tscircuit/soup-util";
 
@@ -1897,8 +2687,8 @@ var convertCourtyard = (circuitJson) => {
 import { su as su9 } from "@tscircuit/soup-util";
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-mm.ts
-import { mmStr as mmStr2 } from "@tscircuit/mm";
-var formatMm = (value) => mmStr2(value ?? 0);
+import { mmStr as mmStr3 } from "@tscircuit/mm";
+var formatMm = (value) => mmStr3(value ?? 0);
 
 // lib/generate-footprint-tsx/convert-cutouts.ts
 var convertCutouts = (circuitJson) => {
@@ -2043,26 +2833,26 @@ var convertFabrication = (circuitJson) => {
 
 // lib/generate-footprint-tsx/convert-holes.ts
 import { su as su11 } from "@tscircuit/soup-util";
-import { mmStr as mmStr3 } from "@tscircuit/mm";
+import { mmStr as mmStr4 } from "@tscircuit/mm";
 var convertHoles = (circuitJson) => {
   const holes = su11(circuitJson).pcb_hole.list();
   const elementStrings = [];
   for (const hole of holes) {
     if (hole.hole_shape === "circle") {
       elementStrings.push(
-        `<hole pcbX="${mmStr3(hole.x)}" pcbY="${mmStr3(hole.y)}" diameter="${mmStr3(hole.hole_diameter)}" />`
+        `<hole pcbX="${mmStr4(hole.x)}" pcbY="${mmStr4(hole.y)}" diameter="${mmStr4(hole.hole_diameter)}" />`
       );
     } else if (hole.hole_shape === "rect") {
       elementStrings.push(
-        `<hole pcbX="${mmStr3(hole.x)}" pcbY="${mmStr3(hole.y)}" width="${mmStr3(hole.hole_width)}" height="${mmStr3(hole.hole_height)}" shape="rect" />`
+        `<hole pcbX="${mmStr4(hole.x)}" pcbY="${mmStr4(hole.y)}" width="${mmStr4(hole.hole_width)}" height="${mmStr4(hole.hole_height)}" shape="rect" />`
       );
     } else if (hole.hole_shape === "oval") {
       elementStrings.push(
-        `<hole pcbX="${mmStr3(hole.x)}" pcbY="${mmStr3(hole.y)}" width="${mmStr3(hole.hole_width)}" height="${mmStr3(hole.hole_height)}" shape="oval" />`
+        `<hole pcbX="${mmStr4(hole.x)}" pcbY="${mmStr4(hole.y)}" width="${mmStr4(hole.hole_width)}" height="${mmStr4(hole.hole_height)}" shape="oval" />`
       );
     } else if (hole.hole_shape === "pill" || hole.hole_shape === "rotated_pill") {
       elementStrings.push(
-        `<hole pcbX="${mmStr3(hole.x)}" pcbY="${mmStr3(hole.y)}" width="${mmStr3(hole.hole_width)}" height="${mmStr3(hole.hole_height)}" shape="pill"${formatPcbRotationAttr("ccw_rotation" in hole ? hole.ccw_rotation : void 0)} />`
+        `<hole pcbX="${mmStr4(hole.x)}" pcbY="${mmStr4(hole.y)}" width="${mmStr4(hole.hole_width)}" height="${mmStr4(hole.hole_height)}" shape="pill"${formatPcbRotationAttr("ccw_rotation" in hole ? hole.ccw_rotation : void 0)} />`
       );
     }
   }
@@ -2276,13 +3066,13 @@ var convertPcbTraces = (circuitJson) => su14(circuitJson).pcb_trace.list().map((
 
 // lib/generate-footprint-tsx/convert-plated-holes.ts
 import { su as su15 } from "@tscircuit/soup-util";
-import { mmStr as mmStr5 } from "@tscircuit/mm";
+import { mmStr as mmStr6 } from "@tscircuit/mm";
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-optional-mm-attr.ts
-import { mmStr as mmStr4 } from "@tscircuit/mm";
+import { mmStr as mmStr5 } from "@tscircuit/mm";
 var formatOptionalMmAttr = (attrName, value) => {
   if (value === void 0) return "";
-  return ` ${attrName}="${mmStr4(value)}"`;
+  return ` ${attrName}="${mmStr5(value)}"`;
 };
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-solder-mask-attrs.ts
@@ -2298,7 +3088,13 @@ var formatSolderMaskAttrs = (platedHole) => {
 var getImportedPortHints = (primitive, context) => {
   if (!primitive.pcb_port_id || !context) return primitive.port_hints;
   const importedHint = context.portHintByPcbPortId.get(primitive.pcb_port_id);
-  return importedHint ? [importedHint] : primitive.port_hints;
+  if (!importedHint) return primitive.port_hints;
+  if (!context.pcbPortIdsWithUnambiguousComponentSelectors.has(
+    primitive.pcb_port_id
+  )) {
+    return [importedHint];
+  }
+  return [.../* @__PURE__ */ new Set([importedHint, ...primitive.port_hints ?? []])];
 };
 
 // lib/generate-footprint-tsx/convert-plated-holes.ts
@@ -2311,26 +3107,26 @@ var convertPlatedHoles = (circuitJson, context) => {
     const tagSpacing = context ? " " : "  ";
     if (platedHole.shape === "oval" || platedHole.shape === "pill") {
       elementStrings.push(
-        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr5(platedHole.x)}" pcbY="${mmStr5(platedHole.y)}"${formatSolderMaskAttrs(platedHole)} outerHeight="${mmStr5(platedHole.outer_height)}" outerWidth="${mmStr5(platedHole.outer_width)}" holeHeight="${mmStr5(platedHole.hole_height)}" holeWidth="${mmStr5(platedHole.hole_width)}" height="${mmStr5(platedHole.hole_height)}" shape="${platedHole.shape}"${formatPcbRotationAttr("ccw_rotation" in platedHole ? platedHole.ccw_rotation : void 0)} />`
+        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr6(platedHole.x)}" pcbY="${mmStr6(platedHole.y)}"${formatSolderMaskAttrs(platedHole)} outerHeight="${mmStr6(platedHole.outer_height)}" outerWidth="${mmStr6(platedHole.outer_width)}" holeHeight="${mmStr6(platedHole.hole_height)}" holeWidth="${mmStr6(platedHole.hole_width)}" height="${mmStr6(platedHole.hole_height)}" shape="${platedHole.shape}"${formatPcbRotationAttr("ccw_rotation" in platedHole ? platedHole.ccw_rotation : void 0)} />`
       );
     } else if (platedHole.shape === "circle") {
       elementStrings.push(
-        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr5(platedHole.x)}" pcbY="${mmStr5(platedHole.y)}"${formatSolderMaskAttrs(platedHole)} outerDiameter="${mmStr5(platedHole.outer_diameter)}" holeDiameter="${mmStr5(platedHole.hole_diameter)}" shape="circle" />`
+        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr6(platedHole.x)}" pcbY="${mmStr6(platedHole.y)}"${formatSolderMaskAttrs(platedHole)} outerDiameter="${mmStr6(platedHole.outer_diameter)}" holeDiameter="${mmStr6(platedHole.hole_diameter)}" shape="circle" />`
       );
     } else if (platedHole.shape === "circular_hole_with_rect_pad") {
       elementStrings.push(
-        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr5(platedHole.x)}" pcbY="${mmStr5(platedHole.y)}"${platedHole.hole_shape === void 0 ? "" : ` holeShape="${platedHole.hole_shape}"`}${platedHole.pad_shape === void 0 ? "" : ` padShape="${platedHole.pad_shape}"`}${formatSolderMaskAttrs(platedHole)} holeDiameter="${mmStr5(platedHole.hole_diameter)}" rectPadWidth="${mmStr5(platedHole.rect_pad_width)}" rectPadHeight="${mmStr5(platedHole.rect_pad_height)}"${formatOptionalMmAttr("rectBorderRadius", platedHole.rect_border_radius)}${formatOptionalMmAttr("holeOffsetX", platedHole.hole_offset_x)}${formatOptionalMmAttr("holeOffsetY", platedHole.hole_offset_y)}${formatPcbRotationAttr(platedHole.rect_ccw_rotation)} shape="circular_hole_with_rect_pad" />`
+        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr6(platedHole.x)}" pcbY="${mmStr6(platedHole.y)}"${platedHole.hole_shape === void 0 ? "" : ` holeShape="${platedHole.hole_shape}"`}${platedHole.pad_shape === void 0 ? "" : ` padShape="${platedHole.pad_shape}"`}${formatSolderMaskAttrs(platedHole)} holeDiameter="${mmStr6(platedHole.hole_diameter)}" rectPadWidth="${mmStr6(platedHole.rect_pad_width)}" rectPadHeight="${mmStr6(platedHole.rect_pad_height)}"${formatOptionalMmAttr("rectBorderRadius", platedHole.rect_border_radius)}${formatOptionalMmAttr("holeOffsetX", platedHole.hole_offset_x)}${formatOptionalMmAttr("holeOffsetY", platedHole.hole_offset_y)}${formatPcbRotationAttr(platedHole.rect_ccw_rotation)} shape="circular_hole_with_rect_pad" />`
       );
     } else if (platedHole.shape === "pill_hole_with_rect_pad" || platedHole.shape === "rotated_pill_hole_with_rect_pad") {
       const holeShape = platedHole.shape === "rotated_pill_hole_with_rect_pad" ? "pill" : platedHole.hole_shape;
       const rotation = platedHole.shape === "rotated_pill_hole_with_rect_pad" ? platedHole.hole_ccw_rotation : void 0;
       elementStrings.push(
-        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr5(platedHole.x)}" pcbY="${mmStr5(platedHole.y)}"${holeShape === void 0 ? "" : ` holeShape="${holeShape}"`}${platedHole.pad_shape === void 0 ? "" : ` padShape="${platedHole.pad_shape}"`}${formatSolderMaskAttrs(platedHole)} holeWidth="${mmStr5(platedHole.hole_width)}" holeHeight="${mmStr5(platedHole.hole_height)}" rectPadWidth="${mmStr5(platedHole.rect_pad_width)}" rectPadHeight="${mmStr5(platedHole.rect_pad_height)}"${formatOptionalMmAttr("rectBorderRadius", platedHole.rect_border_radius)}${formatOptionalMmAttr("holeOffsetX", platedHole.hole_offset_x)}${formatOptionalMmAttr("holeOffsetY", platedHole.hole_offset_y)}${formatPcbRotationAttr(rotation)} shape="pill_hole_with_rect_pad" />`
+        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr6(platedHole.x)}" pcbY="${mmStr6(platedHole.y)}"${holeShape === void 0 ? "" : ` holeShape="${holeShape}"`}${platedHole.pad_shape === void 0 ? "" : ` padShape="${platedHole.pad_shape}"`}${formatSolderMaskAttrs(platedHole)} holeWidth="${mmStr6(platedHole.hole_width)}" holeHeight="${mmStr6(platedHole.hole_height)}" rectPadWidth="${mmStr6(platedHole.rect_pad_width)}" rectPadHeight="${mmStr6(platedHole.rect_pad_height)}"${formatOptionalMmAttr("rectBorderRadius", platedHole.rect_border_radius)}${formatOptionalMmAttr("holeOffsetX", platedHole.hole_offset_x)}${formatOptionalMmAttr("holeOffsetY", platedHole.hole_offset_y)}${formatPcbRotationAttr(rotation)} shape="pill_hole_with_rect_pad" />`
       );
     } else if (platedHole.shape === "hole_with_polygon_pad") {
-      const holeSizeAttrs = platedHole.hole_shape === "circle" ? ` holeDiameter="${mmStr5(platedHole.hole_diameter ?? 0)}"` : `${formatOptionalMmAttr("holeWidth", platedHole.hole_width)}${formatOptionalMmAttr("holeHeight", platedHole.hole_height)}`;
+      const holeSizeAttrs = platedHole.hole_shape === "circle" ? ` holeDiameter="${mmStr6(platedHole.hole_diameter ?? 0)}"` : `${formatOptionalMmAttr("holeWidth", platedHole.hole_width)}${formatOptionalMmAttr("holeHeight", platedHole.hole_height)}`;
       elementStrings.push(
-        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr5(platedHole.x)}" pcbY="${mmStr5(platedHole.y)}"${platedHole.hole_shape === void 0 ? "" : ` holeShape="${platedHole.hole_shape}"`}${formatSolderMaskAttrs(platedHole)}${holeSizeAttrs} padOutline={${JSON.stringify(platedHole.pad_outline)}} holeOffsetX="${mmStr5(platedHole.hole_offset_x ?? 0)}" holeOffsetY="${mmStr5(platedHole.hole_offset_y ?? 0)}" shape="hole_with_polygon_pad" />`
+        `<platedhole${tagSpacing}${portHintsAttr} pcbX="${mmStr6(platedHole.x)}" pcbY="${mmStr6(platedHole.y)}"${platedHole.hole_shape === void 0 ? "" : ` holeShape="${platedHole.hole_shape}"`}${formatSolderMaskAttrs(platedHole)}${holeSizeAttrs} padOutline={${JSON.stringify(platedHole.pad_outline)}} holeOffsetX="${mmStr6(platedHole.hole_offset_x ?? 0)}" holeOffsetY="${mmStr6(platedHole.hole_offset_y ?? 0)}" shape="hole_with_polygon_pad" />`
       );
     }
   }
@@ -2535,7 +3331,7 @@ var convertSilkscreenGraphics = (circuitJson) => {
 
 // lib/generate-footprint-tsx/convert-silkscreen-text.ts
 import { su as su18 } from "@tscircuit/soup-util";
-import { mmStr as mmStr6 } from "@tscircuit/mm";
+import { mmStr as mmStr7 } from "@tscircuit/mm";
 var convertSilkscreenText = (circuitJson) => {
   const silkscreenTexts = su18(circuitJson).pcb_silkscreen_text.list();
   const elementStrings = [];
@@ -2545,7 +3341,7 @@ var convertSilkscreenText = (circuitJson) => {
     const knockoutPadding = silkscreenText.knockout_padding;
     const hasUniformKnockoutPadding = knockoutPadding && knockoutPadding.left === knockoutPadding.top && knockoutPadding.top === knockoutPadding.right && knockoutPadding.right === knockoutPadding.bottom;
     elementStrings.push(
-      `<silkscreentext pcbX={${pcbX}} pcbY={${pcbY}} anchorAlignment="${silkscreenText.anchor_alignment}" fontSize={${silkscreenText.font_size}}${silkscreenText.font !== void 0 ? ` font="${silkscreenText.font}"` : ""}${silkscreenText.ccw_rotation !== void 0 ? ` pcbRotation="${typeof silkscreenText.ccw_rotation === "number" ? `${silkscreenText.ccw_rotation}deg` : silkscreenText.ccw_rotation}"` : ""}${silkscreenText.is_knockout !== void 0 ? ` isKnockout={${silkscreenText.is_knockout}}` : ""}${knockoutPadding ? hasUniformKnockoutPadding ? ` knockoutPadding="${mmStr6(knockoutPadding.left)}"` : ` knockoutPaddingLeft="${mmStr6(knockoutPadding.left)}" knockoutPaddingTop="${mmStr6(knockoutPadding.top)}" knockoutPaddingRight="${mmStr6(knockoutPadding.right)}" knockoutPaddingBottom="${mmStr6(knockoutPadding.bottom)}"` : ""}${silkscreenText.is_mirrored !== void 0 ? ` mirrored={${silkscreenText.is_mirrored}}` : ""}${silkscreenText.layer !== void 0 ? ` layer="${silkscreenText.layer}"` : ""} text="${escapeJsxText2(silkscreenText.text)}" />`
+      `<silkscreentext pcbX={${pcbX}} pcbY={${pcbY}} anchorAlignment="${silkscreenText.anchor_alignment}" fontSize={${silkscreenText.font_size}}${silkscreenText.font !== void 0 ? ` font="${silkscreenText.font}"` : ""}${silkscreenText.ccw_rotation !== void 0 ? ` pcbRotation="${typeof silkscreenText.ccw_rotation === "number" ? `${silkscreenText.ccw_rotation}deg` : silkscreenText.ccw_rotation}"` : ""}${silkscreenText.is_knockout !== void 0 ? ` isKnockout={${silkscreenText.is_knockout}}` : ""}${knockoutPadding ? hasUniformKnockoutPadding ? ` knockoutPadding="${mmStr7(knockoutPadding.left)}"` : ` knockoutPaddingLeft="${mmStr7(knockoutPadding.left)}" knockoutPaddingTop="${mmStr7(knockoutPadding.top)}" knockoutPaddingRight="${mmStr7(knockoutPadding.right)}" knockoutPaddingBottom="${mmStr7(knockoutPadding.bottom)}"` : ""}${silkscreenText.is_mirrored !== void 0 ? ` mirrored={${silkscreenText.is_mirrored}}` : ""}${silkscreenText.layer !== void 0 ? ` layer="${silkscreenText.layer}"` : ""} text="${escapeJsxText2(silkscreenText.text)}" />`
     );
   }
   return elementStrings;
@@ -2553,7 +3349,7 @@ var convertSilkscreenText = (circuitJson) => {
 
 // lib/generate-footprint-tsx/convert-smt-pads.ts
 import { su as su19 } from "@tscircuit/soup-util";
-import { mmStr as mmStr7 } from "@tscircuit/mm";
+import { mmStr as mmStr8 } from "@tscircuit/mm";
 var convertSmtPads = (circuitJson, context) => {
   const smtPads = su19(circuitJson).pcb_smtpad.list();
   const elementStrings = [];
@@ -2565,29 +3361,29 @@ var convertSmtPads = (circuitJson, context) => {
       commonAttrs.push(`portHints={${JSON.stringify(portHints)}}`);
     }
     if ("x" in smtPad && smtPad.x !== void 0) {
-      commonAttrs.push(`pcbX="${mmStr7(smtPad.x)}"`);
+      commonAttrs.push(`pcbX="${mmStr8(smtPad.x)}"`);
     }
     if ("y" in smtPad && smtPad.y !== void 0) {
-      commonAttrs.push(`pcbY="${mmStr7(smtPad.y)}"`);
+      commonAttrs.push(`pcbY="${mmStr8(smtPad.y)}"`);
     }
     if (smtPad.layer !== void 0) {
       commonAttrs.push(`layer="${smtPad.layer}"`);
     }
     if (smtPad.shape === "circle") {
       elementStrings.push(
-        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} radius="${mmStr7(smtPad.radius ?? 0)}" shape="circle" />`
+        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} radius="${mmStr8(smtPad.radius ?? 0)}" shape="circle" />`
       );
     } else if (smtPad.shape === "rect") {
       elementStrings.push(
-        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs}${formatOptionalMmAttr("rectBorderRadius", smtPad.rect_border_radius)}${formatOptionalMmAttr("cornerRadius", smtPad.corner_radius)}${formatOptionalMmAttr("solderMaskMarginLeft", smtPad.soldermask_margin_left)}${formatOptionalMmAttr("solderMaskMarginTop", smtPad.soldermask_margin_top)}${formatOptionalMmAttr("solderMaskMarginRight", smtPad.soldermask_margin_right)}${formatOptionalMmAttr("solderMaskMarginBottom", smtPad.soldermask_margin_bottom)} width="${mmStr7(smtPad.width ?? 0)}" height="${mmStr7(smtPad.height ?? 0)}" shape="rect" />`
+        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs}${formatOptionalMmAttr("rectBorderRadius", smtPad.rect_border_radius)}${formatOptionalMmAttr("cornerRadius", smtPad.corner_radius)}${formatOptionalMmAttr("solderMaskMarginLeft", smtPad.soldermask_margin_left)}${formatOptionalMmAttr("solderMaskMarginTop", smtPad.soldermask_margin_top)}${formatOptionalMmAttr("solderMaskMarginRight", smtPad.soldermask_margin_right)}${formatOptionalMmAttr("solderMaskMarginBottom", smtPad.soldermask_margin_bottom)} width="${mmStr8(smtPad.width ?? 0)}" height="${mmStr8(smtPad.height ?? 0)}" shape="rect" />`
       );
     } else if (smtPad.shape === "pill") {
       elementStrings.push(
-        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} width="${mmStr7(smtPad.width ?? 0)}" height="${mmStr7(smtPad.height ?? 0)}" radius="${mmStr7(smtPad.radius ?? 0)}" shape="pill" />`
+        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} width="${mmStr8(smtPad.width ?? 0)}" height="${mmStr8(smtPad.height ?? 0)}" radius="${mmStr8(smtPad.radius ?? 0)}" shape="pill" />`
       );
     } else if (smtPad.shape === "rotated_pill") {
       elementStrings.push(
-        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} width="${mmStr7(smtPad.width ?? 0)}" height="${mmStr7(smtPad.height ?? 0)}" radius="${mmStr7(smtPad.radius ?? 0)}"${formatPcbRotationAttr(smtPad.ccw_rotation)} shape="pill" />`
+        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs} width="${mmStr8(smtPad.width ?? 0)}" height="${mmStr8(smtPad.height ?? 0)}" radius="${mmStr8(smtPad.radius ?? 0)}"${formatPcbRotationAttr(smtPad.ccw_rotation)} shape="pill" />`
       );
     } else if (smtPad.shape === "polygon") {
       elementStrings.push(
@@ -2596,7 +3392,7 @@ var convertSmtPads = (circuitJson, context) => {
     } else if (smtPad.shape === "rotated_rect") {
       const cornerRadius = smtPad.corner_radius ?? smtPad.rect_border_radius ?? void 0;
       elementStrings.push(
-        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs}${formatOptionalMmAttr("cornerRadius", cornerRadius)}${formatOptionalMmAttr("solderMaskMarginLeft", smtPad.soldermask_margin_left)}${formatOptionalMmAttr("solderMaskMarginTop", smtPad.soldermask_margin_top)}${formatOptionalMmAttr("solderMaskMarginRight", smtPad.soldermask_margin_right)}${formatOptionalMmAttr("solderMaskMarginBottom", smtPad.soldermask_margin_bottom)} width="${mmStr7(smtPad.width ?? 0)}" height="${mmStr7(smtPad.height ?? 0)}" ccwRotation={${smtPad.ccw_rotation ?? 0}} shape="rotated_rect" />`
+        `<smtpad ${commonAttrs.join(" ")}${solderMaskAttrs}${formatOptionalMmAttr("cornerRadius", cornerRadius)}${formatOptionalMmAttr("solderMaskMarginLeft", smtPad.soldermask_margin_left)}${formatOptionalMmAttr("solderMaskMarginTop", smtPad.soldermask_margin_top)}${formatOptionalMmAttr("solderMaskMarginRight", smtPad.soldermask_margin_right)}${formatOptionalMmAttr("solderMaskMarginBottom", smtPad.soldermask_margin_bottom)} width="${mmStr8(smtPad.width ?? 0)}" height="${mmStr8(smtPad.height ?? 0)}" ccwRotation={${smtPad.ccw_rotation ?? 0}} shape="rotated_rect" />`
       );
     }
   }
@@ -2604,7 +3400,7 @@ var convertSmtPads = (circuitJson, context) => {
 };
 
 // lib/generate-footprint-tsx/convert-vias.ts
-import { mmStr as mmStr8 } from "@tscircuit/mm";
+import { mmStr as mmStr9 } from "@tscircuit/mm";
 import { su as su20 } from "@tscircuit/soup-util";
 var convertVias = (circuitJson, context) => {
   return su20(circuitJson).pcb_via.list().map((via) => {
@@ -2620,7 +3416,7 @@ var convertVias = (circuitJson, context) => {
     const tentedAttr = tentedOnTop !== void 0 || tentedOnBottom !== void 0 ? ` tented="${tented}"` : "";
     const runtimeNetName = via.source_net_id ? context?.runtimeNetNameBySourceNetId.get(via.source_net_id) : void 0;
     const connectsToAttr = runtimeNetName ? ` connectsTo={${JSON.stringify(`net.${runtimeNetName}`)}}` : "";
-    return `<via pcbX="${mmStr8(via.x)}" pcbY="${mmStr8(via.y)}" holeDiameter="${mmStr8(via.hole_diameter)}" outerDiameter="${mmStr8(via.outer_diameter)}" fromLayer="${fromLayer}" toLayer="${toLayer}"${tentedAttr}${connectsToAttr} />`;
+    return `<via pcbX="${mmStr9(via.x)}" pcbY="${mmStr9(via.y)}" holeDiameter="${mmStr9(via.hole_diameter)}" outerDiameter="${mmStr9(via.outer_diameter)}" fromLayer="${fromLayer}" toLayer="${toLayer}"${tentedAttr}${connectsToAttr} />`;
   });
 };
 
@@ -2655,80 +3451,567 @@ var generateFootprintTsx = (circuitJson, context) => {
   `.trim();
 };
 
-// lib/get-board-using-template.ts
-var getBoardUsingTemplate = ({
+// lib/board-converter/get-pcb-component-render-placement.ts
+import { getBoundsOfPcbElements } from "@tscircuit/circuit-json-util";
+import { applyToPoint as applyToPoint5, inverse, translate as translate5 } from "transformation-matrix";
+var physicalPcbElementTypes = /* @__PURE__ */ new Set([
+  "pcb_copper_text",
+  "pcb_cutout",
+  "pcb_hole",
+  "pcb_keepout",
+  "pcb_plated_hole",
+  "pcb_smtpad",
+  "pcb_trace",
+  "pcb_via"
+]);
+var isPhysicalPcbElement = (element) => physicalPcbElementTypes.has(element.type);
+var getElementsAsRenderedByGeneratedTsx = (elements) => elements.map((element) => {
+  if (element.type !== "pcb_plated_hole" || element.shape !== "rotated_pill_hole_with_rect_pad") {
+    return element;
+  }
+  return {
+    ...element,
+    rect_ccw_rotation: element.hole_ccw_rotation
+  };
+});
+var getPcbComponentRenderPlacement = ({
   circuitJson,
-  componentName
+  pcbBoard,
+  pcbComponent
+}) => {
+  const componentPosition = applyToPoint5(
+    inverse(translate5(pcbBoard.center.x, pcbBoard.center.y)),
+    pcbComponent.center
+  );
+  const physicalElements = circuitJson.filter(
+    (element) => isPhysicalPcbElement(element) && "pcb_component_id" in element && element.pcb_component_id === pcbComponent.pcb_component_id
+  );
+  const physicalBounds = getBoundsOfPcbElements(
+    getElementsAsRenderedByGeneratedTsx(physicalElements)
+  );
+  const physicalWidth = physicalBounds.maxX - physicalBounds.minX;
+  const physicalHeight = physicalBounds.maxY - physicalBounds.minY;
+  if (Number.isFinite(physicalWidth) && Number.isFinite(physicalHeight) && physicalWidth > 0 && physicalHeight > 0) {
+    return {
+      cadModelParentCenter: {
+        x: (physicalBounds.minX + physicalBounds.maxX) / 2,
+        y: (physicalBounds.minY + physicalBounds.maxY) / 2
+      },
+      componentPosition
+    };
+  }
+  return {
+    cadModelParentCenter: componentPosition,
+    componentPosition
+  };
+};
+
+// lib/board-converter/get-pin-labels.ts
+var getCompoundPinNumber = (sourcePort) => {
+  if (sourcePort.pin_number !== void 0) return sourcePort.pin_number;
+  const firstPinNumber = /^\d+/u.exec(sourcePort.name)?.[0];
+  return firstPinNumber ? Number.parseInt(firstPinNumber, 10) : void 0;
+};
+var getPinLabels = ({
+  circuitJson,
+  footprintConversionContext,
+  pcbComponent,
+  sourceComponents
 }) => {
-  const pcbBoard = su21(circuitJson).pcb_board.list()[0];
-  const boardProps = [];
-  if (pcbBoard) {
-    if (pcbBoard.width !== void 0) {
-      boardProps.push(`width="${mmStr9(pcbBoard.width)}"`);
+  if (sourceComponents.length === 0) return void 0;
+  const pinLabels = {};
+  const sourceComponentIds = new Set(
+    sourceComponents.map((sourceComponent) => sourceComponent.source_component_id).filter(
+      (sourceComponentId) => sourceComponentId !== void 0
+    )
+  );
+  const sourcePorts = circuitJson.filter(
+    (element) => element.type === "source_port" && element.source_component_id !== void 0 && sourceComponentIds.has(element.source_component_id) && (element.pin_number !== void 0 || element.source_component_id === pcbComponent.source_component_id)
+  );
+  const usedPinNumbers = new Set(
+    sourcePorts.map(getCompoundPinNumber).filter((pinNumber) => pinNumber !== void 0)
+  );
+  let nextSyntheticPinNumber = Math.max(0, ...usedPinNumbers) + 1;
+  for (const sourcePort of sourcePorts) {
+    const importedPortHints = circuitJson.flatMap((element) => {
+      if (sourcePort.source_component_id !== pcbComponent.source_component_id || element.type !== "pcb_port" || element.source_port_id !== sourcePort.source_port_id) {
+        return [];
+      }
+      const importedPortHint = footprintConversionContext.portHintByPcbPortId.get(element.pcb_port_id);
+      return importedPortHint ? [importedPortHint] : [];
+    });
+    const aliases = [
+      sourcePort.name,
+      ...sourcePort.port_hints ?? [],
+      ...importedPortHints
+    ].filter(
+      (alias, aliasIndex, allAliases) => alias.length > 0 && allAliases.indexOf(alias) === aliasIndex
+    );
+    let pinNumber = getCompoundPinNumber(sourcePort);
+    if (pinNumber === void 0) {
+      while (usedPinNumbers.has(nextSyntheticPinNumber)) {
+        nextSyntheticPinNumber += 1;
+      }
+      pinNumber = nextSyntheticPinNumber;
+      usedPinNumbers.add(pinNumber);
+      nextSyntheticPinNumber += 1;
     }
-    if (pcbBoard.height !== void 0) {
-      boardProps.push(`height="${mmStr9(pcbBoard.height)}"`);
+    const pinLabelKey = `pin${pinNumber}`;
+    pinLabels[pinLabelKey] = [
+      ...pinLabels[pinLabelKey] ?? [],
+      ...aliases
+    ].filter(
+      (alias, aliasIndex, allAliases) => allAliases.indexOf(alias) === aliasIndex
+    );
+  }
+  return Object.keys(pinLabels).length > 0 ? pinLabels : void 0;
+};
+
+// lib/board-converter/get-schematic-components-for-pcb-component.ts
+var getSchematicComponentsForPcbComponent = ({
+  circuitJson,
+  pcbComponent
+}) => {
+  const sourceComponents = circuitJson.filter(
+    (element) => element.type === "source_component"
+  );
+  const pcbSourceComponent = sourceComponents.find(
+    (sourceComponent) => sourceComponent.source_component_id === pcbComponent.source_component_id
+  );
+  if (!pcbSourceComponent) return [];
+  const matchingSourceComponentIds = new Set(
+    sourceComponents.filter(
+      (sourceComponent) => sourceComponent.source_component_id === pcbSourceComponent.source_component_id || pcbSourceComponent.name !== void 0 && sourceComponent.name === pcbSourceComponent.name
+    ).map((sourceComponent) => sourceComponent.source_component_id).filter(
+      (sourceComponentId) => sourceComponentId !== void 0
+    )
+  );
+  return circuitJson.filter(
+    (element) => element.type === "schematic_component" && element.source_component_id !== void 0 && matchingSourceComponentIds.has(element.source_component_id)
+  );
+};
+
+// lib/board-converter/localize-pcb-component-elements.ts
+import { transformPCBElements } from "@tscircuit/circuit-json-util";
+import {
+  applyToPoint as applyToPoint6,
+  compose as compose4,
+  decomposeTSR,
+  flipY,
+  inverse as inverse2,
+  rotateDEG as rotateDEG3,
+  translate as translate6
+} from "transformation-matrix";
+var FLOATING_POINT_NOISE_THRESHOLD = 1e-12;
+var LOCAL_COORDINATE_DECIMAL_PLACES = 12;
+var normalizeFloatingPointNoise = (elementPropertyValue) => {
+  if (Array.isArray(elementPropertyValue)) {
+    for (const item of elementPropertyValue) normalizeFloatingPointNoise(item);
+    return;
+  }
+  if (typeof elementPropertyValue !== "object" || elementPropertyValue === null)
+    return;
+  const record = elementPropertyValue;
+  for (const [key, property] of Object.entries(record)) {
+    if (typeof property === "number" && Math.abs(property) < FLOATING_POINT_NOISE_THRESHOLD) {
+      record[key] = 0;
+    } else {
+      normalizeFloatingPointNoise(property);
     }
-    if (pcbBoard.outline && pcbBoard.outline.length > 0) {
-      const points = pcbBoard.outline.map((p) => `{ x: ${p.x}, y: ${p.y} }`).join(", ");
-      boardProps.push(`outline={[${points}]}`);
+  }
+};
+var normalizeRoutableElementCoordinates = (localComponentElements) => {
+  for (const element of localComponentElements) {
+    if (element.type !== "pcb_smtpad" && element.type !== "pcb_plated_hole") {
+      continue;
     }
-    if (pcbBoard.thickness !== void 0) {
-      boardProps.push(`thickness="${mmStr9(pcbBoard.thickness)}"`);
+    if (!("x" in element) || !("y" in element)) continue;
+    element.x = Number(element.x.toFixed(LOCAL_COORDINATE_DECIMAL_PLACES));
+    element.y = Number(element.y.toFixed(LOCAL_COORDINATE_DECIMAL_PLACES));
+  }
+};
+var transformSilkscreenGraphic = ({
+  absoluteToComponentLocalTransform,
+  graphic
+}) => {
+  if (graphic.shape !== "brep") return;
+  graphic.brep_shape.outer_ring.vertices = graphic.brep_shape.outer_ring.vertices.map(
+    (vertex) => applyToPoint6(absoluteToComponentLocalTransform, vertex)
+  );
+  graphic.brep_shape.inner_rings = graphic.brep_shape.inner_rings.map(
+    (ring) => ({
+      ...ring,
+      vertices: ring.vertices.map(
+        (vertex) => applyToPoint6(absoluteToComponentLocalTransform, vertex)
+      )
+    })
+  );
+};
+var normalizeDegrees = (degrees) => (degrees % 360 + 360) % 360;
+var getTransformedCcwRotationDegrees = ({
+  absoluteCcwRotationDegrees,
+  absoluteToComponentLocalRotationTransform
+}) => {
+  const transformedRotation = decomposeTSR(
+    compose4(
+      absoluteToComponentLocalRotationTransform,
+      rotateDEG3(absoluteCcwRotationDegrees)
+    )
+  ).rotation.angle;
+  return normalizeDegrees(transformedRotation * 180 / Math.PI);
+};
+var localizePrimitiveRotations = ({
+  absoluteComponentElements,
+  absoluteToComponentLocalRotationTransform,
+  localComponentElements
+}) => {
+  const rotationPropertyNames = [
+    "ccw_rotation",
+    "hole_ccw_rotation",
+    "rect_ccw_rotation"
+  ];
+  for (const [elementIndex, localElement] of localComponentElements.entries()) {
+    if (localElement.type === "pcb_silkscreen_text" || localElement.type === "pcb_copper_text" || localElement.type === "pcb_fabrication_note_text") {
+      continue;
     }
-    if (pcbBoard.num_layers !== void 0) {
-      boardProps.push(`layers={${pcbBoard.num_layers}}`);
+    const absoluteElement = absoluteComponentElements[elementIndex];
+    if (absoluteElement?.type !== localElement.type) continue;
+    const absoluteRotations = absoluteElement;
+    const localRotations = localElement;
+    for (const rotationPropertyName of rotationPropertyNames) {
+      const absoluteCcwRotationDegrees = absoluteRotations[rotationPropertyName];
+      if (typeof absoluteCcwRotationDegrees !== "number") continue;
+      localRotations[rotationPropertyName] = getTransformedCcwRotationDegrees({
+        absoluteCcwRotationDegrees,
+        absoluteToComponentLocalRotationTransform
+      });
     }
-    if (pcbBoard.material !== void 0) {
-      boardProps.push(`material="${pcbBoard.material}"`);
+  }
+};
+var getOppositeOuterLayer = (layer) => {
+  if (layer === "top") return "bottom";
+  if (layer === "bottom") return "top";
+  return layer;
+};
+var localizeBottomComponentLayers = (localComponentElements) => {
+  for (const localElement of localComponentElements) {
+    if ("layer" in localElement && (localElement.layer === "top" || localElement.layer === "bottom")) {
+      localElement.layer = getOppositeOuterLayer(localElement.layer);
     }
-    if (pcbBoard.solder_mask_color !== void 0) {
-      boardProps.push(`solderMaskColor="${pcbBoard.solder_mask_color}"`);
+    if ("layers" in localElement && Array.isArray(localElement.layers)) {
+      localElement.layers = localElement.layers.map(
+        (layer) => layer === "top" || layer === "bottom" ? getOppositeOuterLayer(layer) : layer
+      );
     }
-    if (pcbBoard.silkscreen_color !== void 0) {
-      boardProps.push(`silkscreenColor="${pcbBoard.silkscreen_color}"`);
+  }
+};
+var localizeTextRotations = ({
+  absoluteComponentElements,
+  componentCcwRotationDegrees,
+  localComponentElements
+}) => {
+  for (const [elementIndex, localElement] of localComponentElements.entries()) {
+    if (localElement.type !== "pcb_silkscreen_text" && localElement.type !== "pcb_copper_text" && localElement.type !== "pcb_fabrication_note_text") {
+      continue;
     }
-    const resolvedAnchorPosition = pcbBoard.anchor_position ?? pcbBoard.center;
-    if (pcbBoard.anchor_position !== void 0 || resolvedAnchorPosition.x !== 0 || resolvedAnchorPosition.y !== 0) {
-      boardProps.push(
-        `boardAnchorPosition={{ x: ${resolvedAnchorPosition.x}, y: ${resolvedAnchorPosition.y} }}`
+    const absoluteElement = absoluteComponentElements[elementIndex];
+    if (absoluteElement?.type !== localElement.type) continue;
+    const absoluteRotation = normalizeDegrees(absoluteElement.ccw_rotation ?? 0);
+    if (localElement.type === "pcb_silkscreen_text") {
+      localElement.ccw_rotation = absoluteRotation || 360;
+    } else if (localElement.type === "pcb_copper_text") {
+      localElement.ccw_rotation = absoluteRotation;
+    } else {
+      localElement.ccw_rotation = normalizeDegrees(
+        absoluteRotation - componentCcwRotationDegrees
       );
     }
-    if (pcbBoard.anchor_alignment !== void 0) {
-      boardProps.push(`boardAnchorAlignment="${pcbBoard.anchor_alignment}"`);
+  }
+};
+var localizePcbComponentElements = ({
+  circuitJson,
+  pcbComponent
+}) => {
+  const absoluteComponentElements = circuitJson.filter(
+    (element) => "pcb_component_id" in element && element.pcb_component_id === pcbComponent.pcb_component_id
+  );
+  const localComponentElements = structuredClone(absoluteComponentElements);
+  const componentLocalToAbsoluteTransform = compose4(
+    translate6(pcbComponent.center.x, pcbComponent.center.y),
+    rotateDEG3(pcbComponent.rotation)
+  );
+  let absoluteToComponentLocalTransform = inverse2(
+    componentLocalToAbsoluteTransform
+  );
+  if (pcbComponent.layer === "bottom") {
+    absoluteToComponentLocalTransform = compose4(
+      flipY(),
+      absoluteToComponentLocalTransform
+    );
+  }
+  transformPCBElements(
+    localComponentElements,
+    absoluteToComponentLocalTransform
+  );
+  for (const localElement of localComponentElements) {
+    if (localElement.type === "pcb_silkscreen_graphic") {
+      transformSilkscreenGraphic({
+        absoluteToComponentLocalTransform,
+        graphic: localElement
+      });
     }
   }
-  const boardPropsStr = boardProps.join(" ");
-  const context = createBoardConversionContext(circuitJson);
-  const footprintTsx = generateFootprintTsx(circuitJson, context);
-  const copperPoursTsx = generateCopperPoursTsx(circuitJson, context);
-  const boardNetsTsx = generateBoardNetsTsx(context);
-  const boardCadModelsTsx = generateBoardCadModelsTsx({
-    circuitJson,
-    pcbBoard
+  localizeTextRotations({
+    absoluteComponentElements,
+    componentCcwRotationDegrees: pcbComponent.rotation,
+    localComponentElements
   });
-  const schematicElements = generateBoardSchematicElements(circuitJson);
-  const schematicSheetTsx = generateBoardSchematicSheetTsx({
+  localizePrimitiveRotations({
+    absoluteComponentElements,
+    absoluteToComponentLocalRotationTransform: inverse2(
+      componentLocalToAbsoluteTransform
+    ),
+    localComponentElements
+  });
+  if (pcbComponent.layer === "bottom") {
+    localizeBottomComponentLayers(localComponentElements);
+  }
+  normalizeRoutableElementCoordinates(localComponentElements);
+  normalizeFloatingPointNoise(localComponentElements);
+  return localComponentElements;
+};
+
+// lib/board-converter/stages/convert-pcb-components.ts
+var getComponentFootprintTsx = ({
+  circuitJson,
+  footprintConversionContext,
+  pcbComponent
+}) => {
+  const componentElements = localizePcbComponentElements({
     circuitJson,
-    schematicElements
+    pcbComponent
   });
-  const children = [
-    ...boardNetsTsx,
-    footprintTsx ? `<chip name="${context.pcbChipName}" noSchematicRepresentation footprint={${footprintTsx}} />` : "",
-    ...copperPoursTsx,
-    ...boardCadModelsTsx,
-    schematicSheetTsx
-  ].filter(Boolean).join("\n");
+  return generateFootprintTsx(componentElements, footprintConversionContext);
+};
+var convertPcbComponents = ({
+  circuitJson,
+  footprintConversionContext,
+  pcbComponentRuntimeNameByPcbComponentId,
+  pcbBoard,
+  boardChildren
+}) => {
+  const pcbComponents = circuitJson.filter(
+    (element) => element.type === "pcb_component"
+  );
+  const cadModelGroupByPcbComponentId = /* @__PURE__ */ new Map();
+  for (const cadModelGroup of getCadModelGroups(circuitJson)) {
+    const pcbComponentId = cadModelGroup.cadComponents[0]?.pcb_component_id;
+    if (pcbComponentId === void 0) continue;
+    const existingCadModelGroup = cadModelGroupByPcbComponentId.get(pcbComponentId);
+    cadModelGroupByPcbComponentId.set(
+      pcbComponentId,
+      existingCadModelGroup ? {
+        ...existingCadModelGroup,
+        cadComponents: [
+          ...existingCadModelGroup.cadComponents,
+          ...cadModelGroup.cadComponents
+        ]
+      } : cadModelGroup
+    );
+  }
+  for (const pcbComponent of pcbComponents) {
+    const sourceComponent = circuitJson.find(
+      (element) => element.type === "source_component" && element.source_component_id === pcbComponent.source_component_id
+    );
+    const schematicComponents = getSchematicComponentsForPcbComponent({
+      circuitJson,
+      pcbComponent
+    });
+    const schematicSourceComponentIds = new Set(
+      schematicComponents.map((schematicComponent) => schematicComponent.source_component_id).filter(
+        (sourceComponentId) => sourceComponentId !== void 0
+      )
+    );
+    const sourceComponents = circuitJson.filter(
+      (element) => element.type === "source_component" && (element.source_component_id === pcbComponent.source_component_id || element.source_component_id !== void 0 && schematicSourceComponentIds.has(element.source_component_id))
+    );
+    const { cadModelParentCenter, componentPosition } = getPcbComponentRenderPlacement({
+      circuitJson,
+      pcbBoard,
+      pcbComponent
+    });
+    const footprintTsx = getComponentFootprintTsx({
+      circuitJson,
+      footprintConversionContext,
+      pcbComponent
+    });
+    const pinLabels = getPinLabels({
+      circuitJson,
+      footprintConversionContext,
+      pcbComponent,
+      sourceComponents
+    });
+    const componentName = pcbComponentRuntimeNameByPcbComponentId.get(
+      pcbComponent.pcb_component_id
+    );
+    if (!componentName) {
+      throw new Error("Expected every PCB component to have a runtime name");
+    }
+    const cadModelGroup = cadModelGroupByPcbComponentId.get(
+      pcbComponent.pcb_component_id
+    );
+    const localizedCadModelGroup = cadModelGroup ? {
+      ...cadModelGroup,
+      parentPlacement: {
+        center: cadModelParentCenter,
+        ccwRotationDegrees: pcbComponent.rotation,
+        layer: pcbComponent.layer === "bottom" ? "bottom" : "top"
+      }
+    } : void 0;
+    const cadModelTsx = localizedCadModelGroup ? generateCadModelGroupModelTsx({
+      cadModelGroup: localizedCadModelGroup,
+      pcbBoard
+    }) : void 0;
+    const childModelElementsTsx = localizedCadModelGroup ? generateCadModelGroupChildrenTsx({
+      cadModelGroup: localizedCadModelGroup,
+      pcbBoard
+    }) : [];
+    const componentProps = [
+      `name=${formatJsxStringAttribute(componentName)}`,
+      `pcbX={${componentPosition.x}}`,
+      `pcbY={${componentPosition.y}}`,
+      `pcbRotation="${pcbComponent.rotation}deg"`,
+      `layer="${pcbComponent.layer}"`,
+      "noSchematicRepresentation"
+    ];
+    if (cadModelTsx) {
+      componentProps.push(`cadModel={${cadModelTsx}}`);
+    }
+    if (localizedCadModelGroup && isJscadCadModelGroupTranslucent(localizedCadModelGroup)) {
+      componentProps.push("showAsTranslucentModel");
+    }
+    if (pinLabels) {
+      componentProps.push(`pinLabels={${JSON.stringify(pinLabels)}}`);
+    }
+    if (sourceComponent?.manufacturer_part_number) {
+      componentProps.push(
+        `manufacturerPartNumber=${formatJsxStringAttribute(sourceComponent.manufacturer_part_number)}`
+      );
+    }
+    if (sourceComponent?.supplier_part_numbers && Object.keys(sourceComponent.supplier_part_numbers).length > 0) {
+      componentProps.push(
+        `supplierPartNumbers={${JSON.stringify(sourceComponent.supplier_part_numbers)}}`
+      );
+    }
+    if (pcbComponent.do_not_place === true) {
+      componentProps.push("doNotPlace");
+    }
+    if (pcbComponent.obstructs_within_bounds === false) {
+      componentProps.push("obstructsWithinBounds={false}");
+    }
+    const chipOpeningTsx = `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}}`;
+    boardChildren.push(
+      childModelElementsTsx.length === 0 ? `${chipOpeningTsx} />` : `${chipOpeningTsx}>${childModelElementsTsx.join("\n")}</chip>`
+    );
+  }
+};
+
+// lib/board-converter/stages/convert-standalone-pcb-primitives.ts
+var convertStandalonePcbPrimitives = ({
+  circuitJson,
+  footprintConversionContext,
+  pcbBoard,
+  boardChildren
+}) => {
+  const existingPcbComponentIds = new Set(
+    circuitJson.flatMap(
+      (element) => element.type === "pcb_component" ? [element.pcb_component_id] : []
+    )
+  );
+  const standaloneElements = circuitJson.filter(
+    (element) => !("pcb_component_id" in element) || !element.pcb_component_id || !existingPcbComponentIds.has(element.pcb_component_id)
+  );
+  const footprintTsx = generateFootprintTsx(
+    standaloneElements,
+    footprintConversionContext
+  );
+  if (!footprintTsx) return;
+  const footprintContainerProps = [
+    `name="${footprintConversionContext.pcbChipName}"`,
+    "noSchematicRepresentation",
+    "obstructsWithinBounds={false}"
+  ];
+  if (pcbBoard.center.x !== 0) {
+    footprintContainerProps.push(`pcbX={${-pcbBoard.center.x}}`);
+  }
+  if (pcbBoard.center.y !== 0) {
+    footprintContainerProps.push(`pcbY={${-pcbBoard.center.y}}`);
+  }
+  boardChildren.push(
+    `<chip${footprintContainerProps.length > 0 ? ` ${footprintContainerProps.join(" ")}` : ""} footprint={${footprintTsx}} />`
+  );
+};
+
+// lib/board-converter/convert-board-circuit-json.ts
+var conversionStages = [
+  convertBoardProperties,
+  convertPcbComponents,
+  convertBoardNets,
+  convertBoardTraces,
+  convertCopperPours,
+  convertBoardSchematic,
+  convertStandalonePcbPrimitives,
+  convertBoardCadModels
+];
+var convertBoardCircuitJson = ({
+  circuitJson,
+  componentName
+}) => {
+  const pcbBoard = circuitJson.find((element) => element.type === "pcb_board");
+  if (!pcbBoard) {
+    throw new Error("Board conversion requires a pcb_board element");
+  }
+  const {
+    pcbChipName,
+    pcbComponentRuntimeNameByPcbComponentId,
+    standaloneCadModelRuntimeNameByCadComponentId
+  } = getBoardChildRuntimeNames(circuitJson);
+  const context = {
+    circuitJson,
+    footprintConversionContext: createComponentPreservingBoardConversionContext(
+      {
+        circuitJson,
+        pcbChipName,
+        pcbComponentRuntimeNameByPcbComponentId
+      }
+    ),
+    pcbComponentRuntimeNameByPcbComponentId,
+    standaloneCadModelRuntimeNameByCadComponentId,
+    pcbBoard,
+    boardProps: [],
+    boardChildren: []
+  };
+  for (const convertStage of conversionStages) {
+    convertStage(context);
+  }
+  const boardProps = context.boardProps.join(" ");
+  const boardChildren = context.boardChildren.join("\n");
   return `
 ${componentName ? `export const ${componentName} =` : "export default"} () => (
-  <board${boardPropsStr ? ` ${boardPropsStr}` : ""}>
-    ${children}
+  <board${boardProps ? ` ${boardProps}` : ""}>
+    ${boardChildren.replace(/\n/g, "\n    ")}
   </board>
 )
 ${componentName ? `export default ${componentName}` : ""}
 `.replace(/\n\s*\n/g, "\n").trim();
 };
 
+// lib/get-board-using-template.ts
+var getBoardUsingTemplate = ({
+  circuitJson,
+  componentName
+}) => convertBoardCircuitJson({ circuitJson, componentName });
+
 // lib/get-pin-attributes.ts
 var attributeNames = {
   is_input: "isInput",