@tscircuit/props 0.0.291 → 0.0.293

package/dist/index.js

@@ -592,6 +592,10 @@ var chipProps = commonComponentProps.extend({
 var bugProps = chipProps;
 expectTypesMatch(true);
 
+// lib/components/pinout.ts
+var pinoutProps = chipProps;
+expectTypesMatch(true);
+
 // lib/components/jumper.ts
 import { distance as distance8 } from "circuit-json";
 
@@ -1065,10 +1069,17 @@ var footprintProps = z48.object({
 });
 expectTypesMatch(true);
 
+// lib/components/symbol.ts
+import { z as z49 } from "zod";
+var symbolProps = z49.object({
+  originalFacingDirection: z49.enum(["up", "down", "left", "right"]).default("right").optional()
+});
+expectTypesMatch(true);
+
 // lib/components/battery.ts
 import { voltage as voltage2 } from "circuit-json";
-import { z as z49 } from "zod";
-var capacity = z49.number().or(z49.string().endsWith("mAh")).transform((v) => {
+import { z as z50 } from "zod";
+var capacity = z50.number().or(z50.string().endsWith("mAh")).transform((v) => {
   if (typeof v === "string") {
     const valString = v.replace("mAh", "");
     const num = Number.parseFloat(valString);
@@ -1082,7 +1093,7 @@ var capacity = z49.number().or(z49.string().endsWith("mAh")).transform((v) => {
 var batteryProps = commonComponentProps.extend({
   capacity: capacity.optional(),
   voltage: voltage2.optional(),
-  standard: z49.enum(["AA", "AAA", "9V", "CR2032", "18650", "C"]).optional(),
+  standard: z50.enum(["AA", "AAA", "9V", "CR2032", "18650", "C"]).optional(),
   schOrientation: schematicOrientation.optional()
 });
 var batteryPins = lrPolarPins;
@@ -1090,21 +1101,21 @@ expectTypesMatch(true);
 
 // lib/components/pin-header.ts
 import { distance as distance14 } from "circuit-json";
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var pinHeaderProps = commonComponentProps.extend({
-  pinCount: z50.number(),
+  pinCount: z51.number(),
   pitch: distance14.optional(),
-  schFacingDirection: z50.enum(["up", "down", "left", "right"]).optional(),
-  gender: z50.enum(["male", "female", "unpopulated"]).optional().default("male"),
-  showSilkscreenPinLabels: z50.boolean().optional(),
-  pcbPinLabels: z50.record(z50.string(), z50.string()).optional(),
-  doubleRow: z50.boolean().optional(),
-  rightAngle: z50.boolean().optional(),
+  schFacingDirection: z51.enum(["up", "down", "left", "right"]).optional(),
+  gender: z51.enum(["male", "female", "unpopulated"]).optional().default("male"),
+  showSilkscreenPinLabels: z51.boolean().optional(),
+  pcbPinLabels: z51.record(z51.string(), z51.string()).optional(),
+  doubleRow: z51.boolean().optional(),
+  rightAngle: z51.boolean().optional(),
   holeDiameter: distance14.optional(),
   platedDiameter: distance14.optional(),
-  pinLabels: z50.record(z50.string(), schematicPinLabel).or(z50.array(schematicPinLabel)).optional(),
-  connections: z50.custom().pipe(z50.record(z50.string(), connectionTarget2)).optional(),
-  facingDirection: z50.enum(["left", "right"]).optional(),
+  pinLabels: z51.record(z51.string(), schematicPinLabel).or(z51.array(schematicPinLabel)).optional(),
+  connections: z51.custom().pipe(z51.record(z51.string(), connectionTarget2)).optional(),
+  facingDirection: z51.enum(["left", "right"]).optional(),
   schPinArrangement: schematicPinArrangement.optional(),
   schPinStyle: schematicPinStyle.optional(),
   schPinSpacing: distance14.optional(),
@@ -1114,29 +1125,29 @@ var pinHeaderProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/netalias.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 import { rotation as rotation2 } from "circuit-json";
-var netAliasProps = z51.object({
-  net: z51.string().optional(),
-  connection: z51.string().optional(),
+var netAliasProps = z52.object({
+  net: z52.string().optional(),
+  connection: z52.string().optional(),
   schX: distance12.optional(),
   schY: distance12.optional(),
   schRotation: rotation2.optional(),
-  anchorSide: z51.enum(["left", "top", "right", "bottom"]).optional()
+  anchorSide: z52.enum(["left", "top", "right", "bottom"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/netlabel.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 import { rotation as rotation3 } from "circuit-json";
-var netLabelProps = z52.object({
-  net: z52.string().optional(),
-  connection: z52.string().optional(),
-  connectsTo: z52.string().or(z52.array(z52.string())).optional(),
+var netLabelProps = z53.object({
+  net: z53.string().optional(),
+  connection: z53.string().optional(),
+  connectsTo: z53.string().or(z53.array(z53.string())).optional(),
   schX: distance12.optional(),
   schY: distance12.optional(),
   schRotation: rotation3.optional(),
-  anchorSide: z52.enum(["left", "top", "right", "bottom"]).optional()
+  anchorSide: z53.enum(["left", "top", "right", "bottom"]).optional()
 });
 expectTypesMatch(true);
 
@@ -1150,7 +1161,7 @@ var subcircuitProps = subcircuitGroupProps;
 expectTypesMatch(true);
 
 // lib/components/transistor.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 var transistorPinsLabels = [
   "pin1",
   "pin2",
@@ -1163,7 +1174,7 @@ var transistorPinsLabels = [
   "drain"
 ];
 var transistorProps = commonComponentProps.extend({
-  type: z54.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"]),
+  type: z55.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"]),
   connections: createConnectionsProp(transistorPinsLabels).optional()
 });
 var transistorPins = [
@@ -1177,10 +1188,10 @@ var transistorPins = [
 expectTypesMatch(true);
 
 // lib/components/mosfet.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 var mosfetProps = commonComponentProps.extend({
-  channelType: z55.enum(["n", "p"]),
-  mosfetMode: z55.enum(["enhancement", "depletion"])
+  channelType: z56.enum(["n", "p"]),
+  mosfetMode: z56.enum(["enhancement", "depletion"])
 });
 var mosfetPins = [
   "pin1",
@@ -1194,18 +1205,18 @@ expectTypesMatch(true);
 
 // lib/components/inductor.ts
 import { inductance } from "circuit-json";
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var inductorProps = commonComponentProps.extend({
   inductance,
-  maxCurrentRating: z56.union([z56.string(), z56.number()]).optional(),
+  maxCurrentRating: z57.union([z57.string(), z57.number()]).optional(),
   schOrientation: schematicOrientation.optional()
 });
 var inductorPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/diode.ts
-import { z as z57 } from "zod";
-var diodeConnectionKeys = z57.enum([
+import { z as z58 } from "zod";
+var diodeConnectionKeys = z58.enum([
   "anode",
   "cathode",
   "pin1",
@@ -1213,9 +1224,9 @@ var diodeConnectionKeys = z57.enum([
   "pos",
   "neg"
 ]);
-var connectionTarget3 = z57.string().or(z57.array(z57.string()).readonly()).or(z57.array(z57.string()));
-var connectionsProp2 = z57.record(diodeConnectionKeys, connectionTarget3);
-var diodeVariant = z57.enum([
+var connectionTarget3 = z58.string().or(z58.array(z58.string()).readonly()).or(z58.array(z58.string()));
+var connectionsProp2 = z58.record(diodeConnectionKeys, connectionTarget3);
+var diodeVariant = z58.enum([
   "standard",
   "schottky",
   "zener",
@@ -1226,12 +1237,12 @@ var diodeVariant = z57.enum([
 var diodeProps = commonComponentProps.extend({
   connections: connectionsProp2.optional(),
   variant: diodeVariant.optional().default("standard"),
-  standard: z57.boolean().optional(),
-  schottky: z57.boolean().optional(),
-  zener: z57.boolean().optional(),
-  avalanche: z57.boolean().optional(),
-  photo: z57.boolean().optional(),
-  tvs: z57.boolean().optional(),
+  standard: z58.boolean().optional(),
+  schottky: z58.boolean().optional(),
+  zener: z58.boolean().optional(),
+  avalanche: z58.boolean().optional(),
+  photo: z58.boolean().optional(),
+  tvs: z58.boolean().optional(),
   schOrientation: schematicOrientation.optional()
 }).superRefine((data, ctx) => {
   const enabledFlags = [
@@ -1244,11 +1255,11 @@ var diodeProps = commonComponentProps.extend({
   ].filter(Boolean).length;
   if (enabledFlags > 1) {
     ctx.addIssue({
-      code: z57.ZodIssueCode.custom,
+      code: z58.ZodIssueCode.custom,
       message: "Exactly one diode variant must be enabled",
       path: []
     });
-    return z57.INVALID;
+    return z58.INVALID;
   }
 }).transform((data) => {
   const result = {
@@ -1295,26 +1306,26 @@ var diodePins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/led.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var ledProps = commonComponentProps.extend({
-  color: z58.string().optional(),
-  wavelength: z58.string().optional(),
-  schDisplayValue: z58.string().optional(),
+  color: z59.string().optional(),
+  wavelength: z59.string().optional(),
+  schDisplayValue: z59.string().optional(),
   schOrientation: schematicOrientation.optional(),
   connections: createConnectionsProp(lrPolarPins).optional(),
-  laser: z58.boolean().optional()
+  laser: z59.boolean().optional()
 });
 var ledPins = lrPolarPins;
 
 // lib/components/switch.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 var switchProps = commonComponentProps.extend({
-  type: z59.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
-  isNormallyClosed: z59.boolean().optional().default(false),
-  spst: z59.boolean().optional(),
-  spdt: z59.boolean().optional(),
-  dpst: z59.boolean().optional(),
-  dpdt: z59.boolean().optional()
+  type: z60.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
+  isNormallyClosed: z60.boolean().optional().default(false),
+  spst: z60.boolean().optional(),
+  spdt: z60.boolean().optional(),
+  dpst: z60.boolean().optional(),
+  dpdt: z60.boolean().optional()
 }).transform((props) => {
   const updatedProps = { ...props };
   if (updatedProps.dpdt) {
@@ -1346,52 +1357,52 @@ expectTypesMatch(true);
 
 // lib/components/fabrication-note-text.ts
 import { length as length3 } from "circuit-json";
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: z60.string(),
-  anchorAlignment: z60.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z60.enum(["tscircuit2024"]).optional(),
+  text: z61.string(),
+  anchorAlignment: z61.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z61.enum(["tscircuit2024"]).optional(),
   fontSize: length3.optional(),
-  color: z60.string().optional()
+  color: z61.string().optional()
 });
 
 // lib/components/fabrication-note-path.ts
 import { length as length4, route_hint_point as route_hint_point3 } from "circuit-json";
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z61.array(route_hint_point3),
+  route: z62.array(route_hint_point3),
   strokeWidth: length4.optional(),
-  color: z61.string().optional()
+  color: z62.string().optional()
 });
 
 // lib/components/pcb-trace.ts
 import { distance as distance15, route_hint_point as route_hint_point4 } from "circuit-json";
-import { z as z62 } from "zod";
-var pcbTraceProps = z62.object({
-  layer: z62.string().optional(),
+import { z as z63 } from "zod";
+var pcbTraceProps = z63.object({
+  layer: z63.string().optional(),
   thickness: distance15.optional(),
-  route: z62.array(route_hint_point4)
+  route: z63.array(route_hint_point4)
 });
 
 // lib/components/via.ts
 import { distance as distance16, layer_ref as layer_ref5 } from "circuit-json";
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var viaProps = commonLayoutProps.extend({
-  name: z63.string().optional(),
+  name: z64.string().optional(),
   fromLayer: layer_ref5,
   toLayer: layer_ref5,
   holeDiameter: distance16,
   outerDiameter: distance16,
-  connectsTo: z63.string().or(z63.array(z63.string())).optional()
+  connectsTo: z64.string().or(z64.array(z64.string())).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/testpoint.ts
 import { distance as distance17 } from "circuit-json";
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var testpointProps = commonComponentProps.extend({
-  footprintVariant: z64.enum(["pad", "through_hole"]).optional(),
-  padShape: z64.enum(["rect", "circle"]).optional().default("circle"),
+  footprintVariant: z65.enum(["pad", "through_hole"]).optional(),
+  padShape: z65.enum(["rect", "circle"]).optional().default("circle"),
   padDiameter: distance17.optional(),
   holeDiameter: distance17.optional(),
   width: distance17.optional(),
@@ -1403,22 +1414,22 @@ var testpointProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/breakoutpoint.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 var breakoutPointProps = pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-  connection: z65.string()
+  connection: z66.string()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-keepout.ts
 import { distance as distance18 } from "circuit-json";
-import { z as z66 } from "zod";
-var pcbKeepoutProps = z66.union([
+import { z as z67 } from "zod";
+var pcbKeepoutProps = z67.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: z66.literal("circle"),
+    shape: z67.literal("circle"),
     radius: distance18
   }),
   pcbLayoutProps.extend({
-    shape: z66.literal("rect"),
+    shape: z67.literal("rect"),
     width: distance18,
     height: distance18
   })
@@ -1432,8 +1443,8 @@ var powerSourceProps = commonComponentProps.extend({
 
 // lib/components/voltagesource.ts
 import { frequency as frequency3, rotation as rotation4, voltage as voltage4 } from "circuit-json";
-import { z as z67 } from "zod";
-var percentage = z67.union([z67.string(), z67.number()]).transform((val) => {
+import { z as z68 } from "zod";
+var percentage = z68.union([z68.string(), z68.number()]).transform((val) => {
   if (typeof val === "string") {
     if (val.endsWith("%")) {
       return parseFloat(val.slice(0, -1)) / 100;
@@ -1442,13 +1453,13 @@ var percentage = z67.union([z67.string(), z67.number()]).transform((val) => {
   }
   return val;
 }).pipe(
-  z67.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
+  z68.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
 );
 var voltageSourceProps = commonComponentProps.extend({
   voltage: voltage4.optional(),
   frequency: frequency3.optional(),
   peakToPeakVoltage: voltage4.optional(),
-  waveShape: z67.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
+  waveShape: z68.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
   phase: rotation4.optional(),
   dutyCycle: percentage.optional()
 });
@@ -1456,11 +1467,11 @@ expectTypesMatch(true);
 
 // lib/components/schematic-box.ts
 import { distance as distance19 } from "circuit-json";
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 
 // lib/common/ninePointAnchor.ts
-import { z as z68 } from "zod";
-var ninePointAnchor = z68.enum([
+import { z as z69 } from "zod";
+var ninePointAnchor = z69.enum([
   "top_left",
   "top_center",
   "top_right",
@@ -1473,23 +1484,23 @@ var ninePointAnchor = z68.enum([
 ]);
 
 // lib/components/schematic-box.ts
-var schematicBoxProps = z69.object({
+var schematicBoxProps = z70.object({
   schX: distance19.optional(),
   schY: distance19.optional(),
   width: distance19.optional(),
   height: distance19.optional(),
-  overlay: z69.array(z69.string()).optional(),
+  overlay: z70.array(z70.string()).optional(),
   padding: distance19.optional(),
   paddingLeft: distance19.optional(),
   paddingRight: distance19.optional(),
   paddingTop: distance19.optional(),
   paddingBottom: distance19.optional(),
-  title: z69.string().optional(),
+  title: z70.string().optional(),
   titleAlignment: ninePointAnchor.default("top_left"),
-  titleColor: z69.string().optional(),
+  titleColor: z70.string().optional(),
   titleFontSize: distance19.optional(),
-  titleInside: z69.boolean().default(false),
-  strokeStyle: z69.enum(["solid", "dashed"]).default("solid")
+  titleInside: z70.boolean().default(false),
+  strokeStyle: z70.enum(["solid", "dashed"]).default("solid")
 }).refine(
   (elm) => elm.width !== void 0 && elm.height !== void 0 || Array.isArray(elm.overlay) && elm.overlay.length > 0,
   {
@@ -1504,8 +1515,8 @@ var schematicBoxProps = z69.object({
 
 // lib/components/schematic-line.ts
 import { distance as distance20 } from "circuit-json";
-import { z as z70 } from "zod";
-var schematicLineProps = z70.object({
+import { z as z71 } from "zod";
+var schematicLineProps = z71.object({
   x1: distance20,
   y1: distance20,
   x2: distance20,
@@ -1514,11 +1525,11 @@ var schematicLineProps = z70.object({
 
 // lib/components/schematic-text.ts
 import { distance as distance21, rotation as rotation5 } from "circuit-json";
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 
 // lib/common/fivePointAnchor.ts
-import { z as z71 } from "zod";
-var fivePointAnchor = z71.enum([
+import { z as z72 } from "zod";
+var fivePointAnchor = z72.enum([
   "center",
   "left",
   "right",
@@ -1527,32 +1538,32 @@ var fivePointAnchor = z71.enum([
 ]);
 
 // lib/components/schematic-text.ts
-var schematicTextProps = z72.object({
+var schematicTextProps = z73.object({
   schX: distance21.optional(),
   schY: distance21.optional(),
-  text: z72.string(),
-  fontSize: z72.number().default(1),
-  anchor: z72.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
-  color: z72.string().default("#000000"),
+  text: z73.string(),
+  fontSize: z73.number().default(1),
+  anchor: z73.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
+  color: z73.string().default("#000000"),
   schRotation: rotation5.default(0)
 });
 
 // lib/components/schematic-path.ts
 import { point as point5 } from "circuit-json";
-import { z as z73 } from "zod";
-var schematicPathProps = z73.object({
-  points: z73.array(point5),
-  isFilled: z73.boolean().optional().default(false),
-  fillColor: z73.enum(["red", "blue"]).optional()
+import { z as z74 } from "zod";
+var schematicPathProps = z74.object({
+  points: z74.array(point5),
+  isFilled: z74.boolean().optional().default(false),
+  fillColor: z74.enum(["red", "blue"]).optional()
 });
 
 // lib/components/schematic-table.ts
 import { distance as distance22 } from "circuit-json";
-import { z as z74 } from "zod";
-var schematicTableProps = z74.object({
+import { z as z75 } from "zod";
+var schematicTableProps = z75.object({
   schX: distance22.optional(),
   schY: distance22.optional(),
-  children: z74.any().optional(),
+  children: z75.any().optional(),
   cellPadding: distance22.optional(),
   borderWidth: distance22.optional(),
   anchor: ninePointAnchor.optional(),
@@ -1562,44 +1573,44 @@ expectTypesMatch(true);
 
 // lib/components/schematic-row.ts
 import { distance as distance23 } from "circuit-json";
-import { z as z75 } from "zod";
-var schematicRowProps = z75.object({
-  children: z75.any().optional(),
+import { z as z76 } from "zod";
+var schematicRowProps = z76.object({
+  children: z76.any().optional(),
   height: distance23.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-cell.ts
 import { distance as distance24 } from "circuit-json";
-import { z as z76 } from "zod";
-var schematicCellProps = z76.object({
-  children: z76.string().optional(),
-  horizontalAlign: z76.enum(["left", "center", "right"]).optional(),
-  verticalAlign: z76.enum(["top", "middle", "bottom"]).optional(),
+import { z as z77 } from "zod";
+var schematicCellProps = z77.object({
+  children: z77.string().optional(),
+  horizontalAlign: z77.enum(["left", "center", "right"]).optional(),
+  verticalAlign: z77.enum(["top", "middle", "bottom"]).optional(),
   fontSize: distance24.optional(),
-  rowSpan: z76.number().optional(),
-  colSpan: z76.number().optional(),
+  rowSpan: z77.number().optional(),
+  colSpan: z77.number().optional(),
   width: distance24.optional(),
-  text: z76.string().optional()
+  text: z77.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/silkscreen-text.ts
 import { layer_ref as layer_ref6, length as length5 } from "circuit-json";
-import { z as z77 } from "zod";
+import { z as z78 } from "zod";
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: z77.string(),
+  text: z78.string(),
   anchorAlignment: ninePointAnchor.default("center"),
-  font: z77.enum(["tscircuit2024"]).optional(),
+  font: z78.enum(["tscircuit2024"]).optional(),
   fontSize: length5.optional(),
-  layers: z77.array(layer_ref6).optional()
+  layers: z78.array(layer_ref6).optional()
 });
 
 // lib/components/silkscreen-path.ts
 import { length as length6, route_hint_point as route_hint_point5 } from "circuit-json";
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z78.array(route_hint_point5),
+  route: z79.array(route_hint_point5),
   strokeWidth: length6.optional()
 });
 
@@ -1615,10 +1626,10 @@ var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotat
 
 // lib/components/silkscreen-rect.ts
 import { distance as distance26 } from "circuit-json";
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  filled: z79.boolean().default(true).optional(),
-  stroke: z79.enum(["dashed", "solid", "none"]).optional(),
+  filled: z80.boolean().default(true).optional(),
+  stroke: z80.enum(["dashed", "solid", "none"]).optional(),
   strokeWidth: distance26.optional(),
   width: distance26,
   height: distance26
@@ -1626,64 +1637,64 @@ var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 
 // lib/components/silkscreen-circle.ts
 import { distance as distance27 } from "circuit-json";
-import { z as z80 } from "zod";
+import { z as z81 } from "zod";
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z80.boolean().optional(),
-  isOutline: z80.boolean().optional(),
+  isFilled: z81.boolean().optional(),
+  isOutline: z81.boolean().optional(),
   strokeWidth: distance27.optional(),
   radius: distance27
 });
 
 // lib/components/trace-hint.ts
 import { distance as distance28, layer_ref as layer_ref7, route_hint_point as route_hint_point6 } from "circuit-json";
-import { z as z81 } from "zod";
-var routeHintPointProps = z81.object({
+import { z as z82 } from "zod";
+var routeHintPointProps = z82.object({
   x: distance28,
   y: distance28,
-  via: z81.boolean().optional(),
+  via: z82.boolean().optional(),
   toLayer: layer_ref7.optional()
 });
-var traceHintProps = z81.object({
-  for: z81.string().optional().describe(
+var traceHintProps = z82.object({
+  for: z82.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: z81.number().optional(),
+  order: z82.number().optional(),
   offset: route_hint_point6.or(routeHintPointProps).optional(),
-  offsets: z81.array(route_hint_point6).or(z81.array(routeHintPointProps)).optional(),
-  traceWidth: z81.number().optional()
+  offsets: z82.array(route_hint_point6).or(z82.array(routeHintPointProps)).optional(),
+  traceWidth: z82.number().optional()
 });
 
 // lib/components/port.ts
-import { z as z82 } from "zod";
+import { z as z83 } from "zod";
 var portProps = commonLayoutProps.extend({
-  name: z82.string(),
-  pinNumber: z82.number().optional(),
-  aliases: z82.array(z82.string()).optional(),
+  name: z83.string(),
+  pinNumber: z83.number().optional(),
+  aliases: z83.array(z83.string()).optional(),
   direction
 });
 
 // lib/platformConfig.ts
-import { z as z83 } from "zod";
-var unvalidatedCircuitJson = z83.array(z83.any()).describe("Circuit JSON");
-var pathToCircuitJsonFn = z83.function().args(z83.string()).returns(z83.promise(z83.object({ footprintCircuitJson: z83.array(z83.any()) }))).describe("A function that takes a path and returns Circuit JSON");
-var platformConfig = z83.object({
+import { z as z84 } from "zod";
+var unvalidatedCircuitJson = z84.array(z84.any()).describe("Circuit JSON");
+var pathToCircuitJsonFn = z84.function().args(z84.string()).returns(z84.promise(z84.object({ footprintCircuitJson: z84.array(z84.any()) }))).describe("A function that takes a path and returns Circuit JSON");
+var platformConfig = z84.object({
   partsEngine: partsEngine.optional(),
   autorouter: autorouterProp.optional(),
-  registryApiUrl: z83.string().optional(),
-  cloudAutorouterUrl: z83.string().optional(),
-  projectName: z83.string().optional(),
-  version: z83.string().optional(),
-  url: z83.string().optional(),
-  printBoardInformationToSilkscreen: z83.boolean().optional(),
-  localCacheEngine: z83.any().optional(),
-  pcbDisabled: z83.boolean().optional(),
-  schematicDisabled: z83.boolean().optional(),
-  partsEngineDisabled: z83.boolean().optional(),
-  footprintLibraryMap: z83.record(
-    z83.string(),
-    z83.record(
-      z83.string(),
-      z83.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
+  registryApiUrl: z84.string().optional(),
+  cloudAutorouterUrl: z84.string().optional(),
+  projectName: z84.string().optional(),
+  version: z84.string().optional(),
+  url: z84.string().optional(),
+  printBoardInformationToSilkscreen: z84.boolean().optional(),
+  localCacheEngine: z84.any().optional(),
+  pcbDisabled: z84.boolean().optional(),
+  schematicDisabled: z84.boolean().optional(),
+  partsEngineDisabled: z84.boolean().optional(),
+  footprintLibraryMap: z84.record(
+    z84.string(),
+    z84.record(
+      z84.string(),
+      z84.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
     )
   ).optional()
 });
@@ -1773,6 +1784,7 @@ export {
   pinCompatibleVariant,
   pinHeaderProps,
   pinLabelsProp,
+  pinoutProps,
   platedHoleProps,
   platformConfig,
   point3,
@@ -1820,6 +1832,7 @@ export {
   subcircuitProps,
   supplierProps,
   switchProps,
+  symbolProps,
   testpointProps,
   traceHintProps,
   traceProps,