circuit-json-to-tscircuit 0.0.92 → 0.0.94

package/dist/{chunk-GAMHGAGS.js → chunk-WQVP4ME2.js}

@@ -504,9 +504,9 @@ function getCadModelPlacementAttributes({
   if (cadComponent.size !== void 0) {
     attributes.push(`size={${formatPointProp(cadComponent.size)}}`);
   }
-  if (cadComponent.show_as_translucent_model === true) {
-    attributes.push("showAsTranslucentModel");
-  }
+  attributes.push(
+    `showAsTranslucentModel={${cadComponent.show_as_translucent_model === true}}`
+  );
   return attributes;
 }
 
@@ -539,48 +539,397 @@ function generateCadModelTsx({
   return `<cadmodel ${attributes.join(" ")} />`;
 }
 
-// lib/generate-board-cad-models-tsx/generate-jscad-cad-model-tsx.ts
-function generateJscadCadModelTsx({
+// 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
 }) {
-  if (cadComponent.model_jscad === void 0) return void 0;
-  const attributes = [
-    `jscad={${JSON.stringify(cadComponent.model_jscad)}}`,
-    ...getCadModelPlacementAttributes({
+  const placement = getCadModelPlacement({
+    cadComponent,
+    parentPlacement,
+    pcbBoard
+  });
+  const properties = [
+    `jscad: ${JSON.stringify(cadComponent.model_jscad)}`,
+    `positionOffset: ${formatPointProp(placement.positionOffset)}`,
+    `rotationOffset: ${formatPointProp(placement.ccwRotationOffsetDegrees)}`
+  ];
+  const modelOriginPosition = getCadModelOriginPosition(cadComponent);
+  if (modelOriginPosition !== void 0) {
+    properties.push(
+      `modelOriginPosition: ${formatPointProp(modelOriginPosition)}`
+    );
+  }
+  if (cadComponent.model_unit_to_mm_scale_factor !== void 0) {
+    properties.push(
+      `modelUnitToMmScale: ${cadComponent.model_unit_to_mm_scale_factor}`
+    );
+  }
+  if (cadComponent.model_board_normal_direction !== void 0) {
+    properties.push(
+      `modelBoardNormalDirection: ${JSON.stringify(cadComponent.model_board_normal_direction)}`
+    );
+  }
+  if (cadComponent.size !== void 0) {
+    properties.push(`size: ${formatPointProp(cadComponent.size)}`);
+  }
+  return `{ ${properties.join(", ")} }`;
+}
+function generateJscadCadModelPropTsx({
+  cadComponents,
+  parentPlacement,
+  pcbBoard
+}) {
+  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
-    })
+    });
+    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+"'
   ];
-  return `<cadmodel ${attributes.join(" ")} />`;
+  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 generateCadModelElementsTsx = ({
+var generateUrlCadModelElementsTsx = ({
   cadModelGroup,
   pcbBoard
 }) => cadModelGroup.cadComponents.flatMap((cadComponent) => {
-  const modelElementGenerator = cadComponent.model_jscad === void 0 ? generateCadModelTsx : generateJscadCadModelTsx;
-  const modelElement = modelElementGenerator({
+  if (getCadModelUrl(cadComponent) === void 0) return [];
+  const modelElement = generateCadModelTsx({
     cadComponent,
     parentPlacement: cadModelGroup.parentPlacement,
     pcbBoard
   });
   return modelElement ? [modelElement] : [];
 });
+var getJscadCadComponents = (cadModelGroup) => cadModelGroup.cadComponents.filter(
+  (cadComponent) => cadComponent.model_jscad !== void 0
+);
 function generateCadModelGroupModelTsx({
   cadModelGroup,
   pcbBoard
 }) {
-  const modelElements = generateCadModelElementsTsx({
+  const jscadCadComponents = getJscadCadComponents(cadModelGroup);
+  if (jscadCadComponents.length > 0) {
+    return generateJscadCadModelPropTsx({
+      cadComponents: jscadCadComponents,
+      parentPlacement: cadModelGroup.parentPlacement,
+      pcbBoard
+    });
+  }
+  const urlCadModelElementsTsx = generateUrlCadModelElementsTsx({
     cadModelGroup,
     pcbBoard
   });
-  if (modelElements.length === 0) return void 0;
-  if (modelElements.length === 1) return modelElements[0];
-  return `<cadassembly>${modelElements.join("\n")}</cadassembly>`;
+  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
@@ -606,7 +955,17 @@ function generateCadModelGroupTsx({
     "footprint={<footprint />}",
     `cadModel={${cadModelTsx}}`
   ];
-  return `<chip ${attributes.join(" ")} />`;
+  if (isJscadCadModelGroupTranslucent(cadModelGroup)) {
+    attributes.push("showAsTranslucentModel");
+  }
+  const childModelElementsTsx = generateCadModelGroupChildrenTsx({
+    cadModelGroup,
+    pcbBoard
+  });
+  if (childModelElementsTsx.length === 0) {
+    return `<chip ${attributes.join(" ")} />`;
+  }
+  return `<chip ${attributes.join(" ")}>${childModelElementsTsx.join("\n")}</chip>`;
 }
 
 // lib/board-converter/stages/convert-board-cad-models.ts
@@ -767,55 +1126,6 @@ ${schematicElements.join("\n")}
 // lib/generate-board-schematic-tsx/convert-primitives.ts
 import { schematic_text } from "circuit-json";
 
-// lib/generate-board-schematic-tsx/convert-rect.ts
-import {
-  applyToPoint,
-  compose,
-  rotateDEG,
-  translate
-} from "transformation-matrix";
-
-// lib/generate-board-schematic-tsx/format-attributes.ts
-var formatAttributes = (attributes) => Object.entries(attributes).filter(([, attribute]) => attribute !== void 0 && attribute !== null).map(([name, attribute]) => `${name}={${JSON.stringify(attribute)}}`).join(" ");
-var formatElement = (tagName, attributes) => `<${tagName} ${formatAttributes(attributes)} />`;
-
-// lib/generate-board-schematic-tsx/convert-rect.ts
-var DEFAULT_SCHEMATIC_STROKE_WIDTH = 0.02;
-var DASH_LENGTH_TO_STROKE_WIDTH_RATIO = 3;
-var convertRect = ({
-  center,
-  width,
-  height,
-  ccwRotationDegrees,
-  strokeWidth,
-  color,
-  fillColor,
-  isFilled,
-  isDashed
-}) => {
-  const rectToSchematicTransform = compose(
-    translate(center.x, center.y),
-    rotateDEG(ccwRotationDegrees ?? 0)
-  );
-  const points = [
-    { x: -width / 2, y: -height / 2 },
-    { x: width / 2, y: -height / 2 },
-    { x: width / 2, y: height / 2 },
-    { x: -width / 2, y: height / 2 },
-    { x: -width / 2, y: -height / 2 }
-  ].map((point) => applyToPoint(rectToSchematicTransform, point));
-  const dashLength = isDashed ? (strokeWidth ?? DEFAULT_SCHEMATIC_STROKE_WIDTH) * DASH_LENGTH_TO_STROKE_WIDTH_RATIO : void 0;
-  return formatElement("schematicpath", {
-    points,
-    strokeWidth,
-    strokeColor: color,
-    fillColor,
-    isFilled,
-    dashLength,
-    dashGap: dashLength
-  });
-};
-
 // lib/generate-symbol-tsx.ts
 import { su } from "@tscircuit/soup-util";
 var escapeJsxText = (text) => text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -1035,46 +1345,381 @@ var generateSymbolTsx = (circuitJson) => {
   `.trim();
 };
 
-// lib/generate-board-schematic-tsx/get-schematic-primitives-in-render-order.ts
-var isSchematicPrimitive = (element) => element.type === "schematic_text" || element.type === "schematic_path" || element.type === "schematic_rect" || element.type === "schematic_line" || element.type === "schematic_circle" || element.type === "schematic_arc" || element.type === "schematic_box";
-var isCustomComponentBody = ({
-  component,
-  rect
-}) => component.is_box_with_pins === false && rect.is_filled && rect.center.x === component.center.x && rect.center.y === component.center.y && rect.width === component.size.width && rect.height === component.size.height;
-var getSchematicPrimitivesInRenderOrder = (circuitJson) => {
-  const customComponentById = /* @__PURE__ */ new Map();
-  for (const element of circuitJson) {
-    if (element.type === "schematic_component" && element.is_box_with_pins === false) {
-      customComponentById.set(element.schematic_component_id, element);
-    }
+// lib/generate-board-schematic-tsx/convert-rect.ts
+import {
+  applyToPoint,
+  compose,
+  rotateDEG,
+  translate
+} from "transformation-matrix";
+
+// lib/generate-board-schematic-tsx/format-attributes.ts
+var formatAttributes = (attributes) => Object.entries(attributes).filter(([, attribute]) => attribute !== void 0 && attribute !== null).map(([name, attribute]) => `${name}={${JSON.stringify(attribute)}}`).join(" ");
+var formatElement = (tagName, attributes) => `<${tagName} ${formatAttributes(attributes)} />`;
+
+// lib/generate-board-schematic-tsx/convert-rect.ts
+var DEFAULT_SCHEMATIC_STROKE_WIDTH = 0.02;
+var DASH_LENGTH_TO_STROKE_WIDTH_RATIO = 3;
+var convertRect = ({
+  center,
+  width,
+  height,
+  ccwRotationDegrees,
+  strokeWidth,
+  color,
+  fillColor,
+  isFilled,
+  isDashed
+}) => {
+  const rectToSchematicTransform = compose(
+    translate(center.x, center.y),
+    rotateDEG(ccwRotationDegrees ?? 0)
+  );
+  const points = [
+    { x: -width / 2, y: -height / 2 },
+    { x: width / 2, y: -height / 2 },
+    { x: width / 2, y: height / 2 },
+    { x: -width / 2, y: height / 2 },
+    { x: -width / 2, y: -height / 2 }
+  ].map((point) => applyToPoint(rectToSchematicTransform, point));
+  const dashLength = isDashed ? (strokeWidth ?? DEFAULT_SCHEMATIC_STROKE_WIDTH) * DASH_LENGTH_TO_STROKE_WIDTH_RATIO : void 0;
+  return formatElement("schematicpath", {
+    points,
+    strokeWidth,
+    strokeColor: color,
+    fillColor,
+    isFilled,
+    dashLength,
+    dashGap: dashLength
+  });
+};
+
+// lib/generate-board-schematic-tsx/get-nearest-schematic-text.ts
+var DEGREES_TO_RADIANS = Math.PI / 180;
+var distanceFromComponentCenter = ({
+  schematicText,
+  schematicComponent
+}) => Math.hypot(
+  schematicText.position.x - schematicComponent.center.x,
+  schematicText.position.y - schematicComponent.center.y
+);
+var getNearestSchematicText = ({
+  schematicTexts,
+  schematicComponent
+}) => schematicTexts.toSorted(
+  (firstText, secondText) => distanceFromComponentCenter({
+    schematicText: firstText,
+    schematicComponent
+  }) - distanceFromComponentCenter({
+    schematicText: secondText,
+    schematicComponent
+  })
+)[0];
+var getSchematicTextAxisDistances = ({
+  schematicText,
+  schematicComponent
+}) => {
+  const rotationRadians = schematicText.rotation * DEGREES_TO_RADIANS;
+  const deltaX = schematicComponent.center.x - schematicText.position.x;
+  const deltaY = schematicComponent.center.y - schematicText.position.y;
+  return {
+    alongAxis: deltaX * Math.cos(rotationRadians) + deltaY * Math.sin(rotationRadians),
+    acrossAxis: Math.abs(
+      -deltaX * Math.sin(rotationRadians) + deltaY * Math.cos(rotationRadians)
+    )
+  };
+};
+var getSchematicTextAxisRange = ({
+  schematicText,
+  maximumDistance
+}) => {
+  const maximumTextAdvance = Array.from(schematicText.text).length * schematicText.font_size;
+  if (schematicText.anchor.includes("left")) {
+    return {
+      minimum: -maximumDistance,
+      maximum: maximumTextAdvance + maximumDistance
+    };
   }
-  const primitives = circuitJson.filter(isSchematicPrimitive);
-  const componentBodyById = /* @__PURE__ */ new Map();
-  for (const primitive of primitives) {
-    if (primitive.type !== "schematic_rect" || !primitive.schematic_component_id) {
-      continue;
-    }
-    const component = customComponentById.get(primitive.schematic_component_id);
-    if (component && isCustomComponentBody({ component, rect: primitive })) {
-      componentBodyById.set(primitive.schematic_component_id, primitive);
-    }
+  if (schematicText.anchor.includes("right")) {
+    return {
+      minimum: -maximumTextAdvance - maximumDistance,
+      maximum: maximumDistance
+    };
   }
-  const emittedComponentBodies = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const primitive of primitives) {
-    const componentId = primitive.schematic_component_id;
-    const componentBody = componentId ? componentBodyById.get(componentId) : void 0;
-    if (!componentId || !componentBody) {
-      result.push(primitive);
-      continue;
-    }
-    if (!emittedComponentBodies.has(componentId)) {
-      result.push(componentBody);
-      emittedComponentBodies.add(componentId);
+  return {
+    minimum: -maximumTextAdvance / 2 - maximumDistance,
+    maximum: maximumTextAdvance / 2 + maximumDistance
+  };
+};
+var isSchematicTextWithinComponentLabelRange = ({
+  schematicText,
+  schematicComponent,
+  maximumDistance
+}) => {
+  const distance = getSchematicTextAxisDistances({
+    schematicText,
+    schematicComponent
+  });
+  const textAxisRange = getSchematicTextAxisRange({
+    schematicText,
+    maximumDistance
+  });
+  return distance.alongAxis >= textAxisRange.minimum && distance.alongAxis <= textAxisRange.maximum && distance.acrossAxis <= maximumDistance;
+};
+
+// lib/generate-board-schematic-tsx/resolve-native-schematic-symbol-name.ts
+var normalizePortName = (portName) => portName.toLowerCase().replace(/[^a-z0-9]/gu, "");
+var hasExactPortNames = (sourcePortNames, expectedPortNames) => sourcePortNames.size === expectedPortNames.length && expectedPortNames.every((portName) => sourcePortNames.has(portName));
+var resolveNativeSchematicSymbolName = ({
+  circuitJson,
+  schematicComponent
+}) => {
+  if (schematicComponent.symbol_name) return schematicComponent.symbol_name;
+  const sourceComponent = circuitJson.find(
+    (element) => element.type === "source_component" && element.source_component_id === schematicComponent.source_component_id
+  );
+  if (sourceComponent?.type !== "source_component") return void 0;
+  const sourcePorts = circuitJson.filter(
+    (element) => element.type === "source_port" && element.source_component_id === sourceComponent.source_component_id
+  );
+  const sourcePortNames = new Set(
+    sourcePorts.map((sourcePort) => normalizePortName(sourcePort.name))
+  );
+  const schematicPorts = circuitJson.filter(
+    (element) => element.type === "schematic_port" && element.schematic_component_id === schematicComponent.schematic_component_id
+  );
+  const schematicSourcePortNames = new Set(
+    schematicPorts.flatMap((schematicPort) => {
+      const sourcePort = sourcePorts.find(
+        (candidate) => candidate.source_port_id === schematicPort.source_port_id
+      );
+      return sourcePort ? [normalizePortName(sourcePort.name)] : [];
+    })
+  );
+  const logicPortNames = new Set(
+    [...schematicSourcePortNames].map(
+      (portName) => portName.replace(/^\d+([aby])$/u, "$1")
+    )
+  );
+  const designator = sourceComponent.display_name ?? "";
+  const componentValue = sourceComponent.display_value?.toUpperCase() ?? "";
+  if (componentValue.startsWith("SN74LVC2G08") && hasExactPortNames(logicPortNames, ["a", "b", "y"])) {
+    return "and_gate_right";
+  }
+  if (/^SN74LVC[23]G14/u.test(componentValue) && hasExactPortNames(logicPortNames, ["a", "y"])) {
+    return "schmitt_trigger_inverter_right";
+  }
+  if (designator.startsWith("U") && hasExactPortNames(sourcePortNames, ["a", "k", "c", "e"])) {
+    return "phototransistor_optocoupler_right";
+  }
+  if (designator.startsWith("T") && hasExactPortNames(sourcePortNames, [
+    "1",
+    "2",
+    "3",
+    "5",
+    "6",
+    "7",
+    "9",
+    "10"
+  ])) {
+    return "transformer_4_winding_right";
+  }
+  if (designator.startsWith("D") && hasExactPortNames(sourcePortNames, ["1anode", "2cathode", "1cathode2anode"])) {
+    return "dual_series_schottky_diode_right";
+  }
+  return void 0;
+};
+
+// lib/generate-board-schematic-tsx/has-multiple-native-symbol-units.ts
+var hasMultipleNativeSymbolUnits = ({
+  circuitJson,
+  schematicComponent,
+  symbolName
+}) => circuitJson.filter(
+  (candidate) => candidate.type === "schematic_component" && candidate.source_component_id === schematicComponent.source_component_id && !candidate.symbol_name && resolveNativeSchematicSymbolName({
+    circuitJson,
+    schematicComponent: candidate
+  }) === symbolName
+).length > 1;
+
+// lib/generate-board-schematic-tsx/has-preserved-package-value-text.ts
+var hasPreservedPackageValueText = ({
+  circuitJson,
+  schematicComponent,
+  schematicComponents,
+  replacedSchematicComponentIds,
+  displayTexts
+}) => circuitJson.some((candidate) => {
+  if (candidate.type !== "schematic_text" || !candidate.schematic_component_id || !displayTexts.has(candidate.text) || replacedSchematicComponentIds.has(candidate.schematic_component_id)) {
+    return false;
+  }
+  return schematicComponents.some(
+    (component) => component.schematic_component_id === candidate.schematic_component_id && component.source_component_id === schematicComponent.source_component_id
+  );
+});
+
+// lib/generate-board-schematic-tsx/is-pin-designator-for-port.ts
+var isPinDesignatorForPort = ({
+  schematicText,
+  schematicPort,
+  schematicComponent
+}) => {
+  if (schematicText.text !== String(schematicPort.pin_number)) return false;
+  const portToCenter = {
+    x: schematicComponent.center.x - schematicPort.center.x,
+    y: schematicComponent.center.y - schematicPort.center.y
+  };
+  const portToText = {
+    x: schematicText.position.x - schematicPort.center.x,
+    y: schematicText.position.y - schematicPort.center.y
+  };
+  const portDistance = Math.hypot(portToCenter.x, portToCenter.y);
+  const textDistance = Math.hypot(portToText.x, portToText.y);
+  const pointsTowardComponent = portToCenter.x * portToText.x + portToCenter.y * portToText.y >= 0;
+  return pointsTowardComponent && textDistance <= Math.min(0.3, portDistance * 0.6);
+};
+
+// lib/generate-board-schematic-tsx/get-native-symbol-text-replacement-candidate.ts
+var distanceBetween = (firstPoint, secondPoint) => Math.hypot(firstPoint.x - secondPoint.x, firstPoint.y - secondPoint.y);
+var getNativeSymbolTextReplacementCandidate = (context) => {
+  const { circuitJson, schematicComponent, unownedSchematicTexts } = context;
+  if (schematicComponent.symbol_name) return void 0;
+  const symbolName = resolveNativeSchematicSymbolName({
+    circuitJson,
+    schematicComponent
+  });
+  if (!symbolName) return void 0;
+  const sourceComponent = circuitJson.find(
+    (candidate) => candidate.type === "source_component" && candidate.source_component_id === schematicComponent.source_component_id
+  );
+  const reference = sourceComponent?.display_name ?? sourceComponent?.name;
+  const displayTexts = new Set(
+    [
+      sourceComponent?.display_value,
+      schematicComponent.symbol_display_value
+    ].filter((displayText) => Boolean(displayText))
+  );
+  const labelSearchDistance = Math.max(schematicComponent.size.width, schematicComponent.size.height) / 2 + 0.3;
+  const referenceTexts = unownedSchematicTexts.filter(
+    (schematicText) => schematicText.text === reference && distanceBetween(schematicText.position, schematicComponent.center) <= labelSearchDistance
+  );
+  const displayValueTextsInRange = unownedSchematicTexts.filter(
+    (schematicText) => displayTexts.has(schematicText.text) && isSchematicTextWithinComponentLabelRange({
+      schematicText,
+      schematicComponent,
+      maximumDistance: labelSearchDistance
+    })
+  );
+  const nearestDisplayValueText = getNearestSchematicText({
+    schematicTexts: displayValueTextsInRange,
+    schematicComponent
+  });
+  const displayValueTexts = nearestDisplayValueText ? [nearestDisplayValueText] : [];
+  const schematicPorts = circuitJson.filter(
+    (candidate) => candidate.type === "schematic_port" && candidate.schematic_component_id === schematicComponent.schematic_component_id
+  );
+  const replacedPinPortIds = /* @__PURE__ */ new Set();
+  const pinDesignatorTexts = schematicPorts.flatMap((schematicPort) => {
+    const matches = unownedSchematicTexts.filter(
+      (schematicText) => isPinDesignatorForPort({
+        schematicText,
+        schematicPort,
+        schematicComponent
+      })
+    );
+    if (matches.length > 0)
+      replacedPinPortIds.add(schematicPort.schematic_port_id);
+    return matches;
+  });
+  return {
+    schematicComponentId: schematicComponent.schematic_component_id,
+    importedTextIds: new Set(
+      [...referenceTexts, ...displayValueTexts, ...pinDesignatorTexts].map(
+        (schematicText) => schematicText.schematic_text_id
+      )
+    ),
+    replacedPinPortIds,
+    replacesReference: referenceTexts.length > 0,
+    includeNativeDisplayText: false,
+    referenceFontSize: getNearestSchematicText({
+      schematicTexts: referenceTexts,
+      schematicComponent
+    })?.font_size,
+    displayTextFontSize: nearestDisplayValueText?.font_size,
+    sourceComponentId: schematicComponent.source_component_id,
+    symbolName,
+    displayValueTextIds: new Set(
+      displayValueTexts.map((schematicText) => schematicText.schematic_text_id)
+    ),
+    isMultiUnitSymbol: hasMultipleNativeSymbolUnits({
+      circuitJson,
+      schematicComponent,
+      symbolName
+    }),
+    hasPreservedPackageValueText: hasPreservedPackageValueText({
+      circuitJson,
+      schematicComponent,
+      schematicComponents: context.schematicComponents,
+      replacedSchematicComponentIds: context.replacedSchematicComponentIds,
+      displayTexts
+    })
+  };
+};
+
+// lib/generate-board-schematic-tsx/get-replaced-schematic-component-ids.ts
+import { symbols } from "schematic-symbols";
+var getReplacedSchematicComponentIds = (circuitJson) => {
+  const replacedSchematicComponentIds = /* @__PURE__ */ new Set();
+  for (const element of circuitJson) {
+    if (element.type !== "schematic_component" || element.symbol_name) continue;
+    const inferredSymbolName = resolveNativeSchematicSymbolName({
+      circuitJson,
+      schematicComponent: element
+    });
+    if (inferredSymbolName && inferredSymbolName in symbols) {
+      replacedSchematicComponentIds.add(element.schematic_component_id);
     }
-    if (primitive !== componentBody) result.push(primitive);
   }
-  return result;
+  return replacedSchematicComponentIds;
+};
+
+// lib/generate-board-schematic-tsx/get-native-symbol-text-replacements.ts
+var isFirstUnitWithDisplayValue = ({
+  candidate,
+  allCandidates
+}) => allCandidates.find(
+  (otherCandidate) => otherCandidate.sourceComponentId === candidate.sourceComponentId && otherCandidate.symbolName === candidate.symbolName && otherCandidate.displayValueTextIds.size > 0
+)?.schematicComponentId === candidate.schematicComponentId;
+var getNativeSymbolTextReplacements = (circuitJson) => {
+  const unownedSchematicTexts = circuitJson.filter(
+    (element) => element.type === "schematic_text" && element.schematic_component_id === void 0
+  );
+  const replacedSchematicComponentIds = getReplacedSchematicComponentIds(circuitJson);
+  const schematicComponents = circuitJson.filter(
+    (element) => element.type === "schematic_component"
+  );
+  const candidates = schematicComponents.flatMap((schematicComponent) => {
+    const candidate = getNativeSymbolTextReplacementCandidate({
+      circuitJson,
+      schematicComponent,
+      unownedSchematicTexts,
+      replacedSchematicComponentIds,
+      schematicComponents
+    });
+    return candidate ? [candidate] : [];
+  });
+  return candidates.map((candidate) => ({
+    schematicComponentId: candidate.schematicComponentId,
+    importedTextIds: candidate.importedTextIds,
+    replacedPinPortIds: candidate.replacedPinPortIds,
+    replacesReference: candidate.replacesReference,
+    includeNativeDisplayText: candidate.displayValueTextIds.size > 0 && (!candidate.isMultiUnitSymbol || !candidate.hasPreservedPackageValueText && isFirstUnitWithDisplayValue({
+      candidate,
+      allCandidates: candidates
+    })),
+    referenceFontSize: candidate.referenceFontSize,
+    displayTextFontSize: candidate.displayTextFontSize
+  }));
 };
 
 // lib/generate-board-schematic-tsx/get-schematic-primitive-paint.ts
@@ -1159,14 +1804,71 @@ var getSchematicPrimitivePaint = (primitive) => {
   };
 };
 
+// lib/generate-board-schematic-tsx/get-schematic-primitives-in-render-order.ts
+var isSchematicPrimitive = (element) => element.type === "schematic_text" || element.type === "schematic_path" || element.type === "schematic_rect" || element.type === "schematic_line" || element.type === "schematic_circle" || element.type === "schematic_arc" || element.type === "schematic_box";
+var isCustomComponentBody = ({
+  component,
+  rect
+}) => component.is_box_with_pins === false && rect.is_filled && rect.center.x === component.center.x && rect.center.y === component.center.y && rect.width === component.size.width && rect.height === component.size.height;
+var getSchematicPrimitivesInRenderOrder = (circuitJson, nativeComponentIds = /* @__PURE__ */ new Set()) => {
+  const customComponentById = /* @__PURE__ */ new Map();
+  for (const element of circuitJson) {
+    if (element.type === "schematic_component" && element.is_box_with_pins === false) {
+      customComponentById.set(element.schematic_component_id, element);
+    }
+  }
+  const primitives = circuitJson.filter(isSchematicPrimitive).filter(
+    (primitive) => !primitive.schematic_component_id || !nativeComponentIds.has(primitive.schematic_component_id)
+  );
+  const componentBodyById = /* @__PURE__ */ new Map();
+  for (const primitive of primitives) {
+    if (primitive.type !== "schematic_rect" || !primitive.schematic_component_id) {
+      continue;
+    }
+    const component = customComponentById.get(primitive.schematic_component_id);
+    if (component && isCustomComponentBody({ component, rect: primitive })) {
+      componentBodyById.set(primitive.schematic_component_id, primitive);
+    }
+  }
+  const emittedComponentBodies = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const primitive of primitives) {
+    const componentId = primitive.schematic_component_id;
+    const componentBody = componentId ? componentBodyById.get(componentId) : void 0;
+    if (!componentId || !componentBody) {
+      result.push(primitive);
+      continue;
+    }
+    if (!emittedComponentBodies.has(componentId)) {
+      result.push(componentBody);
+      emittedComponentBodies.add(componentId);
+    }
+    if (primitive !== componentBody) result.push(primitive);
+  }
+  return result;
+};
+
 // lib/generate-board-schematic-tsx/convert-primitives.ts
+var getRenderablePrimitives = (circuitJson) => {
+  const replacedTextIds = new Set(
+    getNativeSymbolTextReplacements(circuitJson).flatMap((replacement) => [
+      ...replacement.importedTextIds
+    ])
+  );
+  return getSchematicPrimitivesInRenderOrder(
+    circuitJson,
+    getReplacedSchematicComponentIds(circuitJson)
+  ).filter(
+    (primitive) => primitive.type !== "schematic_text" || !replacedTextIds.has(primitive.schematic_text_id)
+  );
+};
 var convertPrimitives = (circuitJson) => [
   ...generateSymbolElements(
     circuitJson.filter(
       (element) => element.type === "schematic_table" || element.type === "schematic_table_cell"
     )
   ),
-  ...getSchematicPrimitivesInRenderOrder(circuitJson).flatMap((element) => {
+  ...getRenderablePrimitives(circuitJson).flatMap((element) => {
     const paint = getSchematicPrimitivePaint(element);
     switch (element.type) {
       case "schematic_text":
@@ -1264,7 +1966,7 @@ var convertPrimitives = (circuitJson) => [
 
 // lib/generate-board-schematic-tsx/convert-components.ts
 import { su as su3 } from "@tscircuit/soup-util";
-import { symbols } from "schematic-symbols";
+import { symbols as symbols2 } from "schematic-symbols";
 
 // lib/generate-board-schematic-tsx/get-symbol-to-schematic-transform.ts
 import { fromTriangles as fromTriangles2 } from "transformation-matrix";
@@ -1442,18 +2144,21 @@ var isRigidUniformTransform = (transform) => {
 };
 
 // lib/generate-board-schematic-tsx/match-symbol-ports-by-pin-identity.ts
+var getLogicUnitPortAlias = (portName) => portName?.match(/^\d*([aby])$/iu)?.[1]?.toLowerCase();
 var matchSymbolPortsByPinIdentity = ({
   schematicPorts,
   sourcePorts,
-  symbol
+  symbol,
+  includeSchematicPinNumbers = true
 }) => symbol.ports.flatMap((symbolPort) => {
   const candidates = schematicPorts.filter((schematicPort) => {
     const sourcePort = sourcePorts.find(
       (port) => port.source_port_id === schematicPort.source_port_id
     );
-    const pinNumber = schematicPort.pin_number ?? sourcePort?.pin_number;
+    const pinNumber = includeSchematicPinNumbers ? schematicPort.pin_number ?? sourcePort?.pin_number : sourcePort?.pin_number;
     const portIdentities = [
       sourcePort?.name,
+      getLogicUnitPortAlias(sourcePort?.name),
       ...sourcePort?.port_hints ?? [],
       ...pinNumber === void 0 ? [] : [String(pinNumber), `pin${pinNumber}`]
     ];
@@ -1469,12 +2174,17 @@ var getSymbolToSchematicTransform = ({
   symbol,
   schematicComponent,
   schematicPorts,
-  sourcePorts
+  sourcePorts,
+  includeSchematicPinNumbers
 }) => {
+  const componentSourcePorts = sourcePorts.filter(
+    (sourcePort) => sourcePort.source_component_id === schematicComponent.source_component_id
+  );
   const pinIdentityMatches = matchSymbolPortsByPinIdentity({
     schematicPorts,
-    sourcePorts,
-    symbol
+    sourcePorts: componentSourcePorts,
+    symbol,
+    includeSchematicPinNumbers
   });
   const rigidPinIdentityTransform = getRigidPinIdentityTransform(pinIdentityMatches);
   if (rigidPinIdentityTransform) return rigidPinIdentityTransform;
@@ -1510,6 +2220,17 @@ var getSymbolToSchematicTransform = ({
 import { schematic_text as schematic_text2 } from "circuit-json";
 import { applyToPoint as applyToPoint4 } from "transformation-matrix";
 var SYMBOL_OUTLINE_STROKE_WIDTH = 0.02;
+var MINIMUM_FILL_AREA = 1e-12;
+var pathHasFillArea = (points) => {
+  if (points.length < 3) return false;
+  let doubledArea = 0;
+  for (const [pointIndex, point] of points.entries()) {
+    const nextPoint = points[(pointIndex + 1) % points.length];
+    if (!nextPoint) continue;
+    doubledArea += point.x * nextPoint.y - nextPoint.x * point.y;
+  }
+  return Math.abs(doubledArea) > MINIMUM_FILL_AREA;
+};
 var anchors = {
   middle_top: "top_center",
   middle_bottom: "bottom_center",
@@ -1525,8 +2246,13 @@ var convertSymbolPrimitives = ({
   symbol,
   symbolToSchematicTransform,
   reference,
-  displayText
-}) => symbol.primitives.map((primitive) => {
+  displayText,
+  includeReference = true,
+  includeDisplayText = true,
+  referenceFontSize,
+  displayTextFontSize,
+  filledPrimitiveColor
+}) => symbol.primitives.flatMap((primitive) => {
   if (primitive.type === "path") {
     const points = primitive.points.map(
       (point) => applyToPoint4(symbolToSchematicTransform, point)
@@ -1535,19 +2261,25 @@ var convertSymbolPrimitives = ({
     return formatElement("schematicpath", {
       points,
       strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
+      fillColor: primitive.fill && pathHasFillArea(points) ? filledPrimitiveColor : void 0,
       isFilled: primitive.fill
     });
   }
   const center = applyToPoint4(symbolToSchematicTransform, primitive);
   if (primitive.type === "text") {
+    if (!includeReference && primitive.text === "{REF}") return [];
+    if (!includeDisplayText && primitive.text === "{VAL}") return [];
     const text = primitive.text === "{REF}" ? reference : primitive.text === "{VAL}" ? displayText : primitive.text;
-    return formatElement("schematictext", {
-      text,
-      schX: center.x,
-      schY: center.y,
-      anchor: anchors[primitive.anchor],
-      fontSize: primitive.fontSize ?? schematic_text2.shape.font_size.parse(void 0)
-    });
+    const importedFontSize = primitive.text === "{REF}" ? referenceFontSize : primitive.text === "{VAL}" ? displayTextFontSize : void 0;
+    return [
+      formatElement("schematictext", {
+        text,
+        schX: center.x,
+        schY: center.y,
+        anchor: anchors[primitive.anchor],
+        fontSize: importedFontSize ?? primitive.fontSize ?? schematic_text2.shape.font_size.parse(void 0)
+      })
+    ];
   }
   const symbolToSchematicVectorTransform = {
     ...symbolToSchematicTransform,
@@ -1559,12 +2291,15 @@ var convertSymbolPrimitives = ({
       x: primitive.radius,
       y: 0
     });
-    return formatElement("schematiccircle", {
-      center,
-      radius: Math.hypot(radiusVector.x, radiusVector.y),
-      strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
-      isFilled: primitive.fill
-    });
+    return [
+      formatElement("schematiccircle", {
+        center,
+        radius: Math.hypot(radiusVector.x, radiusVector.y),
+        strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
+        fillColor: primitive.fill ? filledPrimitiveColor : void 0,
+        isFilled: primitive.fill
+      })
+    ];
   }
   const widthVector = applyToPoint4(symbolToSchematicVectorTransform, {
     x: primitive.width,
@@ -1575,13 +2310,15 @@ var convertSymbolPrimitives = ({
     y: primitive.height
   });
   const ccwRotationDegrees = Math.atan2(widthVector.y, widthVector.x) * 180 / Math.PI;
-  return formatElement("schematicrect", {
-    schX: center.x,
-    schY: center.y,
-    width: Math.hypot(widthVector.x, widthVector.y),
-    height: Math.hypot(heightVector.x, heightVector.y),
-    rotation: ccwRotationDegrees
-  });
+  return [
+    formatElement("schematicrect", {
+      schX: center.x,
+      schY: center.y,
+      width: Math.hypot(widthVector.x, widthVector.y),
+      height: Math.hypot(heightVector.x, heightVector.y),
+      rotation: ccwRotationDegrees
+    })
+  ];
 });
 
 // lib/generate-board-schematic-tsx/convert-box-components.ts
@@ -1812,33 +2549,222 @@ var convertBoxComponent = ({
   return primitives;
 };
 
-// lib/generate-board-schematic-tsx/convert-components.ts
-var convertComponents = (circuitJson) => su3(circuitJson).schematic_component.list().flatMap((schematicComponent) => {
-  const symbolName = schematicComponent.symbol_name;
-  if (symbolName && symbolName in symbols) {
-    const symbol = symbols[symbolName];
-    if (!symbol) return [];
-    const sourceComponent = su3(circuitJson).source_component.get(
-      schematicComponent.source_component_id ?? ""
-    );
-    const symbolToSchematicTransform = getSymbolToSchematicTransform({
-      symbol,
-      schematicComponent,
-      schematicPorts: su3(circuitJson).schematic_port.list({
-        schematic_component_id: schematicComponent.schematic_component_id
-      }),
-      sourcePorts: su3(circuitJson).source_port.list()
-    });
-    return convertSymbolPrimitives({
-      symbol,
-      symbolToSchematicTransform,
-      reference: sourceComponent?.display_name ?? sourceComponent?.name ?? "",
-      displayText: schematicComponent.symbol_display_value ?? ""
-    });
+// lib/generate-board-schematic-tsx/convert-native-symbol-pin-numbers.ts
+import { applyToPoint as applyToPoint5 } from "transformation-matrix";
+var PIN_TEXT_FONT_SIZE = 0.15;
+var PIN_TEXT_COLOR = "#a90000";
+var PIN_NUMBER_BASELINE_OFFSET = 0.02;
+var SYMBOL_POINT_TOLERANCE = 1e-6;
+var pointsMatch = (firstPoint, secondPoint) => Math.hypot(firstPoint.x - secondPoint.x, firstPoint.y - secondPoint.y) < SYMBOL_POINT_TOLERANCE;
+var getPortLeadInnerPoint = ({
+  symbol,
+  symbolPort
+}) => {
+  for (const primitive of symbol.primitives) {
+    if (primitive.type !== "path" || primitive.points.length < 2) continue;
+    const firstPoint = primitive.points[0];
+    const lastPoint = primitive.points.at(-1);
+    if (pointsMatch(firstPoint, symbolPort)) return primitive.points[1];
+    if (pointsMatch(lastPoint, symbolPort)) return primitive.points.at(-2);
   }
-  return schematicComponent.is_box_with_pins ? convertBoxComponent({ circuitJson, schematicComponent }) : [];
+  return void 0;
+};
+var convertNativeSymbolPinNumbers = ({
+  symbol,
+  symbolToSchematicTransform,
+  portMatches,
+  replacedPinPortIds
+}) => portMatches.flatMap(({ schematicPort, symbolPort }) => {
+  if (schematicPort.pin_number === void 0 || !replacedPinPortIds.has(schematicPort.schematic_port_id)) {
+    return [];
+  }
+  const leadInnerPoint = getPortLeadInnerPoint({ symbol, symbolPort });
+  if (!leadInnerPoint) return [];
+  const portCenter = applyToPoint5(symbolToSchematicTransform, symbolPort);
+  const leadInnerCenter = applyToPoint5(
+    symbolToSchematicTransform,
+    leadInnerPoint
+  );
+  const pinNumberPosition = {
+    x: (portCenter.x + leadInnerCenter.x) / 2,
+    y: (portCenter.y + leadInnerCenter.y) / 2
+  };
+  const isVerticalLead = Math.abs(leadInnerCenter.y - portCenter.y) > Math.abs(leadInnerCenter.x - portCenter.x);
+  if (isVerticalLead) pinNumberPosition.x -= PIN_NUMBER_BASELINE_OFFSET;
+  else pinNumberPosition.y += PIN_NUMBER_BASELINE_OFFSET;
+  return [
+    formatElement("schematictext", {
+      text: String(schematicPort.pin_number),
+      schX: pinNumberPosition.x,
+      schY: pinNumberPosition.y,
+      anchor: "bottom_center",
+      fontSize: PIN_TEXT_FONT_SIZE,
+      color: PIN_TEXT_COLOR,
+      schRotation: isVerticalLead ? -90 : void 0
+    })
+  ];
 });
 
+// lib/generate-board-schematic-tsx/get-native-symbol-port-matching-inputs.ts
+var getNumericPortHint = (sourcePort) => {
+  const numericPortHint = sourcePort.port_hints?.find(
+    (portHint) => /^(?:pin)?\d+$/.test(portHint)
+  );
+  return numericPortHint?.replace(/^pin/, "");
+};
+var getNumericPortName = (sourcePort) => /^\d+$/.test(sourcePort.name) ? sourcePort.name : void 0;
+var getSourcePinNumber = ({
+  sourcePort,
+  schematicPorts
+}) => {
+  const linkedSchematicPort = schematicPorts.find(
+    (schematicPort) => schematicPort.source_port_id === sourcePort.source_port_id
+  );
+  const sourcePinNumber = sourcePort.pin_number ?? linkedSchematicPort?.pin_number ?? getNumericPortHint(sourcePort) ?? getNumericPortName(sourcePort);
+  return sourcePinNumber === void 0 ? void 0 : String(sourcePinNumber);
+};
+var getFourWindingTransformerAlias = (sourcePinNumber) => {
+  switch (sourcePinNumber) {
+    case "1":
+      return "primary_end";
+    case "2":
+      return "primary_start";
+    case "5":
+      return "auxiliary_end";
+    case "3":
+      return "auxiliary_start";
+    case "9":
+      return "secondary1_end";
+    case "10":
+      return "secondary1_start";
+    case "6":
+      return "secondary2_end";
+    case "7":
+      return "secondary2_start";
+    default:
+      return void 0;
+  }
+};
+var getDualSeriesSchottkyAlias = (sourcePinNumber) => {
+  switch (sourcePinNumber) {
+    case "1":
+      return "anode";
+    case "2":
+      return "cathode";
+    case "3":
+      return "common";
+    default:
+      return void 0;
+  }
+};
+var getInferredPortAlias = ({
+  symbolName,
+  sourcePinNumber
+}) => {
+  if (symbolName === "transformer_4_winding_right") {
+    return getFourWindingTransformerAlias(sourcePinNumber);
+  }
+  if (symbolName === "dual_series_schottky_diode_right") {
+    return getDualSeriesSchottkyAlias(sourcePinNumber);
+  }
+  return void 0;
+};
+var getNativeSymbolPortMatchingInputs = ({
+  symbolName,
+  sourcePorts,
+  schematicPorts,
+  isInferredSymbol
+}) => {
+  const usesInferredPortAliases = symbolName === "transformer_4_winding_right" || symbolName === "dual_series_schottky_diode_right";
+  if (!isInferredSymbol || !usesInferredPortAliases) {
+    return { sourcePorts, includeSchematicPinNumbers: true };
+  }
+  const aliasedSourcePorts = sourcePorts.map((sourcePort) => {
+    const sourcePinNumber = getSourcePinNumber({ sourcePort, schematicPorts });
+    if (!sourcePinNumber) return sourcePort;
+    const inferredPortAlias = getInferredPortAlias({
+      symbolName,
+      sourcePinNumber
+    });
+    if (!inferredPortAlias) return sourcePort;
+    return {
+      ...sourcePort,
+      name: inferredPortAlias,
+      port_hints: [inferredPortAlias],
+      pin_number: void 0
+    };
+  });
+  return {
+    sourcePorts: aliasedSourcePorts,
+    includeSchematicPinNumbers: false
+  };
+};
+
+// lib/generate-board-schematic-tsx/convert-components.ts
+var convertComponents = (circuitJson) => {
+  const textReplacements = getNativeSymbolTextReplacements(circuitJson);
+  return su3(circuitJson).schematic_component.list().flatMap((schematicComponent) => {
+    const symbolName = resolveNativeSchematicSymbolName({
+      circuitJson,
+      schematicComponent
+    });
+    if (symbolName && symbolName in symbols2) {
+      const symbol = symbols2[symbolName];
+      if (!symbol) return [];
+      const isInferredSymbol = !schematicComponent.symbol_name;
+      const sourceComponent = su3(circuitJson).source_component.get(
+        schematicComponent.source_component_id ?? ""
+      );
+      const schematicPorts = su3(circuitJson).schematic_port.list({
+        schematic_component_id: schematicComponent.schematic_component_id
+      });
+      const sourcePorts = su3(circuitJson).source_port.list({
+        source_component_id: schematicComponent.source_component_id
+      });
+      const portMatchingInputs = getNativeSymbolPortMatchingInputs({
+        symbolName,
+        sourcePorts,
+        schematicPorts,
+        isInferredSymbol
+      });
+      const symbolToSchematicTransform = getSymbolToSchematicTransform({
+        symbol,
+        schematicComponent,
+        schematicPorts,
+        ...portMatchingInputs
+      });
+      const textReplacement = textReplacements.find(
+        (replacement) => replacement.schematicComponentId === schematicComponent.schematic_component_id
+      );
+      const portMatches = matchSymbolPortsByPinIdentity({
+        schematicPorts,
+        symbol,
+        ...portMatchingInputs
+      });
+      return [
+        ...convertSymbolPrimitives({
+          symbol,
+          symbolToSchematicTransform,
+          reference: sourceComponent?.display_name ?? sourceComponent?.name ?? "",
+          displayText: isInferredSymbol ? sourceComponent?.display_value ?? schematicComponent.symbol_display_value ?? "" : schematicComponent.symbol_display_value ?? "",
+          includeReference: !isInferredSymbol || textReplacement?.replacesReference,
+          includeDisplayText: !isInferredSymbol || textReplacement?.includeNativeDisplayText,
+          referenceFontSize: textReplacement?.referenceFontSize,
+          displayTextFontSize: textReplacement?.displayTextFontSize,
+          filledPrimitiveColor: isInferredSymbol ? COMPONENT_OUTLINE_COLOR : void 0
+        }),
+        ...isInferredSymbol && textReplacement ? convertNativeSymbolPinNumbers({
+          symbol,
+          symbolToSchematicTransform,
+          portMatches,
+          replacedPinPortIds: textReplacement.replacedPinPortIds
+        }) : []
+      ];
+    }
+    return schematicComponent.is_box_with_pins ? convertBoxComponent({ circuitJson, schematicComponent }) : [];
+  });
+};
+
 // lib/generate-board-schematic-tsx/convert-schematic-graphics.ts
 var convertSchematicGraphics = (circuitJson) => circuitJson.flatMap((element) => {
   if (element.type !== "schematic_graphic") return [];
@@ -1855,7 +2781,7 @@ var convertSchematicGraphics = (circuitJson) => circuitJson.flatMap((element) =>
 // lib/generate-board-schematic-tsx/convert-net-labels.ts
 import { su as su4 } from "@tscircuit/soup-util";
 import { schematic_text as schematic_text3 } from "circuit-json";
-import { symbols as symbols2 } from "schematic-symbols";
+import { symbols as symbols3 } from "schematic-symbols";
 
 // lib/generate-board-schematic-tsx/get-net-label-symbol-to-schematic-transform.ts
 import {
@@ -1884,8 +2810,8 @@ function canRenderNativeNetLabel(name) {
 var convertNetLabels = (circuitJson) => su4(circuitJson).schematic_net_label.list().flatMap((schematicNetLabel) => {
   const anchorPosition = schematicNetLabel.anchor_position ?? schematicNetLabel.center;
   const symbolName = schematicNetLabel.symbol_name;
-  if (symbolName && symbolName in symbols2) {
-    const symbol = symbols2[symbolName];
+  if (symbolName && symbolName in symbols3) {
+    const symbol = symbols3[symbolName];
     if (symbol)
       return convertSymbolPrimitives({
         symbol,
@@ -3094,7 +4020,7 @@ var generateFootprintTsx = (circuitJson, context) => {
 
 // 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";
+import { applyToPoint as applyToPoint6, inverse, translate as translate5 } from "transformation-matrix";
 var physicalPcbElementTypes = /* @__PURE__ */ new Set([
   "pcb_copper_text",
   "pcb_cutout",
@@ -3120,7 +4046,7 @@ var getPcbComponentRenderPlacement = ({
   pcbBoard,
   pcbComponent
 }) => {
-  const componentPosition = applyToPoint5(
+  const componentPosition = applyToPoint6(
     inverse(translate5(pcbBoard.center.x, pcbBoard.center.y)),
     pcbComponent.center
   );
@@ -3235,7 +4161,7 @@ var getSchematicComponentsForPcbComponent = ({
 // lib/board-converter/localize-pcb-component-elements.ts
 import { transformPCBElements } from "@tscircuit/circuit-json-util";
 import {
-  applyToPoint as applyToPoint6,
+  applyToPoint as applyToPoint7,
   compose as compose4,
   decomposeTSR,
   flipY,
@@ -3277,13 +4203,13 @@ var transformSilkscreenGraphic = ({
 }) => {
   if (graphic.shape !== "brep") return;
   graphic.brep_shape.outer_ring.vertices = graphic.brep_shape.outer_ring.vertices.map(
-    (vertex) => applyToPoint6(absoluteToComponentLocalTransform, vertex)
+    (vertex) => applyToPoint7(absoluteToComponentLocalTransform, vertex)
   );
   graphic.brep_shape.inner_rings = graphic.brep_shape.inner_rings.map(
     (ring) => ({
       ...ring,
       vertices: ring.vertices.map(
-        (vertex) => applyToPoint6(absoluteToComponentLocalTransform, vertex)
+        (vertex) => applyToPoint7(absoluteToComponentLocalTransform, vertex)
       )
     })
   );
@@ -3513,6 +4439,10 @@ var convertPcbComponents = ({
       cadModelGroup: localizedCadModelGroup,
       pcbBoard
     }) : void 0;
+    const childModelElementsTsx = localizedCadModelGroup ? generateCadModelGroupChildrenTsx({
+      cadModelGroup: localizedCadModelGroup,
+      pcbBoard
+    }) : [];
     const componentProps = [
       `name=${formatJsxStringAttribute(componentName)}`,
       `pcbX={${componentPosition.x}}`,
@@ -3524,6 +4454,9 @@ var convertPcbComponents = ({
     if (cadModelTsx) {
       componentProps.push(`cadModel={${cadModelTsx}}`);
     }
+    if (localizedCadModelGroup && isJscadCadModelGroupTranslucent(localizedCadModelGroup)) {
+      componentProps.push("showAsTranslucentModel");
+    }
     if (pinLabels) {
       componentProps.push(`pinLabels={${JSON.stringify(pinLabels)}}`);
     }
@@ -3543,8 +4476,9 @@ var convertPcbComponents = ({
     if (pcbComponent.obstructs_within_bounds === false) {
       componentProps.push("obstructsWithinBounds={false}");
     }
+    const chipOpeningTsx = `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}}`;
     boardChildren.push(
-      `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}} />`
+      childModelElementsTsx.length === 0 ? `${chipOpeningTsx} />` : `${chipOpeningTsx}>${childModelElementsTsx.join("\n")}</chip>`
     );
   }
 };