@tscircuit/cli 0.1.187 → 0.1.189

package/dist/main.js

@@ -60975,7 +60975,7 @@ import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
 import fs5 from "node:fs";
 import path8 from "node:path";
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import assert from "node:assert";
 
 // node_modules/dot-prop/index.js
@@ -62068,8 +62068,8 @@ class Conf {
     }
     try {
       const initializationVector = data.slice(0, 16);
-      const password = crypto.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512");
-      const decipher = crypto.createDecipheriv(encryptionAlgorithm, password, initializationVector);
+      const password = crypto2.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512");
+      const decipher = crypto2.createDecipheriv(encryptionAlgorithm, password, initializationVector);
       const slice = data.slice(17);
       const dataUpdate = typeof slice === "string" ? stringToUint8Array(slice) : slice;
       return uint8ArrayToString(concatUint8Arrays([decipher.update(dataUpdate), decipher.final()]));
@@ -62111,9 +62111,9 @@ class Conf {
   _write(value) {
     let data = this._serialize(value);
     if (this.#encryptionKey) {
-      const initializationVector = crypto.randomBytes(16);
-      const password = crypto.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512");
-      const cipher = crypto.createCipheriv(encryptionAlgorithm, password, initializationVector);
+      const initializationVector = crypto2.randomBytes(16);
+      const password = crypto2.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512");
+      const cipher = crypto2.createCipheriv(encryptionAlgorithm, password, initializationVector);
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
@@ -62951,7 +62951,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.186";
+var version = "0.1.188";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -69569,54 +69569,3095 @@ var registerConfigSet = (program3) => {
 };
 
 // cli/search/register.ts
-var import_prompts5 = __toESM2(require_prompts3(), 1);
 var registerSearch = (program3) => {
   program3.command("search").description("Search for packages in the tscircuit registry").argument("<query>", "Search query (e.g. keyword, author, or package name)").action(async (query) => {
     const ky2 = getRegistryApiKy();
     let results = { packages: [] };
+    let jlcResults = [];
     try {
       results = await ky2.post("packages/search", {
         json: { query }
       }).json();
+      const jlcSearchUrl = "https://jlcsearch.tscircuit.com/api/search?limit=10&q=" + encodeURIComponent(query);
+      jlcResults = (await fetch(jlcSearchUrl).then((r) => r.json())).components;
     } catch (error) {
       console.error(kleur_default.red("Failed to search registry:"), error instanceof Error ? error.message : error);
       process.exit(1);
     }
-    if (!results.packages.length) {
-      console.log(kleur_default.yellow("No packages found matching your query."));
+    if (!results.packages.length && !jlcResults.length) {
+      console.log(kleur_default.yellow("No results found matching your query."));
       return;
     }
-    console.log(kleur_default.bold().underline(`Found ${results.packages.length} package(s):`));
-    const choices = results.packages.map((pkg) => ({
-      title: pkg.name,
-      description: pkg.description || "",
-      value: pkg.name
-    }));
-    const { selectedPackage } = await import_prompts5.default({
-      type: "select",
-      name: "selectedPackage",
-      message: "Select a package to add:",
-      choices,
-      initial: 0
+    if (results.packages.length) {
+      console.log(kleur_default.bold().underline(`Found ${results.packages.length} package(s) in the tscircuit registry:`));
+      results.packages.forEach((pkg, idx) => {
+        const star = pkg.star_count ?? 0;
+        console.log(`${idx + 1}. ${pkg.name} (v${pkg.version}) - Stars: ${star}${pkg.description ? ` - ${pkg.description}` : ""}`);
+      });
+    }
+    if (jlcResults.length) {
+      console.log();
+      console.log(kleur_default.bold().underline(`Found ${jlcResults.length} component(s) in JLC search:`));
+      jlcResults.forEach((comp, idx) => {
+        console.log(`${idx + 1}. ${comp.mfr} (C${comp.lcsc}) - ${comp.description}`);
+      });
+    }
+    console.log(`
+`);
+  });
+};
+
+// node_modules/easyeda/dist/browser/index.js
+import { z as z33 } from "zod";
+import { z as z20 } from "zod";
+import { z as z23 } from "zod";
+
+// node_modules/@tscircuit/mm/dist/index.js
+var unitToMm = {
+  in: 25.4,
+  inch: 25.4,
+  mil: 0.0254,
+  mm: 1,
+  m: 1000,
+  cm: 10,
+  ft: 304.8,
+  feet: 304.8
+};
+var mm = (n2) => {
+  let unit = typeof n2 === "number" ? "mm" : n2.replace(/^[^a-zA-Z]+/g, "").toLowerCase();
+  if (!unit)
+    unit = "mm";
+  const val = typeof n2 === "number" ? n2 : Number.parseFloat(n2.split(unit)[0]);
+  if (unit in unitToMm) {
+    return val * unitToMm[unit];
+  }
+  throw new Error(`Unsupported unit: ${unit}`);
+};
+var mmStr = (n2) => {
+  return `${mm(n2)}mm`;
+};
+
+// node_modules/easyeda/dist/browser/index.js
+import { z as z43 } from "zod";
+import { z as z222 } from "zod";
+import { z as z322 } from "zod";
+import { z as z422 } from "zod";
+import { z as z53 } from "zod";
+import { z as z82 } from "zod";
+import { z as z62 } from "zod";
+import { z as z72 } from "zod";
+import { z as z92 } from "zod";
+import { z as z102 } from "zod";
+import { z as z112 } from "zod";
+import { z as z122 } from "zod";
+import { z as z132 } from "zod";
+import { z as z142 } from "zod";
+import { z as z152 } from "zod";
+import { z as z27 } from "zod";
+import { z as z162 } from "zod";
+import { z as z172 } from "zod";
+import { z as z182 } from "zod";
+import { z as z192 } from "zod";
+import { z as z202 } from "zod";
+import { z as z21 } from "zod";
+import { z as z2222 } from "zod";
+import { z as z232 } from "zod";
+import { z as z24 } from "zod";
+import { z as z25 } from "zod";
+import { z as z26 } from "zod";
+import { z as z28 } from "zod";
+import { z as z29 } from "zod";
+import { z as z30 } from "zod";
+import { z as z31 } from "zod";
+import { z as z3222 } from "zod";
+import { z as z332 } from "zod";
+import { z as z34 } from "zod";
+import { z as z35 } from "zod";
+import { z as z36 } from "zod";
+import { z as z37 } from "zod";
+import { z as z38 } from "zod";
+import { z as z39 } from "zod";
+import { z as z40 } from "zod";
+import { z as z41 } from "zod";
+import { z as z4222 } from "zod";
+import { z as z432 } from "zod";
+import { z as z44 } from "zod";
+import { z as z45 } from "zod";
+import { z as z46 } from "zod";
+import { z as z47 } from "zod";
+import { z as z48 } from "zod";
+import { z as z49 } from "zod";
+import { z as z50 } from "zod";
+import { z as z51 } from "zod";
+import { z as z522 } from "zod";
+import { z as z532 } from "zod";
+import { z as z54 } from "zod";
+import { z as z55 } from "zod";
+import { z as z56 } from "zod";
+import { z as z57 } from "zod";
+import { z as z58 } from "zod";
+import { z as z59 } from "zod";
+import { z as z60 } from "zod";
+import { z as z61 } from "zod";
+import { z as z622 } from "zod";
+import { z as z63 } from "zod";
+import { z as z64 } from "zod";
+import { z as z65 } from "zod";
+import { z as z66 } from "zod";
+import { z as z67 } from "zod";
+import { z as z68 } from "zod";
+import { z as z69 } from "zod";
+import { z as z70 } from "zod";
+import { z as z71 } from "zod";
+import { z as z722 } from "zod";
+import { z as z73 } from "zod";
+import { z as z74 } from "zod";
+import { applyToPoint as applyToPoint3, decomposeTSR as decomposeTSR2 } from "transformation-matrix";
+import { compose, scale as scale6, translate } from "transformation-matrix";
+var __defProp3 = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp3(target, name, { get: all[name], enumerable: true });
+};
+var tenthmil = z20.union([z20.number(), z20.string()]).optional().transform((n2) => typeof n2 === "string" && n2.endsWith("mil") ? n2 : `${Number.parseFloat(n2) * 10}mil`).pipe(z20.string());
+var PointSchema = z20.any().transform((p) => {
+  if (Array.isArray(p)) {
+    const [x, y] = p;
+    return { x, y };
+  } else if (typeof p === "object") {
+    return p;
+  }
+  throw new Error(`Invalid point: ${p}`);
+}).pipe(z20.object({
+  x: z20.number(),
+  y: z20.number()
+}));
+var BaseShapeSchema = z20.object({
+  type: z20.string(),
+  id: z20.string().optional(),
+  layer: z20.coerce.number().optional()
+});
+var TrackSchema = BaseShapeSchema.extend({
+  type: z20.literal("TRACK"),
+  width: z20.coerce.number(),
+  points: z20.array(PointSchema)
+});
+var PadSchema = BaseShapeSchema.extend({
+  type: z20.literal("PAD"),
+  shape: z20.enum(["RECT", "ELLIPSE", "OVAL"]),
+  center: z20.object({
+    x: tenthmil,
+    y: tenthmil
+  }),
+  width: tenthmil,
+  height: tenthmil,
+  layermask: z20.number(),
+  net: z20.union([z20.string(), z20.number()]).optional(),
+  number: z20.union([z20.string(), z20.number()]),
+  holeRadius: tenthmil,
+  points: z20.array(PointSchema).optional(),
+  rotation: z20.number().optional(),
+  plated: z20.boolean()
+});
+var ArcSchema = BaseShapeSchema.extend({
+  type: z20.literal("ARC"),
+  width: z20.number(),
+  start: PointSchema,
+  end: PointSchema,
+  radiusX: z20.number(),
+  radiusY: z20.number(),
+  largeArc: z20.boolean(),
+  sweepDirection: z20.enum(["CW", "CCW"])
+});
+var CircleSchema = BaseShapeSchema.extend({
+  type: z20.literal("CIRCLE"),
+  center: PointSchema,
+  radius: z20.number(),
+  width: z20.number()
+});
+var SolidRegionSchema = BaseShapeSchema.extend({
+  type: z20.literal("SOLIDREGION"),
+  layermask: z20.number(),
+  points: z20.array(PointSchema),
+  fillStyle: z20.string()
+});
+var SVGNodeSchema = BaseShapeSchema.extend({
+  type: z20.literal("SVGNODE"),
+  svgData: z20.object({
+    gId: z20.string(),
+    nodeName: z20.string(),
+    nodeType: z20.number(),
+    layerid: z20.string(),
+    attrs: z20.record(z20.string(), z20.string()),
+    childNodes: z20.array(z20.unknown())
+  })
+});
+var HoleSchema = BaseShapeSchema.extend({
+  type: z20.literal("HOLE"),
+  center: PointSchema,
+  radius: z20.number()
+});
+var RectSchema = BaseShapeSchema.extend({
+  type: z20.literal("RECT"),
+  x: tenthmil,
+  y: tenthmil,
+  width: tenthmil,
+  height: tenthmil,
+  lineWidth: z20.number(),
+  fillStyle: z20.string(),
+  rotation: z20.number().optional()
+});
+var TextSchema = BaseShapeSchema.extend({
+  type: z20.literal("TEXT"),
+  text: z20.string(),
+  x: tenthmil,
+  y: tenthmil,
+  size_mm: z20.number(),
+  rotation: z20.number().optional(),
+  layer: z20.number().optional(),
+  textAnchor: z20.enum(["L", "C", "R", ""]).optional().transform((val) => val === "" ? undefined : val),
+  font: z20.string().optional()
+});
+var PackageDetailShapeSchema = z20.discriminatedUnion("type", [
+  TrackSchema,
+  PadSchema,
+  ArcSchema,
+  CircleSchema,
+  SolidRegionSchema,
+  SVGNodeSchema,
+  HoleSchema,
+  RectSchema,
+  TextSchema
+]);
+var pairs = (arr) => {
+  const pairs2 = [];
+  for (let i = 0;i < arr.length; i += 2) {
+    pairs2.push([arr[i], arr[i + 1]]);
+  }
+  return pairs2;
+};
+var parsePoints = (pointsStr) => pairs(pointsStr.trim().split(" ").map((n2) => Number(n2)));
+var ShapeItemSchema = z20.object({
+  type: z20.string(),
+  data: z20.string()
+}).transform((shape) => {
+  const [firstParam, ...restParams] = shape.data.split("~");
+  const lastParam = restParams.pop();
+  switch (shape.type) {
+    case "TRACK": {
+      const [width, layer, _, pointsStr, id, _n] = shape.data.split("~");
+      const points = parsePoints(pointsStr);
+      return TrackSchema.parse({ type: "TRACK", width, layer, points, id });
+    }
+    case "PAD": {
+      const [padShape, ...params2] = shape.data.split("~");
+      const [
+        centerX,
+        centerY,
+        width,
+        height,
+        layermask,
+        net2,
+        number,
+        holeRadius,
+        ...rest
+      ] = params2.map((p) => isNaN(Number(p)) ? p : Number(p));
+      const center = { x: centerX, y: centerY };
+      let points, rotation2;
+      if (padShape === "RECT") {
+        points = parsePoints(rest[0]);
+        rotation2 = Number(rest[1]);
+      }
+      const padInputParams = {
+        type: "PAD",
+        shape: padShape,
+        center,
+        width,
+        height,
+        layermask,
+        net: net2,
+        number,
+        holeRadius,
+        points,
+        rotation: rotation2,
+        plated: rest.includes("Y")
+      };
+      const pad = PadSchema.parse(padInputParams);
+      return pad;
+    }
+    case "ARC": {
+      const [width, layer, , arcData] = shape.data.split("~");
+      const match = arcData.match(/M\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)\s*A\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)\s*([\d.-]+)(?:\s*,\s*|\s+)([\d.-]+)/);
+      if (!match) {
+        throw new Error(`Invalid arc data: ${arcData}`);
+      }
+      const [
+        ,
+        startX,
+        startY,
+        radiusX,
+        radiusY,
+        xAxisRotation,
+        largeArcFlag,
+        sweepFlag,
+        endX,
+        endY
+      ] = match;
+      const start = [Number(startX), Number(startY)];
+      const end = [Number(endX), Number(endY)];
+      return ArcSchema.parse({
+        type: "ARC",
+        width: Number(width),
+        layer: Number(layer),
+        start,
+        end,
+        radiusX: Number(radiusX),
+        radiusY: Number(radiusY),
+        largeArc: largeArcFlag === "1",
+        sweepDirection: sweepFlag === "1" ? "CW" : "CCW"
+      });
+    }
+    case "CIRCLE": {
+      const [centerX, centerY, radius, width, layer, id] = shape.data.split("~");
+      const center = [Number(centerX), Number(centerY)];
+      return CircleSchema.parse({
+        type: "CIRCLE",
+        center,
+        radius: Number(radius),
+        width: Number(width),
+        layer: Number(layer),
+        id
+      });
+    }
+    case "HOLE": {
+      const [centerX, centerY, radius, id] = shape.data.split("~");
+      const center = [Number(centerX), Number(centerY)];
+      return HoleSchema.parse({
+        type: "HOLE",
+        center,
+        radius: Number(radius),
+        id
+      });
+    }
+    case "SOLIDREGION": {
+      const [layermask, , pathData, fillStyle, id] = shape.data.split("~");
+      const points = pathData.match(/[ML] ?(-?[\d.]+)[ ,](-?[\d.]+)/g)?.map((point2) => {
+        const [, x, y] = point2.match(/[ML]? ?(-?[\d.]+)[ ,](-?[\d.]+)/) || [];
+        return [Number(x), Number(y)];
+      }) || [];
+      return SolidRegionSchema.parse({
+        type: "SOLIDREGION",
+        layermask: Number(layermask),
+        points,
+        fillStyle,
+        id
+      });
+    }
+    case "SVGNODE": {
+      const svgData = JSON.parse(shape.data);
+      return SVGNodeSchema.parse({ type: "SVGNODE", svgData });
+    }
+    case "RECT": {
+      const [x, y, width, height, lineWidth, id, rotation2, layer, fillStyle] = shape.data.split("~");
+      return RectSchema.parse({
+        type: "RECT",
+        x,
+        y,
+        width,
+        height,
+        lineWidth: Number(lineWidth),
+        id,
+        rotation: rotation2 ? Number(rotation2) : undefined,
+        layer: layer ? Number(layer) : undefined,
+        fillStyle: fillStyle || undefined
+      });
+    }
+    case "TEXT": {
+      const [textAnchor, x, y, size2, layer, id, rotation2, , font, text] = shape.data.split("~");
+      return TextSchema.parse({
+        type: "TEXT",
+        text,
+        x,
+        y,
+        size_mm: Number(size2) * 2.54,
+        layer: layer ? Number(layer) : undefined,
+        id,
+        rotation: rotation2 ? Number(rotation2) : undefined,
+        textAnchor,
+        font: font || undefined
+      });
+    }
+    default:
+      throw new Error(`Unknown shape type: ${shape.type}`);
+      return BaseShapeSchema.parse({ type: shape.type });
+  }
+}).pipe(PackageDetailShapeSchema);
+var ShapesArraySchema = z20.array(ShapeItemSchema);
+var mil10ToMm = (value) => value * 10 * 0.0254;
+var PointSchema2 = z23.object({
+  x: z23.number(),
+  y: z23.number()
+});
+var RectangleShapeOutputSchema = z23.object({
+  type: z23.literal("RECTANGLE"),
+  position: PointSchema2,
+  width: z23.number(),
+  height: z23.number(),
+  color: z23.string(),
+  lineWidth: z23.number(),
+  id: z23.string()
+});
+var parseRectangle = (str) => {
+  const [, x, y, , , width, height, color, lineWidth, , , id] = str.split("~");
+  return {
+    type: "RECTANGLE",
+    position: { x: Number(x), y: Number(y) },
+    width: Number(width),
+    height: Number(height),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+var RectangleShapeSchema = z23.string().startsWith("R~").transform(parseRectangle).pipe(RectangleShapeOutputSchema);
+var EllipseShapeOutputSchema = z23.object({
+  type: z23.literal("ELLIPSE"),
+  center: PointSchema2,
+  radiusX: z23.number(),
+  radiusY: z23.number(),
+  color: z23.string(),
+  lineWidth: z23.number(),
+  id: z23.string()
+});
+var parseEllipse = (str) => {
+  const [, x, y, radiusX, radiusY, color, lineWidth, , , id] = str.split("~");
+  return {
+    type: "ELLIPSE",
+    center: { x: Number(x), y: Number(y) },
+    radiusX: Number(radiusX),
+    radiusY: Number(radiusY),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+var EllipseShapeSchema = z23.string().startsWith("E~").transform(parseEllipse).pipe(EllipseShapeOutputSchema);
+var PinShapeOutputSchema = z23.object({
+  type: z23.literal("PIN"),
+  visibility: z23.enum(["show", "hide"]),
+  pinNumber: z23.union([z23.string(), z23.number()]),
+  x: z23.number(),
+  y: z23.number(),
+  rotation: z23.number(),
+  id: z23.string(),
+  label: z23.string(),
+  labelColor: z23.string(),
+  path: z23.string(),
+  arrow: z23.string()
+});
+var parsePin = (pinString) => {
+  const parts = pinString.split("~");
+  const [, visibility, , pinNumber, x, y, rotation2, id] = parts;
+  const nameMatch = pinString.match(/~(\w+)~(start|end)~/);
+  const label = nameMatch ? nameMatch[1] : "";
+  const colorMatch = pinString.match(/#[0-9A-F]{6}/);
+  const labelColor = colorMatch ? colorMatch[0] : "";
+  const pathMatch = pinString.match(/\^\^([^~]+)/);
+  const path23 = pathMatch ? pathMatch[1] : "";
+  const arrowMatch = pinString.match(/\^\^0~(.+)$/);
+  const arrow = arrowMatch ? arrowMatch[1] : "";
+  return {
+    type: "PIN",
+    visibility,
+    id,
+    pinNumber: isNaN(Number(pinNumber)) ? pinNumber : Number(pinNumber),
+    x: parseFloat(x),
+    y: parseFloat(y),
+    rotation: parseFloat(rotation2),
+    label,
+    labelColor,
+    path: path23,
+    arrow
+  };
+};
+var PinShapeSchema = z23.string().startsWith("P~").transform(parsePin).pipe(PinShapeOutputSchema);
+var PolylineShapeOutputSchema = z23.object({
+  type: z23.literal("POLYLINE"),
+  points: z23.array(PointSchema2),
+  color: z23.string(),
+  lineWidth: z23.number(),
+  id: z23.string()
+});
+var parsePoints2 = (pointsStr) => {
+  return pointsStr.split(" ").reduce((acc, value, index) => {
+    if (index % 2 === 0) {
+      acc.push({ x: Number(value), y: 0 });
+    } else {
+      acc[acc.length - 1].y = Number(value);
+    }
+    return acc;
+  }, []);
+};
+var parsePolyline = (str) => {
+  const [, ...rest] = str.split("~");
+  const [pointsStr, color, lineWidth, , , id] = rest;
+  return {
+    type: "POLYLINE",
+    points: parsePoints2(pointsStr),
+    color,
+    lineWidth: Number(lineWidth),
+    id
+  };
+};
+var PolylineShapeSchema = z23.string().startsWith("PL~").transform(parsePolyline).pipe(PolylineShapeOutputSchema);
+var PolygonShapeOutputSchema = z23.object({
+  type: z23.literal("POLYGON"),
+  points: z23.array(PointSchema2),
+  fillColor: z23.string(),
+  lineWidth: z23.number(),
+  lineColor: z23.string(),
+  id: z23.string()
+});
+var parsePolygon = (str) => {
+  const [, ...rest] = str.split("~");
+  const [pointsStr, fillColor, lineWidth, lineColor, , id] = rest;
+  return {
+    type: "POLYGON",
+    points: parsePoints2(pointsStr),
+    fillColor,
+    lineWidth: Number(lineWidth),
+    lineColor,
+    id
+  };
+};
+var PolygonShapeSchema = z23.string().startsWith("PG~").transform(parsePolygon).pipe(PolygonShapeOutputSchema);
+var PathShapeOutputSchema = z23.object({
+  type: z23.literal("PATH"),
+  pathData: z23.string(),
+  fillColor: z23.string(),
+  strokeWidth: z23.number(),
+  strokeColor: z23.string(),
+  id: z23.string()
+});
+var parsePath = (str) => {
+  const [, pathData, fillColor, strokeWidth, strokeColor, , id] = str.split("~");
+  return {
+    type: "PATH",
+    pathData,
+    fillColor,
+    strokeWidth: mil10ToMm(Number(strokeWidth)),
+    strokeColor,
+    id
+  };
+};
+var PathShapeSchema = z23.string().startsWith("PT~").transform(parsePath).pipe(PathShapeOutputSchema);
+var TextShapeOutputSchema = z23.object({
+  type: z23.literal("TEXT"),
+  alignment: z23.enum(["L", "C", "R"]),
+  x: z23.number(),
+  y: z23.number(),
+  rotation: z23.number(),
+  fontColor: z23.string(),
+  backgroundColor: z23.string().optional(),
+  fontSize: z23.string(),
+  fontWeight: z23.enum(["normal", "bold"]).optional().default("normal"),
+  fontStyle: z23.enum(["normal", "italic"]).optional().default("normal"),
+  fontDecoration: z23.enum(["", "underline"]),
+  content: z23.string(),
+  textType: z23.string(),
+  visibility: z23.enum(["0", "1"]),
+  mirror: z23.string(),
+  id: z23.string()
+});
+var parseText = (str) => {
+  const [
+    ,
+    alignment,
+    x,
+    y,
+    rotation2,
+    fontColor,
+    backgroundColor,
+    fontSize,
+    fontWeight,
+    fontStyle,
+    fontDecoration,
+    content,
+    textType,
+    visibility,
+    mirror,
+    id
+  ] = str.split("~");
+  return {
+    type: "TEXT",
+    alignment,
+    x: Number(x),
+    y: Number(y),
+    rotation: Number(rotation2),
+    fontColor,
+    backgroundColor: backgroundColor || undefined,
+    fontSize,
+    fontWeight: fontWeight || "normal",
+    fontStyle: fontStyle || "normal",
+    fontDecoration,
+    content,
+    textType,
+    visibility,
+    mirror,
+    id
+  };
+};
+var TextShapeSchema = z23.string().startsWith("T~").transform(parseText).pipe(TextShapeOutputSchema);
+var SingleLetterShapeSchema = z23.string().transform((x) => {
+  if (x.startsWith("R~"))
+    return RectangleShapeSchema.parse(x);
+  if (x.startsWith("E~"))
+    return EllipseShapeSchema.parse(x);
+  if (x.startsWith("P~"))
+    return PinShapeSchema.parse(x);
+  if (x.startsWith("PL~"))
+    return PolylineShapeSchema.parse(x);
+  if (x.startsWith("PG~"))
+    return PolygonShapeSchema.parse(x);
+  if (x.startsWith("PT~"))
+    return PathShapeSchema.parse(x);
+  if (x.startsWith("T~"))
+    return TextShapeSchema.parse(x);
+  throw new Error(`Invalid shape type: ${x}`);
+}).pipe(z23.union([
+  RectangleShapeOutputSchema,
+  EllipseShapeOutputSchema,
+  PinShapeOutputSchema,
+  PolylineShapeOutputSchema,
+  PolygonShapeOutputSchema,
+  PathShapeOutputSchema,
+  TextShapeOutputSchema
+]));
+var maybeNumber = z33.any().transform((k) => k === "nan" || Number.isNaN(k) ? null : k).pipe(z33.number().nullable().optional());
+var SzlcscSchema = z33.object({
+  id: z33.number(),
+  number: z33.string(),
+  step: z33.number().optional(),
+  min: z33.number().optional(),
+  price: z33.number().optional(),
+  stock: z33.number().optional(),
+  url: z33.string().url().optional(),
+  image: z33.string().optional().optional()
+});
+var LcscSchema = z33.object({
+  id: z33.number(),
+  number: z33.string(),
+  step: z33.number().optional(),
+  min: z33.number().optional(),
+  price: z33.number().optional(),
+  stock: z33.number().optional(),
+  url: z33.string().url().optional()
+});
+var OwnerSchema = z33.object({
+  uuid: z33.string(),
+  username: z33.string(),
+  nickname: z33.string(),
+  avatar: z33.string()
+});
+var HeadSchema = z33.object({
+  docType: z33.string(),
+  editorVersion: z33.string(),
+  c_para: z33.record(z33.string(), z33.string()),
+  x: z33.number(),
+  y: z33.number(),
+  puuid: z33.string().optional(),
+  uuid: z33.string(),
+  utime: z33.number(),
+  importFlag: z33.number().optional(),
+  c_spiceCmd: z33.any().optional(),
+  hasIdFlag: z33.boolean()
+});
+var BBoxSchema = z33.object({
+  x: z33.number(),
+  y: z33.number(),
+  width: z33.number(),
+  height: z33.number()
+});
+var LayerItemSchema = z33.object({
+  name: z33.string(),
+  color: z33.string(),
+  visible: z33.boolean(),
+  active: z33.boolean(),
+  config: z33.boolean(),
+  transparency: z33.boolean()
+});
+var ObjectItemSchema = z33.object({
+  name: z33.string(),
+  visible: z33.boolean(),
+  locked: z33.boolean()
+});
+var DataStrSchema = z33.object({
+  head: HeadSchema,
+  canvas: z33.string(),
+  shape: z33.array(SingleLetterShapeSchema),
+  BBox: BBoxSchema,
+  colors: z33.array(z33.unknown())
+});
+var PackageDetailDataStrSchema = z33.object({
+  head: HeadSchema,
+  canvas: z33.string(),
+  shape: z33.array(z33.string()).transform((shapes) => shapes.map((shape) => {
+    const [type, ...data] = shape.split("~");
+    return ShapeItemSchema.parse({ type, data: data.join("~") });
+  })).pipe(z33.array(PackageDetailShapeSchema)),
+  layers: z33.array(z33.string()).transform((layers) => layers.map((layer) => {
+    const [name, color, visible, active, config, transparency] = layer.split("~");
+    return LayerItemSchema.parse({
+      name,
+      color,
+      visible: visible === "true",
+      active: active === "true",
+      config: config === "true",
+      transparency: transparency === "true"
     });
-    if (!selectedPackage) {
-      console.log(kleur_default.yellow("No package selected."));
+  })),
+  objects: z33.array(z33.string()).transform((objects) => objects.map((obj) => {
+    const [name, visible, locked] = obj.split("~");
+    return ObjectItemSchema.parse({
+      name,
+      visible: visible === "true",
+      locked: locked === "true"
+    });
+  })),
+  BBox: BBoxSchema,
+  netColors: z33.array(z33.unknown()).optional()
+});
+var PackageDetailSchema = z33.object({
+  uuid: z33.string(),
+  title: z33.string(),
+  docType: z33.number(),
+  updateTime: z33.number(),
+  owner: OwnerSchema,
+  datastrid: z33.string(),
+  writable: z33.boolean(),
+  dataStr: PackageDetailDataStrSchema
+});
+var EasyEdaJsonSchema = z33.object({
+  uuid: z33.string(),
+  title: z33.string(),
+  description: z33.string(),
+  docType: z33.number(),
+  type: z33.number(),
+  szlcsc: SzlcscSchema,
+  lcsc: LcscSchema,
+  owner: OwnerSchema,
+  tags: z33.array(z33.string()),
+  updateTime: z33.number(),
+  updated_at: z33.string(),
+  dataStr: DataStrSchema,
+  verify: z33.boolean(),
+  SMT: z33.boolean().optional(),
+  datastrid: z33.string(),
+  jlcOnSale: z33.number().optional(),
+  writable: z33.boolean(),
+  isFavorite: z33.boolean(),
+  packageDetail: PackageDetailSchema
+});
+var dist_exports = {};
+__export2(dist_exports, {
+  all_layers: () => all_layers,
+  any_circuit_element: () => any_circuit_element,
+  any_soup_element: () => any_soup_element2,
+  any_source_component: () => any_source_component,
+  battery_capacity: () => battery_capacity,
+  cad_component: () => cad_component,
+  capacitance: () => capacitance,
+  current: () => current,
+  distance: () => distance,
+  frequency: () => frequency,
+  getZodPrefixedIdWithDefault: () => getZodPrefixedIdWithDefault,
+  inductance: () => inductance,
+  layer_ref: () => layer_ref,
+  layer_string: () => layer_string,
+  length: () => length,
+  pcb_autorouting_error: () => pcb_autorouting_error,
+  pcb_board: () => pcb_board,
+  pcb_component: () => pcb_component,
+  pcb_fabrication_note_path: () => pcb_fabrication_note_path,
+  pcb_fabrication_note_text: () => pcb_fabrication_note_text,
+  pcb_group: () => pcb_group,
+  pcb_hole: () => pcb_hole,
+  pcb_hole_circle_or_square_shape: () => pcb_hole_circle_or_square_shape,
+  pcb_hole_oval_shape: () => pcb_hole_oval_shape,
+  pcb_keepout: () => pcb_keepout,
+  pcb_manual_edit_conflict_error: () => pcb_manual_edit_conflict_error,
+  pcb_missing_footprint_error: () => pcb_missing_footprint_error,
+  pcb_placement_error: () => pcb_placement_error,
+  pcb_plated_hole: () => pcb_plated_hole,
+  pcb_port: () => pcb_port,
+  pcb_port_not_matched_error: () => pcb_port_not_matched_error,
+  pcb_route_hint: () => pcb_route_hint,
+  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_path,
+  pcb_silkscreen_rect: () => pcb_silkscreen_rect,
+  pcb_silkscreen_text: () => pcb_silkscreen_text,
+  pcb_smtpad: () => pcb_smtpad,
+  pcb_smtpad_pill: () => pcb_smtpad_pill,
+  pcb_solder_paste: () => pcb_solder_paste,
+  pcb_text: () => pcb_text,
+  pcb_trace: () => pcb_trace,
+  pcb_trace_error: () => pcb_trace_error,
+  pcb_trace_hint: () => pcb_trace_hint,
+  pcb_trace_route_point: () => pcb_trace_route_point,
+  pcb_trace_route_point_via: () => pcb_trace_route_point_via,
+  pcb_trace_route_point_wire: () => pcb_trace_route_point_wire,
+  pcb_via: () => pcb_via,
+  point: () => point,
+  point3: () => point3,
+  port_arrangement: () => port_arrangement,
+  position: () => position,
+  position3: () => position3,
+  resistance: () => resistance,
+  rotation: () => rotation,
+  route_hint_point: () => route_hint_point,
+  schematic_box: () => schematic_box,
+  schematic_component: () => schematic_component,
+  schematic_component_port_arrangement_by_sides: () => schematic_component_port_arrangement_by_sides,
+  schematic_component_port_arrangement_by_size: () => schematic_component_port_arrangement_by_size,
+  schematic_debug_line: () => schematic_debug_line,
+  schematic_debug_object: () => schematic_debug_object,
+  schematic_debug_object_base: () => schematic_debug_object_base,
+  schematic_debug_point: () => schematic_debug_point,
+  schematic_debug_rect: () => schematic_debug_rect,
+  schematic_error: () => schematic_error,
+  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,
+  schematic_voltage_probe: () => schematic_voltage_probe,
+  size: () => size,
+  source_component_base: () => source_component_base,
+  source_group: () => source_group,
+  source_led: () => source_led,
+  source_net: () => source_net,
+  source_port: () => source_port,
+  source_project_metadata: () => source_project_metadata,
+  source_simple_battery: () => source_simple_battery,
+  source_simple_bug: () => source_simple_bug,
+  source_simple_capacitor: () => source_simple_capacitor,
+  source_simple_chip: () => source_simple_chip,
+  source_simple_crystal: () => source_simple_crystal,
+  source_simple_diode: () => source_simple_diode,
+  source_simple_ground: () => source_simple_ground,
+  source_simple_inductor: () => source_simple_inductor,
+  source_simple_mosfet: () => source_simple_mosfet,
+  source_simple_pin_header: () => source_simple_pin_header,
+  source_simple_potentiometer: () => source_simple_potentiometer,
+  source_simple_power_source: () => source_simple_power_source,
+  source_simple_push_button: () => source_simple_push_button,
+  source_simple_resistor: () => source_simple_resistor,
+  source_simple_resonator: () => source_simple_resonator,
+  source_simple_switch: () => source_simple_switch,
+  source_simple_transistor: () => source_simple_transistor,
+  source_trace: () => source_trace,
+  supplier_name: () => supplier_name,
+  time: () => time,
+  visible_layer: () => visible_layer,
+  voltage: () => voltage
+});
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size2 = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size2));
+  while (size2--) {
+    id += urlAlphabet[bytes[size2] & 63];
+  }
+  return id;
+};
+var unitMappings = {
+  Hz: {
+    baseUnit: "Hz",
+    variants: {
+      MHz: 1e6,
+      kHz: 1000,
+      Hz: 1
+    }
+  },
+  g: {
+    baseUnit: "g",
+    variants: {
+      kg: 1000,
+      g: 1
+    }
+  },
+  Ω: {
+    baseUnit: "Ω",
+    variants: {
+      mΩ: 0.001,
+      Ω: 1,
+      kΩ: 1000,
+      KΩ: 1000,
+      kohm: 1000,
+      MΩ: 1e6,
+      GΩ: 1e9,
+      TΩ: 1000000000000
+    }
+  },
+  V: {
+    baseUnit: "V",
+    variants: {
+      mV: 0.001,
+      V: 1,
+      kV: 1000,
+      KV: 1000,
+      MV: 1e6,
+      GV: 1e9,
+      TV: 1000000000000
+    }
+  },
+  A: {
+    baseUnit: "A",
+    variants: {
+      µA: 0.000001,
+      mA: 0.001,
+      ma: 0.001,
+      A: 1,
+      kA: 1000,
+      MA: 1e6
+    }
+  },
+  F: {
+    baseUnit: "F",
+    variants: {
+      pF: 0.000000000001,
+      nF: 0.000000001,
+      µF: 0.000001,
+      uF: 0.000001,
+      mF: 0.001,
+      F: 1
+    }
+  },
+  ml: {
+    baseUnit: "ml",
+    variants: {
+      ml: 1,
+      mL: 1,
+      l: 1000,
+      L: 1000
+    }
+  },
+  deg: {
+    baseUnit: "deg",
+    variants: {
+      rad: 180 / Math.PI
+    }
+  },
+  ms: {
+    baseUnit: "ms",
+    variants: {
+      s: 1000
+    }
+  },
+  mm: {
+    baseUnit: "mm",
+    variants: {
+      nm: 0.000001,
+      µm: 0.001,
+      um: 0.001,
+      mm: 1,
+      cm: 10,
+      dm: 100,
+      m: 1000,
+      km: 1e6,
+      in: 25.4,
+      ft: 304.8,
+      IN: 25.4,
+      FT: 304.8,
+      yd: 914.4,
+      mi: 1609344,
+      mil: 0.0254
+    }
+  }
+};
+var unitMappingAndVariantSuffixes = /* @__PURE__ */ new Set;
+for (const [baseUnit, info] of Object.entries(unitMappings)) {
+  unitMappingAndVariantSuffixes.add(baseUnit);
+  for (const variant of Object.keys(info.variants)) {
+    unitMappingAndVariantSuffixes.add(variant);
+  }
+}
+function getBaseTscircuitUnit(unit) {
+  for (const [baseUnit, info] of Object.entries(unitMappings)) {
+    if (unit in info.variants) {
+      return {
+        baseUnit: info.baseUnit,
+        conversionFactor: info.variants[unit]
+      };
+    }
+  }
+  return {
+    baseUnit: unit,
+    conversionFactor: 1
+  };
+}
+var si_prefix_multiplier = {
+  tera: 1000000000000,
+  T: 1000000000000,
+  giga: 1e9,
+  G: 1e9,
+  mega: 1e6,
+  M: 1e6,
+  kilo: 1000,
+  k: 1000,
+  deci: 0.1,
+  d: 0.1,
+  centi: 0.01,
+  c: 0.01,
+  milli: 0.001,
+  m: 0.001,
+  micro: 0.000001,
+  u: 0.000001,
+  µ: 0.000001,
+  nano: 0.000000001,
+  n: 0.000000001,
+  pico: 0.000000000001,
+  p: 0.000000000001
+};
+var parseAndConvertSiUnit = (v) => {
+  if (typeof v === "undefined")
+    return { parsedUnit: null, unitOfValue: null, value: null };
+  if (typeof v === "string" && v.match(/^-?[\d\.]+$/))
+    return {
+      value: Number.parseFloat(v),
+      parsedUnit: null,
+      unitOfValue: null
+    };
+  if (typeof v === "number")
+    return { value: v, parsedUnit: null, unitOfValue: null };
+  if (typeof v === "object" && "x" in v && "y" in v) {
+    const { parsedUnit, unitOfValue } = parseAndConvertSiUnit(v.x);
+    return {
+      parsedUnit,
+      unitOfValue,
+      value: {
+        x: parseAndConvertSiUnit(v.x).value,
+        y: parseAndConvertSiUnit(v.y).value
+      }
+    };
+  }
+  const reversed_input_string = v.toString().split("").reverse().join("");
+  const unit_reversed = reversed_input_string.match(/[^\d\s]+/)?.[0];
+  if (!unit_reversed) {
+    throw new Error(`Could not determine unit: "${v}"`);
+  }
+  const unit = unit_reversed.split("").reverse().join("");
+  const numberPart = v.slice(0, -unit.length);
+  if (unit in si_prefix_multiplier && !unitMappingAndVariantSuffixes.has(unit)) {
+    const siMultiplier = si_prefix_multiplier[unit];
+    return {
+      parsedUnit: null,
+      unitOfValue: null,
+      value: Number.parseFloat(numberPart) * siMultiplier
+    };
+  }
+  const { baseUnit, conversionFactor } = getBaseTscircuitUnit(unit);
+  return {
+    parsedUnit: unit,
+    unitOfValue: baseUnit,
+    value: conversionFactor * Number.parseFloat(numberPart)
+  };
+};
+var resistance = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var capacitance = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value).transform((value) => {
+  return Number.parseFloat(value.toPrecision(12));
+});
+var inductance = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var voltage = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var length = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var frequency = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var distance = length;
+var current = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var time = z43.string().or(z43.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var rotation = z43.string().or(z43.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 battery_capacity = z43.number().or(z43.string().endsWith("mAh")).transform((v) => {
+  if (typeof v === "string") {
+    const valString = v.replace("mAh", "");
+    const num = Number.parseFloat(valString);
+    if (Number.isNaN(num)) {
+      throw new Error("Invalid capacity");
+    }
+    return num;
+  }
+  return v;
+}).describe("Battery capacity in mAh");
+var point = z222.object({
+  x: distance,
+  y: distance
+});
+var position = point;
+var point3 = z322.object({
+  x: distance,
+  y: distance,
+  z: distance
+});
+var position3 = point3;
+var size = z422.object({
+  width: z422.number(),
+  height: z422.number()
+});
+var getZodPrefixedIdWithDefault = (prefix) => {
+  return z53.string().optional().default(() => `${prefix}_${nanoid(10)}`);
+};
+var supplier_name = z62.enum([
+  "jlcpcb",
+  "macrofab",
+  "pcbway",
+  "digikey",
+  "mouser",
+  "lcsc"
+]);
+var expectTypesMatch = (shouldBe) => {};
+expectTypesMatch("extra props b");
+expectTypesMatch("missing props b");
+expectTypesMatch(true);
+expectTypesMatch("mismatched prop types: a");
+var source_component_base = z72.object({
+  type: z72.literal("source_component"),
+  ftype: z72.string().optional(),
+  source_component_id: z72.string(),
+  name: z72.string(),
+  manufacturer_part_number: z72.string().optional(),
+  supplier_part_numbers: z72.record(supplier_name, z72.array(z72.string())).optional(),
+  display_value: z72.string().optional()
+});
+expectTypesMatch(true);
+var source_simple_capacitor = source_component_base.extend({
+  ftype: z82.literal("simple_capacitor"),
+  capacitance,
+  max_voltage_rating: voltage.optional(),
+  display_capacitance: z82.string().optional(),
+  max_decoupling_trace_length: distance.optional()
+});
+expectTypesMatch(true);
+var source_simple_resistor = source_component_base.extend({
+  ftype: z92.literal("simple_resistor"),
+  resistance,
+  display_resistance: z92.string().optional()
+});
+expectTypesMatch(true);
+var source_simple_diode = source_component_base.extend({
+  ftype: z102.literal("simple_diode")
+});
+expectTypesMatch(true);
+var source_simple_ground = source_component_base.extend({
+  ftype: z112.literal("simple_ground")
+});
+expectTypesMatch(true);
+var source_simple_bug = source_component_base.extend({
+  ftype: z122.literal("simple_bug")
+}).describe("@deprecated");
+var source_simple_chip = source_component_base.extend({
+  ftype: z132.literal("simple_chip")
+});
+expectTypesMatch(true);
+var source_led = source_simple_diode.extend({
+  ftype: z142.literal("led")
+});
+expectTypesMatch(true);
+var source_simple_power_source = source_component_base.extend({
+  ftype: z152.literal("simple_power_source"),
+  voltage
+});
+expectTypesMatch(true);
+var source_simple_battery = source_component_base.extend({
+  ftype: z162.literal("simple_battery"),
+  capacity: battery_capacity
+});
+expectTypesMatch(true);
+var source_simple_inductor = source_component_base.extend({
+  ftype: z172.literal("simple_inductor"),
+  inductance
+});
+expectTypesMatch(true);
+var source_simple_push_button = source_component_base.extend({
+  ftype: z182.literal("simple_push_button")
+});
+expectTypesMatch(true);
+var source_simple_potentiometer = source_component_base.extend({
+  ftype: z192.literal("simple_potentiometer"),
+  max_resistance: resistance
+});
+var source_simple_crystal = source_component_base.extend({
+  ftype: z202.literal("simple_crystal"),
+  frequency: z202.number().describe("Frequency in Hz"),
+  load_capacitance: z202.number().optional().describe("Load capacitance in pF")
+});
+expectTypesMatch(true);
+var source_simple_pin_header = source_component_base.extend({
+  ftype: z21.literal("simple_pin_header"),
+  pin_count: z21.number(),
+  gender: z21.enum(["male", "female"]).optional().default("male")
+});
+var source_simple_resonator = source_component_base.extend({
+  ftype: z2222.literal("simple_resonator"),
+  load_capacitance: capacitance,
+  equivalent_series_resistance: resistance.optional(),
+  frequency
+});
+expectTypesMatch(true);
+var source_simple_transistor = source_component_base.extend({
+  ftype: z232.literal("simple_transistor"),
+  transistor_type: z232.enum(["npn", "pnp"])
+});
+expectTypesMatch(true);
+var source_simple_mosfet = source_component_base.extend({
+  ftype: z24.literal("simple_mosfet"),
+  channel_type: z24.enum(["n", "p"]),
+  mosfet_mode: z24.enum(["enhancement", "depletion"])
+});
+expectTypesMatch(true);
+var source_simple_switch = source_component_base.extend({
+  ftype: z25.literal("simple_switch")
+});
+expectTypesMatch(true);
+var source_project_metadata = z26.object({
+  type: z26.literal("source_project_metadata"),
+  name: z26.string().optional(),
+  software_used_string: z26.string().optional(),
+  created_at: z26.string().datetime().optional()
+});
+expectTypesMatch(true);
+var any_source_component = z27.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,
+  source_simple_battery,
+  source_simple_inductor,
+  source_simple_push_button,
+  source_simple_potentiometer,
+  source_simple_crystal,
+  source_simple_pin_header,
+  source_simple_resonator,
+  source_simple_switch,
+  source_simple_transistor,
+  source_simple_mosfet,
+  source_project_metadata
+]);
+var source_port = z28.object({
+  type: z28.literal("source_port"),
+  pin_number: z28.number().optional(),
+  port_hints: z28.array(z28.string()).optional(),
+  name: z28.string(),
+  source_port_id: z28.string(),
+  source_component_id: z28.string(),
+  subcircuit_id: z28.string().optional()
+});
+expectTypesMatch(true);
+var source_trace = z29.object({
+  type: z29.literal("source_trace"),
+  source_trace_id: z29.string(),
+  connected_source_port_ids: z29.array(z29.string()),
+  connected_source_net_ids: z29.array(z29.string()),
+  subcircuit_id: z29.string().optional(),
+  subcircuit_connectivity_map_key: z29.string().optional(),
+  max_length: z29.number().optional(),
+  min_trace_thickness: z29.number().optional(),
+  display_name: z29.string().optional()
+});
+expectTypesMatch(true);
+var source_group = z30.object({
+  type: z30.literal("source_group"),
+  source_group_id: z30.string(),
+  subcircuit_id: z30.string().optional(),
+  parent_subcircuit_id: z30.string().optional(),
+  is_subcircuit: z30.boolean().optional(),
+  name: z30.string().optional()
+});
+var source_net = z31.object({
+  type: z31.literal("source_net"),
+  source_net_id: z31.string(),
+  name: z31.string(),
+  member_source_group_ids: z31.array(z31.string()),
+  is_power: z31.boolean().optional(),
+  is_ground: z31.boolean().optional(),
+  is_digital_signal: z31.boolean().optional(),
+  is_analog_signal: z31.boolean().optional(),
+  trace_width: z31.number().optional(),
+  subcircuit_id: z31.string().optional()
+});
+var schematic_box = z3222.object({
+  type: z3222.literal("schematic_box"),
+  schematic_component_id: z3222.string(),
+  width: distance,
+  height: distance,
+  x: distance,
+  y: distance
+}).describe("Draws a box on the schematic");
+expectTypesMatch(true);
+var schematic_path = z332.object({
+  type: z332.literal("schematic_path"),
+  schematic_component_id: z332.string(),
+  fill_color: z332.enum(["red", "blue"]).optional(),
+  is_filled: z332.boolean().optional(),
+  points: z332.array(point)
+});
+expectTypesMatch(true);
+var schematic_pin_styles = z34.record(z34.object({
+  left_margin: length.optional(),
+  right_margin: length.optional(),
+  top_margin: length.optional(),
+  bottom_margin: length.optional()
+}));
+var schematic_component_port_arrangement_by_size = z34.object({
+  left_size: z34.number(),
+  right_size: z34.number(),
+  top_size: z34.number().optional(),
+  bottom_size: z34.number().optional()
+});
+expectTypesMatch(true);
+var schematic_component_port_arrangement_by_sides = z34.object({
+  left_side: z34.object({
+    pins: z34.array(z34.number()),
+    direction: z34.enum(["top-to-bottom", "bottom-to-top"]).optional()
+  }).optional(),
+  right_side: z34.object({
+    pins: z34.array(z34.number()),
+    direction: z34.enum(["top-to-bottom", "bottom-to-top"]).optional()
+  }).optional(),
+  top_side: z34.object({
+    pins: z34.array(z34.number()),
+    direction: z34.enum(["left-to-right", "right-to-left"]).optional()
+  }).optional(),
+  bottom_side: z34.object({
+    pins: z34.array(z34.number()),
+    direction: z34.enum(["left-to-right", "right-to-left"]).optional()
+  }).optional()
+});
+expectTypesMatch(true);
+var port_arrangement = z34.union([
+  schematic_component_port_arrangement_by_size,
+  schematic_component_port_arrangement_by_sides
+]);
+var schematic_component = z34.object({
+  type: z34.literal("schematic_component"),
+  size,
+  center: point,
+  source_component_id: z34.string(),
+  schematic_component_id: z34.string(),
+  pin_spacing: length.optional(),
+  pin_styles: schematic_pin_styles.optional(),
+  box_width: length.optional(),
+  symbol_name: z34.string().optional(),
+  port_arrangement: port_arrangement.optional(),
+  port_labels: z34.record(z34.string()).optional(),
+  symbol_display_value: z34.string().optional()
+});
+expectTypesMatch(true);
+var schematic_line = z35.object({
+  type: z35.literal("schematic_line"),
+  schematic_component_id: z35.string(),
+  x1: distance,
+  x2: distance,
+  y1: distance,
+  y2: distance
+});
+expectTypesMatch(true);
+var schematic_trace = z36.object({
+  type: z36.literal("schematic_trace"),
+  schematic_trace_id: z36.string(),
+  source_trace_id: z36.string(),
+  junctions: z36.array(z36.object({
+    x: z36.number(),
+    y: z36.number()
+  })),
+  edges: z36.array(z36.object({
+    from: z36.object({
+      x: z36.number(),
+      y: z36.number()
+    }),
+    to: z36.object({
+      x: z36.number(),
+      y: z36.number()
+    }),
+    is_crossing: z36.boolean().optional(),
+    from_schematic_port_id: z36.string().optional(),
+    to_schematic_port_id: z36.string().optional()
+  }))
+});
+expectTypesMatch(true);
+var schematic_text = z37.object({
+  type: z37.literal("schematic_text"),
+  schematic_component_id: z37.string(),
+  schematic_text_id: z37.string(),
+  text: z37.string(),
+  position: z37.object({
+    x: distance,
+    y: distance
+  }),
+  rotation: z37.number().default(0),
+  anchor: z37.enum(["center", "left", "right", "top", "bottom"]).default("center"),
+  color: z37.string().default("#000000")
+});
+expectTypesMatch(true);
+var schematic_port = z38.object({
+  type: z38.literal("schematic_port"),
+  schematic_port_id: z38.string(),
+  source_port_id: z38.string(),
+  schematic_component_id: z38.string().optional(),
+  center: point,
+  facing_direction: z38.enum(["up", "down", "left", "right"]).optional(),
+  distance_from_component_edge: z38.number().optional(),
+  side_of_component: z38.enum(["top", "bottom", "left", "right"]).optional(),
+  true_ccw_index: z38.number().optional(),
+  pin_number: z38.number().optional(),
+  display_pin_label: z38.string().optional()
+}).describe("Defines a port on a schematic component");
+expectTypesMatch(true);
+var schematic_net_label = z39.object({
+  type: z39.literal("schematic_net_label"),
+  source_net_id: z39.string(),
+  center: point,
+  anchor_position: point.optional(),
+  anchor_side: z39.enum(["top", "bottom", "left", "right"]),
+  text: z39.string(),
+  symbol_name: z39.string().optional()
+});
+var schematic_error = z40.object({
+  type: z40.literal("schematic_error"),
+  schematic_error_id: z40.string(),
+  error_type: z40.literal("schematic_port_not_found"),
+  message: z40.string()
+}).describe("Defines a schematic error on the schematic");
+expectTypesMatch(true);
+var schematic_debug_object_base = z41.object({
+  type: z41.literal("schematic_debug_object"),
+  label: z41.string().optional()
+});
+var schematic_debug_rect = schematic_debug_object_base.extend({
+  shape: z41.literal("rect"),
+  center: point,
+  size
+});
+var schematic_debug_line = schematic_debug_object_base.extend({
+  shape: z41.literal("line"),
+  start: point,
+  end: point
+});
+var schematic_debug_point = schematic_debug_object_base.extend({
+  shape: z41.literal("point"),
+  center: point
+});
+var schematic_debug_object = z41.discriminatedUnion("shape", [
+  schematic_debug_rect,
+  schematic_debug_line,
+  schematic_debug_point
+]);
+expectTypesMatch(true);
+var schematic_voltage_probe = z4222.object({
+  type: z4222.literal("schematic_voltage_probe"),
+  schematic_voltage_probe_id: z4222.string(),
+  position: point,
+  schematic_trace_id: z4222.string(),
+  voltage: voltage.optional()
+}).describe("Defines a voltage probe measurement point on a schematic trace");
+expectTypesMatch(true);
+var all_layers = [
+  "top",
+  "bottom",
+  "inner1",
+  "inner2",
+  "inner3",
+  "inner4",
+  "inner5",
+  "inner6"
+];
+var layer_string = z432.enum(all_layers);
+var layer_ref = layer_string.or(z432.object({
+  name: layer_string
+})).transform((layer) => {
+  if (typeof layer === "string") {
+    return layer;
+  }
+  return layer.name;
+});
+var visible_layer = z432.enum(["top", "bottom"]);
+var pcb_route_hint = z44.object({
+  x: distance,
+  y: distance,
+  via: z44.boolean().optional(),
+  via_to_layer: layer_ref.optional()
+});
+var pcb_route_hints = z44.array(pcb_route_hint);
+var route_hint_point = z45.object({
+  x: distance,
+  y: distance,
+  via: z45.boolean().optional(),
+  to_layer: layer_ref.optional(),
+  trace_width: distance.optional()
+});
+var pcb_component = z46.object({
+  type: z46.literal("pcb_component"),
+  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
+  source_component_id: z46.string(),
+  center: point,
+  layer: layer_ref,
+  rotation,
+  width: length,
+  height: length,
+  subcircuit_id: z46.string().optional()
+}).describe("Defines a component on the PCB");
+expectTypesMatch(true);
+var pcb_hole_circle_or_square = z47.object({
+  type: z47.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  pcb_group_id: z47.string().optional(),
+  subcircuit_id: z47.string().optional(),
+  hole_shape: z47.enum(["circle", "square"]),
+  hole_diameter: z47.number(),
+  x: distance,
+  y: distance
+});
+var pcb_hole_circle_or_square_shape = pcb_hole_circle_or_square.describe("Defines a circular or square hole on the PCB");
+expectTypesMatch(true);
+var pcb_hole_oval = z47.object({
+  type: z47.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  pcb_group_id: z47.string().optional(),
+  subcircuit_id: z47.string().optional(),
+  hole_shape: z47.literal("oval"),
+  hole_width: z47.number(),
+  hole_height: z47.number(),
+  x: distance,
+  y: distance
+});
+var pcb_hole_oval_shape = pcb_hole_oval.describe("Defines an oval hole on the PCB");
+expectTypesMatch(true);
+var pcb_hole = pcb_hole_circle_or_square.or(pcb_hole_oval);
+var pcb_plated_hole_circle = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("circle"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  outer_diameter: z48.number(),
+  hole_diameter: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole_oval = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.enum(["oval", "pill"]),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  outer_width: z48.number(),
+  outer_height: z48.number(),
+  hole_width: z48.number(),
+  hole_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_circular_hole_with_rect_pad = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("circular_hole_with_rect_pad"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  hole_shape: z48.literal("circle"),
+  pad_shape: z48.literal("rect"),
+  hole_diameter: z48.number(),
+  rect_pad_width: z48.number(),
+  rect_pad_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_pill_hole_with_rect_pad = z48.object({
+  type: z48.literal("pcb_plated_hole"),
+  shape: z48.literal("pill_hole_with_rect_pad"),
+  pcb_group_id: z48.string().optional(),
+  subcircuit_id: z48.string().optional(),
+  hole_shape: z48.literal("pill"),
+  pad_shape: z48.literal("rect"),
+  hole_width: z48.number(),
+  hole_height: z48.number(),
+  rect_pad_width: z48.number(),
+  rect_pad_height: z48.number(),
+  x: distance,
+  y: distance,
+  layers: z48.array(layer_ref),
+  port_hints: z48.array(z48.string()).optional(),
+  pcb_component_id: z48.string().optional(),
+  pcb_port_id: z48.string().optional(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole = z48.union([
+  pcb_plated_hole_circle,
+  pcb_plated_hole_oval,
+  pcb_circular_hole_with_rect_pad
+]);
+expectTypesMatch(true);
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_port = z49.object({
+  type: z49.literal("pcb_port"),
+  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
+  pcb_group_id: z49.string().optional(),
+  subcircuit_id: z49.string().optional(),
+  source_port_id: z49.string(),
+  pcb_component_id: z49.string(),
+  x: distance,
+  y: distance,
+  layers: z49.array(layer_ref)
+}).describe("Defines a port on the PCB");
+expectTypesMatch(true);
+var pcb_smtpad_circle = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("circle"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  radius: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_rect = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("rect"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_rotated_rect = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("rotated_rect"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  ccw_rotation: rotation,
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad_pill = z50.object({
+  type: z50.literal("pcb_smtpad"),
+  shape: z50.literal("pill"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  pcb_group_id: z50.string().optional(),
+  subcircuit_id: z50.string().optional(),
+  x: distance,
+  y: distance,
+  width: z50.number(),
+  height: z50.number(),
+  radius: z50.number(),
+  layer: layer_ref,
+  port_hints: z50.array(z50.string()).optional(),
+  pcb_component_id: z50.string().optional(),
+  pcb_port_id: z50.string().optional()
+});
+var pcb_smtpad = z50.union([
+  pcb_smtpad_circle,
+  pcb_smtpad_rect,
+  pcb_smtpad_rotated_rect,
+  pcb_smtpad_pill
+]).describe("Defines an SMT pad on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_solder_paste_circle = z51.object({
+  type: z51.literal("pcb_solder_paste"),
+  shape: z51.literal("circle"),
+  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+  pcb_group_id: z51.string().optional(),
+  subcircuit_id: z51.string().optional(),
+  x: distance,
+  y: distance,
+  radius: z51.number(),
+  layer: layer_ref,
+  pcb_component_id: z51.string().optional(),
+  pcb_smtpad_id: z51.string().optional()
+});
+var pcb_solder_paste_rect = z51.object({
+  type: z51.literal("pcb_solder_paste"),
+  shape: z51.literal("rect"),
+  pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+  pcb_group_id: z51.string().optional(),
+  subcircuit_id: z51.string().optional(),
+  x: distance,
+  y: distance,
+  width: z51.number(),
+  height: z51.number(),
+  layer: layer_ref,
+  pcb_component_id: z51.string().optional(),
+  pcb_smtpad_id: z51.string().optional()
+});
+var pcb_solder_paste = z51.union([pcb_solder_paste_circle, pcb_solder_paste_rect]).describe("Defines solderpaste on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_text = z522.object({
+  type: z522.literal("pcb_text"),
+  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
+  pcb_group_id: z522.string().optional(),
+  subcircuit_id: z522.string().optional(),
+  text: z522.string(),
+  center: point,
+  layer: layer_ref,
+  width: length,
+  height: length,
+  lines: z522.number(),
+  align: z522.enum(["bottom-left"])
+}).describe("Defines text on the PCB");
+expectTypesMatch(true);
+var pcb_trace_route_point_wire = z532.object({
+  route_type: z532.literal("wire"),
+  x: distance,
+  y: distance,
+  width: distance,
+  start_pcb_port_id: z532.string().optional(),
+  end_pcb_port_id: z532.string().optional(),
+  layer: layer_ref
+});
+var pcb_trace_route_point_via = z532.object({
+  route_type: z532.literal("via"),
+  x: distance,
+  y: distance,
+  from_layer: z532.string(),
+  to_layer: z532.string()
+});
+var pcb_trace_route_point = z532.union([
+  pcb_trace_route_point_wire,
+  pcb_trace_route_point_via
+]);
+var pcb_trace = z532.object({
+  type: z532.literal("pcb_trace"),
+  source_trace_id: z532.string().optional(),
+  pcb_component_id: z532.string().optional(),
+  pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
+  pcb_group_id: z532.string().optional(),
+  subcircuit_id: z532.string().optional(),
+  route_thickness_mode: z532.enum(["constant", "interpolated"]).default("constant").optional(),
+  route_order_index: z532.number().optional(),
+  should_round_corners: z532.boolean().optional(),
+  trace_length: z532.number().optional(),
+  route: z532.array(z532.union([
+    z532.object({
+      route_type: z532.literal("wire"),
+      x: distance,
+      y: distance,
+      width: distance,
+      start_pcb_port_id: z532.string().optional(),
+      end_pcb_port_id: z532.string().optional(),
+      layer: layer_ref
+    }),
+    z532.object({
+      route_type: z532.literal("via"),
+      x: distance,
+      y: distance,
+      from_layer: z532.string(),
+      to_layer: z532.string()
+    })
+  ]))
+}).describe("Defines a trace on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_trace_error = z54.object({
+  type: z54.literal("pcb_trace_error"),
+  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
+  error_type: z54.literal("pcb_trace_error"),
+  message: z54.string(),
+  center: point.optional(),
+  pcb_trace_id: z54.string(),
+  source_trace_id: z54.string(),
+  pcb_component_ids: z54.array(z54.string()),
+  pcb_port_ids: z54.array(z54.string())
+}).describe("Defines a trace error on the PCB");
+expectTypesMatch(true);
+var pcb_port_not_matched_error = z55.object({
+  type: z55.literal("pcb_port_not_matched_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
+  message: z55.string(),
+  pcb_component_ids: z55.array(z55.string())
+}).describe("Defines a trace error on the PCB where a port is not matched");
+expectTypesMatch(true);
+var pcb_via = z56.object({
+  type: z56.literal("pcb_via"),
+  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
+  pcb_group_id: z56.string().optional(),
+  subcircuit_id: z56.string().optional(),
+  x: distance,
+  y: distance,
+  outer_diameter: distance.default("0.6mm"),
+  hole_diameter: distance.default("0.25mm"),
+  from_layer: layer_ref.optional(),
+  to_layer: layer_ref.optional(),
+  layers: z56.array(layer_ref),
+  pcb_trace_id: z56.string().optional()
+}).describe("Defines a via on the PCB");
+expectTypesMatch(true);
+var pcb_board = z57.object({
+  type: z57.literal("pcb_board"),
+  pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
+  is_subcircuit: z57.boolean().optional(),
+  subcircuit_id: z57.string().optional(),
+  width: length,
+  height: length,
+  center: point,
+  thickness: length.optional().default(1.4),
+  num_layers: z57.number().optional().default(4),
+  outline: z57.array(point).optional()
+}).describe("Defines the board outline of the PCB");
+expectTypesMatch(true);
+var pcb_placement_error = z58.object({
+  type: z58.literal("pcb_placement_error"),
+  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
+  message: z58.string()
+}).describe("Defines a placement error on the PCB");
+expectTypesMatch(true);
+var pcb_trace_hint = z59.object({
+  type: z59.literal("pcb_trace_hint"),
+  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
+  pcb_port_id: z59.string(),
+  pcb_component_id: z59.string(),
+  route: z59.array(route_hint_point)
+}).describe("A hint that can be used during generation of a PCB trace");
+expectTypesMatch(true);
+var pcb_silkscreen_line = z60.object({
+  type: z60.literal("pcb_silkscreen_line"),
+  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
+  pcb_component_id: z60.string(),
+  pcb_group_id: z60.string().optional(),
+  subcircuit_id: z60.string().optional(),
+  stroke_width: distance.default("0.1mm"),
+  x1: distance,
+  y1: distance,
+  x2: distance,
+  y2: distance,
+  layer: visible_layer
+}).describe("Defines a silkscreen line on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_path = z61.object({
+  type: z61.literal("pcb_silkscreen_path"),
+  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
+  pcb_component_id: z61.string(),
+  pcb_group_id: z61.string().optional(),
+  subcircuit_id: z61.string().optional(),
+  layer: visible_layer,
+  route: z61.array(point),
+  stroke_width: length
+}).describe("Defines a silkscreen path on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_text = z622.object({
+  type: z622.literal("pcb_silkscreen_text"),
+  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
+  pcb_group_id: z622.string().optional(),
+  subcircuit_id: z622.string().optional(),
+  font: z622.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("0.2mm"),
+  pcb_component_id: z622.string(),
+  text: z622.string(),
+  ccw_rotation: z622.number().optional(),
+  layer: layer_ref,
+  is_mirrored: z622.boolean().default(false).optional(),
+  anchor_position: point.default({ x: 0, y: 0 }),
+  anchor_alignment: z622.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+}).describe("Defines silkscreen text on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_rect = z63.object({
+  type: z63.literal("pcb_silkscreen_rect"),
+  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
+  pcb_component_id: z63.string(),
+  pcb_group_id: z63.string().optional(),
+  subcircuit_id: z63.string().optional(),
+  center: point,
+  width: length,
+  height: length,
+  layer: layer_ref,
+  stroke_width: length.default("1mm")
+}).describe("Defines a silkscreen rect on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_circle = z64.object({
+  type: z64.literal("pcb_silkscreen_circle"),
+  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault("pcb_silkscreen_circle"),
+  pcb_component_id: z64.string(),
+  pcb_group_id: z64.string().optional(),
+  subcircuit_id: z64.string().optional(),
+  center: point,
+  radius: length,
+  layer: visible_layer,
+  stroke_width: length.default("1mm")
+}).describe("Defines a silkscreen circle on the PCB");
+expectTypesMatch(true);
+var pcb_silkscreen_oval = z65.object({
+  type: z65.literal("pcb_silkscreen_oval"),
+  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
+  pcb_component_id: z65.string(),
+  pcb_group_id: z65.string().optional(),
+  subcircuit_id: z65.string().optional(),
+  center: point,
+  radius_x: distance,
+  radius_y: distance,
+  layer: visible_layer
+}).describe("Defines a silkscreen oval on the PCB");
+expectTypesMatch(true);
+var pcb_fabrication_note_text = z66.object({
+  type: z66.literal("pcb_fabrication_note_text"),
+  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault("pcb_fabrication_note_text"),
+  subcircuit_id: z66.string().optional(),
+  pcb_group_id: z66.string().optional(),
+  font: z66.literal("tscircuit2024").default("tscircuit2024"),
+  font_size: distance.default("1mm"),
+  pcb_component_id: z66.string(),
+  text: z66.string(),
+  layer: visible_layer,
+  anchor_position: point.default({ x: 0, y: 0 }),
+  anchor_alignment: z66.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  color: z66.string().optional()
+}).describe("Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators");
+expectTypesMatch(true);
+var pcb_fabrication_note_path = z67.object({
+  type: z67.literal("pcb_fabrication_note_path"),
+  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault("pcb_fabrication_note_path"),
+  pcb_component_id: z67.string(),
+  subcircuit_id: z67.string().optional(),
+  layer: layer_ref,
+  route: z67.array(point),
+  stroke_width: length,
+  color: z67.string().optional()
+}).describe("Defines a fabrication path on the PCB for fabricators or assemblers");
+expectTypesMatch(true);
+var pcb_keepout = z68.object({
+  type: z68.literal("pcb_keepout"),
+  shape: z68.literal("rect"),
+  pcb_group_id: z68.string().optional(),
+  subcircuit_id: z68.string().optional(),
+  center: point,
+  width: distance,
+  height: distance,
+  pcb_keepout_id: z68.string(),
+  layers: z68.array(z68.string()),
+  description: z68.string().optional()
+}).or(z68.object({
+  type: z68.literal("pcb_keepout"),
+  shape: z68.literal("circle"),
+  pcb_group_id: z68.string().optional(),
+  subcircuit_id: z68.string().optional(),
+  center: point,
+  radius: distance,
+  pcb_keepout_id: z68.string(),
+  layers: z68.array(z68.string()),
+  description: z68.string().optional()
+}));
+var pcb_missing_footprint_error = z69.object({
+  type: z69.literal("pcb_missing_footprint_error"),
+  pcb_missing_footprint_error_id: getZodPrefixedIdWithDefault("pcb_missing_footprint_error"),
+  pcb_group_id: z69.string().optional(),
+  subcircuit_id: z69.string().optional(),
+  error_type: z69.literal("pcb_missing_footprint_error"),
+  source_component_id: z69.string(),
+  message: z69.string()
+}).describe("Defines a missing footprint error on the PCB");
+expectTypesMatch(true);
+var pcb_manual_edit_conflict_error = z70.object({
+  type: z70.literal("pcb_manual_edit_conflict_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_manual_edit_conflict_error"),
+  message: z70.string(),
+  pcb_component_id: z70.string(),
+  pcb_group_id: z70.string().optional(),
+  subcircuit_id: z70.string().optional(),
+  source_component_id: z70.string()
+}).describe("Error emitted when a component has both manual placement and explicit pcbX/pcbY coordinates");
+expectTypesMatch(true);
+var pcb_group = z71.object({
+  type: z71.literal("pcb_group"),
+  pcb_group_id: getZodPrefixedIdWithDefault("pcb_group"),
+  source_group_id: z71.string(),
+  is_subcircuit: z71.boolean().optional(),
+  subcircuit_id: z71.string().optional(),
+  width: length,
+  height: length,
+  center: point,
+  pcb_component_ids: z71.array(z71.string()),
+  name: z71.string().optional(),
+  description: z71.string().optional()
+}).describe("Defines a group of components on the PCB");
+expectTypesMatch(true);
+var pcb_autorouting_error = z722.object({
+  type: z722.literal("pcb_autorouting_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_autorouting_error"),
+  message: z722.string()
+}).describe("The autorouting has failed to route a portion of the board");
+expectTypesMatch(true);
+var cad_component = z73.object({
+  type: z73.literal("cad_component"),
+  cad_component_id: z73.string(),
+  pcb_component_id: z73.string(),
+  source_component_id: z73.string(),
+  position: point3,
+  rotation: point3.optional(),
+  size: point3.optional(),
+  layer: layer_ref.optional(),
+  footprinter_string: z73.string().optional(),
+  model_obj_url: z73.string().optional(),
+  model_stl_url: z73.string().optional(),
+  model_3mf_url: z73.string().optional(),
+  model_jscad: z73.any().optional()
+}).describe("Defines a component on the PCB");
+var any_circuit_element = z74.union([
+  source_trace,
+  source_port,
+  any_source_component,
+  source_led,
+  source_net,
+  source_group,
+  source_simple_bug,
+  source_simple_chip,
+  source_simple_capacitor,
+  source_simple_diode,
+  source_simple_resistor,
+  source_simple_power_source,
+  source_simple_battery,
+  source_simple_inductor,
+  source_simple_pin_header,
+  source_simple_resonator,
+  source_simple_switch,
+  source_simple_transistor,
+  source_simple_mosfet,
+  source_simple_potentiometer,
+  source_simple_push_button,
+  source_project_metadata,
+  pcb_component,
+  pcb_hole,
+  pcb_missing_footprint_error,
+  pcb_manual_edit_conflict_error,
+  pcb_plated_hole,
+  pcb_keepout,
+  pcb_port,
+  pcb_text,
+  pcb_trace,
+  pcb_via,
+  pcb_smtpad,
+  pcb_solder_paste,
+  pcb_board,
+  pcb_group,
+  pcb_trace_hint,
+  pcb_silkscreen_line,
+  pcb_silkscreen_path,
+  pcb_silkscreen_text,
+  pcb_silkscreen_rect,
+  pcb_silkscreen_circle,
+  pcb_silkscreen_oval,
+  pcb_trace_error,
+  pcb_placement_error,
+  pcb_port_not_matched_error,
+  pcb_fabrication_note_path,
+  pcb_fabrication_note_text,
+  pcb_autorouting_error,
+  schematic_box,
+  schematic_text,
+  schematic_line,
+  schematic_component,
+  schematic_port,
+  schematic_trace,
+  schematic_path,
+  schematic_error,
+  schematic_net_label,
+  schematic_debug_object,
+  schematic_voltage_probe,
+  cad_component
+]);
+var any_soup_element2 = any_circuit_element;
+var su6 = (soup, options = {}) => {
+  let internalStore = soup._internal_store;
+  if (!internalStore) {
+    internalStore = {
+      counts: {}
+    };
+    soup._internal_store = internalStore;
+    for (const elm of soup) {
+      const type = elm.type;
+      const idVal = elm[`${type}_id`];
+      if (!idVal)
+        continue;
+      const idNum = Number.parseInt(idVal.split("_").pop());
+      if (!Number.isNaN(idNum)) {
+        internalStore.counts[type] = Math.max(internalStore.counts[type] ?? 0, idNum);
+      }
+    }
+  }
+  const su22 = new Proxy({}, {
+    get: (proxy_target, component_type) => {
+      if (component_type === "toArray") {
+        return () => soup;
+      }
+      return {
+        get: (id) => soup.find((e) => e.type === component_type && e[`${component_type}_id`] === id),
+        getUsing: (using) => {
+          const keys = Object.keys(using);
+          if (keys.length !== 1) {
+            throw new Error("getUsing requires exactly one key, e.g. { pcb_component_id }");
+          }
+          const join_key = keys[0];
+          const join_type = join_key.replace("_id", "");
+          const joiner = soup.find((e) => e.type === join_type && e[join_key] === using[join_key]);
+          if (!joiner)
+            return null;
+          return soup.find((e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]);
+        },
+        getWhere: (where) => {
+          const keys = Object.keys(where);
+          return soup.find((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
+        },
+        list: (where) => {
+          const keys = !where ? [] : Object.keys(where);
+          return soup.filter((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
+        },
+        insert: (elm) => {
+          internalStore.counts[component_type] ??= -1;
+          internalStore.counts[component_type]++;
+          const index = internalStore.counts[component_type];
+          const newElm = {
+            type: component_type,
+            [`${component_type}_id`]: `${component_type}_${index}`,
+            ...elm
+          };
+          if (options.validateInserts) {
+            const parser = dist_exports[component_type] ?? any_soup_element2;
+            parser.parse(newElm);
+          }
+          soup.push(newElm);
+          return newElm;
+        },
+        delete: (id) => {
+          const elm = soup.find((e) => e[`${component_type}_id`] === id);
+          if (!elm)
+            return;
+          soup.splice(soup.indexOf(elm), 1);
+        },
+        update: (id, newProps) => {
+          const elm = soup.find((e) => e.type === component_type && e[`${component_type}_id`] === id);
+          if (!elm)
+            return;
+          Object.assign(elm, newProps);
+          return elm;
+        },
+        select: (selector) => {
+          if (component_type === "source_component") {
+            return soup.find((e) => e.type === "source_component" && e.name === selector.replace(/\./g, ""));
+          } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
+            const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
+            const source_component = soup.find((e) => e.type === "source_component" && e.name === component_name);
+            if (!source_component)
+              return null;
+            const source_port2 = soup.find((e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector)));
+            if (!source_port2)
+              return null;
+            if (component_type === "source_port")
+              return source_port2;
+            if (component_type === "pcb_port") {
+              return soup.find((e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id);
+            } else if (component_type === "schematic_port") {
+              return soup.find((e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id);
+            }
+          }
+        }
+      };
+    }
+  });
+  return su22;
+};
+su6.unparsed = su6;
+var su_default2 = su6;
+var transformPCBElement = (elm, matrix) => {
+  if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
+    const { x, y } = applyToPoint3(matrix, { x: elm.x, y: elm.y });
+    elm.x = x;
+    elm.y = y;
+  } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
+    elm.center = applyToPoint3(matrix, elm.center);
+  } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
+    elm.anchor_position = applyToPoint3(matrix, elm.anchor_position);
+  } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
+    elm.center = applyToPoint3(matrix, elm.center);
+  } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
+    elm.route = elm.route.map((rp) => {
+      const tp = applyToPoint3(matrix, rp);
+      rp.x = tp.x;
+      rp.y = tp.y;
+      return rp;
+    });
+  } else if (elm.type === "pcb_silkscreen_line") {
+    const p1 = { x: elm.x1, y: elm.y1 };
+    const p2 = { x: elm.x2, y: elm.y2 };
+    const p1t = applyToPoint3(matrix, p1);
+    const p2t = applyToPoint3(matrix, p2);
+    elm.x1 = p1t.x;
+    elm.y1 = p1t.y;
+    elm.x2 = p2t.x;
+    elm.y2 = p2t.y;
+  } else if (elm.type === "cad_component") {
+    const newPos = applyToPoint3(matrix, {
+      x: elm.position.x,
+      y: elm.position.y
+    });
+    elm.position.x = newPos.x;
+    elm.position.y = newPos.y;
+  }
+  return elm;
+};
+var transformPCBElements = (elms, matrix) => {
+  const tsr = decomposeTSR2(matrix);
+  const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
+  let transformedElms = elms.map((elm) => transformPCBElement(elm, matrix));
+  if (flipPadWidthHeight) {
+    transformedElms = transformedElms.map((elm) => {
+      if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
+        [elm.width, elm.height] = [elm.height, elm.width];
+      }
+      return elm;
+    });
+  }
+  return transformedElms;
+};
+function stringHash(str) {
+  let hash = 0;
+  if (str.length == 0)
+    return hash;
+  for (var i = 0;i < str.length; i++) {
+    var char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+var nice_color_palettes = [
+  ["#69d2e7", "#a7dbd8", "#e0e4cc", "#f38630", "#fa6900"],
+  ["#fe4365", "#fc9d9a", "#f9cdad", "#c8c8a9", "#83af9b"],
+  ["#ecd078", "#d95b43", "#c02942", "#542437", "#53777a"],
+  ["#556270", "#4ecdc4", "#c7f464", "#ff6b6b", "#c44d58"],
+  ["#774f38", "#e08e79", "#f1d4af", "#ece5ce", "#c5e0dc"],
+  ["#e8ddcb", "#cdb380", "#036564", "#033649", "#031634"],
+  ["#490a3d", "#bd1550", "#e97f02", "#f8ca00", "#8a9b0f"],
+  ["#594f4f", "#547980", "#45ada8", "#9de0ad", "#e5fcc2"],
+  ["#00a0b0", "#6a4a3c", "#cc333f", "#eb6841", "#edc951"],
+  ["#e94e77", "#d68189", "#c6a49a", "#c6e5d9", "#f4ead5"],
+  ["#3fb8af", "#7fc7af", "#dad8a7", "#ff9e9d", "#ff3d7f"],
+  ["#d9ceb2", "#948c75", "#d5ded9", "#7a6a53", "#99b2b7"],
+  ["#ffffff", "#cbe86b", "#f2e9e1", "#1c140d", "#cbe86b"],
+  ["#efffcd", "#dce9be", "#555152", "#2e2633", "#99173c"],
+  ["#343838", "#005f6b", "#008c9e", "#00b4cc", "#00dffc"],
+  ["#413e4a", "#73626e", "#b38184", "#f0b49e", "#f7e4be"],
+  ["#ff4e50", "#fc913a", "#f9d423", "#ede574", "#e1f5c4"],
+  ["#99b898", "#fecea8", "#ff847c", "#e84a5f", "#2a363b"],
+  ["#655643", "#80bca3", "#f6f7bd", "#e6ac27", "#bf4d28"],
+  ["#00a8c6", "#40c0cb", "#f9f2e7", "#aee239", "#8fbe00"],
+  ["#351330", "#424254", "#64908a", "#e8caa4", "#cc2a41"],
+  ["#554236", "#f77825", "#d3ce3d", "#f1efa5", "#60b99a"],
+  ["#5d4157", "#838689", "#a8caba", "#cad7b2", "#ebe3aa"],
+  ["#8c2318", "#5e8c6a", "#88a65e", "#bfb35a", "#f2c45a"],
+  ["#fad089", "#ff9c5b", "#f5634a", "#ed303c", "#3b8183"],
+  ["#ff4242", "#f4fad2", "#d4ee5e", "#e1edb9", "#f0f2eb"],
+  ["#f8b195", "#f67280", "#c06c84", "#6c5b7b", "#355c7d"],
+  ["#d1e751", "#ffffff", "#000000", "#4dbce9", "#26ade4"],
+  ["#1b676b", "#519548", "#88c425", "#bef202", "#eafde6"],
+  ["#5e412f", "#fcebb6", "#78c0a8", "#f07818", "#f0a830"],
+  ["#bcbdac", "#cfbe27", "#f27435", "#f02475", "#3b2d38"],
+  ["#452632", "#91204d", "#e4844a", "#e8bf56", "#e2f7ce"],
+  ["#eee6ab", "#c5bc8e", "#696758", "#45484b", "#36393b"],
+  ["#f0d8a8", "#3d1c00", "#86b8b1", "#f2d694", "#fa2a00"],
+  ["#2a044a", "#0b2e59", "#0d6759", "#7ab317", "#a0c55f"],
+  ["#f04155", "#ff823a", "#f2f26f", "#fff7bd", "#95cfb7"],
+  ["#b9d7d9", "#668284", "#2a2829", "#493736", "#7b3b3b"],
+  ["#bbbb88", "#ccc68d", "#eedd99", "#eec290", "#eeaa88"],
+  ["#b3cc57", "#ecf081", "#ffbe40", "#ef746f", "#ab3e5b"],
+  ["#a3a948", "#edb92e", "#f85931", "#ce1836", "#009989"],
+  ["#300030", "#480048", "#601848", "#c04848", "#f07241"],
+  ["#67917a", "#170409", "#b8af03", "#ccbf82", "#e33258"],
+  ["#aab3ab", "#c4cbb7", "#ebefc9", "#eee0b7", "#e8caaf"],
+  ["#e8d5b7", "#0e2430", "#fc3a51", "#f5b349", "#e8d5b9"],
+  ["#ab526b", "#bca297", "#c5ceae", "#f0e2a4", "#f4ebc3"],
+  ["#607848", "#789048", "#c0d860", "#f0f0d8", "#604848"],
+  ["#b6d8c0", "#c8d9bf", "#dadabd", "#ecdbbc", "#fedcba"],
+  ["#a8e6ce", "#dcedc2", "#ffd3b5", "#ffaaa6", "#ff8c94"],
+  ["#3e4147", "#fffedf", "#dfba69", "#5a2e2e", "#2a2c31"],
+  ["#fc354c", "#29221f", "#13747d", "#0abfbc", "#fcf7c5"],
+  ["#cc0c39", "#e6781e", "#c8cf02", "#f8fcc1", "#1693a7"],
+  ["#1c2130", "#028f76", "#b3e099", "#ffeaad", "#d14334"],
+  ["#a7c5bd", "#e5ddcb", "#eb7b59", "#cf4647", "#524656"],
+  ["#dad6ca", "#1bb0ce", "#4f8699", "#6a5e72", "#563444"],
+  ["#5c323e", "#a82743", "#e15e32", "#c0d23e", "#e5f04c"],
+  ["#edebe6", "#d6e1c7", "#94c7b6", "#403b33", "#d3643b"],
+  ["#fdf1cc", "#c6d6b8", "#987f69", "#e3ad40", "#fcd036"],
+  ["#230f2b", "#f21d41", "#ebebbc", "#bce3c5", "#82b3ae"],
+  ["#b9d3b0", "#81bda4", "#b28774", "#f88f79", "#f6aa93"],
+  ["#3a111c", "#574951", "#83988e", "#bcdea5", "#e6f9bc"],
+  ["#5e3929", "#cd8c52", "#b7d1a3", "#dee8be", "#fcf7d3"],
+  ["#1c0113", "#6b0103", "#a30006", "#c21a01", "#f03c02"],
+  ["#000000", "#9f111b", "#b11623", "#292c37", "#cccccc"],
+  ["#382f32", "#ffeaf2", "#fcd9e5", "#fbc5d8", "#f1396d"],
+  ["#e3dfba", "#c8d6bf", "#93ccc6", "#6cbdb5", "#1a1f1e"],
+  ["#f6f6f6", "#e8e8e8", "#333333", "#990100", "#b90504"],
+  ["#1b325f", "#9cc4e4", "#e9f2f9", "#3a89c9", "#f26c4f"],
+  ["#a1dbb2", "#fee5ad", "#faca66", "#f7a541", "#f45d4c"],
+  ["#c1b398", "#605951", "#fbeec2", "#61a6ab", "#accec0"],
+  ["#5e9fa3", "#dcd1b4", "#fab87f", "#f87e7b", "#b05574"],
+  ["#951f2b", "#f5f4d7", "#e0dfb1", "#a5a36c", "#535233"],
+  ["#8dccad", "#988864", "#fea6a2", "#f9d6ac", "#ffe9af"],
+  ["#2d2d29", "#215a6d", "#3ca2a2", "#92c7a3", "#dfece6"],
+  ["#413d3d", "#040004", "#c8ff00", "#fa023c", "#4b000f"],
+  ["#eff3cd", "#b2d5ba", "#61ada0", "#248f8d", "#605063"],
+  ["#ffefd3", "#fffee4", "#d0ecea", "#9fd6d2", "#8b7a5e"],
+  ["#cfffdd", "#b4dec1", "#5c5863", "#a85163", "#ff1f4c"],
+  ["#9dc9ac", "#fffec7", "#f56218", "#ff9d2e", "#919167"],
+  ["#4e395d", "#827085", "#8ebe94", "#ccfc8e", "#dc5b3e"],
+  ["#a8a7a7", "#cc527a", "#e8175d", "#474747", "#363636"],
+  ["#f8edd1", "#d88a8a", "#474843", "#9d9d93", "#c5cfc6"],
+  ["#046d8b", "#309292", "#2fb8ac", "#93a42a", "#ecbe13"],
+  ["#f38a8a", "#55443d", "#a0cab5", "#cde9ca", "#f1edd0"],
+  ["#a70267", "#f10c49", "#fb6b41", "#f6d86b", "#339194"],
+  ["#ff003c", "#ff8a00", "#fabe28", "#88c100", "#00c176"],
+  ["#ffedbf", "#f7803c", "#f54828", "#2e0d23", "#f8e4c1"],
+  ["#4e4d4a", "#353432", "#94ba65", "#2790b0", "#2b4e72"],
+  ["#0ca5b0", "#4e3f30", "#fefeeb", "#f8f4e4", "#a5b3aa"],
+  ["#4d3b3b", "#de6262", "#ffb88c", "#ffd0b3", "#f5e0d3"],
+  ["#fffbb7", "#a6f6af", "#66b6ab", "#5b7c8d", "#4f2958"],
+  ["#edf6ee", "#d1c089", "#b3204d", "#412e28", "#151101"],
+  ["#9d7e79", "#ccac95", "#9a947c", "#748b83", "#5b756c"],
+  ["#fcfef5", "#e9ffe1", "#cdcfb7", "#d6e6c3", "#fafbe3"],
+  ["#9cddc8", "#bfd8ad", "#ddd9ab", "#f7af63", "#633d2e"],
+  ["#30261c", "#403831", "#36544f", "#1f5f61", "#0b8185"],
+  ["#aaff00", "#ffaa00", "#ff00aa", "#aa00ff", "#00aaff"],
+  ["#d1313d", "#e5625c", "#f9bf76", "#8eb2c5", "#615375"],
+  ["#ffe181", "#eee9e5", "#fad3b2", "#ffba7f", "#ff9c97"],
+  ["#73c8a9", "#dee1b6", "#e1b866", "#bd5532", "#373b44"],
+  ["#805841", "#dcf7f3", "#fffcdd", "#ffd8d8", "#f5a2a2"]
+];
+var getDebugLayoutObject = (lo) => {
+  let {
+    x,
+    y,
+    width,
+    height
+  } = {
+    ...lo,
+    ...lo.size,
+    ...lo.center,
+    ...lo.position
+  };
+  if (lo.x1 !== undefined && lo.x2 !== undefined && lo.y1 !== undefined && lo.y2 !== undefined) {
+    x = (lo.x1 + lo.x2) / 2;
+    y = (lo.y1 + lo.y2) / 2;
+    width = Math.abs(lo.x1 - lo.x2);
+    height = Math.abs(lo.y1 - lo.y2);
+  }
+  const title = lo.text || lo.name || lo.source?.text || lo.source?.name || "?";
+  const content = lo;
+  if (x === undefined || y === undefined)
+    return null;
+  if (width === undefined) {
+    if ("outer_diameter" in lo) {
+      width = lo.outer_diameter;
+      height = lo.outer_diameter;
+    }
+  }
+  if (width === undefined || height === undefined) {
+    width = 0.1;
+    height = 0.1;
+  }
+  return {
+    x,
+    y,
+    width,
+    height,
+    title,
+    content,
+    bg_color: nice_color_palettes[stringHash(lo.type || title) % nice_color_palettes.length]?.[4] ?? "#f00"
+  };
+};
+var isTruthy = (value) => Boolean(value);
+var findBoundsAndCenter = (elements) => {
+  const debugObjects = elements.filter((elm) => elm.type.startsWith("pcb_")).concat(elements.filter((elm) => elm.type === "pcb_trace").flatMap((elm) => elm.route)).map((elm) => getDebugLayoutObject(elm)).filter(isTruthy);
+  if (debugObjects.length === 0)
+    return { center: { x: 0, y: 0 }, width: 0, height: 0 };
+  let minX = debugObjects[0].x - debugObjects[0].width / 2;
+  let maxX = debugObjects[0].x + debugObjects[0].width / 2;
+  let minY = debugObjects[0].y - debugObjects[0].height / 2;
+  let maxY = debugObjects[0].y + debugObjects[0].height / 2;
+  for (const obj of debugObjects.slice(1)) {
+    minX = Math.min(minX, obj.x - obj.width / 2);
+    maxX = Math.max(maxX, obj.x + obj.width / 2);
+    minY = Math.min(minY, obj.y - obj.height / 2);
+    maxY = Math.max(maxY, obj.y + obj.height / 2);
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const center = { x: minX + width / 2, y: minY + height / 2 };
+  return { center, width, height };
+};
+var generateFootprintTsx = (circuitJson) => {
+  const holes = su_default2(circuitJson).pcb_hole.list();
+  const platedHoles = su_default2(circuitJson).pcb_plated_hole.list();
+  const smtPads = su_default2(circuitJson).pcb_smtpad.list();
+  const silkscreenPaths = su_default2(circuitJson).pcb_silkscreen_path.list();
+  const silkscreenTexts = su_default2(circuitJson).pcb_silkscreen_text.list();
+  const elementStrings = [];
+  for (const hole of holes) {
+    if (hole.hole_shape === "circle") {
+      elementStrings.push(`<hole pcbX="${mmStr(hole.x)}" pcbY="${mmStr(hole.y)}" diameter="${mmStr(hole.hole_diameter)}" />`);
+    } else if (hole.hole_shape === "oval") {
+      console.warn("Unhandled oval hole in conversion (needs implementation)");
+    }
+  }
+  for (const platedHole of platedHoles) {
+    if (platedHole.shape === "oval" || platedHole.shape === "pill") {
+      elementStrings.push(`<platedhole  portHints={${JSON.stringify(platedHole.port_hints)}} pcbX="${mmStr(platedHole.x)}" pcbY="${mmStr(platedHole.y)}" outerHeight="${mmStr(platedHole.outer_height)}" outerWidth="${mmStr(platedHole.outer_width)}" holeHeight="${mmStr(platedHole.hole_height)}" holeWidth="${mmStr(platedHole.hole_width)}" shape="${platedHole.shape}" />`);
+    } else if (platedHole.shape === "circle") {
+      elementStrings.push(`<platedhole  portHints={${JSON.stringify(platedHole.port_hints)}} pcbX="${mmStr(platedHole.x)}" pcbY="${mmStr(platedHole.y)}" outerDiameter="${mmStr(platedHole.outer_diameter)}" holeDiameter="${mmStr(platedHole.hole_diameter)}" shape="circle" />`);
+    }
+  }
+  for (const smtPad of smtPads) {
+    if (smtPad.shape === "circle") {
+      elementStrings.push(`<smtpad portHints={${JSON.stringify(smtPad.port_hints)}} pcbX="${mmStr(smtPad.x)}" pcbY="${mmStr(smtPad.y)}" radius="${mmStr(smtPad.radius)}" shape="circle" />`);
+    } else if (smtPad.shape === "rect") {
+      elementStrings.push(`<smtpad portHints={${JSON.stringify(smtPad.port_hints)}} pcbX="${mmStr(smtPad.x)}" pcbY="${mmStr(smtPad.y)}" width="${mmStr(smtPad.width)}" height="${mmStr(smtPad.height)}" shape="rect" />`);
+    }
+  }
+  for (const silkscreenPath of silkscreenPaths) {
+    elementStrings.push(`<silkscreenpath route={${JSON.stringify(silkscreenPath.route)}} />`);
+  }
+  for (const silkscreenText of silkscreenTexts) {
+    elementStrings.push(`<silkscreentext text="${silkscreenText.text}" pcbX="${mmStr(silkscreenText.anchor_position.x)}" pcbY="${mmStr(silkscreenText.anchor_position.y)}" anchorAlignment="${silkscreenText.anchor_alignment}" ${silkscreenText.font_size ? `fontSize="${mmStr(silkscreenText.font_size)}"` : ""} />`);
+  }
+  return `
+      <footprint>
+        ${elementStrings.join(`
+`)}
+      </footprint>
+  `.trim();
+};
+var generateTypescriptComponent = ({
+  pinLabels,
+  componentName,
+  objUrl,
+  circuitJson,
+  supplierPartNumbers,
+  manufacturerPartNumber
+}) => {
+  const safePinLabels = pinLabels ?? {};
+  const footprintTsx = generateFootprintTsx(circuitJson);
+  const simplifiedPinLabels = Object.fromEntries(Object.entries(safePinLabels).map(([pin, labels]) => {
+    if (Array.isArray(labels) && labels.length > 1) {
+      return [pin, [labels[1]]];
+    }
+    return [pin, labels];
+  }));
+  const pinLabelsString = Object.entries(simplifiedPinLabels).map(([pin, labels]) => `  ${pin}: ${JSON.stringify(labels)}`).join(`,
+`);
+  return `
+import type { ChipProps } from "@tscircuit/props"
+
+const pinLabels = {
+${pinLabelsString}
+} as const
+
+export const ${componentName} = (props: ChipProps<typeof pinLabels>) => {
+  return (
+    <chip
+      pinLabels={pinLabels}
+      supplierPartNumbers={${JSON.stringify(supplierPartNumbers, null, "  ")}}
+      manufacturerPartNumber="${manufacturerPartNumber}"
+      footprint={${footprintTsx}}
+      ${objUrl ? `cadModel={{
+        objUrl: "${objUrl}",
+        rotationOffset: { x: 0, y: 0, z: 0 },
+        positionOffset: { x: 0, y: 0, z: 0 },
+      }}` : ""}
+      {...props}
+    />
+  )
+}
+`.trim();
+};
+function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag, sweepFlag) {
+  const start = { x: startX, y: startY };
+  const end = { x: endX, y: endY };
+  const midX = (startX + endX) / 2;
+  const midY = (startY + endY) / 2;
+  const dx = endX - startX;
+  const dy = endY - startY;
+  const distance2 = Math.sqrt(dx * dx + dy * dy);
+  if (distance2 === 0 || radius < distance2 / 2) {
+    return [start, end];
+  }
+  const h = Math.sqrt(radius * radius - distance2 * distance2 / 4);
+  const angle = Math.atan2(dy, dx);
+  const centerX = midX + h * Math.sin(angle) * (sweepFlag ? 1 : -1);
+  const centerY = midY - h * Math.cos(angle) * (sweepFlag ? 1 : -1);
+  const startAngle = Math.atan2(startY - centerY, startX - centerX);
+  let endAngle = Math.atan2(endY - centerY, endX - centerX);
+  if (!sweepFlag && endAngle > startAngle) {
+    endAngle -= 2 * Math.PI;
+  } else if (sweepFlag && endAngle < startAngle) {
+    endAngle += 2 * Math.PI;
+  }
+  if (!largeArcFlag && Math.abs(endAngle - startAngle) > Math.PI || largeArcFlag && Math.abs(endAngle - startAngle) < Math.PI) {
+    if (endAngle > startAngle) {
+      endAngle -= 2 * Math.PI;
+    } else {
+      endAngle += 2 * Math.PI;
+    }
+  }
+  const numPoints = Math.max(2, Math.ceil(Math.abs(endAngle - startAngle) * radius));
+  const path23 = [];
+  for (let i = 0;i <= numPoints; i++) {
+    const t2 = i / numPoints;
+    const angle2 = startAngle + t2 * (endAngle - startAngle);
+    const x = centerX + radius * Math.cos(angle2);
+    const y = centerY + radius * Math.sin(angle2);
+    path23.push({ x, y });
+  }
+  return path23;
+}
+var computeCenterOffset = (easyeda) => {
+  const pads = easyeda.packageDetail.dataStr.shape.filter((shape) => shape.type === "PAD");
+  const minX = Math.min(...pads.map((pad) => mm(pad.center.x)));
+  const maxX = Math.max(...pads.map((pad) => mm(pad.center.x)));
+  const minY = Math.min(...pads.map((pad) => mm(pad.center.y)));
+  const maxY = Math.max(...pads.map((pad) => mm(pad.center.y)));
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  return {
+    x: centerX,
+    y: centerY
+  };
+};
+var normalizePinLabels = (inputPinLabels) => {
+  const unqInputPinLabels = inputPinLabels.map((labels) => [...new Set(labels)]);
+  const result = unqInputPinLabels.map(() => []);
+  const desiredNumbers = unqInputPinLabels.map(() => null);
+  for (let i = 0;i < unqInputPinLabels.length; i++) {
+    for (const label of unqInputPinLabels[i]) {
+      if (/^\d+$/.test(label)) {
+        desiredNumbers[i] = Number.parseInt(label);
+        break;
+      }
+    }
+  }
+  let highestPinNumber = 0;
+  const alreadyAcceptedDesiredNumbers = /* @__PURE__ */ new Set;
+  for (let i = 0;i < desiredNumbers.length; i++) {
+    const desiredNumber = desiredNumbers[i];
+    if (desiredNumber === null || desiredNumber < 1) {
+      continue;
+    }
+    if (!alreadyAcceptedDesiredNumbers.has(desiredNumber)) {
+      alreadyAcceptedDesiredNumbers.add(desiredNumber);
+      result[i].push(`pin${desiredNumber}`);
+      highestPinNumber = Math.max(highestPinNumber, desiredNumber);
+      continue;
+    }
+    let existingAltsForPin = 0;
+    for (const label of result[i]) {
+      if (label.startsWith(`pin${desiredNumber}_alt`)) {
+        existingAltsForPin++;
+      }
+    }
+    result[i].push(`pin${desiredNumber}_alt${existingAltsForPin + 1}`);
+  }
+  for (let i = 0;i < result.length; i++) {
+    const firstLabel = result[i][0];
+    if (firstLabel?.includes("_alt")) {
+      highestPinNumber++;
+      result[i].unshift(`pin${highestPinNumber}`);
+    }
+  }
+  for (let i = 0;i < result.length; i++) {
+    if (result[i].length === 0) {
+      highestPinNumber++;
+      result[i].push(`pin${highestPinNumber}`);
+    }
+  }
+  const totalLabelCounts = {};
+  for (const inputLabels of unqInputPinLabels) {
+    for (const label of inputLabels) {
+      if (/^\d+$/.test(label)) {
+        continue;
+      }
+      totalLabelCounts[label] = (totalLabelCounts[label] ?? 0) + 1;
+    }
+  }
+  const incrementalLabelCounts = {};
+  for (let i = 0;i < unqInputPinLabels.length; i++) {
+    const inputLabels = unqInputPinLabels[i];
+    for (const label of inputLabels) {
+      if (/^\d+$/.test(label)) {
+        continue;
+      }
+      if (totalLabelCounts[label] === 1) {
+        result[i].push(label);
+      } else {
+        incrementalLabelCounts[label] = (incrementalLabelCounts[label] ?? 0) + 1;
+        result[i].push(`${label}${incrementalLabelCounts[label]}`);
+      }
+    }
+  }
+  return result;
+};
+var mil2mm = (mil) => {
+  if (typeof mil === "number")
+    return mm(`${mil}mil`);
+  if (mil.match(/^\d+$/))
+    return mm(`${mil}mil`);
+  return mm(mil);
+};
+var milx10 = (mil10) => {
+  if (typeof mil10 === "number")
+    return mil2mm(mil10) * 10;
+  if (mil10.match(/^\d+$/))
+    return mil2mm(mil10) * 10;
+  return mil2mm(mil10);
+};
+var handleSilkscreenPath = (track, index) => {
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_path_${index + 1}`,
+    pcb_component_id: "pcb_component_1",
+    layer: "top",
+    route: track.points.map((point2) => ({
+      x: milx10(point2.x),
+      y: milx10(point2.y)
+    })),
+    stroke_width: mil10ToMm(track.width)
+  });
+};
+var handleSilkscreenArc = (arc, index) => {
+  const arcPath = generateArcFromSweep(arc.start.x, arc.start.y, arc.end.x, arc.end.y, arc.radiusX, arc.largeArc, arc.sweepDirection === "CW");
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_arc_${index + 1}`,
+    pcb_component_id: "pcb_component_1",
+    layer: "top",
+    route: arcPath.map((p) => ({
+      x: milx10(p.x),
+      y: milx10(p.y)
+    })),
+    stroke_width: mil10ToMm(arc.width)
+  });
+};
+var handleHole = (hole, index) => {
+  return pcb_hole.parse({
+    type: "pcb_hole",
+    x: milx10(hole.center.x),
+    y: milx10(hole.center.y),
+    hole_diameter: milx10(hole.radius) * 2,
+    hole_shape: "circle",
+    pcb_hole_id: `pcb_hole_${index + 1}`
+  });
+};
+var convertEasyEdaJsonToCircuitJson = (easyEdaJson, { useModelCdn, shouldRecenter = true } = {}) => {
+  const soupElements = [];
+  const centerOffset = computeCenterOffset(easyEdaJson);
+  const source_component = any_source_component.parse({
+    type: "source_component",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug"
+  });
+  const pcb_component2 = pcb_component.parse({
+    type: "pcb_component",
+    pcb_component_id: "pcb_component_1",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug",
+    width: 0,
+    height: 0,
+    rotation: 0,
+    center: { x: 0, y: 0 },
+    layer: "top"
+  });
+  soupElements.push(source_component, pcb_component2);
+  const pads = easyEdaJson.packageDetail.dataStr.shape.filter((shape) => shape.type === "PAD");
+  const pins = easyEdaJson.dataStr.shape.filter((shape) => shape.type === "PIN");
+  const pinLabelSets = pads.map((pad) => {
+    const labels = [];
+    if (pad.number)
+      labels.push(pad.number.toString());
+    const pin = pins.find((p) => p.pinNumber === pad.number);
+    if (pin)
+      labels.push(pin.label);
+    return labels;
+  });
+  const normalizedPinLabels = normalizePinLabels(pinLabelSets);
+  pads.forEach((pad, index) => {
+    const portHints = normalizedPinLabels[index];
+    const pinNumber = Number.parseInt(portHints.find((hint) => hint.match(/pin\d+/)).replace("pin", ""));
+    soupElements.push({
+      type: "source_port",
+      source_port_id: `source_port_${index + 1}`,
+      source_component_id: "source_component_1",
+      name: `pin${pinNumber}`,
+      pin_number: pinNumber,
+      port_hints: portHints.filter((hint) => hint !== `pin${pinNumber}`)
+    });
+    if (pad.holeRadius !== undefined && mil2mm(pad.holeRadius) !== 0) {
+      const commonPlatedHoleProps = {
+        type: "pcb_plated_hole",
+        pcb_plated_hole_id: `pcb_plated_hole_${index + 1}`,
+        x: mil2mm(pad.center.x),
+        y: mil2mm(pad.center.y),
+        layers: ["top"],
+        port_hints: [`pin${pinNumber}`],
+        pcb_component_id: "pcb_component_1",
+        pcb_port_id: `pcb_port_${index + 1}`
+      };
+      let additionalPlatedHoleProps;
+      if (pad.shape === "OVAL") {
+        const largestOuterDimensionName = mil2mm(pad.width) > mil2mm(pad.height) ? "width" : "height";
+        const smallestOuterDimension = Math.min(mil2mm(pad.width), mil2mm(pad.height));
+        const largestOuterDimension = Math.max(mil2mm(pad.width), mil2mm(pad.height));
+        const distanceFromOuterPlatingToHole = smallestOuterDimension / 2 - mil2mm(pad.holeRadius);
+        const largestInnerDimension = largestOuterDimension - distanceFromOuterPlatingToHole * 2;
+        const smallestInnerDimension = mil2mm(pad.holeRadius) * 2;
+        const innerWidth = largestOuterDimensionName === "width" ? largestInnerDimension : smallestInnerDimension;
+        const innerHeight = largestOuterDimensionName === "height" ? largestInnerDimension : smallestInnerDimension;
+        additionalPlatedHoleProps = {
+          shape: "pill",
+          outer_width: mil2mm(pad.width),
+          outer_height: mil2mm(pad.height),
+          hole_width: innerWidth,
+          hole_height: innerHeight
+        };
+      } else {
+        additionalPlatedHoleProps = {
+          shape: "circle",
+          hole_diameter: mil2mm(pad.holeRadius) * 2,
+          outer_diameter: mil2mm(pad.width),
+          radius: mil2mm(pad.holeRadius)
+        };
+      }
+      soupElements.push(pcb_plated_hole.parse({
+        ...commonPlatedHoleProps,
+        ...additionalPlatedHoleProps
+      }));
+    } else {
+      let soupShape;
+      if (pad.shape === "RECT") {
+        soupShape = "rect";
+      } else if (pad.shape === "ELLIPSE") {
+        soupShape = "rect";
+      } else if (pad.shape === "OVAL") {
+        soupShape = "rect";
+      }
+      if (!soupShape) {
+        throw new Error(`unknown pad.shape: "${pad.shape}"`);
+      }
+      const rectSize = { width: mil2mm(pad.width), height: mil2mm(pad.height) };
+      if (pad.rotation === 90 || pad.rotation === 270) {
+        rectSize.width = mil2mm(pad.height);
+        rectSize.height = mil2mm(pad.width);
+      }
+      const parsedPcbSmtpad = pcb_smtpad.parse({
+        type: "pcb_smtpad",
+        pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
+        shape: soupShape,
+        x: mil2mm(pad.center.x),
+        y: mil2mm(pad.center.y),
+        ...soupShape === "rect" ? rectSize : { radius: Math.min(mil2mm(pad.width), mil2mm(pad.height)) / 2 },
+        layer: "top",
+        port_hints: [`pin${pinNumber}`],
+        pcb_component_id: "pcb_component_1",
+        pcb_port_id: `pcb_port_${index + 1}`
+      });
+      soupElements.push(parsedPcbSmtpad);
+    }
+  });
+  easyEdaJson.packageDetail.dataStr.shape.filter((shape) => shape.type === "HOLE").forEach((h, index) => {
+    soupElements.push(handleHole(h, index));
+  });
+  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
+    if (shape.type === "TRACK") {
+      soupElements.push(handleSilkscreenPath(shape, index));
+    } else if (shape.type === "ARC") {
+      soupElements.push(handleSilkscreenArc(shape, index));
+    } else if (shape.type === "TEXT") {
+      soupElements.push(pcb_silkscreen_text.parse({
+        type: "pcb_silkscreen_text",
+        pcb_silkscreen_text_id: `pcb_silkscreen_text_${index + 1}`,
+        pcb_component_id: "pcb_component_1",
+        text: shape.text,
+        anchor_position: {
+          x: mil2mm(shape.x),
+          y: mil2mm(shape.y)
+        },
+        anchor_alignment: {
+          L: "bottom_left",
+          C: "center",
+          R: "bottom_right"
+        }[shape.textAnchor ?? "L"],
+        font_size: shape.size_mm ? shape.size_mm : undefined,
+        layer: "top"
+      }));
+    }
+  });
+  const svgNode = easyEdaJson.packageDetail.dataStr.shape.find((a) => Boolean(a.type === "SVGNODE" && a.svgData.attrs?.uuid));
+  const objFileUuid = svgNode?.svgData?.attrs?.uuid;
+  const objFileUrl = objFileUuid ? useModelCdn ? `https://modelcdn.tscircuit.com/easyeda_models/download?uuid=${objFileUuid}&pn=${easyEdaJson.lcsc.number}` : `https://modules.easyeda.com/3dmodel/${objFileUuid}` : undefined;
+  if (objFileUrl !== undefined) {
+    const [rx, ry, rz] = (svgNode?.svgData.attrs?.c_rotation ?? "0,0,0").split(",").map(Number);
+    soupElements.push(cad_component.parse({
+      type: "cad_component",
+      cad_component_id: "cad_component_1",
+      source_component_id: "source_component_1",
+      pcb_component_id: "pcb_component_1",
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { x: rx, y: ry, z: rz },
+      model_obj_url: objFileUrl
+    }));
+  }
+  if (shouldRecenter) {
+    const bounds = findBoundsAndCenter(soupElements.filter((e) => e.type !== "pcb_component"));
+    transformPCBElements(soupElements, compose(translate(-bounds.center.x, bounds.center.y), scale6(1, -1)));
+    pcb_component2.center = { x: 0, y: 0 };
+  }
+  return soupElements;
+};
+function normalizeManufacturerPartNumber(partNumber) {
+  let normalized = partNumber.replace(/[-]/g, "_").replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(normalized)) {
+    normalized = "A_" + normalized;
+  }
+  return normalized;
+}
+var convertRawEasyToTsx = async (rawEasy) => {
+  const betterEasy = EasyEdaJsonSchema.parse(rawEasy);
+  const result = await convertBetterEasyToTsx({
+    betterEasy
+  });
+  return result;
+};
+var convertBetterEasyToTsx = async ({
+  betterEasy
+}) => {
+  const circuitJson = convertEasyEdaJsonToCircuitJson(betterEasy, {
+    useModelCdn: true,
+    shouldRecenter: true
+  });
+  const rawPn = betterEasy.dataStr.head.c_para["Manufacturer Part"];
+  const pn = normalizeManufacturerPartNumber(rawPn);
+  const sourcePorts = su_default2(circuitJson).source_port.list();
+  const pinLabels = {};
+  const sortedPorts = sourcePorts.sort((a, b) => {
+    const aNum = parseInt(a.name.replace("pin", ""));
+    const bNum = parseInt(b.name.replace("pin", ""));
+    return aNum - bNum;
+  });
+  for (const sourcePort of sortedPorts) {
+    pinLabels[sourcePort.name] = [
+      sourcePort.name,
+      ...sourcePort.port_hints ?? []
+    ];
+  }
+  const [cadComponent] = su_default2(circuitJson).cad_component.list();
+  let modelObjUrl;
+  if (cadComponent?.model_obj_url) {
+    const isValidUrl = await checkModelObjUrlValidity(cadComponent.model_obj_url);
+    if (isValidUrl) {
+      modelObjUrl = cadComponent.model_obj_url;
+    }
+  }
+  const supplierPartNumbers = {
+    jlcpcb: [betterEasy.lcsc.number]
+  };
+  return generateTypescriptComponent({
+    componentName: pn,
+    manufacturerPartNumber: pn,
+    pinLabels,
+    objUrl: modelObjUrl,
+    circuitJson,
+    supplierPartNumbers
+  });
+};
+var checkModelObjUrlValidity = async (url) => {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    return response.status === 200;
+  } catch (error) {
+    console.error(`Error checking model object URL ${url}:`, error);
+    return false;
+  }
+};
+async function fetchEasyEDAComponent(jlcpcbPartNumber, { fetch: fetch2 = globalThis.fetch } = {}) {
+  const searchUrl = "https://easyeda.com/api/components/search";
+  const componentUrl = (uuid) => `https://easyeda.com/api/components/${uuid}?version=6.4.7&uuid=${uuid}&datastrid=`;
+  const searchHeaders = {
+    authority: "easyeda.com",
+    pragma: "no-cache",
+    "cache-control": "no-cache",
+    accept: "application/json, text/javascript, */*; q=0.01",
+    "x-requested-with": "XMLHttpRequest",
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
+    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+    origin: "https://easyeda.com",
+    "sec-fetch-site": "same-origin",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-dest": "empty",
+    referer: "https://easyeda.com/editor",
+    "accept-language": "cs,en;q=0.9,sk;q=0.8,en-GB;q=0.7",
+    cookie: "<PUT your cookies here>"
+  };
+  const searchData = `type=3&doctype%5B%5D=2&uid=0819f05c4eef4c71ace90d822a990e87&returnListStyle=classifyarr&wd=${jlcpcbPartNumber}&version=6.4.7`;
+  const searchResponse = await fetch2(searchUrl, {
+    method: "POST",
+    headers: searchHeaders,
+    body: searchData
+  });
+  if (!searchResponse.ok) {
+    throw new Error("Failed to search for the component");
+  }
+  const searchResult = await searchResponse.json();
+  if (!searchResult.success || !searchResult.result.lists.lcsc.length) {
+    throw new Error("Component not found");
+  }
+  const bestMatchComponent = searchResult.result.lists.lcsc.find((component) => component.dataStr.head.c_para["Supplier Part"] === jlcpcbPartNumber) ?? searchResult.result.lists.lcsc[0];
+  const componentUUID = bestMatchComponent.uuid;
+  const componentResponse = await fetch2(componentUrl(componentUUID), {
+    method: "GET",
+    headers: {
+      ...searchHeaders,
+      referer: `https://easyeda.com/editor?uuid=${componentUUID}`
+    }
+  });
+  if (!componentResponse.ok) {
+    throw new Error("Failed to fetch the component details");
+  }
+  const componentResult = await componentResponse.json();
+  return componentResult.result;
+}
+
+// lib/import/import-component-from-jlcpcb.ts
+import fs23 from "node:fs/promises";
+import path23 from "node:path";
+var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cwd()) => {
+  const component = await fetchEasyEDAComponent(jlcpcbPartNumber);
+  const tsx = await convertRawEasyToTsx(component);
+  const fileName = tsx.match(/export const (\w+) = .*/)?.[1];
+  if (!fileName) {
+    throw new Error("Could not determine file name of converted component");
+  }
+  const importsDir = path23.join(projectDir, "imports");
+  await fs23.mkdir(importsDir, { recursive: true });
+  const filePath = path23.join(importsDir, `${fileName}.tsx`);
+  await fs23.writeFile(filePath, tsx);
+  return { filePath };
+};
+
+// cli/import/register.ts
+var registerImport = (program3) => {
+  program3.command("import").description("Search JLCPCB or the tscircuit registry and import a component").argument("<query>", "Chip name, part number, or package name").action(async (query) => {
+    const ky2 = getRegistryApiKy();
+    let registryResults = [];
+    let jlcResults = [];
+    try {
+      registryResults = (await ky2.post("packages/search", { json: { query } }).json()).packages;
+    } catch (error) {
+      console.error(kleur_default.red("Failed to search registry:"), error instanceof Error ? error.message : error);
+    }
+    try {
+      const searchUrl = "https://jlcsearch.tscircuit.com/api/search?limit=10&q=" + encodeURIComponent(query);
+      const resp = await fetch(searchUrl).then((r) => r.json());
+      jlcResults = resp.components;
+    } catch (error) {
+      console.error(kleur_default.red("Failed to search JLCPCB:"), error instanceof Error ? error.message : error);
+    }
+    if (!registryResults.length && !jlcResults.length) {
+      console.log(kleur_default.yellow("No results found matching your query."));
       return;
     }
-    const { confirm } = await import_prompts5.default({
-      type: "confirm",
-      name: "confirm",
-      message: `Do you want to add ${kleur_default.green(selectedPackage)}?`,
-      initial: true
+    const choices = [];
+    registryResults.forEach((pkg, idx) => {
+      choices.push({
+        title: `${pkg.name}${pkg.description ? ` - ${pkg.description}` : ""}`,
+        value: { type: "registry", name: pkg.name },
+        selected: idx === 0
+      });
+    });
+    jlcResults.forEach((comp, idx) => {
+      choices.push({
+        title: `[jlcpcb] ${comp.mfr} (C${comp.lcsc}) - ${comp.description}`,
+        value: { type: "jlcpcb", part: comp.lcsc },
+        selected: !choices.length && idx === 0
+      });
     });
-    if (confirm) {
+    const { choice } = await prompts({
+      type: "select",
+      name: "choice",
+      message: "Select a part to import",
+      choices
+    });
+    if (!choice) {
+      console.log("Aborted.");
+      return process.exit(0);
+    }
+    if (choice.type === "registry") {
       try {
-        console.log(kleur_default.blue(`Installing ${selectedPackage}...`));
-        await addPackage(selectedPackage);
-        console.log(kleur_default.green(`Successfully installed ${selectedPackage}`));
+        await addPackage(choice.name);
+        console.log(kleur_default.green(`Installed ${choice.name}`));
       } catch (error) {
-        console.error(kleur_default.red(`Failed to install ${selectedPackage}:`), error);
-        process.exit(1);
+        console.error(kleur_default.red("Failed to add package:"), error instanceof Error ? error.message : error);
+        return process.exit(1);
+      }
+    } else {
+      try {
+        console.log(kleur_default.yellow(`Importing "C${choice.part}" from JLCPCB...`));
+        const { filePath } = await importComponentFromJlcpcb(`C${String(choice.part)}`);
+        console.log(kleur_default.green(`Imported ${filePath}`));
+      } catch (error) {
+        console.error(kleur_default.red("Failed to import part:"), error instanceof Error ? error.message : error);
+        return process.exit(1);
       }
     }
   });
@@ -69651,12 +72692,12 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path25 from "node:path";
-import fs25 from "node:fs";
+import path26 from "node:path";
+import fs26 from "node:fs";
 
 // cli/build/build-file.ts
-import path23 from "node:path";
-import fs23 from "node:fs";
+import path24 from "node:path";
+import fs24 from "node:fs";
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -69687,9 +72728,9 @@ var buildFile = async (input, output, projectDir, options) => {
       filePath: input,
       platformConfig: options?.platformConfig
     });
-    fs23.mkdirSync(path23.dirname(output), { recursive: true });
-    fs23.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
-    console.log(`Circuit JSON written to ${path23.relative(projectDir, output)}`);
+    fs24.mkdirSync(path24.dirname(output), { recursive: true });
+    fs24.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path24.relative(projectDir, output)}`);
     const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
     if (!options?.ignoreWarnings) {
       for (const warn of warnings) {
@@ -69717,16 +72758,16 @@ var buildFile = async (input, output, projectDir, options) => {
 };
 
 // cli/build/get-build-entrypoints.ts
-import fs24 from "node:fs";
-import path24 from "node:path";
+import fs25 from "node:fs";
+import path25 from "node:path";
 async function getBuildEntrypoints({
   fileOrDir,
   rootDir = process.cwd()
 }) {
-  const resolvedRoot = path24.resolve(rootDir);
+  const resolvedRoot = path25.resolve(rootDir);
   if (fileOrDir) {
-    const resolved = path24.resolve(resolvedRoot, fileOrDir);
-    if (fs24.existsSync(resolved) && fs24.statSync(resolved).isDirectory()) {
+    const resolved = path25.resolve(resolvedRoot, fileOrDir);
+    if (fs25.existsSync(resolved) && fs25.statSync(resolved).isDirectory()) {
       const projectDir2 = resolved;
       const files2 = globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
         cwd: projectDir2,
@@ -69734,10 +72775,10 @@ async function getBuildEntrypoints({
       });
       return {
         projectDir: projectDir2,
-        circuitFiles: files2.map((f) => path24.join(projectDir2, f))
+        circuitFiles: files2.map((f) => path25.join(projectDir2, f))
       };
     }
-    return { projectDir: path24.dirname(resolved), circuitFiles: [resolved] };
+    return { projectDir: path25.dirname(resolved), circuitFiles: [resolved] };
   }
   const projectDir = resolvedRoot;
   const files = globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
@@ -69746,7 +72787,7 @@ async function getBuildEntrypoints({
   });
   return {
     projectDir,
-    circuitFiles: files.map((f) => path24.join(projectDir, f))
+    circuitFiles: files.map((f) => path25.join(projectDir, f))
   };
 }
 
@@ -69754,13 +72795,13 @@ async function getBuildEntrypoints({
 var registerBuild = (program3) => {
   program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").action(async (file, options) => {
     const { projectDir, mainEntrypoint, circuitFiles } = await getBuildEntrypoints({ fileOrDir: file });
-    const distDir = path25.join(projectDir, "dist");
-    fs25.mkdirSync(distDir, { recursive: true });
+    const distDir = path26.join(projectDir, "dist");
+    fs26.mkdirSync(distDir, { recursive: true });
     let hasErrors = false;
     for (const filePath of circuitFiles) {
-      const relative8 = path25.relative(projectDir, filePath);
+      const relative8 = path26.relative(projectDir, filePath);
       const outputDirName = relative8.replace(/(\.board|\.circuit)?\.tsx$/, "");
-      const outputPath = path25.join(distDir, outputDirName, "circuit.json");
+      const outputPath = path26.join(distDir, outputDirName, "circuit.json");
       const ok = await buildFile(filePath, outputPath, projectDir, options);
       if (!ok)
         hasErrors = true;
@@ -69772,8 +72813,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs26 from "node:fs";
-import path26 from "node:path";
+import fs27 from "node:fs";
+import path27 from "node:path";
 import looksSame from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg2,
@@ -69797,10 +72838,10 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const boardFiles = filePaths.length > 0 ? filePaths.map((f) => path26.resolve(projectDir, f)) : globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
+  const boardFiles = filePaths.length > 0 ? filePaths.map((f) => path27.resolve(projectDir, f)) : globbySync(["**/*.board.tsx", "**/*.circuit.tsx"], {
     cwd: projectDir,
     ignore
-  }).map((f) => path26.join(projectDir, f));
+  }).map((f) => path27.join(projectDir, f));
   if (boardFiles.length === 0) {
     console.log("No entrypoint found. Run 'tsci init' to bootstrap a project or specify a file with 'tsci snapshot <file>'");
     return onExit(0);
@@ -69812,30 +72853,30 @@ var snapshotProject = async ({
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson);
     const schSvg = convertCircuitJsonToSchematicSvg2(circuitJson);
     const svg3d = threeD ? await convertCircuitJsonToSimple3dSvg(circuitJson) : null;
-    const snapDir = path26.join(path26.dirname(file), "__snapshots__");
-    fs26.mkdirSync(snapDir, { recursive: true });
-    const base = path26.basename(file).replace(/\.tsx$/, "");
-    const pairs = [];
+    const snapDir = path27.join(path27.dirname(file), "__snapshots__");
+    fs27.mkdirSync(snapDir, { recursive: true });
+    const base = path27.basename(file).replace(/\.tsx$/, "");
+    const pairs2 = [];
     if (pcbOnly || !schematicOnly)
-      pairs.push(["pcb", pcbSvg]);
+      pairs2.push(["pcb", pcbSvg]);
     if (schematicOnly || !pcbOnly)
-      pairs.push(["schematic", schSvg]);
+      pairs2.push(["schematic", schSvg]);
     if (threeD && svg3d)
-      pairs.push(["3d", svg3d]);
+      pairs2.push(["3d", svg3d]);
     if (!looksSame) {
       console.error("looks-same is required. Install it with 'bun add -d looks-same'");
       return onExit(1);
     }
-    for (const [type, newSvg] of pairs) {
-      const snapPath = path26.join(snapDir, `${base}-${type}.snap.svg`);
-      const existing = fs26.existsSync(snapPath);
+    for (const [type, newSvg] of pairs2) {
+      const snapPath = path27.join(snapDir, `${base}-${type}.snap.svg`);
+      const existing = fs27.existsSync(snapPath);
       if (!existing) {
-        fs26.writeFileSync(snapPath, newSvg, "utf8");
-        console.log("✅", kleur_default.gray(path26.relative(projectDir, snapPath)));
+        fs27.writeFileSync(snapPath, newSvg, "utf8");
+        console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldSvg = fs26.readFileSync(snapPath, "utf8");
+      const oldSvg = fs27.readFileSync(snapPath, "utf8");
       const bufNew = Buffer.from(newSvg, "utf8");
       const bufOld = Buffer.from(oldSvg, "utf8");
       const { equal } = await looksSame(bufNew, bufOld, {
@@ -69844,10 +72885,10 @@ var snapshotProject = async ({
       });
       if (update) {
         if (!forceUpdate && equal) {
-          console.log("✅", kleur_default.gray(path26.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
         } else {
-          fs26.writeFileSync(snapPath, newSvg, "utf8");
-          console.log("✅", kleur_default.gray(path26.relative(projectDir, snapPath)));
+          fs27.writeFileSync(snapPath, newSvg, "utf8");
+          console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal) {
@@ -69858,10 +72899,10 @@ var snapshotProject = async ({
           highlightColor: "#ff00ff",
           tolerance: 2
         });
-        fs26.writeFileSync(diffPath, diffBuffer);
+        fs27.writeFileSync(diffPath, diffBuffer);
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path26.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path27.relative(projectDir, snapPath)));
       }
     }
   }
@@ -69899,22 +72940,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs27 from "node:fs";
-import path27 from "node:path";
+import fs28 from "node:fs";
+import path28 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path27.resolve(startDir);
-    while (dir !== path27.parse(dir).root) {
-      if (fs27.existsSync(path27.join(dir, ".git"))) {
+    let dir = path28.resolve(startDir);
+    while (dir !== path28.parse(dir).root) {
+      if (fs28.existsSync(path28.join(dir, ".git"))) {
         return dir;
       }
-      dir = path27.dirname(dir);
+      dir = path28.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path27.join(gitRoot, ".github", "workflows");
-  fs27.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path28.join(gitRoot, ".github", "workflows");
+  fs28.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -69953,8 +72994,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path27.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path27.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path28.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path28.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -70002,6 +73043,7 @@ registerSnapshot(program2);
 registerSetup(program2);
 registerUpgradeCommand(program2);
 registerSearch(program2);
+registerImport(program2);
 if (process.argv.includes("--version") || process.argv.includes("-v") || process.argv.includes("-V")) {
   console.log(getVersion());
   process.exit(0);