circuit-json-to-tscircuit 0.0.93 → 0.0.95

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

@@ -1126,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, '\\"');
@@ -1394,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
@@ -1518,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":
@@ -1623,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";
@@ -1801,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}`]
     ];
@@ -1828,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;
@@ -1869,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",
@@ -1884,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)
@@ -1894,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,
@@ -1918,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,
@@ -1934,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
@@ -2171,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 [];
@@ -2214,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 {
@@ -2243,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,
@@ -3453,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",
@@ -3479,7 +4046,7 @@ var getPcbComponentRenderPlacement = ({
   pcbBoard,
   pcbComponent
 }) => {
-  const componentPosition = applyToPoint5(
+  const componentPosition = applyToPoint6(
     inverse(translate5(pcbBoard.center.x, pcbBoard.center.y)),
     pcbComponent.center
   );
@@ -3508,7 +4075,10 @@ var getPcbComponentRenderPlacement = ({
 
 // lib/board-converter/get-pin-labels.ts
 var getCompoundPinNumber = (sourcePort) => {
-  if (sourcePort.pin_number !== void 0) return sourcePort.pin_number;
+  if (sourcePort.pin_number !== void 0) {
+    const pinNumber = Number(sourcePort.pin_number);
+    return Number.isSafeInteger(pinNumber) && pinNumber >= 0 ? pinNumber : void 0;
+  }
   const firstPinNumber = /^\d+/u.exec(sourcePort.name)?.[0];
   return firstPinNumber ? Number.parseInt(firstPinNumber, 10) : void 0;
 };
@@ -3594,7 +4164,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,
@@ -3636,13 +4206,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)
       )
     })
   );