easyeda 0.0.27 → 0.0.29

package/dist/cli/main.cjs

@@ -2525,6 +2525,76 @@ var require_lib = __commonJS({
   }
 });
 
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet;
+var init_url_alphabet = __esm({
+  "node_modules/nanoid/url-alphabet/index.js"() {
+    "use strict";
+    urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+  }
+});
+
+// node_modules/nanoid/index.js
+var nanoid_exports = {};
+__export(nanoid_exports, {
+  customAlphabet: () => customAlphabet,
+  customRandom: () => customRandom,
+  nanoid: () => nanoid,
+  random: () => random,
+  urlAlphabet: () => urlAlphabet
+});
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function random(bytes) {
+  fillPool(bytes -= 0);
+  return pool.subarray(poolOffset - bytes, poolOffset);
+}
+function customRandom(alphabet, defaultSize, getRandom) {
+  let mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+  let step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+  return (size = defaultSize) => {
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || "";
+        if (id.length === size) return id;
+      }
+    }
+  };
+}
+function customAlphabet(alphabet, size = 21) {
+  return customRandom(alphabet, size, random);
+}
+function nanoid(size = 21) {
+  fillPool(size -= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+var import_node_crypto, POOL_SIZE_MULTIPLIER, pool, poolOffset;
+var init_nanoid = __esm({
+  "node_modules/nanoid/index.js"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    init_url_alphabet();
+    init_url_alphabet();
+    POOL_SIZE_MULTIPLIER = 128;
+  }
+});
+
 // node_modules/@tscircuit/soup/dist/index.js
 var require_dist = __commonJS({
   "node_modules/@tscircuit/soup/dist/index.js"(exports2, module2) {
@@ -2559,6 +2629,7 @@ var require_dist = __commonJS({
     var src_exports = {};
     __export2(src_exports, {
       all_layers: () => all_layers,
+      any_circuit_element: () => any_circuit_element,
       any_soup_element: () => any_soup_element,
       any_source_component: () => any_source_component2,
       cad_component: () => cad_component2,
@@ -2574,6 +2645,7 @@ var require_dist = __commonJS({
       pcb_fabrication_note_path: () => pcb_fabrication_note_path,
       pcb_fabrication_note_text: () => pcb_fabrication_note_text,
       pcb_hole: () => pcb_hole,
+      pcb_keepout: () => pcb_keepout,
       pcb_placement_error: () => pcb_placement_error,
       pcb_plated_hole: () => pcb_plated_hole2,
       pcb_port: () => pcb_port,
@@ -2582,6 +2654,7 @@ var require_dist = __commonJS({
       pcb_route_hints: () => pcb_route_hints,
       pcb_silkscreen_circle: () => pcb_silkscreen_circle,
       pcb_silkscreen_line: () => pcb_silkscreen_line,
+      pcb_silkscreen_oval: () => pcb_silkscreen_oval,
       pcb_silkscreen_path: () => pcb_silkscreen_path2,
       pcb_silkscreen_rect: () => pcb_silkscreen_rect,
       pcb_silkscreen_text: () => pcb_silkscreen_text,
@@ -2604,6 +2677,7 @@ var require_dist = __commonJS({
       schematic_line: () => schematic_line,
       schematic_net_label: () => schematic_net_label,
       schematic_path: () => schematic_path,
+      schematic_pin_styles: () => schematic_pin_styles,
       schematic_port: () => schematic_port,
       schematic_text: () => schematic_text,
       schematic_trace: () => schematic_trace,
@@ -2615,6 +2689,7 @@ var require_dist = __commonJS({
       source_port: () => source_port,
       source_simple_bug: () => source_simple_bug,
       source_simple_capacitor: () => source_simple_capacitor,
+      source_simple_chip: () => source_simple_chip,
       source_simple_diode: () => source_simple_diode,
       source_simple_ground: () => source_simple_ground,
       source_simple_power_source: () => source_simple_power_source,
@@ -2720,7 +2795,17 @@ var require_dist = __commonJS({
     var distance = length;
     var current = import_zod6.z.string().or(import_zod6.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
     var time = import_zod6.z.string().or(import_zod6.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-    var rotation = import_zod6.z.string().or(import_zod6.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+    var rotation = import_zod6.z.string().or(import_zod6.z.number()).transform((arg) => {
+      if (typeof arg === "number")
+        return arg;
+      if (arg.endsWith("deg")) {
+        return Number.parseFloat(arg.split("deg")[0]);
+      }
+      if (arg.endsWith("rad")) {
+        return Number.parseFloat(arg.split("rad")[0]) * 180 / Math.PI;
+      }
+      return Number.parseFloat(arg);
+    });
     var import_zod22 = require("zod");
     var point = import_zod22.z.object({
       x: distance,
@@ -2755,7 +2840,7 @@ var require_dist = __commonJS({
       ftype: import_zod62.z.string().optional(),
       source_component_id: import_zod62.z.string(),
       name: import_zod62.z.string(),
-      // part_numbers: z.array(z.string()).optional(),
+      manufacturer_part_number: import_zod62.z.string().optional(),
       supplier_part_numbers: import_zod62.z.record(supplier_name, import_zod62.z.array(import_zod62.z.string())).optional()
     });
     var source_simple_capacitor = source_component_base.extend({
@@ -2778,187 +2863,203 @@ var require_dist = __commonJS({
     var import_zod11 = require("zod");
     var source_simple_bug = source_component_base.extend({
       ftype: import_zod11.z.literal("simple_bug")
-    });
+    }).describe("@deprecated");
     var import_zod12 = require("zod");
+    var source_simple_chip = source_component_base.extend({
+      ftype: import_zod12.z.literal("simple_chip")
+    });
+    var import_zod13 = require("zod");
     var source_simple_inductor = source_component_base.extend({
-      ftype: import_zod12.z.literal("simple_inductor"),
+      ftype: import_zod13.z.literal("simple_inductor"),
       inductance
     });
-    var import_zod13 = require("zod");
+    var import_zod14 = require("zod");
     var source_led = source_simple_diode.extend({
-      ftype: import_zod13.z.literal("led")
+      ftype: import_zod14.z.literal("led")
     });
-    var import_zod14 = require("zod");
+    var import_zod15 = require("zod");
     var source_simple_power_source = source_component_base.extend({
-      ftype: import_zod14.z.literal("simple_power_source"),
+      ftype: import_zod15.z.literal("simple_power_source"),
       voltage
     });
-    var import_zod15 = require("zod");
-    var any_source_component2 = import_zod15.z.union([
+    var import_zod16 = require("zod");
+    var any_source_component2 = import_zod16.z.union([
       source_simple_resistor,
       source_simple_capacitor,
       source_simple_diode,
       source_simple_ground,
+      source_simple_chip,
       source_simple_bug,
       source_led,
       source_simple_power_source
     ]);
-    var import_zod16 = require("zod");
-    var source_port = import_zod16.z.object({
-      type: import_zod16.z.literal("source_port"),
-      pin_number: import_zod16.z.number().optional(),
-      port_hints: import_zod16.z.array(import_zod16.z.string()).optional(),
-      name: import_zod16.z.string(),
-      source_port_id: import_zod16.z.string(),
-      source_component_id: import_zod16.z.string()
-    });
     var import_zod17 = require("zod");
-    var source_trace = import_zod17.z.object({
-      type: import_zod17.z.literal("source_trace"),
-      source_trace_id: import_zod17.z.string(),
-      connected_source_port_ids: import_zod17.z.array(import_zod17.z.string()),
-      connected_source_net_ids: import_zod17.z.array(import_zod17.z.string())
+    var source_port = import_zod17.z.object({
+      type: import_zod17.z.literal("source_port"),
+      pin_number: import_zod17.z.number().optional(),
+      port_hints: import_zod17.z.array(import_zod17.z.string()).optional(),
+      name: import_zod17.z.string(),
+      source_port_id: import_zod17.z.string(),
+      source_component_id: import_zod17.z.string()
     });
     var import_zod18 = require("zod");
-    var source_group = import_zod18.z.object({
-      type: import_zod18.z.literal("source_group"),
-      source_group_id: import_zod18.z.string(),
-      name: import_zod18.z.string().optional()
+    var source_trace = import_zod18.z.object({
+      type: import_zod18.z.literal("source_trace"),
+      source_trace_id: import_zod18.z.string(),
+      connected_source_port_ids: import_zod18.z.array(import_zod18.z.string()),
+      connected_source_net_ids: import_zod18.z.array(import_zod18.z.string())
     });
     var import_zod19 = require("zod");
-    var source_net = import_zod19.z.object({
-      type: import_zod19.z.literal("source_net"),
-      source_net_id: import_zod19.z.string(),
-      name: import_zod19.z.string(),
-      member_source_group_ids: import_zod19.z.array(import_zod19.z.string()),
-      is_power: import_zod19.z.boolean().optional(),
-      is_ground: import_zod19.z.boolean().optional(),
-      is_digital_signal: import_zod19.z.boolean().optional(),
-      is_analog_signal: import_zod19.z.boolean().optional()
+    var source_group = import_zod19.z.object({
+      type: import_zod19.z.literal("source_group"),
+      source_group_id: import_zod19.z.string(),
+      name: import_zod19.z.string().optional()
     });
     var import_zod20 = require("zod");
-    var schematic_box = import_zod20.z.object({
-      type: import_zod20.z.literal("schematic_box"),
-      schematic_component_id: import_zod20.z.string(),
+    var source_net = import_zod20.z.object({
+      type: import_zod20.z.literal("source_net"),
+      source_net_id: import_zod20.z.string(),
+      name: import_zod20.z.string(),
+      member_source_group_ids: import_zod20.z.array(import_zod20.z.string()),
+      is_power: import_zod20.z.boolean().optional(),
+      is_ground: import_zod20.z.boolean().optional(),
+      is_digital_signal: import_zod20.z.boolean().optional(),
+      is_analog_signal: import_zod20.z.boolean().optional(),
+      trace_width: import_zod20.z.number().optional()
+    });
+    var import_zod21 = require("zod");
+    var schematic_box = import_zod21.z.object({
+      type: import_zod21.z.literal("schematic_box"),
+      schematic_component_id: import_zod21.z.string(),
       width: distance,
       height: distance,
       x: distance,
       y: distance
     }).describe("Draws a box on the schematic");
-    var import_zod21 = require("zod");
-    var schematic_path = import_zod21.z.object({
-      type: import_zod21.z.literal("schematic_path"),
-      schematic_component_id: import_zod21.z.string(),
-      fill_color: import_zod21.z.enum(["red", "blue"]).optional(),
-      is_filled: import_zod21.z.boolean().optional(),
-      points: import_zod21.z.array(point)
-    });
     var import_zod222 = require("zod");
-    var schematic_component = import_zod222.z.object({
-      type: import_zod222.z.literal("schematic_component"),
+    var schematic_path = import_zod222.z.object({
+      type: import_zod222.z.literal("schematic_path"),
+      schematic_component_id: import_zod222.z.string(),
+      fill_color: import_zod222.z.enum(["red", "blue"]).optional(),
+      is_filled: import_zod222.z.boolean().optional(),
+      points: import_zod222.z.array(point)
+    });
+    var import_zod23 = require("zod");
+    var schematic_pin_styles = import_zod23.z.record(
+      import_zod23.z.object({
+        left_margin: length.optional(),
+        right_margin: length.optional(),
+        top_margin: length.optional(),
+        bottom_margin: length.optional()
+      })
+    );
+    var schematic_component = import_zod23.z.object({
+      type: import_zod23.z.literal("schematic_component"),
       rotation: rotation.default(0),
       size,
       center: point,
-      source_component_id: import_zod222.z.string(),
-      schematic_component_id: import_zod222.z.string(),
+      source_component_id: import_zod23.z.string(),
+      schematic_component_id: import_zod23.z.string(),
       pin_spacing: length.optional(),
+      pin_styles: schematic_pin_styles.optional(),
       box_width: length.optional(),
-      port_arrangement: import_zod222.z.union([
-        import_zod222.z.object({
-          left_size: import_zod222.z.number(),
-          right_size: import_zod222.z.number(),
-          top_size: import_zod222.z.number().optional(),
-          bottom_size: import_zod222.z.number().optional()
+      symbol_name: import_zod23.z.string().optional(),
+      port_arrangement: import_zod23.z.union([
+        import_zod23.z.object({
+          left_size: import_zod23.z.number(),
+          right_size: import_zod23.z.number(),
+          top_size: import_zod23.z.number().optional(),
+          bottom_size: import_zod23.z.number().optional()
         }),
-        import_zod222.z.object({
-          left_side: import_zod222.z.object({
-            pins: import_zod222.z.array(import_zod222.z.number()),
-            direction: import_zod222.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+        import_zod23.z.object({
+          left_side: import_zod23.z.object({
+            pins: import_zod23.z.array(import_zod23.z.number()),
+            direction: import_zod23.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
           }).optional(),
-          right_side: import_zod222.z.object({
-            pins: import_zod222.z.array(import_zod222.z.number()),
-            direction: import_zod222.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+          right_side: import_zod23.z.object({
+            pins: import_zod23.z.array(import_zod23.z.number()),
+            direction: import_zod23.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
           }).optional(),
-          top_side: import_zod222.z.object({
-            pins: import_zod222.z.array(import_zod222.z.number()),
-            direction: import_zod222.z.enum(["left-to-right", "right-to-left"]).optional()
+          top_side: import_zod23.z.object({
+            pins: import_zod23.z.array(import_zod23.z.number()),
+            direction: import_zod23.z.enum(["left-to-right", "right-to-left"]).optional()
           }).optional(),
-          bottom_side: import_zod222.z.object({
-            pins: import_zod222.z.array(import_zod222.z.number()),
-            direction: import_zod222.z.enum(["left-to-right", "right-to-left"]).optional()
+          bottom_side: import_zod23.z.object({
+            pins: import_zod23.z.array(import_zod23.z.number()),
+            direction: import_zod23.z.enum(["left-to-right", "right-to-left"]).optional()
           }).optional()
         })
       ]).optional(),
-      port_labels: import_zod222.z.record(import_zod222.z.string()).optional()
+      port_labels: import_zod23.z.record(import_zod23.z.string()).optional()
     });
-    var import_zod23 = require("zod");
-    var schematic_line = import_zod23.z.object({
-      type: import_zod23.z.literal("schematic_line"),
-      schematic_component_id: import_zod23.z.string(),
+    var import_zod24 = require("zod");
+    var schematic_line = import_zod24.z.object({
+      type: import_zod24.z.literal("schematic_line"),
+      schematic_component_id: import_zod24.z.string(),
       x1: distance,
       x2: distance,
       y1: distance,
       y2: distance
     });
-    var import_zod24 = require("zod");
-    var schematic_trace = import_zod24.z.object({
-      type: import_zod24.z.literal("schematic_trace"),
-      schematic_trace_id: import_zod24.z.string(),
-      source_trace_id: import_zod24.z.string(),
-      edges: import_zod24.z.array(
-        import_zod24.z.object({
-          from: import_zod24.z.object({
-            x: import_zod24.z.number(),
-            y: import_zod24.z.number()
+    var import_zod25 = require("zod");
+    var schematic_trace = import_zod25.z.object({
+      type: import_zod25.z.literal("schematic_trace"),
+      schematic_trace_id: import_zod25.z.string(),
+      source_trace_id: import_zod25.z.string(),
+      edges: import_zod25.z.array(
+        import_zod25.z.object({
+          from: import_zod25.z.object({
+            x: import_zod25.z.number(),
+            y: import_zod25.z.number()
           }),
-          to: import_zod24.z.object({
-            x: import_zod24.z.number(),
-            y: import_zod24.z.number()
+          to: import_zod25.z.object({
+            x: import_zod25.z.number(),
+            y: import_zod25.z.number()
           }),
-          from_schematic_port_id: import_zod24.z.string().optional(),
-          to_schematic_port_id: import_zod24.z.string().optional()
+          from_schematic_port_id: import_zod25.z.string().optional(),
+          to_schematic_port_id: import_zod25.z.string().optional()
         })
       )
     });
-    var import_zod25 = require("zod");
-    var schematic_text = import_zod25.z.object({
-      type: import_zod25.z.literal("schematic_text"),
-      schematic_component_id: import_zod25.z.string(),
-      schematic_text_id: import_zod25.z.string(),
-      text: import_zod25.z.string(),
-      position: import_zod25.z.object({
+    var import_zod26 = require("zod");
+    var schematic_text = import_zod26.z.object({
+      type: import_zod26.z.literal("schematic_text"),
+      schematic_component_id: import_zod26.z.string(),
+      schematic_text_id: import_zod26.z.string(),
+      text: import_zod26.z.string(),
+      position: import_zod26.z.object({
         x: distance,
         y: distance
       }),
-      rotation: import_zod25.z.number().default(0),
-      anchor: import_zod25.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
+      rotation: import_zod26.z.number().default(0),
+      anchor: import_zod26.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
     });
-    var import_zod26 = require("zod");
-    var schematic_port = import_zod26.z.object({
-      type: import_zod26.z.literal("schematic_port"),
-      schematic_port_id: import_zod26.z.string(),
-      source_port_id: import_zod26.z.string(),
-      schematic_component_id: import_zod26.z.string().optional(),
+    var import_zod27 = require("zod");
+    var schematic_port = import_zod27.z.object({
+      type: import_zod27.z.literal("schematic_port"),
+      schematic_port_id: import_zod27.z.string(),
+      source_port_id: import_zod27.z.string(),
+      schematic_component_id: import_zod27.z.string().optional(),
       center: point,
-      facing_direction: import_zod26.z.enum(["up", "down", "left", "right"]).optional()
+      facing_direction: import_zod27.z.enum(["up", "down", "left", "right"]).optional()
     }).describe("Defines a port on a schematic component");
-    var import_zod27 = require("zod");
-    var schematic_net_label = import_zod27.z.object({
-      type: import_zod27.z.literal("schematic_net_label"),
-      source_net_id: import_zod27.z.string(),
+    var import_zod28 = require("zod");
+    var schematic_net_label = import_zod28.z.object({
+      type: import_zod28.z.literal("schematic_net_label"),
+      source_net_id: import_zod28.z.string(),
       center: point,
-      anchor_side: import_zod27.z.enum(["top", "bottom", "left", "right"]),
-      text: import_zod27.z.string()
+      anchor_side: import_zod28.z.enum(["top", "bottom", "left", "right"]),
+      text: import_zod28.z.string()
     });
-    var import_zod28 = require("zod");
-    var schematic_error = import_zod28.z.object({
-      schematic_error_id: import_zod28.z.string(),
-      type: import_zod28.z.literal("schematic_error"),
+    var import_zod29 = require("zod");
+    var schematic_error = import_zod29.z.object({
+      schematic_error_id: import_zod29.z.string(),
+      type: import_zod29.z.literal("schematic_error"),
       // eventually each error type should be broken out into a dir of files
-      error_type: import_zod28.z.literal("schematic_port_not_found"),
-      message: import_zod28.z.string()
+      error_type: import_zod29.z.literal("schematic_port_not_found"),
+      message: import_zod29.z.string()
     }).describe("Defines a schematic error on the schematic");
-    var import_zod29 = require("zod");
+    var import_zod30 = require("zod");
     var all_layers = [
       "top",
       "bottom",
@@ -2969,9 +3070,9 @@ var require_dist = __commonJS({
       "inner5",
       "inner6"
     ];
-    var layer_string = import_zod29.z.enum(all_layers);
+    var layer_string = import_zod30.z.enum(all_layers);
     var layer_ref = layer_string.or(
-      import_zod29.z.object({
+      import_zod30.z.object({
         name: layer_string
       })
     ).transform((layer) => {
@@ -2980,176 +3081,196 @@ var require_dist = __commonJS({
       }
       return layer.name;
     });
-    var visible_layer = import_zod29.z.enum(["top", "bottom"]);
-    var import_zod30 = require("zod");
-    var pcb_route_hint = import_zod30.z.object({
+    var visible_layer = import_zod30.z.enum(["top", "bottom"]);
+    var import_zod31 = require("zod");
+    var pcb_route_hint = import_zod31.z.object({
       x: distance,
       y: distance,
-      via: import_zod30.z.boolean().optional(),
+      via: import_zod31.z.boolean().optional(),
       via_to_layer: layer_ref.optional()
     });
-    var pcb_route_hints = import_zod30.z.array(pcb_route_hint);
-    var import_zod31 = require("zod");
-    var route_hint_point = import_zod31.z.object({
+    var pcb_route_hints = import_zod31.z.array(pcb_route_hint);
+    var import_zod322 = require("zod");
+    var route_hint_point = import_zod322.z.object({
       x: distance,
       y: distance,
-      via: import_zod31.z.boolean().optional(),
-      to_layer: layer_ref.optional()
+      via: import_zod322.z.boolean().optional(),
+      to_layer: layer_ref.optional(),
+      trace_width: distance.optional()
     });
-    var import_zod322 = require("zod");
-    var pcb_component2 = import_zod322.z.object({
-      type: import_zod322.z.literal("pcb_component"),
-      pcb_component_id: import_zod322.z.string(),
-      source_component_id: import_zod322.z.string(),
+    var import_zod34 = require("zod");
+    var import_zod33 = require("zod");
+    var import_nanoid = (init_nanoid(), __toCommonJS(nanoid_exports));
+    var getZodPrefixedIdWithDefault = (prefix) => {
+      return import_zod33.z.string().optional().default(() => `${prefix}_${(0, import_nanoid.nanoid)(10)}`);
+    };
+    var expectTypesMatch = (shouldBe) => {
+    };
+    var pcb_component2 = import_zod34.z.object({
+      type: import_zod34.z.literal("pcb_component"),
+      pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
+      source_component_id: import_zod34.z.string(),
       center: point,
       layer: layer_ref,
       rotation,
       width: length,
       height: length
     }).describe("Defines a component on the PCB");
-    var import_zod33 = require("zod");
-    var pcb_hole = import_zod33.z.object({
-      type: import_zod33.z.literal("pcb_hole"),
-      hole_shape: import_zod33.z.enum(["round", "square"]).default("round"),
-      hole_diameter: import_zod33.z.number(),
+    expectTypesMatch(true);
+    var import_zod35 = require("zod");
+    var pcb_hole = import_zod35.z.object({
+      pcb_hole_id: import_zod35.z.string(),
+      type: import_zod35.z.literal("pcb_hole"),
+      hole_shape: import_zod35.z.enum(["circle", "square", "round"]).default("circle").transform((shape) => {
+        if (shape === "round")
+          return "circle";
+        return shape;
+      }),
+      hole_diameter: import_zod35.z.number(),
       x: distance,
       y: distance
     }).or(
-      import_zod33.z.object({
-        type: import_zod33.z.literal("pcb_hole"),
-        hole_shape: import_zod33.z.literal("oval"),
-        hole_width: import_zod33.z.number(),
-        hole_height: import_zod33.z.number(),
+      import_zod35.z.object({
+        pcb_hole_id: import_zod35.z.string(),
+        type: import_zod35.z.literal("pcb_hole"),
+        hole_shape: import_zod35.z.literal("oval"),
+        hole_width: import_zod35.z.number(),
+        hole_height: import_zod35.z.number(),
         x: distance,
         y: distance
       })
     ).describe("Defines a hole on the PCB");
-    var import_zod34 = require("zod");
-    var pcb_plated_hole2 = import_zod34.z.object({
-      type: import_zod34.z.literal("pcb_plated_hole"),
-      shape: import_zod34.z.literal("circle"),
-      outer_diameter: import_zod34.z.number(),
-      hole_diameter: import_zod34.z.number(),
+    var import_zod36 = require("zod");
+    var pcb_plated_hole2 = import_zod36.z.object({
+      type: import_zod36.z.literal("pcb_plated_hole"),
+      shape: import_zod36.z.literal("circle"),
+      outer_diameter: import_zod36.z.number(),
+      hole_diameter: import_zod36.z.number(),
       x: distance,
       y: distance,
-      layers: import_zod34.z.array(layer_ref),
-      port_hints: import_zod34.z.array(import_zod34.z.string()).optional(),
-      pcb_component_id: import_zod34.z.string().optional(),
-      pcb_port_id: import_zod34.z.string().optional()
+      layers: import_zod36.z.array(layer_ref),
+      port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
+      pcb_component_id: import_zod36.z.string().optional(),
+      pcb_port_id: import_zod36.z.string().optional(),
+      pcb_plated_hole_id: import_zod36.z.string()
     }).or(
-      import_zod34.z.object({
-        type: import_zod34.z.literal("pcb_plated_hole"),
-        shape: import_zod34.z.enum(["oval", "pill"]),
-        outer_width: import_zod34.z.number(),
-        outer_height: import_zod34.z.number(),
-        hole_width: import_zod34.z.number(),
-        hole_height: import_zod34.z.number(),
+      import_zod36.z.object({
+        type: import_zod36.z.literal("pcb_plated_hole"),
+        shape: import_zod36.z.enum(["oval", "pill"]),
+        outer_width: import_zod36.z.number(),
+        outer_height: import_zod36.z.number(),
+        hole_width: import_zod36.z.number(),
+        hole_height: import_zod36.z.number(),
         x: distance,
         y: distance,
-        layers: import_zod34.z.array(layer_ref),
-        port_hints: import_zod34.z.array(import_zod34.z.string()).optional(),
-        pcb_component_id: import_zod34.z.string().optional(),
-        pcb_port_id: import_zod34.z.string().optional()
+        layers: import_zod36.z.array(layer_ref),
+        port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
+        pcb_component_id: import_zod36.z.string().optional(),
+        pcb_port_id: import_zod36.z.string().optional(),
+        pcb_plated_hole_id: import_zod36.z.string()
       })
     ).describe("Defines a plated hole on the PCB");
-    var import_zod35 = require("zod");
-    var pcb_port = import_zod35.z.object({
-      type: import_zod35.z.literal("pcb_port"),
-      pcb_port_id: import_zod35.z.string(),
-      source_port_id: import_zod35.z.string(),
-      pcb_component_id: import_zod35.z.string(),
+    var import_zod37 = require("zod");
+    var pcb_port = import_zod37.z.object({
+      type: import_zod37.z.literal("pcb_port"),
+      pcb_port_id: import_zod37.z.string(),
+      source_port_id: import_zod37.z.string(),
+      pcb_component_id: import_zod37.z.string(),
       x: distance,
       y: distance,
-      layers: import_zod35.z.array(layer_ref)
+      layers: import_zod37.z.array(layer_ref)
     }).describe("Defines a port on the PCB");
-    var import_zod36 = require("zod");
-    var pcb_smtpad2 = import_zod36.z.union([
-      import_zod36.z.object({
-        pcb_smtpad_id: import_zod36.z.string(),
-        type: import_zod36.z.literal("pcb_smtpad"),
-        shape: import_zod36.z.literal("circle"),
+    var import_zod38 = require("zod");
+    var pcb_smtpad2 = import_zod38.z.union([
+      import_zod38.z.object({
+        pcb_smtpad_id: import_zod38.z.string(),
+        type: import_zod38.z.literal("pcb_smtpad"),
+        shape: import_zod38.z.literal("circle"),
         x: distance,
         y: distance,
-        radius: import_zod36.z.number(),
+        radius: import_zod38.z.number(),
         layer: layer_ref,
-        port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
-        pcb_component_id: import_zod36.z.string().optional(),
-        pcb_port_id: import_zod36.z.string().optional()
+        port_hints: import_zod38.z.array(import_zod38.z.string()).optional(),
+        pcb_component_id: import_zod38.z.string().optional(),
+        pcb_port_id: import_zod38.z.string().optional()
       }),
-      import_zod36.z.object({
-        pcb_smtpad_id: import_zod36.z.string(),
-        type: import_zod36.z.literal("pcb_smtpad"),
-        shape: import_zod36.z.literal("rect"),
+      import_zod38.z.object({
+        pcb_smtpad_id: import_zod38.z.string(),
+        type: import_zod38.z.literal("pcb_smtpad"),
+        shape: import_zod38.z.literal("rect"),
         x: distance,
         y: distance,
-        width: import_zod36.z.number(),
-        height: import_zod36.z.number(),
+        width: import_zod38.z.number(),
+        height: import_zod38.z.number(),
         layer: layer_ref,
-        port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
-        pcb_component_id: import_zod36.z.string().optional(),
-        pcb_port_id: import_zod36.z.string().optional()
+        port_hints: import_zod38.z.array(import_zod38.z.string()).optional(),
+        pcb_component_id: import_zod38.z.string().optional(),
+        pcb_port_id: import_zod38.z.string().optional()
       })
     ]).describe("Defines an SMT pad on the PCB");
-    var import_zod37 = require("zod");
-    var pcb_text = import_zod37.z.object({
-      type: import_zod37.z.literal("pcb_text"),
-      text: import_zod37.z.string(),
+    var import_zod39 = require("zod");
+    var pcb_text = import_zod39.z.object({
+      type: import_zod39.z.literal("pcb_text"),
+      text: import_zod39.z.string(),
       x: distance,
       y: distance,
-      align: import_zod37.z.enum(["bottom-left"]),
+      align: import_zod39.z.enum(["bottom-left"]),
       width: distance,
       height: distance,
-      lines: import_zod37.z.number()
+      lines: import_zod39.z.number()
     }).describe("Defines text on the PCB");
-    var import_zod38 = require("zod");
-    var pcb_trace = import_zod38.z.object({
-      type: import_zod38.z.literal("pcb_trace"),
-      source_trace_id: import_zod38.z.string().optional(),
-      pcb_component_id: import_zod38.z.string().optional(),
-      pcb_trace_id: import_zod38.z.string(),
-      route: import_zod38.z.array(
-        import_zod38.z.union([
-          import_zod38.z.object({
-            route_type: import_zod38.z.literal("wire"),
+    var import_zod40 = require("zod");
+    var pcb_trace = import_zod40.z.object({
+      type: import_zod40.z.literal("pcb_trace"),
+      source_trace_id: import_zod40.z.string().optional(),
+      pcb_component_id: import_zod40.z.string().optional(),
+      pcb_trace_id: import_zod40.z.string(),
+      route_thickness_mode: import_zod40.z.enum(["constant", "interpolated"]).default("constant").optional(),
+      should_round_corners: import_zod40.z.boolean().optional(),
+      route: import_zod40.z.array(
+        import_zod40.z.union([
+          import_zod40.z.object({
+            route_type: import_zod40.z.literal("wire"),
             x: distance,
             y: distance,
             width: distance,
-            start_pcb_port_id: import_zod38.z.string().optional(),
-            end_pcb_port_id: import_zod38.z.string().optional(),
-            layer: import_zod38.z.string()
+            start_pcb_port_id: import_zod40.z.string().optional(),
+            end_pcb_port_id: import_zod40.z.string().optional(),
+            layer: layer_ref
           }),
-          import_zod38.z.object({
-            route_type: import_zod38.z.literal("via"),
+          import_zod40.z.object({
+            route_type: import_zod40.z.literal("via"),
             x: distance,
             y: distance,
-            from_layer: import_zod38.z.string(),
-            to_layer: import_zod38.z.string()
+            from_layer: import_zod40.z.string(),
+            to_layer: import_zod40.z.string()
           })
         ])
       )
     });
-    var import_zod39 = require("zod");
-    var pcb_trace_error = import_zod39.z.object({
-      pcb_error_id: import_zod39.z.string(),
-      type: import_zod39.z.literal("pcb_error"),
-      error_type: import_zod39.z.literal("pcb_trace_error"),
-      message: import_zod39.z.string(),
-      pcb_trace_id: import_zod39.z.string(),
-      source_trace_id: import_zod39.z.string(),
-      pcb_component_ids: import_zod39.z.array(import_zod39.z.string()),
-      pcb_port_ids: import_zod39.z.array(import_zod39.z.string())
+    var import_zod41 = require("zod");
+    var pcb_trace_error = import_zod41.z.object({
+      pcb_error_id: import_zod41.z.string(),
+      type: import_zod41.z.literal("pcb_error"),
+      error_type: import_zod41.z.literal("pcb_trace_error"),
+      message: import_zod41.z.string(),
+      center: point.optional(),
+      pcb_trace_id: import_zod41.z.string(),
+      source_trace_id: import_zod41.z.string(),
+      pcb_component_ids: import_zod41.z.array(import_zod41.z.string()),
+      pcb_port_ids: import_zod41.z.array(import_zod41.z.string())
     }).describe("Defines a trace error on the PCB");
-    var import_zod40 = require("zod");
-    var pcb_port_not_matched_error = import_zod40.z.object({
-      pcb_error_id: import_zod40.z.string(),
-      type: import_zod40.z.literal("pcb_error"),
-      error_type: import_zod40.z.literal("pcb_port_not_matched_error"),
-      message: import_zod40.z.string(),
-      pcb_component_ids: import_zod40.z.array(import_zod40.z.string())
+    var import_zod422 = require("zod");
+    var pcb_port_not_matched_error = import_zod422.z.object({
+      pcb_error_id: import_zod422.z.string(),
+      type: import_zod422.z.literal("pcb_error"),
+      error_type: import_zod422.z.literal("pcb_port_not_matched_error"),
+      message: import_zod422.z.string(),
+      pcb_component_ids: import_zod422.z.array(import_zod422.z.string())
     }).describe("Defines a trace error on the PCB");
-    var import_zod41 = require("zod");
-    var pcb_via = import_zod41.z.object({
-      type: import_zod41.z.literal("pcb_via"),
+    var import_zod43 = require("zod");
+    var pcb_via = import_zod43.z.object({
+      type: import_zod43.z.literal("pcb_via"),
       x: distance,
       y: distance,
       outer_diameter: distance.default("0.6mm"),
@@ -3158,35 +3279,37 @@ var require_dist = __commonJS({
       from_layer: layer_ref.optional(),
       /** @deprecated */
       to_layer: layer_ref.optional(),
-      layers: import_zod41.z.array(layer_ref)
+      layers: import_zod43.z.array(layer_ref)
     }).describe("Defines a via on the PCB");
-    var import_zod422 = require("zod");
-    var pcb_board = import_zod422.z.object({
-      type: import_zod422.z.literal("pcb_board"),
+    var import_zod44 = require("zod");
+    var pcb_board = import_zod44.z.object({
+      type: import_zod44.z.literal("pcb_board"),
+      pcb_board_id: import_zod44.z.string().default("pcb_board_0").optional(),
       width: length,
       height: length,
-      center: point
+      center: point,
+      outline: import_zod44.z.array(point).optional()
     }).describe("Defines the board outline of the PCB");
-    var import_zod43 = require("zod");
-    var pcb_placement_error = import_zod43.z.object({
-      pcb_error_id: import_zod43.z.string(),
-      type: import_zod43.z.literal("pcb_error"),
-      error_type: import_zod43.z.literal("pcb_placement_error"),
-      message: import_zod43.z.string()
+    var import_zod45 = require("zod");
+    var pcb_placement_error = import_zod45.z.object({
+      pcb_error_id: import_zod45.z.string(),
+      type: import_zod45.z.literal("pcb_error"),
+      error_type: import_zod45.z.literal("pcb_placement_error"),
+      message: import_zod45.z.string()
     }).describe("Defines a placement error on the PCB");
-    var import_zod44 = require("zod");
-    var pcb_trace_hint = import_zod44.z.object({
-      pcb_trace_hint_id: import_zod44.z.string(),
-      type: import_zod44.z.literal("pcb_trace_hint"),
-      pcb_port_id: import_zod44.z.string(),
-      pcb_component_id: import_zod44.z.string(),
-      route: import_zod44.z.array(route_hint_point)
+    var import_zod46 = require("zod");
+    var pcb_trace_hint = import_zod46.z.object({
+      pcb_trace_hint_id: import_zod46.z.string(),
+      type: import_zod46.z.literal("pcb_trace_hint"),
+      pcb_port_id: import_zod46.z.string(),
+      pcb_component_id: import_zod46.z.string(),
+      route: import_zod46.z.array(route_hint_point.optional())
     }).describe("A hint that can be used to generate a PCB trace");
-    var import_zod45 = require("zod");
-    var pcb_silkscreen_line = import_zod45.z.object({
-      type: import_zod45.z.literal("pcb_silkscreen_line"),
-      pcb_silkscreen_line_id: import_zod45.z.string(),
-      pcb_component_id: import_zod45.z.string(),
+    var import_zod47 = require("zod");
+    var pcb_silkscreen_line = import_zod47.z.object({
+      type: import_zod47.z.literal("pcb_silkscreen_line"),
+      pcb_silkscreen_line_id: import_zod47.z.string(),
+      pcb_component_id: import_zod47.z.string(),
       stroke_width: distance.default("0.1mm"),
       x1: distance,
       y1: distance,
@@ -3194,88 +3317,130 @@ var require_dist = __commonJS({
       y2: distance,
       layer: visible_layer
     }).describe("Defines a silkscreen line on the PCB");
-    var import_zod46 = require("zod");
-    var pcb_silkscreen_path2 = import_zod46.z.object({
-      type: import_zod46.z.literal("pcb_silkscreen_path"),
-      pcb_silkscreen_path_id: import_zod46.z.string(),
-      pcb_component_id: import_zod46.z.string(),
+    var import_zod48 = require("zod");
+    var pcb_silkscreen_path2 = import_zod48.z.object({
+      type: import_zod48.z.literal("pcb_silkscreen_path"),
+      pcb_silkscreen_path_id: import_zod48.z.string(),
+      pcb_component_id: import_zod48.z.string(),
       layer: visible_layer,
-      route: import_zod46.z.array(point),
+      route: import_zod48.z.array(point),
       stroke_width: length
     }).describe("Defines a silkscreen path on the PCB");
-    var import_zod47 = require("zod");
-    var pcb_silkscreen_text = import_zod47.z.object({
-      type: import_zod47.z.literal("pcb_silkscreen_text"),
-      font: import_zod47.z.literal("tscircuit2024").default("tscircuit2024"),
+    var import_zod49 = require("zod");
+    var pcb_silkscreen_text = import_zod49.z.object({
+      type: import_zod49.z.literal("pcb_silkscreen_text"),
+      font: import_zod49.z.literal("tscircuit2024").default("tscircuit2024"),
       font_size: distance.default("0.2mm"),
-      pcb_component_id: import_zod47.z.string(),
-      text: import_zod47.z.string(),
+      pcb_component_id: import_zod49.z.string(),
+      text: import_zod49.z.string(),
       layer: visible_layer,
       anchor_position: point.default({ x: 0, y: 0 }),
-      anchor_alignment: import_zod47.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+      anchor_alignment: import_zod49.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
     }).describe("Defines silkscreen text on the PCB");
-    var import_zod48 = require("zod");
-    var pcb_silkscreen_rect = import_zod48.z.object({
-      type: import_zod48.z.literal("pcb_silkscreen_rect"),
-      pcb_silkscreen_rect_id: import_zod48.z.string(),
-      pcb_component_id: import_zod48.z.string(),
+    var import_zod50 = require("zod");
+    var pcb_silkscreen_rect = import_zod50.z.object({
+      type: import_zod50.z.literal("pcb_silkscreen_rect"),
+      pcb_silkscreen_rect_id: import_zod50.z.string(),
+      pcb_component_id: import_zod50.z.string(),
       center: point,
       width: distance,
       height: distance,
       layer: visible_layer
     }).describe("Defines a silkscreen rect on the PCB");
-    var import_zod49 = require("zod");
-    var pcb_silkscreen_circle = import_zod49.z.object({
-      type: import_zod49.z.literal("pcb_silkscreen_circle"),
-      pcb_silkscreen_circle_id: import_zod49.z.string(),
-      pcb_component_id: import_zod49.z.string(),
+    var import_zod51 = require("zod");
+    var pcb_silkscreen_circle = import_zod51.z.object({
+      type: import_zod51.z.literal("pcb_silkscreen_circle"),
+      pcb_silkscreen_circle_id: import_zod51.z.string(),
+      pcb_component_id: import_zod51.z.string(),
       center: point,
       radius: distance,
       layer: visible_layer
     }).describe("Defines a silkscreen circle on the PCB");
-    var import_zod50 = require("zod");
-    var pcb_fabrication_note_text = import_zod50.z.object({
-      type: import_zod50.z.literal("pcb_fabrication_note_text"),
-      font: import_zod50.z.literal("tscircuit2024").default("tscircuit2024"),
+    var import_zod522 = require("zod");
+    var pcb_silkscreen_oval = import_zod522.z.object({
+      type: import_zod522.z.literal("pcb_silkscreen_oval"),
+      pcb_silkscreen_oval_id: import_zod522.z.string(),
+      pcb_component_id: import_zod522.z.string(),
+      center: point,
+      radius_x: distance,
+      radius_y: distance,
+      layer: visible_layer
+    }).describe("Defines a silkscreen oval on the PCB");
+    var import_zod53 = require("zod");
+    var pcb_fabrication_note_text = import_zod53.z.object({
+      type: import_zod53.z.literal("pcb_fabrication_note_text"),
+      pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
+        "pcb_fabrication_note_text"
+      ),
+      font: import_zod53.z.literal("tscircuit2024").default("tscircuit2024"),
       font_size: distance.default("1mm"),
-      pcb_component_id: import_zod50.z.string(),
-      text: import_zod50.z.string(),
+      pcb_component_id: import_zod53.z.string(),
+      text: import_zod53.z.string(),
       layer: visible_layer,
       anchor_position: point.default({ x: 0, y: 0 }),
-      anchor_alignment: import_zod50.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+      anchor_alignment: import_zod53.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+      color: import_zod53.z.string().optional()
     }).describe(
       "Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators"
     );
-    var import_zod51 = require("zod");
-    var pcb_fabrication_note_path = import_zod51.z.object({
-      type: import_zod51.z.literal("pcb_fabrication_note_path"),
-      fabrication_note_path_id: import_zod51.z.string(),
-      pcb_component_id: import_zod51.z.string(),
+    var import_zod54 = require("zod");
+    var pcb_fabrication_note_path = import_zod54.z.object({
+      type: import_zod54.z.literal("pcb_fabrication_note_path"),
+      pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
+        "pcb_fabrication_note_path"
+      ),
+      pcb_component_id: import_zod54.z.string(),
       layer: visible_layer,
-      route: import_zod51.z.array(point),
-      stroke_width: length
+      route: import_zod54.z.array(point),
+      stroke_width: length,
+      color: import_zod54.z.string().optional()
     }).describe(
       "Defines a fabrication path on the PCB for fabricators or assemblers"
     );
-    var import_zod522 = require("zod");
-    var cad_component2 = import_zod522.z.object({
-      type: import_zod522.z.literal("cad_component"),
-      cad_component_id: import_zod522.z.string(),
-      pcb_component_id: import_zod522.z.string(),
-      source_component_id: import_zod522.z.string(),
+    var import_zod55 = require("zod");
+    var pcb_keepout = import_zod55.z.object({
+      type: import_zod55.z.literal("pcb_keepout"),
+      shape: import_zod55.z.literal("rect"),
+      center: point,
+      width: distance,
+      height: distance,
+      pcb_keepout_id: import_zod55.z.string(),
+      layers: import_zod55.z.array(import_zod55.z.string()),
+      // Specify layers where the keepout applies
+      description: import_zod55.z.string().optional()
+      // Optional description of the keepout
+    }).or(
+      import_zod55.z.object({
+        type: import_zod55.z.literal("pcb_keepout"),
+        shape: import_zod55.z.literal("circle"),
+        center: point,
+        radius: distance,
+        pcb_keepout_id: import_zod55.z.string(),
+        layers: import_zod55.z.array(import_zod55.z.string()),
+        // Specify layers where the keepout applies
+        description: import_zod55.z.string().optional()
+        // Optional description of the keepout
+      })
+    );
+    var import_zod56 = require("zod");
+    var cad_component2 = import_zod56.z.object({
+      type: import_zod56.z.literal("cad_component"),
+      cad_component_id: import_zod56.z.string(),
+      pcb_component_id: import_zod56.z.string(),
+      source_component_id: import_zod56.z.string(),
       position: point3,
       rotation: point3.optional(),
       size: point3.optional(),
       layer: layer_ref.optional(),
       // These are all ways to generate/load the 3d model
-      footprinter_string: import_zod522.z.string().optional(),
-      model_obj_url: import_zod522.z.string().optional(),
-      model_stl_url: import_zod522.z.string().optional(),
-      model_3mf_url: import_zod522.z.string().optional(),
-      model_jscad: import_zod522.z.array(import_zod522.z.any()).optional()
+      footprinter_string: import_zod56.z.string().optional(),
+      model_obj_url: import_zod56.z.string().optional(),
+      model_stl_url: import_zod56.z.string().optional(),
+      model_3mf_url: import_zod56.z.string().optional(),
+      model_jscad: import_zod56.z.any().optional()
     }).describe("Defines a component on the PCB");
-    var import_zod53 = require("zod");
-    var any_soup_element = import_zod53.z.union([
+    var import_zod57 = require("zod");
+    var any_circuit_element = import_zod57.z.union([
       source_trace,
       source_port,
       any_source_component2,
@@ -3283,6 +3448,7 @@ var require_dist = __commonJS({
       source_net,
       source_group,
       source_simple_bug,
+      source_simple_chip,
       source_simple_capacitor,
       source_simple_diode,
       source_simple_resistor,
@@ -3290,6 +3456,7 @@ var require_dist = __commonJS({
       pcb_component2,
       pcb_hole,
       pcb_plated_hole2,
+      pcb_keepout,
       pcb_port,
       pcb_text,
       pcb_trace,
@@ -3302,6 +3469,7 @@ var require_dist = __commonJS({
       pcb_silkscreen_text,
       pcb_silkscreen_rect,
       pcb_silkscreen_circle,
+      pcb_silkscreen_oval,
       pcb_trace_error,
       pcb_placement_error,
       pcb_port_not_matched_error,
@@ -3318,6 +3486,7 @@ var require_dist = __commonJS({
       schematic_net_label,
       cad_component2
     ]);
+    var any_soup_element = any_circuit_element;
   }
 });
 
@@ -16962,7 +17131,7 @@ var require_dist7 = __commonJS({
               number = toNumber(number);
               return baseInRange(number, start, end);
             }
-            function random(lower, upper, floating) {
+            function random2(lower, upper, floating) {
               if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
                 upper = floating = undefined2;
               }
@@ -17716,7 +17885,7 @@ var require_dist7 = __commonJS({
             lodash.padEnd = padEnd;
             lodash.padStart = padStart;
             lodash.parseInt = parseInt2;
-            lodash.random = random;
+            lodash.random = random2;
             lodash.reduce = reduce;
             lodash.reduceRight = reduceRight;
             lodash.repeat = repeat;
@@ -29176,8 +29345,10 @@ var import_promises = __toESM(require("fs/promises"), 1);
 var package_default = {
   name: "easyeda",
   type: "module",
-  version: "0.0.26",
-  files: ["dist"],
+  version: "0.0.28",
+  files: [
+    "dist"
+  ],
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/easyeda-converter"
@@ -29198,7 +29369,7 @@ var package_default = {
     "@biomejs/biome": "^1.8.3",
     "@tscircuit/builder": "^1.5.131",
     "@tscircuit/log-soup": "1.0.2",
-    "@tscircuit/soup": "^0.0.37",
+    "@tscircuit/soup": "^0.0.73",
     "@tscircuit/soup-util": "^0.0.11",
     "@types/bun": "latest",
     tsup: "^8.1.0"