@tscircuit/props 0.0.237 → 0.0.239

package/dist/index.js

@@ -125,26 +125,46 @@ var lrPolarPins = [
 ];
 var distanceOrMultiplier = distance2.or(z6.enum(["2x", "3x", "4x"]));
 
-// lib/common/schematicPinDefinitions.ts
+// lib/common/schematicOrientation.ts
 import { z as z7 } from "zod";
-var explicitPinSideDefinition = z7.object({
-  pins: z7.array(z7.union([z7.number(), z7.string()])),
-  direction: z7.union([
-    z7.literal("top-to-bottom"),
-    z7.literal("left-to-right"),
-    z7.literal("bottom-to-top"),
-    z7.literal("right-to-left")
+var schematicOrientation = z7.enum([
+  "vertical",
+  "horizontal",
+  "pos_top",
+  "pos_bottom",
+  "pos_left",
+  "pos_right",
+  "neg_top",
+  "neg_bottom",
+  "neg_left",
+  "neg_right"
+]).describe(
+  "horizontal means pins go 1->2 rightward and vertical means pins go 1->2 downward (generally, positive on top)"
+);
+expectTypesMatch(
+  true
+);
+
+// lib/common/schematicPinDefinitions.ts
+import { z as z8 } from "zod";
+var explicitPinSideDefinition = z8.object({
+  pins: z8.array(z8.union([z8.number(), z8.string()])),
+  direction: z8.union([
+    z8.literal("top-to-bottom"),
+    z8.literal("left-to-right"),
+    z8.literal("bottom-to-top"),
+    z8.literal("right-to-left")
   ])
 });
-var schematicPortArrangement = z7.object({
-  leftSize: z7.number().optional().describe("@deprecated, use leftPinCount"),
-  topSize: z7.number().optional().describe("@deprecated, use topPinCount"),
-  rightSize: z7.number().optional().describe("@deprecated, use rightPinCount"),
-  bottomSize: z7.number().optional().describe("@deprecated, use bottomPinCount"),
-  leftPinCount: z7.number().optional(),
-  rightPinCount: z7.number().optional(),
-  topPinCount: z7.number().optional(),
-  bottomPinCount: z7.number().optional(),
+var schematicPortArrangement = z8.object({
+  leftSize: z8.number().optional().describe("@deprecated, use leftPinCount"),
+  topSize: z8.number().optional().describe("@deprecated, use topPinCount"),
+  rightSize: z8.number().optional().describe("@deprecated, use rightPinCount"),
+  bottomSize: z8.number().optional().describe("@deprecated, use bottomPinCount"),
+  leftPinCount: z8.number().optional(),
+  rightPinCount: z8.number().optional(),
+  topPinCount: z8.number().optional(),
+  bottomPinCount: z8.number().optional(),
   leftSide: explicitPinSideDefinition.optional(),
   rightSide: explicitPinSideDefinition.optional(),
   topSide: explicitPinSideDefinition.optional(),
@@ -155,9 +175,9 @@ expectTypesMatch(true);
 
 // lib/common/schematicPinStyle.ts
 import { distance as distance3 } from "circuit-json";
-import { z as z8 } from "zod";
-var schematicPinStyle = z8.record(
-  z8.object({
+import { z as z9 } from "zod";
+var schematicPinStyle = z9.record(
+  z9.object({
     marginLeft: distance3.optional(),
     marginRight: distance3.optional(),
     marginTop: distance3.optional(),
@@ -175,51 +195,51 @@ import { distance as distance5 } from "circuit-json";
 
 // lib/common/point.ts
 import { distance as distance4 } from "circuit-json";
-import { z as z9 } from "zod";
-var point = z9.object({
+import { z as z10 } from "zod";
+var point = z10.object({
   x: distance4,
   y: distance4
 });
 
 // lib/components/board.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // lib/components/group.ts
 import { length } from "circuit-json";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // lib/manual-edits/manual-edit-events/base_manual_edit_event.ts
-import { z as z10 } from "zod";
-var base_manual_edit_event = z10.object({
-  edit_event_id: z10.string(),
-  in_progress: z10.boolean().optional(),
-  created_at: z10.number()
+import { z as z11 } from "zod";
+var base_manual_edit_event = z11.object({
+  edit_event_id: z11.string(),
+  in_progress: z11.boolean().optional(),
+  created_at: z11.number()
 });
 expectTypesMatch(
   true
 );
 
 // lib/manual-edits/manual-edit-events/edit_pcb_component_location_event.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var edit_pcb_component_location_event = base_manual_edit_event.extend({
-  pcb_edit_event_type: z11.literal("edit_component_location").describe("deprecated"),
-  edit_event_type: z11.literal("edit_pcb_component_location"),
-  pcb_component_id: z11.string(),
-  original_center: z11.object({ x: z11.number(), y: z11.number() }),
-  new_center: z11.object({ x: z11.number(), y: z11.number() })
+  pcb_edit_event_type: z12.literal("edit_component_location").describe("deprecated"),
+  edit_event_type: z12.literal("edit_pcb_component_location"),
+  pcb_component_id: z12.string(),
+  original_center: z12.object({ x: z12.number(), y: z12.number() }),
+  new_center: z12.object({ x: z12.number(), y: z12.number() })
 });
 var edit_component_location_event = edit_pcb_component_location_event;
 expectTypesMatch(true);
 
 // lib/manual-edits/manual-edit-events/edit_trace_hint_event.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var edit_trace_hint_event = base_manual_edit_event.extend({
-  pcb_edit_event_type: z12.literal("edit_trace_hint").describe("deprecated"),
-  edit_event_type: z12.literal("edit_pcb_trace_hint").optional(),
-  pcb_port_id: z12.string(),
-  pcb_trace_hint_id: z12.string().optional(),
-  route: z12.array(
-    z12.object({ x: z12.number(), y: z12.number(), via: z12.boolean().optional() })
+  pcb_edit_event_type: z13.literal("edit_trace_hint").describe("deprecated"),
+  edit_event_type: z13.literal("edit_pcb_trace_hint").optional(),
+  pcb_port_id: z13.string(),
+  pcb_trace_hint_id: z13.string().optional(),
+  route: z13.array(
+    z13.object({ x: z13.number(), y: z13.number(), via: z13.boolean().optional() })
   )
 });
 expectTypesMatch(
@@ -227,38 +247,38 @@ expectTypesMatch(
 );
 
 // lib/manual-edits/manual-edit-events/edit_schematic_component_location_event.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var edit_schematic_component_location_event = base_manual_edit_event.extend({
-  edit_event_type: z13.literal("edit_schematic_component_location"),
-  schematic_component_id: z13.string(),
-  original_center: z13.object({ x: z13.number(), y: z13.number() }),
-  new_center: z13.object({ x: z13.number(), y: z13.number() })
+  edit_event_type: z14.literal("edit_schematic_component_location"),
+  schematic_component_id: z14.string(),
+  original_center: z14.object({ x: z14.number(), y: z14.number() }),
+  new_center: z14.object({ x: z14.number(), y: z14.number() })
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual-edit-events/edit_pcb_group_location_event.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var edit_pcb_group_location_event = base_manual_edit_event.extend({
-  edit_event_type: z14.literal("edit_pcb_group_location"),
-  pcb_group_id: z14.string(),
-  original_center: z14.object({ x: z14.number(), y: z14.number() }),
-  new_center: z14.object({ x: z14.number(), y: z14.number() })
+  edit_event_type: z15.literal("edit_pcb_group_location"),
+  pcb_group_id: z15.string(),
+  original_center: z15.object({ x: z15.number(), y: z15.number() }),
+  new_center: z15.object({ x: z15.number(), y: z15.number() })
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual-edit-events/edit_schematic_group_location_event.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var edit_schematic_group_location_event = base_manual_edit_event.extend({
-  edit_event_type: z15.literal("edit_schematic_group_location"),
-  schematic_group_id: z15.string(),
-  original_center: z15.object({ x: z15.number(), y: z15.number() }),
-  new_center: z15.object({ x: z15.number(), y: z15.number() })
+  edit_event_type: z16.literal("edit_schematic_group_location"),
+  schematic_group_id: z16.string(),
+  original_center: z16.object({ x: z16.number(), y: z16.number() }),
+  new_center: z16.object({ x: z16.number(), y: z16.number() })
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_edit_event.ts
-import { z as z16 } from "zod";
-var manual_edit_event = z16.union([
+import { z as z17 } from "zod";
+var manual_edit_event = z17.union([
   edit_pcb_component_location_event,
   edit_trace_hint_event,
   edit_schematic_component_location_event
@@ -266,33 +286,33 @@ var manual_edit_event = z16.union([
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_edits_file.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // lib/manual-edits/manual_pcb_placement.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 import { point as point2 } from "circuit-json";
-var manual_pcb_placement = z17.object({
-  selector: z17.string(),
-  relative_to: z17.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
+var manual_pcb_placement = z18.object({
+  selector: z18.string(),
+  relative_to: z18.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
   center: point2
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_trace_hint.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 import { route_hint_point } from "circuit-json";
-var manual_trace_hint = z18.object({
-  pcb_port_selector: z18.string(),
-  offsets: z18.array(route_hint_point)
+var manual_trace_hint = z19.object({
+  pcb_port_selector: z19.string(),
+  offsets: z19.array(route_hint_point)
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_schematic_placement.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 import { point as point4 } from "circuit-json";
-var manual_schematic_placement = z19.object({
-  selector: z19.string(),
-  relative_to: z19.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
+var manual_schematic_placement = z20.object({
+  selector: z20.string(),
+  relative_to: z20.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
   center: point4
 });
 expectTypesMatch(
@@ -300,31 +320,31 @@ expectTypesMatch(
 );
 
 // lib/manual-edits/manual_edits_file.ts
-var manual_edits_file = z20.object({
-  pcb_placements: z20.array(manual_pcb_placement).optional(),
-  manual_trace_hints: z20.array(manual_trace_hint).optional(),
-  schematic_placements: z20.array(manual_schematic_placement).optional()
+var manual_edits_file = z21.object({
+  pcb_placements: z21.array(manual_pcb_placement).optional(),
+  manual_trace_hints: z21.array(manual_trace_hint).optional(),
+  schematic_placements: z21.array(manual_schematic_placement).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/group.ts
-var layoutConfig = z21.object({
-  layoutMode: z21.enum(["grid", "flex", "match-adapt", "none"]).optional(),
-  position: z21.enum(["absolute", "relative"]).optional(),
-  grid: z21.boolean().optional(),
-  gridCols: z21.number().or(z21.string()).optional(),
-  gridRows: z21.number().or(z21.string()).optional(),
-  gridTemplateRows: z21.string().optional(),
-  gridTemplateColumns: z21.string().optional(),
-  gridTemplate: z21.string().optional(),
-  gridGap: z21.number().or(z21.string()).optional(),
-  flex: z21.boolean().or(z21.string()).optional(),
-  flexDirection: z21.enum(["row", "column"]).optional(),
-  alignItems: z21.enum(["start", "center", "end", "stretch"]).optional(),
-  justifyContent: z21.enum(["start", "center", "end", "stretch"]).optional(),
-  flexRow: z21.boolean().optional(),
-  flexColumn: z21.boolean().optional(),
-  gap: z21.number().or(z21.string()).optional(),
+var layoutConfig = z22.object({
+  layoutMode: z22.enum(["grid", "flex", "match-adapt", "none"]).optional(),
+  position: z22.enum(["absolute", "relative"]).optional(),
+  grid: z22.boolean().optional(),
+  gridCols: z22.number().or(z22.string()).optional(),
+  gridRows: z22.number().or(z22.string()).optional(),
+  gridTemplateRows: z22.string().optional(),
+  gridTemplateColumns: z22.string().optional(),
+  gridTemplate: z22.string().optional(),
+  gridGap: z22.number().or(z22.string()).optional(),
+  flex: z22.boolean().or(z22.string()).optional(),
+  flexDirection: z22.enum(["row", "column"]).optional(),
+  alignItems: z22.enum(["start", "center", "end", "stretch"]).optional(),
+  justifyContent: z22.enum(["start", "center", "end", "stretch"]).optional(),
+  flexRow: z22.boolean().optional(),
+  flexColumn: z22.boolean().optional(),
+  gap: z22.number().or(z22.string()).optional(),
   padding: length.optional(),
   paddingLeft: length.optional(),
   paddingRight: length.optional(),
@@ -334,39 +354,39 @@ var layoutConfig = z21.object({
   paddingY: length.optional(),
   width: length.optional(),
   height: length.optional(),
-  matchAdapt: z21.boolean().optional(),
-  matchAdaptTemplate: z21.any().optional()
+  matchAdapt: z22.boolean().optional(),
+  matchAdaptTemplate: z22.any().optional()
 });
 expectTypesMatch(true);
-var border = z21.object({
+var border = z22.object({
   strokeWidth: length.optional(),
-  dashed: z21.boolean().optional(),
-  solid: z21.boolean().optional()
-});
-var autorouterConfig = z21.object({
-  serverUrl: z21.string().optional(),
-  inputFormat: z21.enum(["simplified", "circuit-json"]).optional(),
-  serverMode: z21.enum(["job", "solve-endpoint"]).optional(),
-  serverCacheEnabled: z21.boolean().optional(),
-  cache: z21.custom((v) => true).optional(),
-  groupMode: z21.enum(["sequential-trace", "subcircuit"]).optional(),
-  algorithmFn: z21.custom(
+  dashed: z22.boolean().optional(),
+  solid: z22.boolean().optional()
+});
+var autorouterConfig = z22.object({
+  serverUrl: z22.string().optional(),
+  inputFormat: z22.enum(["simplified", "circuit-json"]).optional(),
+  serverMode: z22.enum(["job", "solve-endpoint"]).optional(),
+  serverCacheEnabled: z22.boolean().optional(),
+  cache: z22.custom((v) => true).optional(),
+  groupMode: z22.enum(["sequential-trace", "subcircuit"]).optional(),
+  algorithmFn: z22.custom(
     (v) => typeof v === "function" || v === void 0
   ).optional(),
-  local: z21.boolean().optional()
+  local: z22.boolean().optional()
 });
-var autorouterProp = z21.union([
+var autorouterProp = z22.union([
   autorouterConfig,
-  z21.literal("sequential-trace"),
-  z21.literal("subcircuit"),
-  z21.literal("auto"),
-  z21.literal("auto-local"),
-  z21.literal("auto-cloud")
+  z22.literal("sequential-trace"),
+  z22.literal("subcircuit"),
+  z22.literal("auto"),
+  z22.literal("auto-local"),
+  z22.literal("auto-cloud")
 ]);
 var baseGroupProps = commonLayoutProps.extend({
-  name: z21.string().optional(),
-  children: z21.any().optional(),
-  key: z21.any().optional(),
+  name: z22.string().optional(),
+  children: z22.any().optional(),
+  key: z22.any().optional(),
   ...layoutConfig.shape,
   pcbWidth: length.optional(),
   pcbHeight: length.optional(),
@@ -382,24 +402,24 @@ var baseGroupProps = commonLayoutProps.extend({
   schPaddingTop: length.optional(),
   schPaddingBottom: length.optional()
 });
-var partsEngine = z21.custom((v) => "findPart" in v);
+var partsEngine = z22.custom((v) => "findPart" in v);
 var subcircuitGroupProps = baseGroupProps.extend({
-  layout: z21.custom((v) => true).optional(),
+  layout: z22.custom((v) => true).optional(),
   manualEdits: manual_edits_file.optional(),
-  schAutoLayoutEnabled: z21.boolean().optional(),
-  schTraceAutoLabelEnabled: z21.boolean().optional(),
-  routingDisabled: z21.boolean().optional(),
+  schAutoLayoutEnabled: z22.boolean().optional(),
+  schTraceAutoLabelEnabled: z22.boolean().optional(),
+  routingDisabled: z22.boolean().optional(),
   defaultTraceWidth: length.optional(),
   minTraceWidth: length.optional(),
   partsEngine: partsEngine.optional(),
-  pcbRouteCache: z21.custom((v) => true).optional(),
+  pcbRouteCache: z22.custom((v) => true).optional(),
   autorouter: autorouterProp.optional()
 });
 var subcircuitGroupPropsWithBool = subcircuitGroupProps.extend({
-  subcircuit: z21.literal(true)
+  subcircuit: z22.literal(true)
 });
-var groupProps = z21.discriminatedUnion("subcircuit", [
-  baseGroupProps.extend({ subcircuit: z21.literal(false).optional() }),
+var groupProps = z22.discriminatedUnion("subcircuit", [
+  baseGroupProps.extend({ subcircuit: z22.literal(false).optional() }),
   subcircuitGroupPropsWithBool
 ]);
 expectTypesMatch(true);
@@ -410,10 +430,10 @@ expectTypesMatch(true);
 var boardProps = subcircuitGroupProps.extend({
   width: distance5.optional(),
   height: distance5.optional(),
-  outline: z22.array(point).optional(),
+  outline: z23.array(point).optional(),
   outlineOffsetX: distance5.optional(),
   outlineOffsetY: distance5.optional(),
-  material: z22.enum(["fr4", "fr1"]).default("fr4")
+  material: z23.enum(["fr4", "fr1"]).default("fr4")
 });
 expectTypesMatch(true);
 
@@ -431,32 +451,32 @@ expectTypesMatch(true);
 
 // lib/components/chip.ts
 import { distance as distance7, supplier_name as supplier_name2 } from "circuit-json";
-import { z as z24 } from "zod";
-var connectionTarget = z24.string().or(z24.array(z24.string()).readonly()).or(z24.array(z24.string()));
-var connectionsProp = z24.custom().pipe(z24.record(z24.string(), connectionTarget));
-var pinLabelsProp = z24.record(
-  z24.string(),
-  z24.string().or(z24.array(z24.string()).readonly()).or(z24.array(z24.string()))
+import { z as z25 } from "zod";
+var connectionTarget = z25.string().or(z25.array(z25.string()).readonly()).or(z25.array(z25.string()));
+var connectionsProp = z25.custom().pipe(z25.record(z25.string(), connectionTarget));
+var pinLabelsProp = z25.record(
+  z25.string(),
+  z25.string().or(z25.array(z25.string()).readonly()).or(z25.array(z25.string()))
 );
 expectTypesMatch(true);
-var pinCompatibleVariant = z24.object({
-  manufacturerPartNumber: z24.string().optional(),
-  supplierPartNumber: z24.record(supplier_name2, z24.array(z24.string())).optional()
+var pinCompatibleVariant = z25.object({
+  manufacturerPartNumber: z25.string().optional(),
+  supplierPartNumber: z25.record(supplier_name2, z25.array(z25.string())).optional()
 });
 var chipProps = commonComponentProps.extend({
-  manufacturerPartNumber: z24.string().optional(),
+  manufacturerPartNumber: z25.string().optional(),
   pinLabels: pinLabelsProp.optional(),
-  showPinAliases: z24.boolean().optional(),
-  internallyConnectedPins: z24.array(z24.array(z24.string())).optional(),
-  externallyConnectedPins: z24.array(z24.array(z24.string())).optional(),
+  showPinAliases: z25.boolean().optional(),
+  internallyConnectedPins: z25.array(z25.array(z25.string())).optional(),
+  externallyConnectedPins: z25.array(z25.array(z25.string())).optional(),
   schPinArrangement: schematicPortArrangement.optional(),
   schPortArrangement: schematicPortArrangement.optional(),
-  pinCompatibleVariants: z24.array(pinCompatibleVariant).optional(),
+  pinCompatibleVariants: z25.array(pinCompatibleVariant).optional(),
   schPinStyle: schematicPinStyle.optional(),
   schPinSpacing: distance7.optional(),
   schWidth: distance7.optional(),
   schHeight: distance7.optional(),
-  noSchematicRepresentation: z24.boolean().optional(),
+  noSchematicRepresentation: z25.boolean().optional(),
   connections: connectionsProp.optional()
 });
 var bugProps = chipProps;
@@ -464,81 +484,92 @@ expectTypesMatch(true);
 
 // lib/components/jumper.ts
 import { distance as distance8 } from "circuit-json";
-import { z as z25 } from "zod";
+
+// lib/common/connectionsProp.ts
+import { z as z26 } from "zod";
+var connectionTarget2 = z26.string().or(z26.array(z26.string()).readonly()).or(z26.array(z26.string()));
+var createConnectionsProp = (labels) => {
+  return z26.record(z26.enum(labels), connectionTarget2);
+};
+
+// lib/components/jumper.ts
+import { z as z27 } from "zod";
 var jumperProps = commonComponentProps.extend({
-  manufacturerPartNumber: z25.string().optional(),
-  pinLabels: z25.record(z25.number().or(z25.string()), z25.string().or(z25.array(z25.string()))).optional(),
+  manufacturerPartNumber: z27.string().optional(),
+  pinLabels: z27.record(z27.number().or(z27.string()), z27.string().or(z27.array(z27.string()))).optional(),
   schPinStyle: schematicPinStyle.optional(),
   schPinSpacing: distance8.optional(),
   schWidth: distance8.optional(),
   schHeight: distance8.optional(),
-  schDirection: z25.enum(["left", "right"]).optional(),
+  schDirection: z27.enum(["left", "right"]).optional(),
   schPortArrangement: schematicPortArrangement.optional(),
-  pinCount: z25.union([z25.literal(2), z25.literal(3)]).optional(),
-  internallyConnectedPins: z25.array(z25.array(z25.string())).optional()
+  pinCount: z27.union([z27.literal(2), z27.literal(3)]).optional(),
+  internallyConnectedPins: z27.array(z27.array(z27.string())).optional(),
+  connections: z27.custom().pipe(z27.record(z27.string(), connectionTarget2)).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/solderjumper.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 var solderjumperProps = jumperProps.extend({
-  bridgedPins: z26.array(z26.array(z26.string())).optional()
+  bridgedPins: z28.array(z28.array(z28.string())).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/connector.ts
 import { distance as distance9 } from "circuit-json";
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 var connectorProps = commonComponentProps.extend({
-  manufacturerPartNumber: z27.string().optional(),
-  pinLabels: z27.record(z27.number().or(z27.string()), z27.string().or(z27.array(z27.string()))).optional(),
+  manufacturerPartNumber: z29.string().optional(),
+  pinLabels: z29.record(z29.number().or(z29.string()), z29.string().or(z29.array(z29.string()))).optional(),
   schPinStyle: schematicPinStyle.optional(),
   schPinSpacing: distance9.optional(),
   schWidth: distance9.optional(),
   schHeight: distance9.optional(),
-  schDirection: z27.enum(["left", "right"]).optional(),
+  schDirection: z29.enum(["left", "right"]).optional(),
   schPortArrangement: schematicPortArrangement.optional(),
-  internallyConnectedPins: z27.array(z27.array(z27.string())).optional(),
-  standard: z27.enum(["usb_c", "m2"]).optional()
+  internallyConnectedPins: z29.array(z29.array(z29.string())).optional(),
+  standard: z29.enum(["usb_c", "m2"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/fuse.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 var fusePinLabels = ["pin1", "pin2"];
 var fuseProps = commonComponentProps.extend({
-  currentRating: z28.union([z28.number(), z28.string()]),
-  voltageRating: z28.union([z28.number(), z28.string()]).optional(),
-  schShowRatings: z28.boolean().optional(),
-  connections: z28.record(
-    z28.string(),
-    z28.union([
-      z28.string(),
-      z28.array(z28.string()).readonly(),
-      z28.array(z28.string())
+  currentRating: z30.union([z30.number(), z30.string()]),
+  voltageRating: z30.union([z30.number(), z30.string()]).optional(),
+  schShowRatings: z30.boolean().optional(),
+  schOrientation: schematicOrientation.optional(),
+  connections: z30.record(
+    z30.string(),
+    z30.union([
+      z30.string(),
+      z30.array(z30.string()).readonly(),
+      z30.array(z30.string())
     ])
   ).optional()
 });
 
 // lib/components/platedhole.ts
 import { distance as distance10 } from "circuit-json";
-import { z as z29 } from "zod";
-var distanceHiddenUndefined = z29.custom().transform((a) => {
+import { z as z31 } from "zod";
+var distanceHiddenUndefined = z31.custom().transform((a) => {
   if (a === void 0)
     return void 0;
   return distance10.parse(a);
 });
-var platedHoleProps = z29.discriminatedUnion("shape", [
+var platedHoleProps = z31.discriminatedUnion("shape", [
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: z29.string().optional(),
-    shape: z29.literal("circle"),
+    name: z31.string().optional(),
+    shape: z31.literal("circle"),
     holeDiameter: distance10,
     outerDiameter: distance10,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: z29.string().optional(),
-    shape: z29.literal("oval"),
+    name: z31.string().optional(),
+    shape: z31.literal("oval"),
     outerWidth: distance10,
     outerHeight: distance10,
     holeWidth: distanceHiddenUndefined,
@@ -548,8 +579,8 @@ var platedHoleProps = z29.discriminatedUnion("shape", [
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: z29.string().optional(),
-    shape: z29.literal("pill"),
+    name: z31.string().optional(),
+    shape: z31.literal("pill"),
     outerWidth: distance10,
     outerHeight: distance10,
     holeWidth: distanceHiddenUndefined,
@@ -559,20 +590,20 @@ var platedHoleProps = z29.discriminatedUnion("shape", [
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: z29.string().optional(),
-    shape: z29.literal("circular_hole_with_rect_pad"),
+    name: z31.string().optional(),
+    shape: z31.literal("circular_hole_with_rect_pad"),
     holeDiameter: distance10,
     rectPadWidth: distance10,
     rectPadHeight: distance10,
-    holeShape: z29.literal("circle").optional(),
-    padShape: z29.literal("rect").optional(),
+    holeShape: z31.literal("circle").optional(),
+    padShape: z31.literal("rect").optional(),
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: z29.string().optional(),
-    shape: z29.literal("pill_hole_with_rect_pad"),
-    holeShape: z29.literal("pill"),
-    padShape: z29.literal("rect"),
+    name: z31.string().optional(),
+    shape: z31.literal("pill_hole_with_rect_pad"),
+    holeShape: z31.literal("pill"),
+    padShape: z31.literal("rect"),
     holeWidth: distance10,
     holeHeight: distance10,
     rectPadWidth: distance10,
@@ -592,23 +623,15 @@ expectTypesMatch(true);
 
 // lib/components/resistor.ts
 import { resistance } from "circuit-json";
-
-// lib/common/connectionsProp.ts
-import { z as z30 } from "zod";
-var connectionTarget2 = z30.string().or(z30.array(z30.string()).readonly()).or(z30.array(z30.string()));
-var createConnectionsProp = (labels) => {
-  return z30.record(z30.enum(labels), connectionTarget2);
-};
-
-// lib/components/resistor.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var resistorPinLabels = ["pin1", "pin2", "pos", "neg"];
 var resistorProps = commonComponentProps.extend({
   resistance,
-  pullupFor: z31.string().optional(),
-  pullupTo: z31.string().optional(),
-  pulldownFor: z31.string().optional(),
-  pulldownTo: z31.string().optional(),
+  pullupFor: z32.string().optional(),
+  pullupTo: z32.string().optional(),
+  pulldownFor: z32.string().optional(),
+  pulldownTo: z32.string().optional(),
+  schOrientation: schematicOrientation.optional(),
   connections: createConnectionsProp(resistorPinLabels).optional()
 });
 var resistorPins = lrPins;
@@ -616,54 +639,55 @@ expectTypesMatch(true);
 
 // lib/components/potentiometer.ts
 import { resistance as resistance2 } from "circuit-json";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var potentiometerProps = commonComponentProps.extend({
   maxResistance: resistance2,
-  pinVariant: z32.enum(["two_pin", "three_pin"]).optional()
+  pinVariant: z33.enum(["two_pin", "three_pin"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/crystal.ts
 import { frequency, capacitance } from "circuit-json";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var crystalProps = commonComponentProps.extend({
   frequency,
   loadCapacitance: capacitance,
-  pinVariant: z33.enum(["two_pin", "four_pin"]).optional()
+  pinVariant: z34.enum(["two_pin", "four_pin"]).optional(),
+  schOrientation: schematicOrientation.optional()
 });
 var crystalPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/resonator.ts
 import { frequency as frequency2, capacitance as capacitance2 } from "circuit-json";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var resonatorProps = commonComponentProps.extend({
   frequency: frequency2,
   loadCapacitance: capacitance2,
-  pinVariant: z34.enum(["no_ground", "ground_pin", "two_ground_pins"]).optional()
+  pinVariant: z35.enum(["no_ground", "ground_pin", "two_ground_pins"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/stampboard.ts
 import { distance as distance11 } from "circuit-json";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var stampboardProps = boardProps.extend({
-  leftPinCount: z35.number().optional(),
-  rightPinCount: z35.number().optional(),
-  topPinCount: z35.number().optional(),
-  bottomPinCount: z35.number().optional(),
-  leftPins: z35.array(z35.string()).optional(),
-  rightPins: z35.array(z35.string()).optional(),
-  topPins: z35.array(z35.string()).optional(),
-  bottomPins: z35.array(z35.string()).optional(),
+  leftPinCount: z36.number().optional(),
+  rightPinCount: z36.number().optional(),
+  topPinCount: z36.number().optional(),
+  bottomPinCount: z36.number().optional(),
+  leftPins: z36.array(z36.string()).optional(),
+  rightPins: z36.array(z36.string()).optional(),
+  topPins: z36.array(z36.string()).optional(),
+  bottomPins: z36.array(z36.string()).optional(),
   pinPitch: distance11.optional(),
-  innerHoles: z35.boolean().optional()
+  innerHoles: z36.boolean().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/capacitor.ts
 import { capacitance as capacitance3, voltage } from "circuit-json";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var capacitorPinLabels = [
   "pin1",
   "pin2",
@@ -675,31 +699,32 @@ var capacitorPinLabels = [
 var capacitorProps = commonComponentProps.extend({
   capacitance: capacitance3,
   maxVoltageRating: voltage.optional(),
-  schShowRatings: z36.boolean().optional().default(false),
-  polarized: z36.boolean().optional().default(false),
-  decouplingFor: z36.string().optional(),
-  decouplingTo: z36.string().optional(),
-  bypassFor: z36.string().optional(),
-  bypassTo: z36.string().optional(),
-  maxDecouplingTraceLength: z36.number().optional(),
+  schShowRatings: z37.boolean().optional().default(false),
+  polarized: z37.boolean().optional().default(false),
+  decouplingFor: z37.string().optional(),
+  decouplingTo: z37.string().optional(),
+  bypassFor: z37.string().optional(),
+  bypassTo: z37.string().optional(),
+  maxDecouplingTraceLength: z37.number().optional(),
+  schOrientation: schematicOrientation.optional(),
   connections: createConnectionsProp(capacitorPinLabels).optional()
 });
 var capacitorPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/net.ts
-import { z as z37 } from "zod";
-var netProps = z37.object({
-  name: z37.string()
+import { z as z38 } from "zod";
+var netProps = z38.object({
+  name: z38.string()
 });
 expectTypesMatch(true);
 
 // lib/components/constrainedlayout.ts
-import { z as z38 } from "zod";
-var constrainedLayoutProps = z38.object({
-  name: z38.string().optional(),
-  pcbOnly: z38.boolean().optional(),
-  schOnly: z38.boolean().optional()
+import { z as z39 } from "zod";
+var constrainedLayoutProps = z39.object({
+  name: z39.string().optional(),
+  pcbOnly: z39.boolean().optional(),
+  schOnly: z39.boolean().optional()
 });
 expectTypesMatch(true);
 
@@ -708,46 +733,46 @@ import "zod";
 import { distance as distance12, length as length2 } from "circuit-json";
 
 // lib/components/constraint.ts
-import { z as z40 } from "zod";
-var pcbXDistConstraintProps = z40.object({
-  pcb: z40.literal(true).optional(),
+import { z as z41 } from "zod";
+var pcbXDistConstraintProps = z41.object({
+  pcb: z41.literal(true).optional(),
   xDist: distance12,
-  left: z40.string(),
-  right: z40.string(),
-  edgeToEdge: z40.literal(true).optional(),
-  centerToCenter: z40.literal(true).optional()
+  left: z41.string(),
+  right: z41.string(),
+  edgeToEdge: z41.literal(true).optional(),
+  centerToCenter: z41.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbYDistConstraintProps = z40.object({
-  pcb: z40.literal(true).optional(),
+var pcbYDistConstraintProps = z41.object({
+  pcb: z41.literal(true).optional(),
   yDist: distance12,
-  top: z40.string(),
-  bottom: z40.string(),
-  edgeToEdge: z40.literal(true).optional(),
-  centerToCenter: z40.literal(true).optional()
+  top: z41.string(),
+  bottom: z41.string(),
+  edgeToEdge: z41.literal(true).optional(),
+  centerToCenter: z41.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbSameYConstraintProps = z40.object({
-  pcb: z40.literal(true).optional(),
-  sameY: z40.literal(true).optional(),
-  for: z40.array(z40.string())
+var pcbSameYConstraintProps = z41.object({
+  pcb: z41.literal(true).optional(),
+  sameY: z41.literal(true).optional(),
+  for: z41.array(z41.string())
 });
 expectTypesMatch(
   true
 );
-var pcbSameXConstraintProps = z40.object({
-  pcb: z40.literal(true).optional(),
-  sameX: z40.literal(true).optional(),
-  for: z40.array(z40.string())
+var pcbSameXConstraintProps = z41.object({
+  pcb: z41.literal(true).optional(),
+  sameX: z41.literal(true).optional(),
+  for: z41.array(z41.string())
 });
 expectTypesMatch(
   true
 );
-var constraintProps = z40.union([
+var constraintProps = z41.union([
   pcbXDistConstraintProps,
   pcbYDistConstraintProps,
   pcbSameYConstraintProps,
@@ -756,13 +781,13 @@ var constraintProps = z40.union([
 expectTypesMatch(true);
 
 // lib/components/cutout.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var rectCutoutProps = pcbLayoutProps.omit({
   layer: true,
   pcbRotation: true
 }).extend({
-  name: z41.string().optional(),
-  shape: z41.literal("rect"),
+  name: z42.string().optional(),
+  shape: z42.literal("rect"),
   width: distance12,
   height: distance12
 });
@@ -771,8 +796,8 @@ var circleCutoutProps = pcbLayoutProps.omit({
   layer: true,
   pcbRotation: true
 }).extend({
-  name: z41.string().optional(),
-  shape: z41.literal("circle"),
+  name: z42.string().optional(),
+  shape: z42.literal("circle"),
   radius: distance12
 });
 expectTypesMatch(true);
@@ -780,42 +805,42 @@ var polygonCutoutProps = pcbLayoutProps.omit({
   layer: true,
   pcbRotation: true
 }).extend({
-  name: z41.string().optional(),
-  shape: z41.literal("polygon"),
-  points: z41.array(point)
+  name: z42.string().optional(),
+  shape: z42.literal("polygon"),
+  points: z42.array(point)
 });
 expectTypesMatch(true);
-var cutoutProps = z41.discriminatedUnion("shape", [
+var cutoutProps = z42.discriminatedUnion("shape", [
   rectCutoutProps,
   circleCutoutProps,
   polygonCutoutProps
 ]);
 
 // lib/components/smtpad.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z42.literal("rect"),
+  shape: z43.literal("rect"),
   width: distance12,
   height: distance12,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var rotatedRectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z42.literal("rotated_rect"),
+  shape: z43.literal("rotated_rect"),
   width: distance12,
   height: distance12,
-  ccwRotation: z42.number(),
+  ccwRotation: z43.number(),
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z42.literal("circle"),
+  shape: z43.literal("circle"),
   radius: distance12,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var pillSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z42.literal("pill"),
+  shape: z43.literal("pill"),
   width: distance12,
   height: distance12,
   radius: distance12,
@@ -823,12 +848,12 @@ var pillSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 });
 expectTypesMatch(true);
 var polygonSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z42.literal("polygon"),
-  points: z42.array(point),
+  shape: z43.literal("polygon"),
+  points: z43.array(point),
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
-var smtPadProps = z42.discriminatedUnion("shape", [
+var smtPadProps = z43.discriminatedUnion("shape", [
   circleSmtPadProps,
   rectSmtPadProps,
   rotatedRectSmtPadProps,
@@ -838,28 +863,28 @@ var smtPadProps = z42.discriminatedUnion("shape", [
 expectTypesMatch(true);
 
 // lib/components/solderpaste.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var rectSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z43.literal("rect"),
+  shape: z44.literal("rect"),
   width: distance12,
   height: distance12
 });
 expectTypesMatch(true);
 var circleSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z43.literal("circle"),
+  shape: z44.literal("circle"),
   radius: distance12
 });
 expectTypesMatch(true);
-var solderPasteProps = z43.union([
+var solderPasteProps = z44.union([
   circleSolderPasteProps,
   rectSolderPasteProps
 ]);
 expectTypesMatch(true);
 
 // lib/components/hole.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  name: z44.string().optional(),
+  name: z45.string().optional(),
   diameter: distance12.optional(),
   radius: distance12.optional()
 }).transform((d) => ({
@@ -871,24 +896,24 @@ expectTypesMatch(true);
 
 // lib/components/trace.ts
 import { distance as distance13, route_hint_point as route_hint_point2 } from "circuit-json";
-import { z as z45 } from "zod";
-var portRef = z45.union([
-  z45.string(),
-  z45.custom(
+import { z as z46 } from "zod";
+var portRef = z46.union([
+  z46.string(),
+  z46.custom(
     (v) => Boolean(v.getPortSelector)
   )
 ]);
-var baseTraceProps = z45.object({
-  key: z45.string().optional(),
+var baseTraceProps = z46.object({
+  key: z46.string().optional(),
   thickness: distance13.optional(),
-  schematicRouteHints: z45.array(point).optional(),
-  pcbRouteHints: z45.array(route_hint_point2).optional(),
-  schDisplayLabel: z45.string().optional(),
+  schematicRouteHints: z46.array(point).optional(),
+  pcbRouteHints: z46.array(route_hint_point2).optional(),
+  schDisplayLabel: z46.string().optional(),
   maxLength: distance13.optional()
 });
-var traceProps = z45.union([
+var traceProps = z46.union([
   baseTraceProps.extend({
-    path: z45.array(portRef)
+    path: z46.array(portRef)
   }),
   baseTraceProps.extend({
     from: portRef,
@@ -898,15 +923,15 @@ var traceProps = z45.union([
 
 // lib/components/footprint.ts
 import { layer_ref as layer_ref4 } from "circuit-json";
-import { z as z46 } from "zod";
-var footprintProps = z46.object({
+import { z as z47 } from "zod";
+var footprintProps = z47.object({
   originalLayer: layer_ref4.default("top").optional()
 });
 expectTypesMatch(true);
 
 // lib/components/battery.ts
-import { z as z47 } from "zod";
-var capacity = z47.number().or(z47.string().endsWith("mAh")).transform((v) => {
+import { z as z48 } from "zod";
+var capacity = z48.number().or(z48.string().endsWith("mAh")).transform((v) => {
   if (typeof v === "string") {
     const valString = v.replace("mAh", "");
     const num = Number.parseFloat(valString);
@@ -918,26 +943,27 @@ var capacity = z47.number().or(z47.string().endsWith("mAh")).transform((v) => {
   return v;
 }).describe("Battery capacity in mAh");
 var batteryProps = commonComponentProps.extend({
-  capacity: capacity.optional()
+  capacity: capacity.optional(),
+  schOrientation: schematicOrientation.optional()
 });
 var batteryPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/pin-header.ts
 import { distance as distance14 } from "circuit-json";
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 var pinHeaderProps = commonComponentProps.extend({
-  pinCount: z48.number(),
+  pinCount: z49.number(),
   pitch: distance14.optional(),
-  schFacingDirection: z48.enum(["up", "down", "left", "right"]).optional(),
-  gender: z48.enum(["male", "female"]).optional().default("male"),
-  showSilkscreenPinLabels: z48.boolean().optional(),
-  doubleRow: z48.boolean().optional(),
+  schFacingDirection: z49.enum(["up", "down", "left", "right"]).optional(),
+  gender: z49.enum(["male", "female"]).optional().default("male"),
+  showSilkscreenPinLabels: z49.boolean().optional(),
+  doubleRow: z49.boolean().optional(),
   holeDiameter: distance14.optional(),
   platedDiameter: distance14.optional(),
-  pinLabels: z48.array(z48.string()).optional(),
-  connections: z48.custom().pipe(z48.record(z48.string(), connectionTarget2)).optional(),
-  facingDirection: z48.enum(["left", "right"]).optional(),
+  pinLabels: z49.array(z49.string()).optional(),
+  connections: z49.custom().pipe(z49.record(z49.string(), connectionTarget2)).optional(),
+  facingDirection: z49.enum(["left", "right"]).optional(),
   schPinArrangement: schematicPinArrangement.optional(),
   schPinStyle: schematicPinStyle.optional(),
   schPinSpacing: distance14.optional(),
@@ -947,29 +973,29 @@ var pinHeaderProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/netalias.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 import { rotation as rotation2 } from "circuit-json";
-var netAliasProps = z49.object({
-  net: z49.string().optional(),
-  connection: z49.string().optional(),
+var netAliasProps = z50.object({
+  net: z50.string().optional(),
+  connection: z50.string().optional(),
   schX: distance12.optional(),
   schY: distance12.optional(),
   schRotation: rotation2.optional(),
-  anchorSide: z49.enum(["left", "top", "right", "bottom"]).optional()
+  anchorSide: z50.enum(["left", "top", "right", "bottom"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/netlabel.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 import { rotation as rotation3 } from "circuit-json";
-var netLabelProps = z50.object({
-  net: z50.string().optional(),
-  connection: z50.string().optional(),
-  connectsTo: z50.string().or(z50.array(z50.string())).optional(),
+var netLabelProps = z51.object({
+  net: z51.string().optional(),
+  connection: z51.string().optional(),
+  connectsTo: z51.string().or(z51.array(z51.string())).optional(),
   schX: distance12.optional(),
   schY: distance12.optional(),
   schRotation: rotation3.optional(),
-  anchorSide: z50.enum(["left", "top", "right", "bottom"]).optional()
+  anchorSide: z51.enum(["left", "top", "right", "bottom"]).optional()
 });
 expectTypesMatch(true);
 
@@ -983,9 +1009,9 @@ var subcircuitProps = subcircuitGroupProps;
 expectTypesMatch(true);
 
 // lib/components/transistor.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var transistorProps = commonComponentProps.extend({
-  type: z52.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"])
+  type: z53.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"])
 });
 var transistorPins = [
   "pin1",
@@ -998,10 +1024,10 @@ var transistorPins = [
 expectTypesMatch(true);
 
 // lib/components/mosfet.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 var mosfetProps = commonComponentProps.extend({
-  channelType: z53.enum(["n", "p"]),
-  mosfetMode: z53.enum(["enhancement", "depletion"])
+  channelType: z54.enum(["n", "p"]),
+  mosfetMode: z54.enum(["enhancement", "depletion"])
 });
 var mosfetPins = [
   "pin1",
@@ -1015,17 +1041,18 @@ expectTypesMatch(true);
 
 // lib/components/inductor.ts
 import { inductance } from "circuit-json";
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 var inductorProps = commonComponentProps.extend({
   inductance,
-  maxCurrentRating: z54.union([z54.string(), z54.number()]).optional()
+  maxCurrentRating: z55.union([z55.string(), z55.number()]).optional(),
+  schOrientation: schematicOrientation.optional()
 });
 var inductorPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/diode.ts
-import { z as z55 } from "zod";
-var diodeConnectionKeys = z55.enum([
+import { z as z56 } from "zod";
+var diodeConnectionKeys = z56.enum([
   "anode",
   "cathode",
   "pin1",
@@ -1033,17 +1060,18 @@ var diodeConnectionKeys = z55.enum([
   "pos",
   "neg"
 ]);
-var connectionTarget3 = z55.string().or(z55.array(z55.string()).readonly()).or(z55.array(z55.string()));
-var connectionsProp2 = z55.record(diodeConnectionKeys, connectionTarget3);
-var diodeVariant = z55.enum(["standard", "schottky", "zener", "photo", "tvs"]);
+var connectionTarget3 = z56.string().or(z56.array(z56.string()).readonly()).or(z56.array(z56.string()));
+var connectionsProp2 = z56.record(diodeConnectionKeys, connectionTarget3);
+var diodeVariant = z56.enum(["standard", "schottky", "zener", "photo", "tvs"]);
 var diodeProps = commonComponentProps.extend({
   connections: connectionsProp2.optional(),
   variant: diodeVariant.optional().default("standard"),
-  standard: z55.boolean().optional(),
-  schottky: z55.boolean().optional(),
-  zener: z55.boolean().optional(),
-  photo: z55.boolean().optional(),
-  tvs: z55.boolean().optional()
+  standard: z56.boolean().optional(),
+  schottky: z56.boolean().optional(),
+  zener: z56.boolean().optional(),
+  photo: z56.boolean().optional(),
+  tvs: z56.boolean().optional(),
+  schOrientation: schematicOrientation.optional()
 }).superRefine((data, ctx) => {
   const enabledFlags = [
     data.standard,
@@ -1054,11 +1082,11 @@ var diodeProps = commonComponentProps.extend({
   ].filter(Boolean).length;
   if (enabledFlags > 1) {
     ctx.addIssue({
-      code: z55.ZodIssueCode.custom,
+      code: z56.ZodIssueCode.custom,
       message: "Exactly one diode variant must be enabled",
       path: []
     });
-    return z55.INVALID;
+    return z56.INVALID;
   }
 }).transform((data) => {
   const result = {
@@ -1106,23 +1134,24 @@ var diodePins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/led.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var ledProps = commonComponentProps.extend({
-  color: z56.string().optional(),
-  wavelength: z56.string().optional(),
-  schDisplayValue: z56.string().optional()
+  color: z57.string().optional(),
+  wavelength: z57.string().optional(),
+  schDisplayValue: z57.string().optional(),
+  schOrientation: schematicOrientation.optional()
 });
 var ledPins = lrPolarPins;
 
 // lib/components/switch.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var switchProps = commonComponentProps.extend({
-  type: z57.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
-  isNormallyClosed: z57.boolean().optional().default(false),
-  spst: z57.boolean().optional(),
-  spdt: z57.boolean().optional(),
-  dpst: z57.boolean().optional(),
-  dpdt: z57.boolean().optional()
+  type: z58.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
+  isNormallyClosed: z58.boolean().optional().default(false),
+  spst: z58.boolean().optional(),
+  spdt: z58.boolean().optional(),
+  dpst: z58.boolean().optional(),
+  dpdt: z58.boolean().optional()
 }).transform((props) => {
   const updatedProps = { ...props };
   if (updatedProps.dpdt) {
@@ -1154,31 +1183,31 @@ expectTypesMatch(true);
 
 // lib/components/fabrication-note-text.ts
 import { length as length3 } from "circuit-json";
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: z58.string(),
-  anchorAlignment: z58.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z58.enum(["tscircuit2024"]).optional(),
+  text: z59.string(),
+  anchorAlignment: z59.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z59.enum(["tscircuit2024"]).optional(),
   fontSize: length3.optional(),
-  color: z58.string().optional()
+  color: z59.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 z59 } from "zod";
+import { z as z60 } from "zod";
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z59.array(route_hint_point3),
+  route: z60.array(route_hint_point3),
   strokeWidth: length4.optional(),
-  color: z59.string().optional()
+  color: z60.string().optional()
 });
 
 // lib/components/pcb-trace.ts
 import { distance as distance15, route_hint_point as route_hint_point4 } from "circuit-json";
-import { z as z60 } from "zod";
-var pcbTraceProps = z60.object({
-  layer: z60.string().optional(),
+import { z as z61 } from "zod";
+var pcbTraceProps = z61.object({
+  layer: z61.string().optional(),
   thickness: distance15.optional(),
-  route: z60.array(route_hint_point4)
+  route: z61.array(route_hint_point4)
 });
 
 // lib/components/via.ts
@@ -1192,10 +1221,10 @@ var viaProps = commonLayoutProps.extend({
 
 // lib/components/testpoint.ts
 import { distance as distance17 } from "circuit-json";
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 var testpointProps = commonComponentProps.extend({
-  footprintVariant: z61.enum(["pad", "through_hole"]).optional(),
-  padShape: z61.enum(["rect", "circle"]).optional().default("circle"),
+  footprintVariant: z62.enum(["pad", "through_hole"]).optional(),
+  padShape: z62.enum(["rect", "circle"]).optional().default("circle"),
   padDiameter: distance17.optional(),
   holeDiameter: distance17.optional(),
   width: distance17.optional(),
@@ -1207,22 +1236,22 @@ var testpointProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/breakoutpoint.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var breakoutPointProps = pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-  connection: z62.string()
+  connection: z63.string()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-keepout.ts
 import { distance as distance18 } from "circuit-json";
-import { z as z63 } from "zod";
-var pcbKeepoutProps = z63.union([
+import { z as z64 } from "zod";
+var pcbKeepoutProps = z64.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: z63.literal("circle"),
+    shape: z64.literal("circle"),
     radius: distance18
   }),
   pcbLayoutProps.extend({
-    shape: z63.literal("rect"),
+    shape: z64.literal("rect"),
     width: distance18,
     height: distance18
   })
@@ -1236,11 +1265,11 @@ var powerSourceProps = commonComponentProps.extend({
 
 // lib/components/schematic-box.ts
 import { distance as distance19 } from "circuit-json";
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 
 // lib/common/ninePointAnchor.ts
-import { z as z64 } from "zod";
-var ninePointAnchor = z64.enum([
+import { z as z65 } from "zod";
+var ninePointAnchor = z65.enum([
   "top_left",
   "top_center",
   "top_right",
@@ -1253,23 +1282,23 @@ var ninePointAnchor = z64.enum([
 ]);
 
 // lib/components/schematic-box.ts
-var schematicBoxProps = z65.object({
+var schematicBoxProps = z66.object({
   schX: distance19.optional(),
   schY: distance19.optional(),
   width: distance19.optional(),
   height: distance19.optional(),
-  overlay: z65.array(z65.string()).optional(),
+  overlay: z66.array(z66.string()).optional(),
   padding: distance19.optional(),
   paddingLeft: distance19.optional(),
   paddingRight: distance19.optional(),
   paddingTop: distance19.optional(),
   paddingBottom: distance19.optional(),
-  title: z65.string().optional(),
+  title: z66.string().optional(),
   titleAlignment: ninePointAnchor.default("top_left"),
-  titleColor: z65.string().optional(),
+  titleColor: z66.string().optional(),
   titleFontSize: distance19.optional(),
-  titleInside: z65.boolean().default(false),
-  strokeStyle: z65.enum(["solid", "dashed"]).default("solid")
+  titleInside: z66.boolean().default(false),
+  strokeStyle: z66.enum(["solid", "dashed"]).default("solid")
 }).refine(
   (elm) => elm.width !== void 0 && elm.height !== void 0 || Array.isArray(elm.overlay) && elm.overlay.length > 0,
   {
@@ -1284,8 +1313,8 @@ var schematicBoxProps = z65.object({
 
 // lib/components/schematic-line.ts
 import { distance as distance20 } from "circuit-json";
-import { z as z66 } from "zod";
-var schematicLineProps = z66.object({
+import { z as z67 } from "zod";
+var schematicLineProps = z67.object({
   x1: distance20,
   y1: distance20,
   x2: distance20,
@@ -1294,11 +1323,11 @@ var schematicLineProps = z66.object({
 
 // lib/components/schematic-text.ts
 import { distance as distance21, rotation as rotation4 } from "circuit-json";
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 
 // lib/common/fivePointAnchor.ts
-import { z as z67 } from "zod";
-var fivePointAnchor = z67.enum([
+import { z as z68 } from "zod";
+var fivePointAnchor = z68.enum([
   "center",
   "left",
   "right",
@@ -1307,40 +1336,40 @@ var fivePointAnchor = z67.enum([
 ]);
 
 // lib/components/schematic-text.ts
-var schematicTextProps = z68.object({
+var schematicTextProps = z69.object({
   schX: distance21.optional(),
   schY: distance21.optional(),
-  text: z68.string(),
-  fontSize: z68.number().default(1),
-  anchor: z68.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
-  color: z68.string().default("#000000"),
+  text: z69.string(),
+  fontSize: z69.number().default(1),
+  anchor: z69.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
+  color: z69.string().default("#000000"),
   schRotation: rotation4.default(0)
 });
 
 // lib/components/schematic-path.ts
 import { point as point5 } from "circuit-json";
-import { z as z69 } from "zod";
-var schematicPathProps = z69.object({
-  points: z69.array(point5),
-  isFilled: z69.boolean().optional().default(false),
-  fillColor: z69.enum(["red", "blue"]).optional()
+import { z as z70 } from "zod";
+var schematicPathProps = z70.object({
+  points: z70.array(point5),
+  isFilled: z70.boolean().optional().default(false),
+  fillColor: z70.enum(["red", "blue"]).optional()
 });
 
 // lib/components/silkscreen-text.ts
 import { length as length5 } from "circuit-json";
-import { z as z70 } from "zod";
+import { z as z71 } from "zod";
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: z70.string(),
+  text: z71.string(),
   anchorAlignment: ninePointAnchor.default("center"),
-  font: z70.enum(["tscircuit2024"]).optional(),
+  font: z71.enum(["tscircuit2024"]).optional(),
   fontSize: length5.optional()
 });
 
 // lib/components/silkscreen-path.ts
 import { length as length6, route_hint_point as route_hint_point5 } from "circuit-json";
-import { z as z71 } from "zod";
+import { z as z72 } from "zod";
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z71.array(route_hint_point5),
+  route: z72.array(route_hint_point5),
   strokeWidth: length6.optional()
 });
 
@@ -1356,10 +1385,10 @@ var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotat
 
 // lib/components/silkscreen-rect.ts
 import { distance as distance23 } from "circuit-json";
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  filled: z72.boolean().default(true).optional(),
-  stroke: z72.enum(["dashed", "solid", "none"]).optional(),
+  filled: z73.boolean().default(true).optional(),
+  stroke: z73.enum(["dashed", "solid", "none"]).optional(),
   strokeWidth: distance23.optional(),
   width: distance23,
   height: distance23
@@ -1367,60 +1396,60 @@ var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 
 // lib/components/silkscreen-circle.ts
 import { distance as distance24 } from "circuit-json";
-import { z as z73 } from "zod";
+import { z as z74 } from "zod";
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z73.boolean().optional(),
-  isOutline: z73.boolean().optional(),
+  isFilled: z74.boolean().optional(),
+  isOutline: z74.boolean().optional(),
   strokeWidth: distance24.optional(),
   radius: distance24
 });
 
 // lib/components/trace-hint.ts
 import { distance as distance25, layer_ref as layer_ref6, route_hint_point as route_hint_point6 } from "circuit-json";
-import { z as z74 } from "zod";
-var routeHintPointProps = z74.object({
+import { z as z75 } from "zod";
+var routeHintPointProps = z75.object({
   x: distance25,
   y: distance25,
-  via: z74.boolean().optional(),
+  via: z75.boolean().optional(),
   toLayer: layer_ref6.optional()
 });
-var traceHintProps = z74.object({
-  for: z74.string().optional().describe(
+var traceHintProps = z75.object({
+  for: z75.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: z74.number().optional(),
+  order: z75.number().optional(),
   offset: route_hint_point6.or(routeHintPointProps).optional(),
-  offsets: z74.array(route_hint_point6).or(z74.array(routeHintPointProps)).optional(),
-  traceWidth: z74.number().optional()
+  offsets: z75.array(route_hint_point6).or(z75.array(routeHintPointProps)).optional(),
+  traceWidth: z75.number().optional()
 });
 
 // lib/components/port.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 var portProps = commonLayoutProps.extend({
-  name: z75.string(),
-  pinNumber: z75.number().optional(),
-  aliases: z75.array(z75.string()).optional(),
+  name: z76.string(),
+  pinNumber: z76.number().optional(),
+  aliases: z76.array(z76.string()).optional(),
   direction
 });
 
 // lib/platformConfig.ts
-import { z as z76 } from "zod";
-var unvalidatedCircuitJson = z76.array(z76.any()).describe("Circuit JSON");
-var pathToCircuitJsonFn = z76.function().args(z76.string()).returns(z76.promise(z76.object({ footprintCircuitJson: z76.array(z76.any()) }))).describe("A function that takes a path and returns Circuit JSON");
-var platformConfig = z76.object({
+import { z as z77 } from "zod";
+var unvalidatedCircuitJson = z77.array(z77.any()).describe("Circuit JSON");
+var pathToCircuitJsonFn = z77.function().args(z77.string()).returns(z77.promise(z77.object({ footprintCircuitJson: z77.array(z77.any()) }))).describe("A function that takes a path and returns Circuit JSON");
+var platformConfig = z77.object({
   partsEngine: partsEngine.optional(),
   autorouter: autorouterProp.optional(),
-  registryApiUrl: z76.string().optional(),
-  cloudAutorouterUrl: z76.string().optional(),
-  localCacheEngine: z76.any().optional(),
-  pcbDisabled: z76.boolean().optional(),
-  schematicDisabled: z76.boolean().optional(),
-  partsEngineDisabled: z76.boolean().optional(),
-  footprintLibraryMap: z76.record(
-    z76.string(),
-    z76.record(
-      z76.string(),
-      z76.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
+  registryApiUrl: z77.string().optional(),
+  cloudAutorouterUrl: z77.string().optional(),
+  localCacheEngine: z77.any().optional(),
+  pcbDisabled: z77.boolean().optional(),
+  schematicDisabled: z77.boolean().optional(),
+  partsEngineDisabled: z77.boolean().optional(),
+  footprintLibraryMap: z77.record(
+    z77.string(),
+    z77.record(
+      z77.string(),
+      z77.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
     )
   ).optional()
 });
@@ -1532,6 +1561,7 @@ export {
   routeHintPointProps,
   schematicBoxProps,
   schematicLineProps,
+  schematicOrientation,
   schematicPathProps,
   schematicPinArrangement,
   schematicPinStyle,