@tscircuit/props 0.0.83 → 0.0.85

package/dist/index.js

@@ -102,7 +102,7 @@ __export(lib_exports, {
   viaProps: () => viaProps
 });
 module.exports = __toCommonJS(lib_exports);
-var import_soup16 = require("@tscircuit/soup");
+var import_circuit_json16 = require("circuit-json");
 var import_zod28 = require("zod");
 
 // lib/typecheck.ts
@@ -127,20 +127,22 @@ var portHints = import_zod2.z.array(import_zod2.z.string().or(import_zod2.z.numb
 expectTypesMatch(true);
 
 // lib/common/layout.ts
+var import_circuit_json2 = require("circuit-json");
 var import_zod6 = require("zod");
-var import_soup2 = require("@tscircuit/soup");
+
+// lib/common/cadModel.ts
+var import_zod4 = require("zod");
 
 // lib/common/point3.ts
-var import_soup = require("@tscircuit/soup");
+var import_circuit_json = require("circuit-json");
 var import_zod3 = require("zod");
 var point3 = import_zod3.z.object({
-  x: import_soup.distance,
-  y: import_soup.distance,
-  z: import_soup.distance
+  x: import_circuit_json.distance,
+  y: import_circuit_json.distance,
+  z: import_circuit_json.distance
 });
 
 // lib/common/cadModel.ts
-var import_zod4 = require("zod");
 var rotationPoint3 = import_zod4.z.object({
   x: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
   y: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
@@ -176,25 +178,25 @@ var footprintProp = import_zod5.z.custom((v) => true);
 
 // lib/common/layout.ts
 var pcbLayoutProps = import_zod6.z.object({
-  pcbX: import_soup2.distance.optional(),
-  pcbY: import_soup2.distance.optional(),
-  pcbRotation: import_soup2.rotation.optional(),
-  layer: import_soup2.layer_ref.optional()
+  pcbX: import_circuit_json2.distance.optional(),
+  pcbY: import_circuit_json2.distance.optional(),
+  pcbRotation: import_circuit_json2.rotation.optional(),
+  layer: import_circuit_json2.layer_ref.optional()
 });
 expectTypesMatch(true);
 var commonLayoutProps = import_zod6.z.object({
-  pcbX: import_soup2.distance.optional(),
-  pcbY: import_soup2.distance.optional(),
-  pcbRotation: import_soup2.rotation.optional(),
-  schX: import_soup2.distance.optional(),
-  schY: import_soup2.distance.optional(),
-  schRotation: import_soup2.rotation.optional(),
-  layer: import_soup2.layer_ref.optional(),
+  pcbX: import_circuit_json2.distance.optional(),
+  pcbY: import_circuit_json2.distance.optional(),
+  pcbRotation: import_circuit_json2.rotation.optional(),
+  schX: import_circuit_json2.distance.optional(),
+  schY: import_circuit_json2.distance.optional(),
+  schRotation: import_circuit_json2.rotation.optional(),
+  layer: import_circuit_json2.layer_ref.optional(),
   footprint: footprintProp.optional()
 });
 expectTypesMatch(true);
 var supplierProps = import_zod6.z.object({
-  supplierPartNumbers: import_zod6.z.record(import_soup2.supplier_name, import_zod6.z.array(import_zod6.z.string())).optional()
+  supplierPartNumbers: import_zod6.z.record(import_circuit_json2.supplier_name, import_zod6.z.array(import_zod6.z.string())).optional()
 });
 expectTypesMatch(true);
 var commonComponentProps = commonLayoutProps.merge(supplierProps).extend({
@@ -216,12 +218,12 @@ var lrPolarPins = [
   "cathode",
   "neg"
 ];
-var distanceOrMultiplier = import_soup2.distance.or(import_zod6.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier = import_circuit_json2.distance.or(import_zod6.z.enum(["2x", "3x", "4x"]));
 
 // lib/common/schematicPinDefinitions.ts
 var import_zod7 = require("zod");
 var explicitPinSideDefinition = import_zod7.z.object({
-  pins: import_zod7.z.array(import_zod7.z.number()),
+  pins: import_zod7.z.array(import_zod7.z.number()).or(import_zod7.z.array(import_zod7.z.string())),
   direction: import_zod7.z.union([
     import_zod7.z.literal("top-to-bottom"),
     import_zod7.z.literal("left-to-right"),
@@ -246,113 +248,113 @@ var schematicPortArrangement = import_zod7.z.object({
 expectTypesMatch(true);
 
 // lib/common/schematicPinStyle.ts
+var import_circuit_json3 = require("circuit-json");
 var import_zod8 = require("zod");
-var import_soup3 = require("@tscircuit/soup");
 var schematicPinStyle = import_zod8.z.record(
   import_zod8.z.object({
-    leftMargin: import_soup3.distance.optional(),
-    rightMargin: import_soup3.distance.optional(),
-    topMargin: import_soup3.distance.optional(),
-    bottomMargin: import_soup3.distance.optional()
+    leftMargin: import_circuit_json3.distance.optional(),
+    rightMargin: import_circuit_json3.distance.optional(),
+    topMargin: import_circuit_json3.distance.optional(),
+    bottomMargin: import_circuit_json3.distance.optional()
   })
 );
 expectTypesMatch(true);
 
 // lib/components/board.ts
-var import_soup5 = require("@tscircuit/soup");
+var import_circuit_json5 = require("circuit-json");
 
 // lib/common/point.ts
-var import_soup4 = require("@tscircuit/soup");
+var import_circuit_json4 = require("circuit-json");
 var import_zod9 = require("zod");
 var point = import_zod9.z.object({
-  x: import_soup4.distance,
-  y: import_soup4.distance
+  x: import_circuit_json4.distance,
+  y: import_circuit_json4.distance
 });
 
 // lib/components/board.ts
 var import_zod10 = require("zod");
 var boardProps = import_zod10.z.object({
-  width: import_soup5.distance.optional(),
-  height: import_soup5.distance.optional(),
+  width: import_circuit_json5.distance.optional(),
+  height: import_circuit_json5.distance.optional(),
   outline: import_zod10.z.array(point).optional(),
-  pcbX: import_soup5.distance.optional().default(0),
-  pcbY: import_soup5.distance.optional().default(0),
+  pcbX: import_circuit_json5.distance.optional().default(0),
+  pcbY: import_circuit_json5.distance.optional().default(0),
   layout: import_zod10.z.custom((v) => true).optional(),
   manualEdits: import_zod10.z.custom((v) => true).optional(),
   routingDisabled: import_zod10.z.boolean().optional(),
   children: import_zod10.z.any(),
-  defaultTraceWidth: import_soup5.distance.optional(),
+  defaultTraceWidth: import_circuit_json5.distance.optional(),
   schAutoLayoutEnabled: import_zod10.z.boolean().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/chip.ts
+var import_circuit_json6 = require("circuit-json");
 var import_zod11 = require("zod");
-var import_soup6 = require("@tscircuit/soup");
 var chipProps = commonComponentProps.extend({
   manufacturerPartNumber: import_zod11.z.string().optional(),
   pinLabels: import_zod11.z.record(import_zod11.z.number().or(import_zod11.z.string()), import_zod11.z.string().or(import_zod11.z.array(import_zod11.z.string()))).optional(),
   schPortArrangement: schematicPortArrangement.optional(),
   schPinStyle: schematicPinStyle.optional(),
-  schPinSpacing: import_soup6.distance.optional(),
-  schWidth: import_soup6.distance.optional(),
-  schHeight: import_soup6.distance.optional()
+  schPinSpacing: import_circuit_json6.distance.optional(),
+  schWidth: import_circuit_json6.distance.optional(),
+  schHeight: import_circuit_json6.distance.optional()
 });
 var bugProps = chipProps;
 expectTypesMatch(true);
 
 // lib/components/jumper.ts
+var import_circuit_json7 = require("circuit-json");
 var import_zod12 = require("zod");
-var import_soup7 = require("@tscircuit/soup");
 var jumperProps = commonComponentProps.extend({
   manufacturerPartNumber: import_zod12.z.string().optional(),
   pinLabels: import_zod12.z.record(import_zod12.z.number().or(import_zod12.z.string()), import_zod12.z.string()).optional(),
   schPinStyle: schematicPinStyle.optional(),
-  schPinSpacing: import_soup7.distance.optional(),
-  schWidth: import_soup7.distance.optional(),
-  schHeight: import_soup7.distance.optional(),
+  schPinSpacing: import_circuit_json7.distance.optional(),
+  schWidth: import_circuit_json7.distance.optional(),
+  schHeight: import_circuit_json7.distance.optional(),
   schDirection: import_zod12.z.enum(["left", "right"]).optional(),
   schPortArrangement: schematicPortArrangement.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/platedhole.ts
+var import_circuit_json8 = require("circuit-json");
 var import_zod13 = require("zod");
-var import_soup8 = require("@tscircuit/soup");
 var platedHoleProps = import_zod13.z.discriminatedUnion("shape", [
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
     name: import_zod13.z.string().optional(),
     shape: import_zod13.z.literal("circle"),
-    holeDiameter: import_soup8.distance,
-    outerDiameter: import_soup8.distance,
+    holeDiameter: import_circuit_json8.distance,
+    outerDiameter: import_circuit_json8.distance,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
     name: import_zod13.z.string().optional(),
     shape: import_zod13.z.literal("oval"),
-    outerWidth: import_soup8.distance,
-    outerHeight: import_soup8.distance,
-    innerWidth: import_soup8.distance,
-    innerHeight: import_soup8.distance,
+    outerWidth: import_circuit_json8.distance,
+    outerHeight: import_circuit_json8.distance,
+    innerWidth: import_circuit_json8.distance,
+    innerHeight: import_circuit_json8.distance,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
     name: import_zod13.z.string().optional(),
     shape: import_zod13.z.literal("pill"),
-    outerWidth: import_soup8.distance,
-    outerHeight: import_soup8.distance,
-    innerWidth: import_soup8.distance,
-    innerHeight: import_soup8.distance,
+    outerWidth: import_circuit_json8.distance,
+    outerHeight: import_circuit_json8.distance,
+    innerWidth: import_circuit_json8.distance,
+    innerHeight: import_circuit_json8.distance,
     portHints: portHints.optional()
   })
 ]);
 expectTypesMatch(true);
 
 // lib/components/resistor.ts
+var import_circuit_json9 = require("circuit-json");
 var import_zod14 = require("zod");
-var import_soup9 = require("@tscircuit/soup");
 var resistorProps = commonComponentProps.extend({
-  resistance: import_soup9.resistance,
+  resistance: import_circuit_json9.resistance,
   pullupFor: import_zod14.z.string().optional(),
   pullupTo: import_zod14.z.string().optional(),
   pulldownFor: import_zod14.z.string().optional(),
@@ -362,10 +364,10 @@ var resistorPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/capacitor.ts
+var import_circuit_json10 = require("circuit-json");
 var import_zod15 = require("zod");
-var import_soup10 = require("@tscircuit/soup");
 var capacitorProps = commonComponentProps.extend({
-  capacitance: import_soup10.capacitance,
+  capacitance: import_circuit_json10.capacitance,
   decouplingFor: import_zod15.z.string().optional(),
   decouplingTo: import_zod15.z.string().optional(),
   bypassFor: import_zod15.z.string().optional(),
@@ -375,7 +377,7 @@ var capacitorPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/group.ts
-var import_soup11 = require("@tscircuit/soup");
+var import_circuit_json11 = require("circuit-json");
 var import_zod16 = require("zod");
 var baseGroupProps = commonLayoutProps.extend({
   name: import_zod16.z.string().optional(),
@@ -387,7 +389,7 @@ var subcircuitGroupProps = baseGroupProps.extend({
   manualEdits: import_zod16.z.custom((v) => true).optional(),
   schAutoLayoutEnabled: import_zod16.z.boolean().optional(),
   routingDisabled: import_zod16.z.boolean().optional(),
-  defaultTraceWidth: import_soup11.length.optional()
+  defaultTraceWidth: import_circuit_json11.length.optional()
 });
 var groupProps = import_zod16.z.union([baseGroupProps, subcircuitGroupProps]);
 expectTypesMatch(true);
@@ -412,13 +414,13 @@ expectTypesMatch(true);
 
 // lib/common/distance.ts
 var import_zod19 = require("zod");
-var import_soup12 = require("@tscircuit/soup");
+var import_circuit_json12 = require("circuit-json");
 
 // lib/components/constraint.ts
 var import_zod20 = require("zod");
 var pcbXDistConstraintProps = import_zod20.z.object({
   pcb: import_zod20.z.literal(true).optional(),
-  xDist: import_soup12.distance,
+  xDist: import_circuit_json12.distance,
   left: import_zod20.z.string(),
   right: import_zod20.z.string(),
   edgeToEdge: import_zod20.z.literal(true).optional(),
@@ -429,7 +431,7 @@ expectTypesMatch(
 );
 var pcbYDistConstraintProps = import_zod20.z.object({
   pcb: import_zod20.z.literal(true).optional(),
-  yDist: import_soup12.distance,
+  yDist: import_circuit_json12.distance,
   top: import_zod20.z.string(),
   bottom: import_zod20.z.string(),
   edgeToEdge: import_zod20.z.literal(true).optional(),
@@ -466,14 +468,14 @@ expectTypesMatch(true);
 var import_zod21 = require("zod");
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod21.z.literal("rect"),
-  width: import_soup12.distance,
-  height: import_soup12.distance,
+  width: import_circuit_json12.distance,
+  height: import_circuit_json12.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod21.z.literal("circle"),
-  radius: import_soup12.distance,
+  radius: import_circuit_json12.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
@@ -484,13 +486,13 @@ expectTypesMatch(true);
 var import_zod22 = require("zod");
 var rectSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod22.z.literal("rect"),
-  width: import_soup12.distance,
-  height: import_soup12.distance
+  width: import_circuit_json12.distance,
+  height: import_circuit_json12.distance
 });
 expectTypesMatch(true);
 var circleSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod22.z.literal("circle"),
-  radius: import_soup12.distance
+  radius: import_circuit_json12.distance
 });
 expectTypesMatch(true);
 var solderPasteProps = import_zod22.z.union([
@@ -503,8 +505,8 @@ expectTypesMatch(true);
 var import_zod23 = require("zod");
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   name: import_zod23.z.string().optional(),
-  diameter: import_soup12.distance.optional(),
-  radius: import_soup12.distance.optional()
+  diameter: import_circuit_json12.distance.optional(),
+  radius: import_circuit_json12.distance.optional()
 }).transform((d) => ({
   ...d,
   diameter: d.diameter ?? 2 * d.radius,
@@ -513,8 +515,8 @@ var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 expectTypesMatch(true);
 
 // lib/components/trace.ts
+var import_circuit_json13 = require("circuit-json");
 var import_zod24 = require("zod");
-var import_soup13 = require("@tscircuit/soup");
 var portRef = import_zod24.z.union([
   import_zod24.z.string(),
   import_zod24.z.custom(
@@ -523,9 +525,9 @@ var portRef = import_zod24.z.union([
 ]);
 var baseTraceProps = import_zod24.z.object({
   key: import_zod24.z.string().optional(),
-  thickness: import_soup13.distance.optional(),
+  thickness: import_circuit_json13.distance.optional(),
   schematicRouteHints: import_zod24.z.array(point).optional(),
-  pcbRouteHints: import_zod24.z.array(import_soup13.route_hint_point).optional()
+  pcbRouteHints: import_zod24.z.array(import_circuit_json13.route_hint_point).optional()
 });
 var traceProps = import_zod24.z.union([
   baseTraceProps.extend({
@@ -538,10 +540,10 @@ var traceProps = import_zod24.z.union([
 ]);
 
 // lib/components/footprint.ts
-var import_soup14 = require("@tscircuit/soup");
+var import_circuit_json14 = require("circuit-json");
 var import_zod25 = require("zod");
 var footprintProps = import_zod25.z.object({
-  originalLayer: import_soup14.layer_ref.default("top").optional()
+  originalLayer: import_circuit_json14.layer_ref.default("top").optional()
 });
 expectTypesMatch(true);
 
@@ -565,23 +567,23 @@ var batteryPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/pin-header.ts
+var import_circuit_json15 = require("circuit-json");
 var import_zod27 = require("zod");
-var import_soup15 = require("@tscircuit/soup");
 var pinHeaderProps = commonComponentProps.extend({
   pinCount: import_zod27.z.number(),
-  pitch: import_soup15.distance.optional(),
+  pitch: import_circuit_json15.distance.optional(),
   gender: import_zod27.z.enum(["male", "female"]).optional(),
   showSilkscreenPinLabels: import_zod27.z.boolean().optional(),
   doubleRow: import_zod27.z.boolean().optional(),
-  holeDiameter: import_soup15.distance.optional(),
-  platedDiameter: import_soup15.distance.optional(),
+  holeDiameter: import_circuit_json15.distance.optional(),
+  platedDiameter: import_circuit_json15.distance.optional(),
   pinLabels: import_zod27.z.array(import_zod27.z.string()).optional()
 });
 expectTypesMatch(true);
 
 // lib/index.ts
 var inductorProps = commonComponentProps.extend({
-  inductance: import_soup16.inductance
+  inductance: import_circuit_json16.inductance
 });
 var inductorPins = lrPins;
 var diodeProps = commonComponentProps.extend({});
@@ -595,12 +597,12 @@ var switchProps = commonComponentProps.extend({
   switchType: import_zod28.z.enum(["spst"]).default("spst"),
   isNormallyClosed: import_zod28.z.boolean().default(false)
 });
-var distanceOrMultiplier2 = import_soup16.distance.or(import_zod28.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier2 = import_circuit_json16.distance.or(import_zod28.z.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
-  fromLayer: import_soup16.layer_ref,
-  toLayer: import_soup16.layer_ref,
-  holeDiameter: import_soup16.distance,
-  outerDiameter: import_soup16.distance
+  fromLayer: import_circuit_json16.layer_ref,
+  toLayer: import_circuit_json16.layer_ref,
+  holeDiameter: import_circuit_json16.distance,
+  outerDiameter: import_circuit_json16.distance
 });
 var netAliasProps = commonLayoutProps.extend({
   net: import_zod28.z.string().optional()
@@ -608,39 +610,39 @@ var netAliasProps = commonLayoutProps.extend({
 var pcbKeepoutProps = import_zod28.z.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
     shape: import_zod28.z.literal("circle"),
-    radius: import_soup16.distance
+    radius: import_circuit_json16.distance
   }),
   pcbLayoutProps.extend({
     shape: import_zod28.z.literal("rect"),
-    width: import_soup16.distance,
-    height: import_soup16.distance
+    width: import_circuit_json16.distance,
+    height: import_circuit_json16.distance
   })
 ]);
 var schematicBoxProps = import_zod28.z.object({
-  schX: import_soup16.distance,
-  schY: import_soup16.distance,
-  width: import_soup16.distance,
-  height: import_soup16.distance
+  schX: import_circuit_json16.distance,
+  schY: import_circuit_json16.distance,
+  width: import_circuit_json16.distance,
+  height: import_circuit_json16.distance
 });
 var schematicTextProps = import_zod28.z.object({
-  schX: import_soup16.distance,
-  schY: import_soup16.distance,
+  schX: import_circuit_json16.distance,
+  schY: import_circuit_json16.distance,
   text: import_zod28.z.string()
 });
 var schematicLineProps = import_zod28.z.object({
-  x1: import_soup16.distance,
-  y1: import_soup16.distance,
-  x2: import_soup16.distance,
-  y2: import_soup16.distance
+  x1: import_circuit_json16.distance,
+  y1: import_circuit_json16.distance,
+  x2: import_circuit_json16.distance,
+  y2: import_circuit_json16.distance
 });
 var schematicPathProps = import_zod28.z.object({
-  points: import_zod28.z.array(import_soup16.point),
+  points: import_zod28.z.array(import_circuit_json16.point),
   isFilled: import_zod28.z.boolean().optional().default(false),
   fillColor: import_zod28.z.enum(["red", "blue"]).optional()
 });
 var componentProps = commonComponentProps;
 var powerSourceProps = commonComponentProps.extend({
-  voltage: import_soup16.voltage
+  voltage: import_circuit_json16.voltage
 });
 var portProps = commonLayoutProps.extend({
   name: import_zod28.z.string(),
@@ -652,62 +654,62 @@ var silkscreenTextProps = pcbLayoutProps.extend({
   text: import_zod28.z.string(),
   anchorAlignment: import_zod28.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
   font: import_zod28.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup16.length.optional()
+  fontSize: import_circuit_json16.length.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod28.z.array(import_soup16.route_hint_point),
-  strokeWidth: import_soup16.length.optional()
+  route: import_zod28.z.array(import_circuit_json16.route_hint_point),
+  strokeWidth: import_circuit_json16.length.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: import_soup16.distance,
-  x1: import_soup16.distance,
-  y1: import_soup16.distance,
-  x2: import_soup16.distance,
-  y2: import_soup16.distance
+  strokeWidth: import_circuit_json16.distance,
+  x1: import_circuit_json16.distance,
+  y1: import_circuit_json16.distance,
+  x2: import_circuit_json16.distance,
+  y2: import_circuit_json16.distance
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   isFilled: import_zod28.z.boolean().optional(),
   isOutline: import_zod28.z.boolean().optional(),
-  strokeWidth: import_soup16.distance.optional(),
-  width: import_soup16.distance,
-  height: import_soup16.distance
+  strokeWidth: import_circuit_json16.distance.optional(),
+  width: import_circuit_json16.distance,
+  height: import_circuit_json16.distance
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   isFilled: import_zod28.z.boolean().optional(),
   isOutline: import_zod28.z.boolean().optional(),
-  strokeWidth: import_soup16.distance.optional(),
-  radius: import_soup16.distance
+  strokeWidth: import_circuit_json16.distance.optional(),
+  radius: import_circuit_json16.distance
 });
 var routeHintPointProps = import_zod28.z.object({
-  x: import_soup16.distance,
-  y: import_soup16.distance,
+  x: import_circuit_json16.distance,
+  y: import_circuit_json16.distance,
   via: import_zod28.z.boolean().optional(),
-  toLayer: import_soup16.layer_ref.optional()
+  toLayer: import_circuit_json16.layer_ref.optional()
 });
 var traceHintProps = import_zod28.z.object({
   for: import_zod28.z.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
   order: import_zod28.z.number().optional(),
-  offset: import_soup16.route_hint_point.or(routeHintPointProps).optional(),
-  offsets: import_zod28.z.array(import_soup16.route_hint_point).or(import_zod28.z.array(routeHintPointProps)).optional(),
+  offset: import_circuit_json16.route_hint_point.or(routeHintPointProps).optional(),
+  offsets: import_zod28.z.array(import_circuit_json16.route_hint_point).or(import_zod28.z.array(routeHintPointProps)).optional(),
   traceWidth: import_zod28.z.number().optional()
 });
 var pcbTraceProps = import_zod28.z.object({
   layer: import_zod28.z.string().optional(),
-  thickness: import_soup16.distance.optional(),
-  route: import_zod28.z.array(import_soup16.route_hint_point)
+  thickness: import_circuit_json16.distance.optional(),
+  route: import_zod28.z.array(import_circuit_json16.route_hint_point)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
   text: import_zod28.z.string(),
   anchorAlignment: import_zod28.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
   font: import_zod28.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup16.length.optional(),
+  fontSize: import_circuit_json16.length.optional(),
   color: import_zod28.z.string().optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod28.z.array(import_soup16.route_hint_point),
-  strokeWidth: import_soup16.length.optional(),
+  route: import_zod28.z.array(import_circuit_json16.route_hint_point),
+  strokeWidth: import_circuit_json16.length.optional(),
   color: import_zod28.z.string().optional()
 });
 // Annotate the CommonJS export names for ESM import in node: