@tscircuit/cli 0.1.1371 → 0.1.1372

package/dist/cli/build/build.worker.js

@@ -11504,7 +11504,7 @@ import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
 import fs10 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -12005,7 +12005,2307 @@ var resolveImageFormatSelection = (options) => {
 
 // cli/build/worker-output-generators.ts
 import fs9 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
+
+// node_modules/circuit-json-to-step/node_modules/stepts/dist/index.js
+var Entity = class {
+  static parse(_a, _ctx) {
+    throw new Error("not implemented");
+  }
+};
+var eid = (n) => n;
+var Ref = class {
+  constructor(id) {
+    this.id = id;
+  }
+  resolve(repo) {
+    const e = repo.get(this.id);
+    if (!e)
+      throw new Error(`Unresolved #${this.id}`);
+    return e;
+  }
+  toString() {
+    return `#${this.id}`;
+  }
+};
+var stepStr = (s) => `'${s.replace(/'/g, "''")}'`;
+var fmtNum = (n) => Number.isInteger(n) ? `${n}.` : `${n}`;
+var Repository = class {
+  map = /* @__PURE__ */ new Map;
+  order = [];
+  maxId = 0;
+  schema = "AP214";
+  units = { length: "MM", angle: "RAD", solidAngle: "SR" };
+  set(id, e) {
+    if (!this.map.has(id)) {
+      this.order.push(id);
+      if (id > this.maxId)
+        this.maxId = id;
+    }
+    this.map.set(id, e);
+  }
+  add(e) {
+    this.maxId++;
+    const id = eid(this.maxId);
+    this.set(id, e);
+    return new Ref(id);
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  entries() {
+    return this.order.map((id) => [id, this.map.get(id)]);
+  }
+  toPartFile(meta) {
+    const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "-");
+    const hdr = [
+      "ISO-10303-21;",
+      "HEADER;",
+      `FILE_DESCRIPTION((${stepStr(meta.name)}),'2;1');`,
+      `FILE_NAME(${stepStr(meta.name)},${stepStr(now)},(${stepStr(meta.author ?? "tscircuit")}),(${stepStr(meta.org ?? "tscircuit")}),${stepStr("generator")},${stepStr("")},${stepStr("")});`,
+      `FILE_SCHEMA(('${this.schema === "AP214" ? "AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }" : "AP242_MANAGED_MODEL_BASED_3D_ENGINEERING"}'));`,
+      "ENDSEC;",
+      "DATA;"
+    ];
+    const data = this.entries().map(([id, e]) => `#${id} = ${e.toStep(this)};`);
+    const ftr = ["ENDSEC;", "END-ISO-10303-21;"];
+    return [...hdr, ...data, ...ftr].join(`
+`);
+  }
+};
+var registry = /* @__PURE__ */ new Map;
+function register(type, parser) {
+  registry.set(type, parser);
+}
+function getParser(type) {
+  return registry.get(type);
+}
+var Axis2Placement3D = class _Axis2Placement3D extends Entity {
+  constructor(name, location, axis, refDirection) {
+    super();
+    this.name = name;
+    this.location = location;
+    this.axis = axis;
+    this.refDirection = refDirection;
+  }
+  type = "AXIS2_PLACEMENT_3D";
+  static parse(a, ctx) {
+    const name = ctx.parseString(a[0]);
+    const loc = ctx.parseRef(a[1]);
+    const axis = a[2] !== "$" ? ctx.parseRef(a[2]) : undefined;
+    const refd = a[3] !== "$" ? ctx.parseRef(a[3]) : undefined;
+    return new _Axis2Placement3D(name, loc, axis, refd);
+  }
+  toStep() {
+    const A = this.axis ? this.axis.toString() : "$";
+    const R = this.refDirection ? this.refDirection.toString() : "$";
+    return `AXIS2_PLACEMENT_3D(${stepStr(this.name)},${this.location},${A},${R})`;
+  }
+};
+register("AXIS2_PLACEMENT_3D", Axis2Placement3D.parse.bind(Axis2Placement3D));
+var CartesianPoint = class _CartesianPoint extends Entity {
+  constructor(name, x, y, z) {
+    super();
+    this.name = name;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  type = "CARTESIAN_POINT";
+  static parse(a, ctx) {
+    const name = ctx.parseString(a[0]);
+    const coords = a[1].replace(/^\(|\)$/g, "").split(",").map(ctx.parseNumber);
+    return new _CartesianPoint(name, coords[0], coords[1], coords[2] ?? 0);
+  }
+  toStep() {
+    return `CARTESIAN_POINT(${stepStr(this.name)},(${fmtNum(this.x)},${fmtNum(this.y)},${fmtNum(this.z)}))`;
+  }
+};
+register("CARTESIAN_POINT", CartesianPoint.parse.bind(CartesianPoint));
+var Circle = class _Circle extends Entity {
+  constructor(name, placement, radius) {
+    super();
+    this.name = name;
+    this.placement = placement;
+    this.radius = radius;
+  }
+  type = "CIRCLE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const pl = ctx.parseRef(a[1]);
+    const r = ctx.parseNumber(a[2]);
+    return new _Circle(name, pl, r);
+  }
+  toStep() {
+    return `CIRCLE(${this.name ? `'${this.name}'` : "''"},${this.placement},${fmtNum(this.radius)})`;
+  }
+};
+register("CIRCLE", Circle.parse.bind(Circle));
+var CylindricalSurface = class _CylindricalSurface extends Entity {
+  constructor(name, position, radius) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.radius = radius;
+  }
+  type = "CYLINDRICAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const radius = ctx.parseNumber(a[2]);
+    return new _CylindricalSurface(name, position, radius);
+  }
+  toStep() {
+    return `CYLINDRICAL_SURFACE(${stepStr(this.name)},${this.position},${fmtNum(this.radius)})`;
+  }
+};
+register("CYLINDRICAL_SURFACE", CylindricalSurface.parse.bind(CylindricalSurface));
+var Direction = class _Direction extends Entity {
+  constructor(name, dx, dy, dz) {
+    super();
+    this.name = name;
+    this.dx = dx;
+    this.dy = dy;
+    this.dz = dz;
+  }
+  type = "DIRECTION";
+  static parse(a, ctx) {
+    const name = ctx.parseString(a[0]);
+    const comps = a[1].replace(/^\(|\)$/g, "").split(",").map(ctx.parseNumber);
+    return new _Direction(name, comps[0], comps[1], comps[2] ?? 0);
+  }
+  toStep() {
+    return `DIRECTION(${stepStr(this.name)},(${fmtNum(this.dx)},${fmtNum(this.dy)},${fmtNum(this.dz)}))`;
+  }
+};
+register("DIRECTION", Direction.parse.bind(Direction));
+var Line = class _Line extends Entity {
+  constructor(name, pnt, dir) {
+    super();
+    this.name = name;
+    this.pnt = pnt;
+    this.dir = dir;
+  }
+  type = "LINE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const p = ctx.parseRef(a[1]);
+    const vecTok = a[2];
+    if (vecTok.startsWith("VECTOR(")) {
+      throw new Error("Inline VECTOR in LINE is not supported - VECTOR should be a separate entity");
+    }
+    const vec = ctx.parseRef(vecTok);
+    return new _Line(name, p, vec);
+  }
+  toStep() {
+    return `LINE(${this.name ? `'${this.name}'` : "''"},${this.pnt},${this.dir})`;
+  }
+};
+register("LINE", Line.parse.bind(Line));
+var Plane = class _Plane extends Entity {
+  constructor(name, placement) {
+    super();
+    this.name = name;
+    this.placement = placement;
+  }
+  type = "PLANE";
+  static parse(a, ctx) {
+    return new _Plane(ctx.parseString(a[0]), ctx.parseRef(a[1]));
+  }
+  toStep() {
+    return `PLANE(${stepStr(this.name)},${this.placement})`;
+  }
+};
+register("PLANE", Plane.parse.bind(Plane));
+var ToroidalSurface = class _ToroidalSurface extends Entity {
+  constructor(name, position, majorRadius, minorRadius) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.majorRadius = majorRadius;
+    this.minorRadius = minorRadius;
+  }
+  type = "TOROIDAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const majorRadius = ctx.parseNumber(a[2]);
+    const minorRadius = ctx.parseNumber(a[3]);
+    return new _ToroidalSurface(name, position, majorRadius, minorRadius);
+  }
+  toStep() {
+    return `TOROIDAL_SURFACE(${stepStr(this.name)},${this.position},${fmtNum(this.majorRadius)},${fmtNum(this.minorRadius)})`;
+  }
+};
+register("TOROIDAL_SURFACE", ToroidalSurface.parse.bind(ToroidalSurface));
+var Vector = class _Vector extends Entity {
+  constructor(name, orientation, magnitude) {
+    super();
+    this.name = name;
+    this.orientation = orientation;
+    this.magnitude = magnitude;
+  }
+  type = "VECTOR";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const orientation = ctx.parseRef(a[1]);
+    const magnitude = ctx.parseNumber(a[2]);
+    return new _Vector(name, orientation, magnitude);
+  }
+  toStep() {
+    return `VECTOR(${stepStr(this.name)},${this.orientation},${fmtNum(this.magnitude)})`;
+  }
+};
+register("VECTOR", Vector.parse.bind(Vector));
+var Ellipse = class _Ellipse extends Entity {
+  constructor(name, placement, semiAxis1, semiAxis2) {
+    super();
+    this.name = name;
+    this.placement = placement;
+    this.semiAxis1 = semiAxis1;
+    this.semiAxis2 = semiAxis2;
+  }
+  type = "ELLIPSE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const placement = ctx.parseRef(a[1]);
+    const semiAxis1 = ctx.parseNumber(a[2]);
+    const semiAxis2 = ctx.parseNumber(a[3]);
+    return new _Ellipse(name, placement, semiAxis1, semiAxis2);
+  }
+  toStep() {
+    return `ELLIPSE(${stepStr(this.name)},${this.placement},${fmtNum(this.semiAxis1)},${fmtNum(this.semiAxis2)})`;
+  }
+};
+register("ELLIPSE", Ellipse.parse.bind(Ellipse));
+var ConicalSurface = class _ConicalSurface extends Entity {
+  constructor(name, position, radius, semiAngle) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.radius = radius;
+    this.semiAngle = semiAngle;
+  }
+  type = "CONICAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const radius = ctx.parseNumber(a[2]);
+    const semiAngle = ctx.parseNumber(a[3]);
+    return new _ConicalSurface(name, position, radius, semiAngle);
+  }
+  toStep() {
+    return `CONICAL_SURFACE(${stepStr(this.name)},${this.position},${fmtNum(this.radius)},${fmtNum(this.semiAngle)})`;
+  }
+};
+register("CONICAL_SURFACE", ConicalSurface.parse.bind(ConicalSurface));
+var SphericalSurface = class _SphericalSurface extends Entity {
+  constructor(name, position, radius) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.radius = radius;
+  }
+  type = "SPHERICAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const radius = ctx.parseNumber(a[2]);
+    return new _SphericalSurface(name, position, radius);
+  }
+  toStep() {
+    return `SPHERICAL_SURFACE(${stepStr(this.name)},${this.position},${fmtNum(this.radius)})`;
+  }
+};
+register("SPHERICAL_SURFACE", SphericalSurface.parse.bind(SphericalSurface));
+var BSplineCurveWithKnots = class _BSplineCurveWithKnots extends Entity {
+  constructor(name, degree, controlPointsList, curveForm, closedCurve, selfIntersect, knotMultiplicities, knots, knotSpec) {
+    super();
+    this.name = name;
+    this.degree = degree;
+    this.controlPointsList = controlPointsList;
+    this.curveForm = curveForm;
+    this.closedCurve = closedCurve;
+    this.selfIntersect = selfIntersect;
+    this.knotMultiplicities = knotMultiplicities;
+    this.knots = knots;
+    this.knotSpec = knotSpec;
+  }
+  type = "B_SPLINE_CURVE_WITH_KNOTS";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const degree = ctx.parseNumber(a[1]);
+    const controlPoints = a[2].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    const curveForm = a[3].trim();
+    const closedCurve = a[4].trim() === ".T.";
+    const selfIntersect = a[5].trim() === ".T.";
+    const knotMults = a[6].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knots = a[7].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knotSpec = a[8].trim();
+    return new _BSplineCurveWithKnots(name, degree, controlPoints, curveForm, closedCurve, selfIntersect, knotMults, knots, knotSpec);
+  }
+  toStep() {
+    const cps = `(${this.controlPointsList.join(",")})`;
+    const kms = `(${this.knotMultiplicities.map(fmtNum).join(",")})`;
+    const ks = `(${this.knots.map(fmtNum).join(",")})`;
+    const closed = this.closedCurve ? ".T." : ".F.";
+    const self = this.selfIntersect ? ".T." : ".F.";
+    return `B_SPLINE_CURVE_WITH_KNOTS(${stepStr(this.name)},${this.degree},${cps},${this.curveForm},${closed},${self},${kms},${ks},${this.knotSpec})`;
+  }
+};
+register("B_SPLINE_CURVE_WITH_KNOTS", BSplineCurveWithKnots.parse.bind(BSplineCurveWithKnots));
+var ColourRgb = class _ColourRgb extends Entity {
+  constructor(name, r, g, b) {
+    super();
+    this.name = name;
+    this.r = r;
+    this.g = g;
+    this.b = b;
+  }
+  type = "COLOUR_RGB";
+  static parse(a, ctx) {
+    return new _ColourRgb(ctx.parseString(a[0]), ctx.parseNumber(a[1]), ctx.parseNumber(a[2]), ctx.parseNumber(a[3]));
+  }
+  toStep() {
+    return `COLOUR_RGB(${stepStr(this.name)},${this.r},${this.g},${this.b})`;
+  }
+};
+register("COLOUR_RGB", ColourRgb.parse.bind(ColourRgb));
+var FillAreaStyle = class _FillAreaStyle extends Entity {
+  constructor(name, items) {
+    super();
+    this.name = name;
+    this.items = items;
+  }
+  type = "FILL_AREA_STYLE";
+  static parse(a, ctx) {
+    const items = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _FillAreaStyle(a[0] === "$" ? "" : ctx.parseString(a[0]), items);
+  }
+  toStep() {
+    return `FILL_AREA_STYLE(${stepStr(this.name)},(${this.items.join(",")}))`;
+  }
+};
+register("FILL_AREA_STYLE", FillAreaStyle.parse.bind(FillAreaStyle));
+var FillAreaStyleColour = class _FillAreaStyleColour extends Entity {
+  constructor(name, colour) {
+    super();
+    this.name = name;
+    this.colour = colour;
+  }
+  type = "FILL_AREA_STYLE_COLOUR";
+  static parse(a, ctx) {
+    return new _FillAreaStyleColour(ctx.parseString(a[0]), ctx.parseRef(a[1]));
+  }
+  toStep() {
+    return `FILL_AREA_STYLE_COLOUR(${stepStr(this.name)},${this.colour})`;
+  }
+};
+register("FILL_AREA_STYLE_COLOUR", FillAreaStyleColour.parse.bind(FillAreaStyleColour));
+var MechanicalDesignGeometricPresentationRepresentation = class _MechanicalDesignGeometricPresentationRepresentation extends Entity {
+  constructor(name, items, contextOfItems) {
+    super();
+    this.name = name;
+    this.items = items;
+    this.contextOfItems = contextOfItems;
+  }
+  type = "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const items = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const contextOfItems = ctx.parseRef(a[2]);
+    return new _MechanicalDesignGeometricPresentationRepresentation(name, items, contextOfItems);
+  }
+  toStep() {
+    return `MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(${stepStr(this.name)},(${this.items.join(",")}),${this.contextOfItems})`;
+  }
+};
+register("MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION", MechanicalDesignGeometricPresentationRepresentation.parse.bind(MechanicalDesignGeometricPresentationRepresentation));
+var PresentationStyleAssignment = class _PresentationStyleAssignment extends Entity {
+  constructor(items) {
+    super();
+    this.items = items;
+  }
+  type = "PRESENTATION_STYLE_ASSIGNMENT";
+  static parse(a, ctx) {
+    const list = a[0].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _PresentationStyleAssignment(list);
+  }
+  toStep() {
+    return `PRESENTATION_STYLE_ASSIGNMENT((${this.items.join(",")}))`;
+  }
+};
+register("PRESENTATION_STYLE_ASSIGNMENT", PresentationStyleAssignment.parse.bind(PresentationStyleAssignment));
+var StyledItem = class _StyledItem extends Entity {
+  constructor(name, styles, item) {
+    super();
+    this.name = name;
+    this.styles = styles;
+    this.item = item;
+  }
+  type = "STYLED_ITEM";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const styles = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const item = ctx.parseRef(a[2]);
+    return new _StyledItem(name, styles, item);
+  }
+  toStep() {
+    return `STYLED_ITEM(${stepStr(this.name)},(${this.styles.join(",")}),${this.item})`;
+  }
+};
+register("STYLED_ITEM", StyledItem.parse.bind(StyledItem));
+var SurfaceSideStyle = class _SurfaceSideStyle extends Entity {
+  constructor(name, styles) {
+    super();
+    this.name = name;
+    this.styles = styles;
+  }
+  type = "SURFACE_SIDE_STYLE";
+  static parse(a, ctx) {
+    const list = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _SurfaceSideStyle(a[0] === "$" ? "" : ctx.parseString(a[0]), list);
+  }
+  toStep() {
+    return `SURFACE_SIDE_STYLE(${stepStr(this.name)},(${this.styles.join(",")}))`;
+  }
+};
+register("SURFACE_SIDE_STYLE", SurfaceSideStyle.parse.bind(SurfaceSideStyle));
+var SurfaceStyleFillArea = class _SurfaceStyleFillArea extends Entity {
+  constructor(style) {
+    super();
+    this.style = style;
+  }
+  type = "SURFACE_STYLE_FILL_AREA";
+  static parse(a, ctx) {
+    return new _SurfaceStyleFillArea(ctx.parseRef(a[0]));
+  }
+  toStep() {
+    return `SURFACE_STYLE_FILL_AREA(${this.style})`;
+  }
+};
+register("SURFACE_STYLE_FILL_AREA", SurfaceStyleFillArea.parse.bind(SurfaceStyleFillArea));
+var SurfaceStyleUsage = class _SurfaceStyleUsage extends Entity {
+  constructor(side, style) {
+    super();
+    this.side = side;
+    this.style = style;
+  }
+  type = "SURFACE_STYLE_USAGE";
+  static parse(a, ctx) {
+    return new _SurfaceStyleUsage(a[0].trim(), ctx.parseRef(a[1]));
+  }
+  toStep() {
+    return `SURFACE_STYLE_USAGE(${this.side},${this.style})`;
+  }
+};
+register("SURFACE_STYLE_USAGE", SurfaceStyleUsage.parse.bind(SurfaceStyleUsage));
+var AdvancedBrepShapeRepresentation = class _AdvancedBrepShapeRepresentation extends Entity {
+  constructor(name, items, context) {
+    super();
+    this.name = name;
+    this.items = items;
+    this.context = context;
+  }
+  type = "ADVANCED_BREP_SHAPE_REPRESENTATION";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const items = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const c = ctx.parseRef(a[2]);
+    return new _AdvancedBrepShapeRepresentation(name, items, c);
+  }
+  toStep() {
+    return `ADVANCED_BREP_SHAPE_REPRESENTATION(${stepStr(this.name)},(${this.items.join(",")}),${this.context})`;
+  }
+};
+register("ADVANCED_BREP_SHAPE_REPRESENTATION", AdvancedBrepShapeRepresentation.parse.bind(AdvancedBrepShapeRepresentation));
+var ApplicationContext = class _ApplicationContext extends Entity {
+  constructor(application) {
+    super();
+    this.application = application;
+  }
+  type = "APPLICATION_CONTEXT";
+  static parse(a, ctx) {
+    const application = ctx.parseString(a[0]);
+    return new _ApplicationContext(application);
+  }
+  toStep() {
+    return `APPLICATION_CONTEXT(${stepStr(this.application)})`;
+  }
+};
+register("APPLICATION_CONTEXT", ApplicationContext.parse.bind(ApplicationContext));
+var ApplicationProtocolDefinition = class _ApplicationProtocolDefinition extends Entity {
+  constructor(status, applicationInterpretedModelSchemaName, applicationProtocolYear, application) {
+    super();
+    this.status = status;
+    this.applicationInterpretedModelSchemaName = applicationInterpretedModelSchemaName;
+    this.applicationProtocolYear = applicationProtocolYear;
+    this.application = application;
+  }
+  type = "APPLICATION_PROTOCOL_DEFINITION";
+  static parse(a, ctx) {
+    const status = ctx.parseString(a[0]);
+    const schemaName = ctx.parseString(a[1]);
+    const year = ctx.parseNumber(a[2]);
+    const application = ctx.parseRef(a[3]);
+    return new _ApplicationProtocolDefinition(status, schemaName, year, application);
+  }
+  toStep() {
+    return `APPLICATION_PROTOCOL_DEFINITION(${stepStr(this.status)},${stepStr(this.applicationInterpretedModelSchemaName)},${this.applicationProtocolYear},${this.application})`;
+  }
+};
+register("APPLICATION_PROTOCOL_DEFINITION", ApplicationProtocolDefinition.parse.bind(ApplicationProtocolDefinition));
+var ContextDependentShapeRepresentation = class _ContextDependentShapeRepresentation extends Entity {
+  constructor(representationRelation, representedProductRelation) {
+    super();
+    this.representationRelation = representationRelation;
+    this.representedProductRelation = representedProductRelation;
+  }
+  type = "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION";
+  static parse(a, ctx) {
+    const representationRelation = ctx.parseRef(a[0]);
+    const representedProductRelation = ctx.parseRef(a[1]);
+    return new _ContextDependentShapeRepresentation(representationRelation, representedProductRelation);
+  }
+  toStep() {
+    return `CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(${this.representationRelation},${this.representedProductRelation})`;
+  }
+};
+register("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION", ContextDependentShapeRepresentation.parse.bind(ContextDependentShapeRepresentation));
+var ItemDefinedTransformation = class _ItemDefinedTransformation extends Entity {
+  constructor(name, description, transformItem1, transformItem2) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.transformItem1 = transformItem1;
+    this.transformItem2 = transformItem2;
+  }
+  type = "ITEM_DEFINED_TRANSFORMATION";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const description = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const item1 = ctx.parseRef(a[2]);
+    const item2 = ctx.parseRef(a[3]);
+    return new _ItemDefinedTransformation(name, description, item1, item2);
+  }
+  toStep() {
+    return `ITEM_DEFINED_TRANSFORMATION(${stepStr(this.name)},${stepStr(this.description)},${this.transformItem1},${this.transformItem2})`;
+  }
+};
+register("ITEM_DEFINED_TRANSFORMATION", ItemDefinedTransformation.parse.bind(ItemDefinedTransformation));
+var NextAssemblyUsageOccurrence = class _NextAssemblyUsageOccurrence extends Entity {
+  constructor(id, name, description, relatingProductDefinition, relatedProductDefinition, referenceDesignator) {
+    super();
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this.relatingProductDefinition = relatingProductDefinition;
+    this.relatedProductDefinition = relatedProductDefinition;
+    this.referenceDesignator = referenceDesignator;
+  }
+  type = "NEXT_ASSEMBLY_USAGE_OCCURRENCE";
+  static parse(a, ctx) {
+    const id = ctx.parseString(a[0]);
+    const name = ctx.parseString(a[1]);
+    const description = a[2] === "$" ? "" : ctx.parseString(a[2]);
+    const relating = ctx.parseRef(a[3]);
+    const related = ctx.parseRef(a[4]);
+    const designator = a[5] === "$" ? "" : ctx.parseString(a[5]);
+    return new _NextAssemblyUsageOccurrence(id, name, description, relating, related, designator);
+  }
+  toStep() {
+    return `NEXT_ASSEMBLY_USAGE_OCCURRENCE(${stepStr(this.id)},${stepStr(this.name)},${this.description ? stepStr(this.description) : "$"},${this.relatingProductDefinition},${this.relatedProductDefinition},${this.referenceDesignator ? stepStr(this.referenceDesignator) : "$"})`;
+  }
+};
+register("NEXT_ASSEMBLY_USAGE_OCCURRENCE", NextAssemblyUsageOccurrence.parse.bind(NextAssemblyUsageOccurrence));
+var Product = class _Product extends Entity {
+  constructor(name, id, description, frameOfReference) {
+    super();
+    this.name = name;
+    this.id = id;
+    this.description = description;
+    this.frameOfReference = frameOfReference;
+  }
+  type = "PRODUCT";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const id = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const description = a[2] === "$" ? "" : ctx.parseString(a[2]);
+    const refs = a[3].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    return new _Product(name, id, description, refs);
+  }
+  toStep() {
+    return `PRODUCT(${stepStr(this.name)},${stepStr(this.id)},${stepStr(this.description)},(${this.frameOfReference.join(",")}))`;
+  }
+};
+register("PRODUCT", Product.parse.bind(Product));
+var ProductContext = class _ProductContext extends Entity {
+  constructor(name, frameOfReference, disciplineType) {
+    super();
+    this.name = name;
+    this.frameOfReference = frameOfReference;
+    this.disciplineType = disciplineType;
+  }
+  type = "PRODUCT_CONTEXT";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const frameOfReference = ctx.parseRef(a[1]);
+    const disciplineType = ctx.parseString(a[2]);
+    return new _ProductContext(name, frameOfReference, disciplineType);
+  }
+  toStep() {
+    return `PRODUCT_CONTEXT(${stepStr(this.name)},${this.frameOfReference},${stepStr(this.disciplineType)})`;
+  }
+};
+register("PRODUCT_CONTEXT", ProductContext.parse.bind(ProductContext));
+var ProductDefinition = class _ProductDefinition extends Entity {
+  constructor(id, description, formation, frameOfReference) {
+    super();
+    this.id = id;
+    this.description = description;
+    this.formation = formation;
+    this.frameOfReference = frameOfReference;
+  }
+  type = "PRODUCT_DEFINITION";
+  static parse(a, ctx) {
+    const id = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const description = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const formation = ctx.parseRef(a[2]);
+    const frameOfReference = ctx.parseRef(a[3]);
+    return new _ProductDefinition(id, description, formation, frameOfReference);
+  }
+  toStep() {
+    return `PRODUCT_DEFINITION(${stepStr(this.id)},${stepStr(this.description)},${this.formation},${this.frameOfReference})`;
+  }
+};
+register("PRODUCT_DEFINITION", ProductDefinition.parse.bind(ProductDefinition));
+var ProductDefinitionContext = class _ProductDefinitionContext extends Entity {
+  constructor(name, frameOfReference, lifecycleStage) {
+    super();
+    this.name = name;
+    this.frameOfReference = frameOfReference;
+    this.lifecycleStage = lifecycleStage;
+  }
+  type = "PRODUCT_DEFINITION_CONTEXT";
+  static parse(a, ctx) {
+    const name = ctx.parseString(a[0]);
+    const frameOfReference = ctx.parseRef(a[1]);
+    const lifecycleStage = ctx.parseString(a[2]);
+    return new _ProductDefinitionContext(name, frameOfReference, lifecycleStage);
+  }
+  toStep() {
+    return `PRODUCT_DEFINITION_CONTEXT(${stepStr(this.name)},${this.frameOfReference},${stepStr(this.lifecycleStage)})`;
+  }
+};
+register("PRODUCT_DEFINITION_CONTEXT", ProductDefinitionContext.parse.bind(ProductDefinitionContext));
+var ProductDefinitionFormation = class _ProductDefinitionFormation extends Entity {
+  constructor(id, description, ofProduct) {
+    super();
+    this.id = id;
+    this.description = description;
+    this.ofProduct = ofProduct;
+  }
+  type = "PRODUCT_DEFINITION_FORMATION";
+  static parse(a, ctx) {
+    const id = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const description = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const ofProduct = ctx.parseRef(a[2]);
+    return new _ProductDefinitionFormation(id, description, ofProduct);
+  }
+  toStep() {
+    return `PRODUCT_DEFINITION_FORMATION(${stepStr(this.id)},${stepStr(this.description)},${this.ofProduct})`;
+  }
+};
+register("PRODUCT_DEFINITION_FORMATION", ProductDefinitionFormation.parse.bind(ProductDefinitionFormation));
+var ProductDefinitionShape = class _ProductDefinitionShape extends Entity {
+  constructor(name, description, definition) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.definition = definition;
+  }
+  type = "PRODUCT_DEFINITION_SHAPE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const description = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const definition = ctx.parseRef(a[2]);
+    return new _ProductDefinitionShape(name, description, definition);
+  }
+  toStep() {
+    return `PRODUCT_DEFINITION_SHAPE(${stepStr(this.name)},${stepStr(this.description)},${this.definition})`;
+  }
+};
+register("PRODUCT_DEFINITION_SHAPE", ProductDefinitionShape.parse.bind(ProductDefinitionShape));
+var ProductRelatedProductCategory = class _ProductRelatedProductCategory extends Entity {
+  constructor(name, description, products) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.products = products;
+  }
+  type = "PRODUCT_RELATED_PRODUCT_CATEGORY";
+  static parse(a, ctx) {
+    const name = ctx.parseString(a[0]);
+    const description = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const products = a[2].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _ProductRelatedProductCategory(name, description, products);
+  }
+  toStep() {
+    return `PRODUCT_RELATED_PRODUCT_CATEGORY(${stepStr(this.name)},${this.description ? stepStr(this.description) : "$"},(${this.products.join(",")}))`;
+  }
+};
+register("PRODUCT_RELATED_PRODUCT_CATEGORY", ProductRelatedProductCategory.parse.bind(ProductRelatedProductCategory));
+var ShapeDefinitionRepresentation = class _ShapeDefinitionRepresentation extends Entity {
+  constructor(definition, usedRepresentation) {
+    super();
+    this.definition = definition;
+    this.usedRepresentation = usedRepresentation;
+  }
+  type = "SHAPE_DEFINITION_REPRESENTATION";
+  static parse(a, ctx) {
+    const definition = ctx.parseRef(a[0]);
+    const usedRepresentation = ctx.parseRef(a[1]);
+    return new _ShapeDefinitionRepresentation(definition, usedRepresentation);
+  }
+  toStep() {
+    return `SHAPE_DEFINITION_REPRESENTATION(${this.definition},${this.usedRepresentation})`;
+  }
+};
+register("SHAPE_DEFINITION_REPRESENTATION", ShapeDefinitionRepresentation.parse.bind(ShapeDefinitionRepresentation));
+var ShapeRepresentation = class _ShapeRepresentation extends Entity {
+  constructor(name, items, contextOfItems) {
+    super();
+    this.name = name;
+    this.items = items;
+    this.contextOfItems = contextOfItems;
+  }
+  type = "SHAPE_REPRESENTATION";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const items = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const contextOfItems = ctx.parseRef(a[2]);
+    return new _ShapeRepresentation(name, items, contextOfItems);
+  }
+  toStep() {
+    return `SHAPE_REPRESENTATION(${stepStr(this.name)},(${this.items.join(",")}),${this.contextOfItems})`;
+  }
+};
+register("SHAPE_REPRESENTATION", ShapeRepresentation.parse.bind(ShapeRepresentation));
+var AdvancedFace = class _AdvancedFace extends Entity {
+  constructor(name, bounds, surface, sameSense) {
+    super();
+    this.name = name;
+    this.bounds = bounds;
+    this.surface = surface;
+    this.sameSense = sameSense;
+  }
+  type = "ADVANCED_FACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const bounds = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    const surf = ctx.parseRef(a[2]);
+    const ss = a[3].trim() === ".T.";
+    return new _AdvancedFace(name, bounds, surf, ss);
+  }
+  toStep() {
+    return `ADVANCED_FACE(${this.name ? `'${this.name}'` : "''"},(${this.bounds.join(",")}),${this.surface},${this.sameSense ? ".T." : ".F."})`;
+  }
+};
+register("ADVANCED_FACE", AdvancedFace.parse.bind(AdvancedFace));
+var ClosedShell = class _ClosedShell extends Entity {
+  constructor(name, faces) {
+    super();
+    this.name = name;
+    this.faces = faces;
+  }
+  type = "CLOSED_SHELL";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const faces = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    return new _ClosedShell(name, faces);
+  }
+  toStep() {
+    return `CLOSED_SHELL(${this.name ? `'${this.name}'` : "''"},(${this.faces.join(",")}))`;
+  }
+};
+register("CLOSED_SHELL", ClosedShell.parse.bind(ClosedShell));
+var EdgeCurve = class _EdgeCurve extends Entity {
+  constructor(name, start, end, curve, sameSense) {
+    super();
+    this.name = name;
+    this.start = start;
+    this.end = end;
+    this.curve = curve;
+    this.sameSense = sameSense;
+  }
+  type = "EDGE_CURVE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const s = ctx.parseRef(a[1]);
+    const e = ctx.parseRef(a[2]);
+    const c = ctx.parseRef(a[3]);
+    const same = a[4].trim() === ".T.";
+    return new _EdgeCurve(name, s, e, c, same);
+  }
+  toStep() {
+    return `EDGE_CURVE(${this.name ? `'${this.name}'` : "''"},${this.start},${this.end},${this.curve},${this.sameSense ? ".T." : ".F."})`;
+  }
+};
+register("EDGE_CURVE", EdgeCurve.parse.bind(EdgeCurve));
+var EdgeLoop = class _EdgeLoop extends Entity {
+  constructor(name, edges) {
+    super();
+    this.name = name;
+    this.edges = edges;
+  }
+  type = "EDGE_LOOP";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const list = a[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _EdgeLoop(name, list);
+  }
+  toStep() {
+    return `EDGE_LOOP(${stepStr(this.name)},(${this.edges.join(",")}))`;
+  }
+};
+register("EDGE_LOOP", EdgeLoop.parse.bind(EdgeLoop));
+var FaceBound = class _FaceBound extends Entity {
+  constructor(name, bound, sameSense) {
+    super();
+    this.name = name;
+    this.bound = bound;
+    this.sameSense = sameSense;
+  }
+  type = "FACE_BOUND";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    return new _FaceBound(name, ctx.parseRef(a[1]), a[2].trim() === ".T.");
+  }
+  toStep() {
+    return `FACE_BOUND(${stepStr(this.name)},${this.bound},${this.sameSense ? ".T." : ".F."})`;
+  }
+};
+register("FACE_BOUND", FaceBound.parse.bind(FaceBound));
+var FaceOuterBound = class _FaceOuterBound extends Entity {
+  constructor(name, bound, sameSense) {
+    super();
+    this.name = name;
+    this.bound = bound;
+    this.sameSense = sameSense;
+  }
+  type = "FACE_OUTER_BOUND";
+  static parse(a, ctx) {
+    return new _FaceOuterBound(ctx.parseString(a[0]), ctx.parseRef(a[1]), a[2].trim() === ".T.");
+  }
+  toStep() {
+    return `FACE_OUTER_BOUND('${this.name}',${this.bound},${this.sameSense ? ".T." : ".F."})`;
+  }
+};
+register("FACE_OUTER_BOUND", FaceOuterBound.parse.bind(FaceOuterBound));
+var ManifoldSolidBrep = class _ManifoldSolidBrep extends Entity {
+  constructor(name, outer) {
+    super();
+    this.name = name;
+    this.outer = outer;
+  }
+  type = "MANIFOLD_SOLID_BREP";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    return new _ManifoldSolidBrep(name, ctx.parseRef(a[1]));
+  }
+  toStep() {
+    return `MANIFOLD_SOLID_BREP(${stepStr(this.name)},${this.outer})`;
+  }
+};
+register("MANIFOLD_SOLID_BREP", ManifoldSolidBrep.parse.bind(ManifoldSolidBrep));
+var OrientedEdge = class _OrientedEdge extends Entity {
+  constructor(name, edge, orientation) {
+    super();
+    this.name = name;
+    this.edge = edge;
+    this.orientation = orientation;
+  }
+  type = "ORIENTED_EDGE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const edge = ctx.parseRef(a[3]);
+    const orient = a[4]?.trim?.() === ".T." || a[2]?.trim?.() === ".T.";
+    return new _OrientedEdge(name, edge, orient);
+  }
+  toStep() {
+    return `ORIENTED_EDGE(${stepStr(this.name)},*,*,${this.edge},${this.orientation ? ".T." : ".F."})`;
+  }
+};
+register("ORIENTED_EDGE", OrientedEdge.parse.bind(OrientedEdge));
+var VertexPoint = class _VertexPoint extends Entity {
+  constructor(name, pnt) {
+    super();
+    this.name = name;
+    this.pnt = pnt;
+  }
+  type = "VERTEX_POINT";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    return new _VertexPoint(name, ctx.parseRef(a[1]));
+  }
+  toStep() {
+    return `VERTEX_POINT(${this.name ? `'${this.name}'` : "''"},${this.pnt})`;
+  }
+};
+register("VERTEX_POINT", VertexPoint.parse.bind(VertexPoint));
+var Unknown = class extends Entity {
+  constructor(type, args) {
+    super();
+    this.type = type;
+    this.args = args;
+  }
+  toStep() {
+    if (this.args.length === 1 && this.args[0].startsWith("( ")) {
+      const content = this.args[0].slice(2, -2).trim();
+      const parts = content.split(/\s+(?=[A-Z_])/g);
+      return `(
+${parts.join(`
+`)}
+)`;
+    }
+    return `${this.type}(${this.args.join(",")})`;
+  }
+};
+function tokenizeSTEP(data) {
+  const entities = [];
+  const dataStart = data.indexOf("DATA;");
+  const dataEnd = data.indexOf("ENDSEC;", dataStart);
+  if (dataStart === -1 || dataEnd === -1) {
+    throw new Error("Could not find DATA section in STEP file");
+  }
+  const dataSection = data.substring(dataStart + 5, dataEnd);
+  const entityPattern = /#(\d+)\s*=\s*/g;
+  let match;
+  const entityStarts = [];
+  while ((match = entityPattern.exec(dataSection)) !== null) {
+    entityStarts.push({
+      index: match.index,
+      id: parseInt(match[1], 10)
+    });
+  }
+  for (let i = 0;i < entityStarts.length; i++) {
+    const start = entityStarts[i];
+    const nextStart = i + 1 < entityStarts.length ? entityStarts[i + 1].index : dataSection.length;
+    const entityText = dataSection.substring(start.index, nextStart);
+    const semiIndex = entityText.indexOf(";");
+    if (semiIndex === -1) {
+      throw new Error(`Could not find closing semicolon for entity #${start.id}`);
+    }
+    const fullEntity = entityText.substring(0, semiIndex + 1);
+    if (fullEntity.match(/#\d+\s*=\s*\(/)) {
+      const complexMatch = fullEntity.match(/#\d+\s*=\s*\(([\s\S]*)\);/);
+      if (!complexMatch) {
+        throw new Error(`Could not parse complex entity: ${fullEntity.substring(0, 100)}`);
+      }
+      entities.push({
+        id: eid(start.id),
+        type: "Unknown",
+        args: [`( ${complexMatch[1].trim()} )`]
+      });
+    } else {
+      const match2 = fullEntity.match(/#\d+\s*=\s*([A-Z0-9_]+)\s*\(([\s\S]*)\);/);
+      if (!match2) {
+        throw new Error(`Could not parse entity: ${fullEntity.substring(0, 100)}`);
+      }
+      const type = match2[1].trim();
+      const argsBody = match2[2].trim();
+      const args = splitArgs(argsBody);
+      entities.push({ id: eid(start.id), type, args });
+    }
+  }
+  return entities;
+}
+function splitArgs(s) {
+  const out = [];
+  let buf = "";
+  let depth = 0;
+  let inStr = false;
+  for (let i = 0;i < s.length; i++) {
+    const c = s[i];
+    if (c === "'" && s[i - 1] !== "\\")
+      inStr = !inStr;
+    if (!inStr) {
+      if (c === "(")
+        depth++;
+      if (c === ")")
+        depth--;
+      if (c === "," && depth === 0) {
+        out.push(buf.trim());
+        buf = "";
+        continue;
+      }
+    }
+    buf += c;
+  }
+  if (buf.trim())
+    out.push(buf.trim());
+  return out;
+}
+function parseRepository(data) {
+  const repo = new Repository;
+  const ctx = {
+    repo,
+    parseRef(_tok) {
+      const n = +_tok.replace("#", "").trim();
+      return new Ref(eid(n));
+    },
+    parseNumber(tok) {
+      return Number(tok);
+    },
+    parseString(tok) {
+      const m = tok.match(/^'(.*)'$/);
+      if (!m)
+        throw new Error(`Expected string: ${tok}`);
+      return m[1].replace(/''/g, "'");
+    }
+  };
+  for (const row of tokenizeSTEP(data)) {
+    const parser = getParser(row.type);
+    if (!parser) {
+      repo.set(row.id, new Unknown(row.type, row.args));
+      continue;
+    }
+    const entity = parser(row.args, ctx);
+    repo.set(row.id, entity);
+  }
+  return repo;
+}
+
+// node_modules/circuit-json-to-step/dist/index.js
+var getCircuitJsonToGltfModule = async () => {
+  try {
+    return await import("circuit-json-to-gltf");
+  } catch (error) {
+    const dynamicGlobal = globalThis.tscircuitDynamicModules?.["circuit-json-to-gltf"];
+    if (dynamicGlobal)
+      return dynamicGlobal;
+    throw new Error('Unable to load "circuit-json-to-gltf" from import() or globalThis.tscircuitDynamicModules.', { cause: error });
+  }
+};
+function createStyleCache() {
+  return /* @__PURE__ */ new Map;
+}
+function createStyledItem(repo, options) {
+  const { itemRef, rgb, styleCache, name = "color" } = options;
+  const key = rgb.map((value) => value.toFixed(6)).join(",");
+  let presStyle = styleCache.get(key);
+  if (!presStyle) {
+    const color = repo.add(new ColourRgb("", rgb[0], rgb[1], rgb[2]));
+    const fillColor = repo.add(new FillAreaStyleColour("", color));
+    const fillStyle = repo.add(new FillAreaStyle("", [fillColor]));
+    const surfaceFill = repo.add(new SurfaceStyleFillArea(fillStyle));
+    const surfaceSide = repo.add(new SurfaceSideStyle("", [surfaceFill]));
+    const surfaceUsage = repo.add(new SurfaceStyleUsage(".BOTH.", surfaceSide));
+    presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
+    styleCache.set(key, presStyle);
+  }
+  return repo.add(new StyledItem(name, [presStyle], itemRef));
+}
+function createStyledItems(repo, options) {
+  const { itemRefs, rgb, styleCache, name } = options;
+  return itemRefs.map((itemRef) => createStyledItem(repo, { itemRef, rgb, styleCache, name }));
+}
+function rotatePoint3(point, rotation) {
+  if (!rotation)
+    return point;
+  let { x, y, z } = point;
+  if (rotation.x) {
+    const cos = Math.cos(rotation.x);
+    const sin = Math.sin(rotation.x);
+    const nextY = y * cos - z * sin;
+    const nextZ = y * sin + z * cos;
+    y = nextY;
+    z = nextZ;
+  }
+  if (rotation.y) {
+    const cos = Math.cos(rotation.y);
+    const sin = Math.sin(rotation.y);
+    const nextX = x * cos + z * sin;
+    const nextZ = -x * sin + z * cos;
+    x = nextX;
+    z = nextZ;
+  }
+  if (rotation.z) {
+    const cos = Math.cos(rotation.z);
+    const sin = Math.sin(rotation.z);
+    const nextX = x * cos - y * sin;
+    const nextY = x * sin + y * cos;
+    x = nextX;
+    y = nextY;
+  }
+  return { x, y, z };
+}
+function createVertex(repo, point) {
+  return repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point.x, point.y, point.z))));
+}
+function createEdge(repo, vStart, vEnd) {
+  const pStart = vStart.resolve(repo).pnt.resolve(repo);
+  const pEnd = vEnd.resolve(repo).pnt.resolve(repo);
+  const dx = pEnd.x - pStart.x;
+  const dy = pEnd.y - pStart.y;
+  const dz = pEnd.z - pStart.z;
+  const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (length < 0.0000000001) {
+    const dir2 = repo.add(new Direction("", 1, 0, 0));
+    const vec2 = repo.add(new Vector("", dir2, 0.0000000001));
+    const line2 = repo.add(new Line("", vStart.resolve(repo).pnt, vec2));
+    return repo.add(new EdgeCurve("", vStart, vEnd, line2, true));
+  }
+  const dir = repo.add(new Direction("", dx / length, dy / length, dz / length));
+  const vec = repo.add(new Vector("", dir, length));
+  const line = repo.add(new Line("", vStart.resolve(repo).pnt, vec));
+  return repo.add(new EdgeCurve("", vStart, vEnd, line, true));
+}
+function createFaceFromVertices(repo, vertices) {
+  const edges = vertices.map((vertex, index) => createEdge(repo, vertex, vertices[(index + 1) % vertices.length]));
+  const edgeLoop = repo.add(new EdgeLoop("", edges.map((edge) => repo.add(new OrientedEdge("", edge, true)))));
+  const p1 = vertices[0].resolve(repo).pnt.resolve(repo);
+  const p2 = vertices[1].resolve(repo).pnt.resolve(repo);
+  const p3 = vertices[2].resolve(repo).pnt.resolve(repo);
+  const ux = p2.x - p1.x;
+  const uy = p2.y - p1.y;
+  const uz = p2.z - p1.z;
+  const vx = p3.x - p1.x;
+  const vy = p3.y - p1.y;
+  const vz = p3.z - p1.z;
+  const nx = uy * vz - uz * vy;
+  const ny = uz * vx - ux * vz;
+  const nz = ux * vy - uy * vx;
+  const normalLength = Math.sqrt(nx * nx + ny * ny + nz * nz);
+  const normal = normalLength < 0.0000000001 ? repo.add(new Direction("", 0, 0, 1)) : repo.add(new Direction("", nx / normalLength, ny / normalLength, nz / normalLength));
+  const refLength = Math.sqrt(ux * ux + uy * uy + uz * uz);
+  const refDir = refLength < 0.0000000001 ? repo.add(new Direction("", 1, 0, 0)) : repo.add(new Direction("", ux / refLength, uy / refLength, uz / refLength));
+  const placement = repo.add(new Axis2Placement3D("", vertices[0].resolve(repo).pnt, normal, refDir));
+  const plane = repo.add(new Plane("", placement));
+  return repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", edgeLoop, true))], plane, true));
+}
+function createSceneBoxSolid(repo, box) {
+  if (box.mesh?.triangles?.length) {
+    return createSceneMeshSolid(repo, box);
+  }
+  const localBounds = box.mesh?.boundingBox ? {
+    min: box.mesh.boundingBox.min,
+    max: box.mesh.boundingBox.max
+  } : {
+    min: {
+      x: -box.size.x / 2,
+      y: -box.size.y / 2,
+      z: -box.size.z / 2
+    },
+    max: {
+      x: box.size.x / 2,
+      y: box.size.y / 2,
+      z: box.size.z / 2
+    }
+  };
+  const corners = [
+    { x: localBounds.min.x, y: localBounds.min.y, z: localBounds.min.z },
+    { x: localBounds.max.x, y: localBounds.min.y, z: localBounds.min.z },
+    { x: localBounds.max.x, y: localBounds.max.y, z: localBounds.min.z },
+    { x: localBounds.min.x, y: localBounds.max.y, z: localBounds.min.z },
+    { x: localBounds.min.x, y: localBounds.min.y, z: localBounds.max.z },
+    { x: localBounds.max.x, y: localBounds.min.y, z: localBounds.max.z },
+    { x: localBounds.max.x, y: localBounds.max.y, z: localBounds.max.z },
+    { x: localBounds.min.x, y: localBounds.max.y, z: localBounds.max.z }
+  ].map((corner) => {
+    const rotated = rotatePoint3(corner, box.rotation);
+    return {
+      x: rotated.x + box.center.x,
+      y: rotated.y + box.center.y,
+      z: rotated.z + box.center.z
+    };
+  });
+  const stepCorners = corners.map((corner) => ({
+    x: corner.x,
+    y: corner.z,
+    z: corner.y
+  }));
+  const vertices = stepCorners.map((corner) => createVertex(repo, corner));
+  const faces = [
+    [vertices[0], vertices[1], vertices[2], vertices[3]],
+    [vertices[4], vertices[7], vertices[6], vertices[5]],
+    [vertices[0], vertices[4], vertices[5], vertices[1]],
+    [vertices[1], vertices[5], vertices[6], vertices[2]],
+    [vertices[2], vertices[6], vertices[7], vertices[3]],
+    [vertices[3], vertices[7], vertices[4], vertices[0]]
+  ].map((faceVertices) => createFaceFromVertices(repo, faceVertices));
+  const shell = repo.add(new ClosedShell("", faces));
+  return {
+    solid: repo.add(new ManifoldSolidBrep(box.label ?? "Component", shell)),
+    styledItems: [],
+    usesIntrinsicFaceStyles: false,
+    styleTargets: faces
+  };
+}
+function createSceneMeshSolid(repo, box) {
+  const styleCache = createStyleCache();
+  const styledItems = [];
+  const faces = box.mesh.triangles.map((triangle) => {
+    const vertices = triangle.vertices.map((vertex) => {
+      const rotated = rotatePoint3(vertex, box.rotation);
+      const translated = {
+        x: rotated.x + box.center.x,
+        y: rotated.z + box.center.z,
+        z: rotated.y + box.center.y
+      };
+      return createVertex(repo, translated);
+    });
+    const face = createFaceFromVertices(repo, vertices);
+    const faceColor = normalizeTriangleColor(triangle.color);
+    if (faceColor) {
+      styledItems.push(createStyledItem(repo, {
+        itemRef: face,
+        rgb: faceColor,
+        styleCache
+      }));
+    }
+    return face;
+  });
+  const shell = repo.add(new ClosedShell("", faces));
+  return {
+    solid: repo.add(new ManifoldSolidBrep(box.label ?? "Component", shell)),
+    styledItems,
+    usesIntrinsicFaceStyles: faces.length > 0 && styledItems.length === faces.length,
+    styleTargets: []
+  };
+}
+function normalizeTriangleColor(color) {
+  if (!Array.isArray(color) || color.length < 3)
+    return null;
+  const scale = color.some((value) => value > 1) ? 255 : 1;
+  return [
+    clampColorChannel(color[0] / scale),
+    clampColorChannel(color[1] / scale),
+    clampColorChannel(color[2] / scale)
+  ];
+}
+function clampColorChannel(value) {
+  return Math.max(0, Math.min(1, value));
+}
+async function generateComponentMeshes(options) {
+  const {
+    repo,
+    circuitJson,
+    boardThickness,
+    includeExternalMeshes = false,
+    excludeCadComponentIds,
+    excludePcbComponentIds,
+    pcbComponentIdsWithStepUrl
+  } = options;
+  const solids = [];
+  try {
+    const filteredCircuitJson = circuitJson.filter((element) => {
+      if (element.type === "pcb_board")
+        return false;
+      if (element.type === "cad_component" && element.cad_component_id && excludeCadComponentIds?.has(element.cad_component_id)) {
+        return false;
+      }
+      if (element.type === "pcb_component" && element.pcb_component_id && excludePcbComponentIds?.has(element.pcb_component_id)) {
+        return false;
+      }
+      if (element.type === "cad_component" && element.model_step_url) {
+        return false;
+      }
+      if (element.type === "cad_component" && element.pcb_component_id && pcbComponentIdsWithStepUrl?.has(element.pcb_component_id)) {
+        return false;
+      }
+      return true;
+    }).map((element) => {
+      if (!includeExternalMeshes && element.type === "cad_component") {
+        return {
+          ...element,
+          model_3mf_url: undefined,
+          model_obj_url: undefined,
+          model_stl_url: undefined,
+          model_glb_url: undefined,
+          model_gltf_url: undefined
+        };
+      }
+      return element;
+    });
+    const { convertCircuitJsonTo3D } = await getCircuitJsonToGltfModule();
+    const scene3d = await convertCircuitJsonTo3D(filteredCircuitJson, {
+      boardThickness,
+      renderBoardTextures: false
+    });
+    for (const box of scene3d.boxes) {
+      solids.push(createSceneBoxSolid(repo, box));
+    }
+  } catch (error) {
+    console.warn("Failed to generate component mesh:", error);
+  }
+  return solids;
+}
+var EXCLUDED_ENTITY_TYPES = /* @__PURE__ */ new Set([
+  "APPLICATION_CONTEXT",
+  "APPLICATION_PROTOCOL_DEFINITION",
+  "PRODUCT",
+  "PRODUCT_CONTEXT",
+  "PRODUCT_DEFINITION",
+  "PRODUCT_DEFINITION_FORMATION",
+  "PRODUCT_DEFINITION_CONTEXT",
+  "PRODUCT_DEFINITION_SHAPE",
+  "SHAPE_DEFINITION_REPRESENTATION",
+  "ADVANCED_BREP_SHAPE_REPRESENTATION",
+  "PRODUCT_RELATED_PRODUCT_CATEGORY",
+  "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
+  "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
+  "ITEM_DEFINED_TRANSFORMATION"
+]);
+function asVector3(value) {
+  return {
+    x: value?.x ?? 0,
+    y: value?.y ?? 0,
+    z: value?.z ?? 0
+  };
+}
+function toRadians(rotation) {
+  const factor = Math.PI / 180;
+  return {
+    x: rotation.x * factor,
+    y: rotation.y * factor,
+    z: rotation.z * factor
+  };
+}
+function transformPoint(point, rotation, translation) {
+  const rotated = rotateVector(point, rotation);
+  return [
+    rotated[0] + translation.x,
+    rotated[1] + translation.y,
+    rotated[2] + translation.z
+  ];
+}
+function transformDirection(vector, rotation) {
+  return rotateVector(vector, rotation);
+}
+function rotateVector(vector, rotation) {
+  let [x, y, z] = vector;
+  if (rotation.x !== 0) {
+    const cosX = Math.cos(rotation.x);
+    const sinX = Math.sin(rotation.x);
+    const y1 = y * cosX - z * sinX;
+    const z1 = y * sinX + z * cosX;
+    y = y1;
+    z = z1;
+  }
+  if (rotation.y !== 0) {
+    const cosY = Math.cos(rotation.y);
+    const sinY = Math.sin(rotation.y);
+    const x1 = x * cosY + z * sinY;
+    const z1 = -x * sinY + z * cosY;
+    x = x1;
+    z = z1;
+  }
+  if (rotation.z !== 0) {
+    const cosZ = Math.cos(rotation.z);
+    const sinZ = Math.sin(rotation.z);
+    const x1 = x * cosZ - y * sinZ;
+    const y1 = x * sinZ + y * cosZ;
+    x = x1;
+    y = y1;
+  }
+  return [x, y, z];
+}
+async function readStepFile(modelUrl) {
+  if (!/^https?:\/\//i.test(modelUrl)) {
+    throw new Error(`Only HTTP(S) URLs are supported. For local files, read the file content and pass it directly. Received: ${modelUrl}`);
+  }
+  const globalFetch = globalThis.fetch;
+  if (!globalFetch) {
+    throw new Error("fetch is not available in this environment");
+  }
+  const res = await globalFetch(modelUrl);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  }
+  return await res.text();
+}
+async function mergeExternalStepModels(options) {
+  const { repo, circuitJson, boardThickness, fsMap } = options;
+  const cadComponents = circuitJson.filter((item) => item?.type === "cad_component" && typeof item.model_step_url === "string");
+  const pcbComponentMap = /* @__PURE__ */ new Map;
+  for (const item of circuitJson) {
+    if (item?.type === "pcb_component" && item.pcb_component_id) {
+      pcbComponentMap.set(item.pcb_component_id, item);
+    }
+  }
+  const solids = [];
+  const handledComponentIds = /* @__PURE__ */ new Set;
+  const handledPcbComponentIds = /* @__PURE__ */ new Set;
+  for (const component of cadComponents) {
+    const componentId = component.cad_component_id ?? "";
+    const stepUrl = component.model_step_url;
+    try {
+      const stepText = fsMap?.[stepUrl] ?? await readStepFile(stepUrl);
+      if (!stepText.trim()) {
+        throw new Error("STEP file is empty");
+      }
+      const pcbComponent = component.pcb_component_id ? pcbComponentMap.get(component.pcb_component_id) : undefined;
+      const layer = pcbComponent?.layer?.toLowerCase();
+      const transform = {
+        translation: asVector3(component.position),
+        rotation: asVector3(component.rotation)
+      };
+      const componentSolids = mergeSingleStepModel(repo, stepText, transform, {
+        layer,
+        boardThickness
+      });
+      if (componentSolids.length > 0) {
+        if (componentId) {
+          handledComponentIds.add(componentId);
+        }
+        const pcbComponentId = component.pcb_component_id;
+        if (pcbComponentId) {
+          handledPcbComponentIds.add(pcbComponentId);
+        }
+      }
+      solids.push(...componentSolids);
+    } catch (error) {
+      console.warn(`Failed to merge STEP model from ${stepUrl}:`, error);
+    }
+  }
+  return { solids, handledComponentIds, handledPcbComponentIds };
+}
+function mergeSingleStepModel(targetRepo, stepText, transform, placement) {
+  const sourceRepo = parseRepository(stepText);
+  let entries = sourceRepo.entries().map(([id, entity]) => [Number(id), entity]).filter(([, entity]) => !EXCLUDED_ENTITY_TYPES.has(entity.type));
+  entries = pruneInvalidEntries(entries);
+  adjustTransformForPlacement(entries, transform, placement);
+  applyTransform(entries, transform);
+  const idMapping = allocateIds(targetRepo, entries);
+  remapReferences(entries, idMapping);
+  for (const [oldId, entity] of entries) {
+    const mappedId = idMapping.get(oldId);
+    if (mappedId === undefined)
+      continue;
+    targetRepo.set(eid(mappedId), entity);
+  }
+  const solids = [];
+  for (const [oldId, entity] of entries) {
+    if (entity instanceof ManifoldSolidBrep) {
+      const mappedId = idMapping.get(oldId);
+      if (mappedId !== undefined) {
+        solids.push(new Ref(eid(mappedId)));
+      }
+    }
+  }
+  return solids;
+}
+function adjustTransformForPlacement(entries, transform, placement) {
+  if (!placement)
+    return;
+  const points = [];
+  for (const [, entity] of entries) {
+    if (entity instanceof CartesianPoint) {
+      points.push([entity.x, entity.y, entity.z]);
+    }
+  }
+  if (!points.length)
+    return;
+  const rotationRadians = toRadians(transform.rotation);
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (const point of points) {
+    const [x, y, z] = rotateVector(point, rotationRadians);
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (z < minZ)
+      minZ = z;
+    if (x > maxX)
+      maxX = x;
+    if (y > maxY)
+      maxY = y;
+    if (z > maxZ)
+      maxZ = z;
+  }
+  if (!Number.isFinite(minX))
+    return;
+  const center = {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2,
+    z: (minZ + maxZ) / 2
+  };
+  const normalizedLayer = placement.layer?.toLowerCase() === "bottom" ? "bottom" : "top";
+  const boardThickness = placement.boardThickness ?? 0;
+  const targetX = transform.translation.x;
+  const targetY = transform.translation.y;
+  const targetZ = transform.translation.z;
+  const THROUGH_HOLE_Z_TOLERANCE = 0.001;
+  const isThroughHoleComponent = minZ < -THROUGH_HOLE_Z_TOLERANCE && maxZ > THROUGH_HOLE_Z_TOLERANCE;
+  transform.translation.x = targetX - center.x;
+  transform.translation.y = targetY - center.y;
+  if (isThroughHoleComponent) {
+    transform.translation.z = boardThickness / 2;
+  }
+  if (!isThroughHoleComponent && boardThickness > 0) {
+    const halfThickness = boardThickness / 2;
+    const offsetZ = targetZ;
+    if (normalizedLayer === "bottom") {
+      transform.translation.z = -maxZ + offsetZ;
+      transform.rotation.x = normalizeDegrees(transform.rotation.x + 180);
+    } else {
+      transform.translation.z = halfThickness - minZ + offsetZ;
+    }
+  } else if (!isThroughHoleComponent) {
+    transform.translation.z = targetZ - center.z;
+  }
+}
+function normalizeDegrees(value) {
+  const wrapped = value % 360;
+  return wrapped < 0 ? wrapped + 360 : wrapped;
+}
+function pruneInvalidEntries(entries) {
+  let remaining = entries.slice();
+  let remainingIds = new Set(remaining.map(([id]) => id));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const toRemove = /* @__PURE__ */ new Set;
+    for (const [entityId, entity] of remaining) {
+      const refs = collectReferencedIds(entity);
+      for (const refId of refs) {
+        if (!remainingIds.has(refId)) {
+          toRemove.add(entityId);
+          break;
+        }
+      }
+    }
+    if (toRemove.size > 0) {
+      changed = true;
+      remaining = remaining.filter(([id]) => !toRemove.has(id));
+      remainingIds = new Set(remaining.map(([id]) => id));
+    }
+  }
+  return remaining;
+}
+function collectReferencedIds(entity) {
+  const result = /* @__PURE__ */ new Set;
+  collectReferencedIdsRecursive(entity, result, /* @__PURE__ */ new Set);
+  return result;
+}
+function collectReferencedIdsRecursive(value, result, seen) {
+  if (!value)
+    return;
+  if (value instanceof Ref) {
+    result.add(Number(value.id));
+    return;
+  }
+  if (value instanceof Unknown) {
+    for (const arg of value.args) {
+      arg.replace(/#(\d+)/g, (_, num) => {
+        result.add(Number(num));
+        return _;
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectReferencedIdsRecursive(item, result, seen);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of Object.values(value)) {
+      collectReferencedIdsRecursive(entry, result, seen);
+    }
+  }
+}
+function applyTransform(entries, transform) {
+  const rotation = toRadians(transform.rotation);
+  for (const [, entity] of entries) {
+    if (entity instanceof CartesianPoint) {
+      const [x, y, z] = transformPoint([entity.x, entity.y, entity.z], rotation, transform.translation);
+      entity.x = x;
+      entity.y = y;
+      entity.z = z;
+    } else if (entity instanceof Direction) {
+      const [dx, dy, dz] = transformDirection([entity.dx, entity.dy, entity.dz], rotation);
+      const length = Math.hypot(dx, dy, dz);
+      if (length > 0) {
+        entity.dx = dx / length;
+        entity.dy = dy / length;
+        entity.dz = dz / length;
+      }
+    }
+  }
+}
+function allocateIds(targetRepo, entries) {
+  let nextId = getNextEntityId(targetRepo);
+  const idMapping = /* @__PURE__ */ new Map;
+  for (const [oldId] of entries) {
+    idMapping.set(oldId, nextId);
+    nextId += 1;
+  }
+  return idMapping;
+}
+function getNextEntityId(repo) {
+  let maxId = 0;
+  for (const [id] of repo.entries()) {
+    const numericId = Number(id);
+    if (numericId > maxId) {
+      maxId = numericId;
+    }
+  }
+  return maxId + 1;
+}
+function remapReferences(entries, idMapping) {
+  for (const [, entity] of entries) {
+    remapValue(entity, idMapping, /* @__PURE__ */ new Set);
+  }
+}
+function remapValue(value, idMapping, seen) {
+  if (!value)
+    return;
+  if (value instanceof Ref) {
+    const mapped = idMapping.get(Number(value.id));
+    if (mapped !== undefined) {
+      value.id = eid(mapped);
+    }
+    return;
+  }
+  if (value instanceof Unknown) {
+    value.args = value.args.map((arg) => arg.replace(/#(\d+)/g, (match, num) => {
+      const mapped = idMapping.get(Number(num));
+      return mapped !== undefined ? `#${mapped}` : match;
+    }));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      remapValue(item, idMapping, seen);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value))
+      return;
+    seen.add(value);
+    for (const key of Object.keys(value)) {
+      remapValue(value[key], idMapping, seen);
+    }
+  }
+}
+function normalizeStepNumericExponents(stepText) {
+  return stepText.replace(/(-?(?:\d+\.\d*|\.\d+|\d+))e([+-]?\d+)/g, (_match, mantissa, exponent) => `${mantissa}E${exponent}`);
+}
+var package_default = {
+  name: "circuit-json-to-step",
+  main: "dist/index.js",
+  version: "0.0.27",
+  type: "module",
+  scripts: {
+    "pull-reference": `git clone https://github.com/tscircuit/circuit-json.git && find circuit-json/tests -name '*.test.ts' -exec bash -c 'mv "$0" "\${0%.test.ts}.ts"' {} \\; && git clone https://github.com/tscircuit/stepts.git && find stepts/tests -name '*.test.ts' -exec bash -c 'mv "$0" "\${0%.test.ts}.ts"' {} \\;`,
+    test: "bun test",
+    "test:update-snapshots": "BUN_UPDATE_SNAPSHOTS=1 bun test",
+    build: "tsup-node ./lib/index.ts --format esm --dts",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    start: "bun site/index.html",
+    "build:site": "bun build site/index.html --outdir=site-export"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.8",
+    "@resvg/resvg-js": "^2.6.2",
+    "@resvg/resvg-wasm": "^2.6.2",
+    "@tscircuit/circuit-json-util": "^0.0.75",
+    "@types/bun": "latest",
+    "circuit-json": "^0.0.425",
+    "looks-same": "^10.0.1",
+    "occt-import-js": "^0.0.23",
+    poppygl: "^0.0.17",
+    tsup: "^8.5.0"
+  },
+  peerDependencies: {
+    "@tscircuit/circuit-json-util": "*",
+    typescript: "^5"
+  },
+  dependencies: {
+    "circuit-json-to-connectivity-map": "^0.0.22",
+    "circuit-json-to-gltf": "^0.0.100",
+    "circuit-to-svg": "^0.0.345",
+    "schematic-symbols": "^0.0.202",
+    stepts: "^0.0.4"
+  }
+};
+var VERSION = package_default.version;
+function getPillGeometry(hole) {
+  const centerX = typeof hole.x === "number" ? hole.x : hole.x.value;
+  const centerY = typeof hole.y === "number" ? hole.y : hole.y.value;
+  const width = hole.hole_width;
+  const height = hole.hole_height;
+  const ccwRotation = hole.ccw_rotation ?? 0;
+  const rotation = ccwRotation * Math.PI / 180;
+  const isHorizontal = width >= height;
+  const radius = Math.min(width, height) / 2;
+  const straightHalfLength = Math.abs(width - height) / 2;
+  return {
+    centerX,
+    centerY,
+    width,
+    height,
+    rotation,
+    radius,
+    straightHalfLength,
+    isHorizontal
+  };
+}
+function rotatePoint(x, y, centerX, centerY, angle) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const dx = x - centerX;
+  const dy = y - centerY;
+  return {
+    x: centerX + dx * cos - dy * sin,
+    y: centerY + dx * sin + dy * cos
+  };
+}
+function createLineEdge(repo, v1, v2) {
+  const p1 = v1.resolve(repo).pnt.resolve(repo);
+  const p2 = v2.resolve(repo).pnt.resolve(repo);
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const dz = p2.z - p1.z;
+  const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (length < 0.0000000001) {
+    const dir2 = repo.add(new Direction("", 1, 0, 0));
+    const vec2 = repo.add(new Vector("", dir2, 0.0000000001));
+    const line2 = repo.add(new Line("", v1.resolve(repo).pnt, vec2));
+    return repo.add(new EdgeCurve("", v1, v2, line2, true));
+  }
+  const dir = repo.add(new Direction("", dx / length, dy / length, dz / length));
+  const vec = repo.add(new Vector("", dir, length));
+  const line = repo.add(new Line("", v1.resolve(repo).pnt, vec));
+  return repo.add(new EdgeCurve("", v1, v2, line, true));
+}
+function createArcEdge(repo, centerX, centerY, z, radius, startAngle, endAngle, rotation, centerX0, centerY0) {
+  const startX = centerX + radius * Math.cos(startAngle);
+  const startY = centerY + radius * Math.sin(startAngle);
+  const endX = centerX + radius * Math.cos(endAngle);
+  const endY = centerY + radius * Math.sin(endAngle);
+  const startRotated = rotatePoint(startX, startY, centerX0, centerY0, rotation);
+  const endRotated = rotatePoint(endX, endY, centerX0, centerY0, rotation);
+  const startVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", startRotated.x, startRotated.y, z))));
+  const endVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", endRotated.x, endRotated.y, z))));
+  const centerRotated = rotatePoint(centerX, centerY, centerX0, centerY0, rotation);
+  const centerPoint = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, z));
+  const normalDir = repo.add(new Direction("", 0, 0, -1));
+  const refAngle = rotation;
+  const refDir = repo.add(new Direction("", Math.cos(refAngle), Math.sin(refAngle), 0));
+  const placement = repo.add(new Axis2Placement3D("", centerPoint, normalDir, refDir));
+  const circle = repo.add(new Circle("", placement, radius));
+  return repo.add(new EdgeCurve("", startVertex, endVertex, circle, false));
+}
+function createPillHoleLoop(repo, hole, z, xDir) {
+  const geom = getPillGeometry(hole);
+  const {
+    centerX,
+    centerY,
+    radius,
+    straightHalfLength,
+    rotation,
+    isHorizontal
+  } = geom;
+  const edges = [];
+  if (isHorizontal) {
+    const capOffset = straightHalfLength;
+    const rightArc = createArcEdge(repo, centerX + capOffset, centerY, z, radius, -Math.PI / 2, Math.PI / 2, rotation, centerX, centerY);
+    edges.push(rightArc);
+    const bottomStart = rotatePoint(centerX + capOffset, centerY - radius, centerX, centerY, rotation);
+    const bottomEnd = rotatePoint(centerX - capOffset, centerY - radius, centerX, centerY, rotation);
+    const bottomV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, z))));
+    const bottomV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, z))));
+    edges.push(createLineEdge(repo, bottomV1, bottomV2));
+    const leftArc = createArcEdge(repo, centerX - capOffset, centerY, z, radius, Math.PI / 2, 3 * Math.PI / 2, rotation, centerX, centerY);
+    edges.push(leftArc);
+    const topStart = rotatePoint(centerX - capOffset, centerY + radius, centerX, centerY, rotation);
+    const topEnd = rotatePoint(centerX + capOffset, centerY + radius, centerX, centerY, rotation);
+    const topV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", topStart.x, topStart.y, z))));
+    const topV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", topEnd.x, topEnd.y, z))));
+    edges.push(createLineEdge(repo, topV1, topV2));
+  } else {
+    const capOffset = straightHalfLength;
+    const topArc = createArcEdge(repo, centerX, centerY - capOffset, z, radius, Math.PI, 0, rotation, centerX, centerY);
+    edges.push(topArc);
+    const rightStart = rotatePoint(centerX + radius, centerY - capOffset, centerX, centerY, rotation);
+    const rightEnd = rotatePoint(centerX + radius, centerY + capOffset, centerX, centerY, rotation);
+    const rightV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", rightStart.x, rightStart.y, z))));
+    const rightV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", rightEnd.x, rightEnd.y, z))));
+    edges.push(createLineEdge(repo, rightV1, rightV2));
+    const bottomArc = createArcEdge(repo, centerX, centerY + capOffset, z, radius, 0, Math.PI, rotation, centerX, centerY);
+    edges.push(bottomArc);
+    const leftStart = rotatePoint(centerX - radius, centerY + capOffset, centerX, centerY, rotation);
+    const leftEnd = rotatePoint(centerX - radius, centerY - capOffset, centerX, centerY, rotation);
+    const leftV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", leftStart.x, leftStart.y, z))));
+    const leftV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", leftEnd.x, leftEnd.y, z))));
+    edges.push(createLineEdge(repo, leftV1, leftV2));
+  }
+  const orientedEdges = edges.map((edge) => repo.add(new OrientedEdge("", edge, true)));
+  return repo.add(new EdgeLoop("", orientedEdges));
+}
+function createPillCylindricalFaces(repo, hole, zMin, zMax, xDir, zDir) {
+  const geom = getPillGeometry(hole);
+  const {
+    centerX,
+    centerY,
+    radius,
+    straightHalfLength,
+    rotation,
+    isHorizontal
+  } = geom;
+  const faces = [];
+  if (isHorizontal) {
+    const capOffset = straightHalfLength;
+    faces.push(createCylindricalWall(repo, centerX + capOffset, centerY, radius, -Math.PI / 2, Math.PI / 2, rotation, centerX, centerY, zMin, zMax, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX - capOffset, centerY - radius, centerX + capOffset, centerY - radius, rotation, centerX, centerY, zMin, zMax, zDir));
+    faces.push(createCylindricalWall(repo, centerX - capOffset, centerY, radius, Math.PI / 2, 3 * Math.PI / 2, rotation, centerX, centerY, zMin, zMax, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX + capOffset, centerY + radius, centerX - capOffset, centerY + radius, rotation, centerX, centerY, zMin, zMax, zDir));
+  } else {
+    const capOffset = straightHalfLength;
+    faces.push(createCylindricalWall(repo, centerX, centerY - capOffset, radius, Math.PI, 0, rotation, centerX, centerY, zMin, zMax, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX + radius, centerY - capOffset, centerX + radius, centerY + capOffset, rotation, centerX, centerY, zMin, zMax, zDir));
+    faces.push(createCylindricalWall(repo, centerX, centerY + capOffset, radius, 0, Math.PI, rotation, centerX, centerY, zMin, zMax, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX - radius, centerY + capOffset, centerX - radius, centerY - capOffset, rotation, centerX, centerY, zMin, zMax, zDir));
+  }
+  return faces;
+}
+function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAngle, rotation, centerX0, centerY0, zMin, zMax, zDir, xDir) {
+  const bottomStartX = centerX + radius * Math.cos(startAngle);
+  const bottomStartY = centerY + radius * Math.sin(startAngle);
+  const bottomEndX = centerX + radius * Math.cos(endAngle);
+  const bottomEndY = centerY + radius * Math.sin(endAngle);
+  const bottomStart = rotatePoint(bottomStartX, bottomStartY, centerX0, centerY0, rotation);
+  const bottomEnd = rotatePoint(bottomEndX, bottomEndY, centerX0, centerY0, rotation);
+  const bottomStartVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, zMin))));
+  const bottomEndVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, zMin))));
+  const topStart = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, zMax))));
+  const topEnd = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, zMax))));
+  const centerRotated = rotatePoint(centerX, centerY, centerX0, centerY0, rotation);
+  const bottomCenter = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, zMin));
+  const bottomPlacement = repo.add(new Axis2Placement3D("", bottomCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+  const bottomCircle = repo.add(new Circle("", bottomPlacement, radius));
+  const bottomArc = repo.add(new EdgeCurve("", bottomStartVertex, bottomEndVertex, bottomCircle, false));
+  const topCenter = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, zMax));
+  const topPlacement = repo.add(new Axis2Placement3D("", topCenter, zDir, xDir));
+  const topCircle = repo.add(new Circle("", topPlacement, radius));
+  const topArc = repo.add(new EdgeCurve("", topEnd, topStart, topCircle, false));
+  const v1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, zMin))));
+  const v2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, zMax))));
+  const v3 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, zMin))));
+  const v4 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, zMax))));
+  const dir1 = repo.add(new Direction("", 0, 0, 1));
+  const height = zMax - zMin;
+  const vec1 = repo.add(new Vector("", dir1, height));
+  const line1 = repo.add(new Line("", v1.resolve(repo).pnt, vec1));
+  const edge1 = repo.add(new EdgeCurve("", v1, v2, line1, true));
+  const dir2 = repo.add(new Direction("", 0, 0, 1));
+  const vec2 = repo.add(new Vector("", dir2, height));
+  const line2 = repo.add(new Line("", v3.resolve(repo).pnt, vec2));
+  const edge2 = repo.add(new EdgeCurve("", v3, v4, line2, true));
+  const loop = repo.add(new EdgeLoop("", [
+    repo.add(new OrientedEdge("", bottomArc, true)),
+    repo.add(new OrientedEdge("", edge2, true)),
+    repo.add(new OrientedEdge("", topArc, false)),
+    repo.add(new OrientedEdge("", edge1, false))
+  ]));
+  const cylinderPlacement = repo.add(new Axis2Placement3D("", bottomCenter, zDir, xDir));
+  const cylinderSurface = repo.add(new CylindricalSurface("", cylinderPlacement, radius));
+  return repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", loop, true))], cylinderSurface, false));
+}
+function createPlanarWall(repo, startX, startY, endX, endY, rotation, centerX0, centerY0, zMin, zMax, zDir) {
+  const start = rotatePoint(startX, startY, centerX0, centerY0, rotation);
+  const end = rotatePoint(endX, endY, centerX0, centerY0, rotation);
+  const v1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", start.x, start.y, zMin))));
+  const v2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", end.x, end.y, zMin))));
+  const v3 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", end.x, end.y, zMax))));
+  const v4 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", start.x, start.y, zMax))));
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  const edgeLength = Math.sqrt(dx * dx + dy * dy);
+  const bottomDir = repo.add(new Direction("", dx / edgeLength, dy / edgeLength, 0));
+  const bottomVec = repo.add(new Vector("", bottomDir, edgeLength));
+  const bottomLine = repo.add(new Line("", v1.resolve(repo).pnt, bottomVec));
+  const bottomEdge = repo.add(new EdgeCurve("", v1, v2, bottomLine, true));
+  const topDir = repo.add(new Direction("", dx / edgeLength, dy / edgeLength, 0));
+  const topVec = repo.add(new Vector("", topDir, edgeLength));
+  const topLine = repo.add(new Line("", v4.resolve(repo).pnt, topVec));
+  const topEdge = repo.add(new EdgeCurve("", v4, v3, topLine, true));
+  const vertDir = repo.add(new Direction("", 0, 0, 1));
+  const height = zMax - zMin;
+  const vertVec1 = repo.add(new Vector("", vertDir, height));
+  const vertLine1 = repo.add(new Line("", v2.resolve(repo).pnt, vertVec1));
+  const vertEdge1 = repo.add(new EdgeCurve("", v2, v3, vertLine1, true));
+  const vertVec2 = repo.add(new Vector("", vertDir, height));
+  const vertLine2 = repo.add(new Line("", v1.resolve(repo).pnt, vertVec2));
+  const vertEdge2 = repo.add(new EdgeCurve("", v1, v4, vertLine2, true));
+  const loop = repo.add(new EdgeLoop("", [
+    repo.add(new OrientedEdge("", bottomEdge, true)),
+    repo.add(new OrientedEdge("", vertEdge1, true)),
+    repo.add(new OrientedEdge("", topEdge, false)),
+    repo.add(new OrientedEdge("", vertEdge2, false))
+  ]));
+  const normalDir = repo.add(new Direction("", dy / edgeLength, -dx / edgeLength, 0));
+  const refDir = repo.add(new Direction("", dx / edgeLength, dy / edgeLength, 0));
+  const planeOrigin = repo.add(new CartesianPoint("", start.x, start.y, zMin));
+  const placement = repo.add(new Axis2Placement3D("", planeOrigin, normalDir, refDir));
+  const plane = repo.add(new Plane("", placement));
+  return repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", loop, true))], plane, true));
+}
+async function circuitJsonToStep(circuitJson, options = {}) {
+  const repo = new Repository;
+  const pcbBoard = circuitJson.find((item) => item.type === "pcb_board");
+  const holes = circuitJson.filter((item) => item.type === "pcb_hole" || item.type === "pcb_plated_hole");
+  const boardWidth = options.boardWidth ?? pcbBoard?.width;
+  const boardHeight = options.boardHeight ?? pcbBoard?.height;
+  const boardThickness = options.boardThickness ?? pcbBoard?.thickness ?? 1.6;
+  const productName = options.productName ?? "PCB";
+  const boardCenterX = pcbBoard?.center?.x ?? 0;
+  const boardCenterY = pcbBoard?.center?.y ?? 0;
+  const halfBoardThickness = boardThickness / 2;
+  if (!boardWidth || !boardHeight) {
+    throw new Error("Board dimensions not found. Either provide boardWidth and boardHeight in options, or include a pcb_board in the circuit JSON with width and height properties.");
+  }
+  const appContext = repo.add(new ApplicationContext("core data for automotive mechanical design processes"));
+  repo.add(new ApplicationProtocolDefinition("international standard", "automotive_design", 2010, appContext));
+  const productContext = repo.add(new ProductContext("", appContext, "mechanical"));
+  const productDescription = `Generated by circuit-json-to-step v${VERSION}`;
+  const product = repo.add(new Product(productName, productName, productDescription, [productContext]));
+  const productDefContext = repo.add(new ProductDefinitionContext("part definition", appContext, "design"));
+  const productDefFormation = repo.add(new ProductDefinitionFormation("", "", product));
+  const productDef = repo.add(new ProductDefinition("", "", productDefFormation, productDefContext));
+  const productDefShape = repo.add(new ProductDefinitionShape("", "", productDef));
+  const lengthUnit = repo.add(new Unknown("", [
+    "( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) )"
+  ]));
+  const angleUnit = repo.add(new Unknown("", [
+    "( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) )"
+  ]));
+  const solidAngleUnit = repo.add(new Unknown("", [
+    "( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() )"
+  ]));
+  const uncertainty = repo.add(new Unknown("UNCERTAINTY_MEASURE_WITH_UNIT", [
+    `LENGTH_MEASURE(1.E-07)`,
+    `${lengthUnit}`,
+    `'distance_accuracy_value'`,
+    `'Maximum Tolerance'`
+  ]));
+  const geomContext = repo.add(new Unknown("", [
+    `( GEOMETRIC_REPRESENTATION_CONTEXT(3) GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((${uncertainty})) GLOBAL_UNIT_ASSIGNED_CONTEXT((${lengthUnit},${angleUnit},${solidAngleUnit})) REPRESENTATION_CONTEXT('${productName}','3D') )`
+  ]));
+  const outline = pcbBoard?.outline;
+  let bottomVertices;
+  let topVertices;
+  if (outline && Array.isArray(outline) && outline.length >= 3) {
+    const cleanedOutline = [];
+    for (let i = 0;i < outline.length; i++) {
+      const current = outline[i];
+      const next = outline[(i + 1) % outline.length];
+      const dx = next.x - current.x;
+      const dy = next.y - current.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist > 0.000001) {
+        cleanedOutline.push(current);
+      }
+    }
+    if (cleanedOutline.length < 3) {
+      throw new Error(`Outline has too few unique vertices after removing duplicates (${cleanedOutline.length}). Need at least 3.`);
+    }
+    bottomVertices = cleanedOutline.map((point) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point.x, point.y, -halfBoardThickness)))));
+    topVertices = cleanedOutline.map((point) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point.x, point.y, halfBoardThickness)))));
+  } else {
+    const halfWidth = boardWidth / 2;
+    const halfHeight = boardHeight / 2;
+    const corners = [
+      [
+        boardCenterX - halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX - halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness
+      ],
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, halfBoardThickness],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, halfBoardThickness]
+    ];
+    const vertices = corners.map(([x, y, z]) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x, y, z)))));
+    bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
+    topVertices = [vertices[4], vertices[5], vertices[6], vertices[7]];
+  }
+  function createEdge2(v1, v2) {
+    const p1 = v1.resolve(repo).pnt.resolve(repo);
+    const p2 = v2.resolve(repo).pnt.resolve(repo);
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    const dz = p2.z - p1.z;
+    const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (length < 0.0000000001) {
+      const dir2 = repo.add(new Direction("", 1, 0, 0));
+      const vec2 = repo.add(new Vector("", dir2, 0.0000000001));
+      const line2 = repo.add(new Line("", v1.resolve(repo).pnt, vec2));
+      return repo.add(new EdgeCurve("", v1, v2, line2, true));
+    }
+    const dir = repo.add(new Direction("", dx / length, dy / length, dz / length));
+    const vec = repo.add(new Vector("", dir, length));
+    const line = repo.add(new Line("", v1.resolve(repo).pnt, vec));
+    return repo.add(new EdgeCurve("", v1, v2, line, true));
+  }
+  const bottomEdges = [];
+  const topEdges = [];
+  const verticalEdges = [];
+  for (let i = 0;i < bottomVertices.length; i++) {
+    const v1 = bottomVertices[i];
+    const v2 = bottomVertices[(i + 1) % bottomVertices.length];
+    bottomEdges.push(createEdge2(v1, v2));
+  }
+  for (let i = 0;i < topVertices.length; i++) {
+    const v1 = topVertices[i];
+    const v2 = topVertices[(i + 1) % topVertices.length];
+    topEdges.push(createEdge2(v1, v2));
+  }
+  for (let i = 0;i < bottomVertices.length; i++) {
+    verticalEdges.push(createEdge2(bottomVertices[i], topVertices[i]));
+  }
+  const origin = repo.add(new CartesianPoint("", 0, 0, -halfBoardThickness));
+  const xDir = repo.add(new Direction("", 1, 0, 0));
+  const zDir = repo.add(new Direction("", 0, 0, 1));
+  const bottomFrame = repo.add(new Axis2Placement3D("", origin, repo.add(new Direction("", 0, 0, -1)), xDir));
+  const bottomPlane = repo.add(new Plane("", bottomFrame));
+  const bottomLoop = repo.add(new EdgeLoop("", bottomEdges.map((edge) => repo.add(new OrientedEdge("", edge, true)))));
+  const bottomHoleLoops = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape ?? hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 2;
+      const holeCenter = repo.add(new CartesianPoint("", holeX, holeY, -halfBoardThickness));
+      const holeVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, -halfBoardThickness))));
+      const holePlacement = repo.add(new Axis2Placement3D("", holeCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+      const holeCircle = repo.add(new Circle("", holePlacement, radius));
+      const holeEdge = repo.add(new EdgeCurve("", holeVertex, holeVertex, holeCircle, true));
+      const holeLoop = repo.add(new EdgeLoop("", [repo.add(new OrientedEdge("", holeEdge, false))]));
+      bottomHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
+    } else if (holeShape === "rotated_pill" || holeShape === "pill") {
+      const pillLoop = createPillHoleLoop(repo, hole, -halfBoardThickness, xDir);
+      bottomHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)));
+    }
+  }
+  const bottomFace = repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", bottomLoop, true)), ...bottomHoleLoops], bottomPlane, true));
+  const topOrigin = repo.add(new CartesianPoint("", 0, 0, halfBoardThickness));
+  const topFrame = repo.add(new Axis2Placement3D("", topOrigin, zDir, xDir));
+  const topPlane = repo.add(new Plane("", topFrame));
+  const topLoop = repo.add(new EdgeLoop("", topEdges.map((edge) => repo.add(new OrientedEdge("", edge, false)))));
+  const topHoleLoops = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape ?? hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 2;
+      const holeCenter = repo.add(new CartesianPoint("", holeX, holeY, halfBoardThickness));
+      const holeVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, halfBoardThickness))));
+      const holePlacement = repo.add(new Axis2Placement3D("", holeCenter, zDir, xDir));
+      const holeCircle = repo.add(new Circle("", holePlacement, radius));
+      const holeEdge = repo.add(new EdgeCurve("", holeVertex, holeVertex, holeCircle, true));
+      const holeLoop = repo.add(new EdgeLoop("", [repo.add(new OrientedEdge("", holeEdge, true))]));
+      topHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
+    } else if (holeShape === "rotated_pill" || holeShape === "pill") {
+      const pillLoop = createPillHoleLoop(repo, hole, halfBoardThickness, xDir);
+      topHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)));
+    }
+  }
+  const topFace = repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", topLoop, true)), ...topHoleLoops], topPlane, true));
+  const sideFaces = [];
+  for (let i = 0;i < bottomEdges.length; i++) {
+    const nextI = (i + 1) % bottomEdges.length;
+    const bottomV1Pnt = bottomVertices[i].resolve(repo).pnt;
+    const bottomV2Pnt = bottomVertices[nextI].resolve(repo).pnt;
+    const bottomV1 = bottomV1Pnt.resolve(repo);
+    const bottomV2 = bottomV2Pnt.resolve(repo);
+    const edgeDir = {
+      x: bottomV2.x - bottomV1.x,
+      y: bottomV2.y - bottomV1.y,
+      z: -halfBoardThickness
+    };
+    const normalDir = repo.add(new Direction("", edgeDir.y, -edgeDir.x, 0));
+    const refDir = repo.add(new Direction("", edgeDir.x, edgeDir.y, 0));
+    const sideFrame = repo.add(new Axis2Placement3D("", bottomV1Pnt, normalDir, refDir));
+    const sidePlane = repo.add(new Plane("", sideFrame));
+    const sideLoop = repo.add(new EdgeLoop("", [
+      repo.add(new OrientedEdge("", bottomEdges[i], true)),
+      repo.add(new OrientedEdge("", verticalEdges[nextI], true)),
+      repo.add(new OrientedEdge("", topEdges[i], false)),
+      repo.add(new OrientedEdge("", verticalEdges[i], false))
+    ]));
+    const sideFace = repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", sideLoop, true))], sidePlane, true));
+    sideFaces.push(sideFace);
+  }
+  const holeCylindricalFaces = [];
+  for (const hole of holes) {
+    const holeShape = hole.hole_shape ?? hole.shape;
+    if (holeShape === "circle") {
+      const holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 2;
+      const bottomHoleCenter = repo.add(new CartesianPoint("", holeX, holeY, -halfBoardThickness));
+      const bottomHoleVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, -halfBoardThickness))));
+      const bottomHolePlacement = repo.add(new Axis2Placement3D("", bottomHoleCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+      const bottomHoleCircle = repo.add(new Circle("", bottomHolePlacement, radius));
+      const bottomHoleEdge = repo.add(new EdgeCurve("", bottomHoleVertex, bottomHoleVertex, bottomHoleCircle, true));
+      const topHoleCenter = repo.add(new CartesianPoint("", holeX, holeY, halfBoardThickness));
+      const topHoleVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, halfBoardThickness))));
+      const topHolePlacement = repo.add(new Axis2Placement3D("", topHoleCenter, zDir, xDir));
+      const topHoleCircle = repo.add(new Circle("", topHolePlacement, radius));
+      const topHoleEdge = repo.add(new EdgeCurve("", topHoleVertex, topHoleVertex, topHoleCircle, true));
+      const holeCylinderLoop = repo.add(new EdgeLoop("", [
+        repo.add(new OrientedEdge("", bottomHoleEdge, true)),
+        repo.add(new OrientedEdge("", topHoleEdge, false))
+      ]));
+      const holeCylinderPlacement = repo.add(new Axis2Placement3D("", bottomHoleCenter, zDir, xDir));
+      const holeCylinderSurface = repo.add(new CylindricalSurface("", holeCylinderPlacement, radius));
+      const holeCylinderFace = repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", holeCylinderLoop, true))], holeCylinderSurface, false));
+      holeCylindricalFaces.push(holeCylinderFace);
+    } else if (holeShape === "rotated_pill" || holeShape === "pill") {
+      const pillFaces = createPillCylindricalFaces(repo, hole, -halfBoardThickness, halfBoardThickness, xDir, zDir);
+      holeCylindricalFaces.push(...pillFaces);
+    }
+  }
+  const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
+  const styleCache = createStyleCache();
+  const boardStyledItems = createStyledItems(repo, {
+    itemRefs: allFaces,
+    rgb: [0.2, 0.6, 0.2],
+    styleCache
+  });
+  const shell = repo.add(new ClosedShell("", allFaces));
+  const solid = repo.add(new ManifoldSolidBrep(productName, shell));
+  const allSolids = [solid];
+  const componentStyledItems = [];
+  const solidsWithIntrinsicFaceStyles = /* @__PURE__ */ new Set;
+  let handledComponentIds = /* @__PURE__ */ new Set;
+  let handledPcbComponentIds = /* @__PURE__ */ new Set;
+  if (options.includeComponents && options.includeExternalMeshes) {
+    const mergeResult = await mergeExternalStepModels({
+      repo,
+      circuitJson,
+      boardThickness,
+      fsMap: options.fsMap
+    });
+    handledComponentIds = mergeResult.handledComponentIds;
+    handledPcbComponentIds = mergeResult.handledPcbComponentIds;
+    allSolids.push(...mergeResult.solids);
+    mergeResult.solids.forEach((solidRef) => {
+      solidsWithIntrinsicFaceStyles.add(String(solidRef.id));
+    });
+  }
+  if (options.includeComponents) {
+    const pcbComponentIdsWithStepUrl = /* @__PURE__ */ new Set;
+    for (const item of circuitJson) {
+      if (item.type === "cad_component" && item.model_step_url && item.pcb_component_id) {
+        pcbComponentIdsWithStepUrl.add(item.pcb_component_id);
+      }
+    }
+    const hasComponentsNeedingMesh = circuitJson.some((item) => {
+      if (item.type === "cad_component") {
+        if (item.cad_component_id && handledComponentIds.has(item.cad_component_id)) {
+          return false;
+        }
+        if (item.pcb_component_id && pcbComponentIdsWithStepUrl.has(item.pcb_component_id)) {
+          return false;
+        }
+        return !item.model_step_url;
+      }
+      if (item.type === "pcb_component") {
+        if (item.pcb_component_id && handledPcbComponentIds.has(item.pcb_component_id)) {
+          return false;
+        }
+        if (item.pcb_component_id && pcbComponentIdsWithStepUrl.has(item.pcb_component_id)) {
+          return false;
+        }
+        return true;
+      }
+      return false;
+    });
+    if (hasComponentsNeedingMesh) {
+      const componentSolids = await generateComponentMeshes({
+        repo,
+        circuitJson,
+        boardThickness,
+        includeExternalMeshes: options.includeExternalMeshes,
+        excludeCadComponentIds: handledComponentIds,
+        excludePcbComponentIds: handledPcbComponentIds,
+        pcbComponentIdsWithStepUrl
+      });
+      for (const componentSolid of componentSolids) {
+        allSolids.push(componentSolid.solid);
+        componentStyledItems.push(...componentSolid.styledItems);
+        if (componentSolid.usesIntrinsicFaceStyles) {
+          solidsWithIntrinsicFaceStyles.add(String(componentSolid.solid.id));
+        } else if (componentSolid.styleTargets.length > 0) {
+          componentStyledItems.push(...createStyledItems(repo, {
+            itemRefs: componentSolid.styleTargets,
+            rgb: [0.75, 0.75, 0.75],
+            styleCache
+          }));
+          solidsWithIntrinsicFaceStyles.add(String(componentSolid.solid.id));
+        }
+      }
+    }
+  }
+  const styledItems = [
+    ...boardStyledItems,
+    ...componentStyledItems
+  ];
+  allSolids.forEach((itemRef, index) => {
+    const isBoard = index === 0;
+    if (isBoard || solidsWithIntrinsicFaceStyles.has(String(itemRef.id))) {
+      return;
+    }
+    const styledItem = createStyledItem(repo, {
+      itemRef,
+      rgb: [0.75, 0.75, 0.75],
+      styleCache,
+      name: ""
+    });
+    styledItems.push(styledItem);
+  });
+  repo.add(new MechanicalDesignGeometricPresentationRepresentation("", styledItems, geomContext));
+  const shapeRep = repo.add(new AdvancedBrepShapeRepresentation(productName, allSolids, geomContext));
+  repo.add(new ShapeDefinitionRepresentation(productDefShape, shapeRep));
+  const stepText = repo.toPartFile({ name: productName });
+  return normalizeStepNumericExponents(stepText);
+}
+
+// cli/build/worker-output-generators.ts
 import {
   convertCircuitJsonToGltf,
   getBestCameraPosition
@@ -13581,35 +15881,67 @@ var convertSvgToPngBuffer = async (svg) => {
   return resvg.render().asPng();
 };
 
+// lib/shared/load-local-step-model-fs-map.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path12 from "node:path";
+var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
+async function loadLocalStepModelFsMap(circuitJson) {
+  const fsMap = {};
+  for (const element of circuitJson) {
+    if (!element || typeof element !== "object")
+      continue;
+    const modelUrl = element.model_step_url;
+    if (typeof modelUrl !== "string" || modelUrl.length === 0)
+      continue;
+    if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
+      continue;
+    const localPath = path12.resolve(process.cwd(), modelUrl);
+    if (!existsSync(localPath))
+      continue;
+    fsMap[modelUrl] = await readFile(localPath, "utf-8");
+  }
+  return fsMap;
+}
+
 // cli/build/worker-output-generators.ts
 var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array(glbBuffer);
-  fs9.mkdirSync(path12.dirname(glbOutputPath), { recursive: true });
+  fs9.mkdirSync(path13.dirname(glbOutputPath), { recursive: true });
   fs9.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
+var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
+  const stepContent = await circuitJsonToStep(circuitJson, {
+    includeComponents: true,
+    includeExternalMeshes: true,
+    fsMap: await loadLocalStepModelFsMap(circuitJson)
+  });
+  fs9.mkdirSync(path13.dirname(stepOutputPath), { recursive: true });
+  fs9.writeFileSync(stepOutputPath, stepContent);
+};
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
   fs9.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs9.writeFileSync(path12.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs9.writeFileSync(path13.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs9.writeFileSync(path12.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs9.writeFileSync(path13.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs9.writeFileSync(path12.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs9.writeFileSync(path13.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   if (imageFormats.threeDPngs) {
     const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
     const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
     const glbArrayBuffer = await normalizeToArrayBuffer(glbBuffer);
     const pngBuffer = await renderGLTFToPNGBufferFromGLBBuffer(glbArrayBuffer, getBestCameraPosition(circuitJson));
-    fs9.writeFileSync(path12.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
+    fs9.writeFileSync(path13.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
   }
 };
 
@@ -13618,13 +15950,13 @@ var loadCircuitJsonFromInputFile = (filePath) => {
   const parsed = JSON.parse(fs10.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
-var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
+var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
   const errors = [];
   const warnings = [];
   const startedAt = options?.profile ? performance.now() : 0;
   try {
     process.chdir(projectDir);
-    workerLog(`Generating circuit JSON for ${path13.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path14.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders();
     const completePlatformConfig = getCompletePlatformConfig(options?.platformConfig);
     const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
@@ -13637,9 +15969,9 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputD
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs10.mkdirSync(path13.dirname(outputPath), { recursive: true });
+    fs10.mkdirSync(path14.dirname(outputPath), { recursive: true });
     fs10.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path13.relative(projectDir, outputPath)}`);
+    workerLog(`Circuit JSON written to ${path14.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -13663,11 +15995,13 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputD
     const hasErrors = filteredDiagnostics.errors.length > 0 && !options?.ignoreErrors;
     let glbOk;
     let glbError;
+    let stepOk;
+    let stepError;
     let previewOk;
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path13.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path14.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -13676,10 +16010,21 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputD
         workerLog(`GLB conversion error: ${glbError}`);
       }
     }
+    if (stepOutputPath) {
+      try {
+        workerLog(`Converting ${path14.relative(projectDir, outputPath)} to STEP in same worker...`);
+        await writeStepFromCircuitJson(circuitJson, stepOutputPath);
+        stepOk = true;
+      } catch (err) {
+        stepOk = false;
+        stepError = err instanceof Error ? err.message : String(err);
+        workerLog(`STEP conversion error: ${stepError}`);
+      }
+    }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path13.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path13.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path14.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path14.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,
@@ -13698,9 +16043,12 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputD
       output_path: outputPath,
       circuit_json_path: outputPath,
       glb_output_path: glbOutputPath,
+      step_output_path: stepOutputPath,
       preview_output_dir: previewOutputDir,
       glb_ok: glbOk,
       glb_error: glbError,
+      step_ok: stepOk,
+      step_error: stepError,
       preview_ok: previewOk,
       preview_error: previewError,
       ok: true,
@@ -13721,6 +16069,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, previewOutputD
       output_path: outputPath,
       circuit_json_path: outputPath,
       glb_output_path: glbOutputPath,
+      step_output_path: stepOutputPath,
       preview_output_dir: previewOutputDir,
       ok: false,
       hasErrors: true,
@@ -13760,7 +16109,7 @@ var workerStatus = (statusLine) => {
 };
 parentPort.on("message", async (msg) => {
   if (msg.message_type === "build_file") {
-    const result = await handleBuildFile(msg.file_path, msg.output_path, msg.glb_output_path, msg.preview_output_dir, msg.project_dir, msg.options, workerLog, workerStatus);
+    const result = await handleBuildFile(msg.file_path, msg.output_path, msg.glb_output_path, msg.step_output_path, msg.preview_output_dir, msg.project_dir, msg.options, workerLog, workerStatus);
     sendMessage(result);
   }
 });