@tscircuit/cli 0.1.1162 → 0.1.1163

package/dist/cli/main.js

@@ -10751,6 +10751,7 @@ var require_constants3 = __commonJS((exports2, module2) => {
   var path2 = __require("path");
   var WIN_SLASH = "\\\\/";
   var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+  var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
   var DOT_LITERAL = "\\.";
   var PLUS_LITERAL = "\\+";
   var QMARK_LITERAL = "\\?";
@@ -10798,6 +10799,7 @@ var require_constants3 = __commonJS((exports2, module2) => {
     END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
   };
   var POSIX_REGEX_SOURCE = {
+    __proto__: null,
     alnum: "a-zA-Z0-9",
     alpha: "a-zA-Z",
     ascii: "\\x00-\\x7F",
@@ -10814,6 +10816,7 @@ var require_constants3 = __commonJS((exports2, module2) => {
     xdigit: "A-Fa-f0-9"
   };
   module2.exports = {
+    DEFAULT_MAX_EXTGLOB_RECURSION,
     MAX_LENGTH: 1024 * 64,
     POSIX_REGEX_SOURCE,
     REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
@@ -10823,6 +10826,7 @@ var require_constants3 = __commonJS((exports2, module2) => {
     REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
     REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
     REPLACEMENTS: {
+      __proto__: null,
       "***": "*",
       "**/**": "**",
       "**/**/**": "**"
@@ -11288,6 +11292,213 @@ var require_parse3 = __commonJS((exports2, module2) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
+  var splitTopLevel = (input) => {
+    const parts = [];
+    let bracket = 0;
+    let paren = 0;
+    let quote = 0;
+    let value = "";
+    let escaped = false;
+    for (const ch of input) {
+      if (escaped === true) {
+        value += ch;
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        value += ch;
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        quote = quote === 1 ? 0 : 1;
+        value += ch;
+        continue;
+      }
+      if (quote === 0) {
+        if (ch === "[") {
+          bracket++;
+        } else if (ch === "]" && bracket > 0) {
+          bracket--;
+        } else if (bracket === 0) {
+          if (ch === "(") {
+            paren++;
+          } else if (ch === ")" && paren > 0) {
+            paren--;
+          } else if (ch === "|" && paren === 0) {
+            parts.push(value);
+            value = "";
+            continue;
+          }
+        }
+      }
+      value += ch;
+    }
+    parts.push(value);
+    return parts;
+  };
+  var isPlainBranch = (branch) => {
+    let escaped = false;
+    for (const ch of branch) {
+      if (escaped === true) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (/[?*+@!()[\]{}]/.test(ch)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var normalizeSimpleBranch = (branch) => {
+    let value = branch.trim();
+    let changed = true;
+    while (changed === true) {
+      changed = false;
+      if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+        value = value.slice(2, -1);
+        changed = true;
+      }
+    }
+    if (!isPlainBranch(value)) {
+      return;
+    }
+    return value.replace(/\\(.)/g, "$1");
+  };
+  var hasRepeatedCharPrefixOverlap = (branches) => {
+    const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+    for (let i = 0;i < values.length; i++) {
+      for (let j = i + 1;j < values.length; j++) {
+        const a = values[i];
+        const b = values[j];
+        const char = a[0];
+        if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+          continue;
+        }
+        if (a === b || a.startsWith(b) || b.startsWith(a)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+    if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+      return;
+    }
+    let bracket = 0;
+    let paren = 0;
+    let quote = 0;
+    let escaped = false;
+    for (let i = 1;i < pattern.length; i++) {
+      const ch = pattern[i];
+      if (escaped === true) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        quote = quote === 1 ? 0 : 1;
+        continue;
+      }
+      if (quote === 1) {
+        continue;
+      }
+      if (ch === "[") {
+        bracket++;
+        continue;
+      }
+      if (ch === "]" && bracket > 0) {
+        bracket--;
+        continue;
+      }
+      if (bracket > 0) {
+        continue;
+      }
+      if (ch === "(") {
+        paren++;
+        continue;
+      }
+      if (ch === ")") {
+        paren--;
+        if (paren === 0) {
+          if (requireEnd === true && i !== pattern.length - 1) {
+            return;
+          }
+          return {
+            type: pattern[0],
+            body: pattern.slice(2, i),
+            end: i
+          };
+        }
+      }
+    }
+  };
+  var getStarExtglobSequenceOutput = (pattern) => {
+    let index = 0;
+    const chars = [];
+    while (index < pattern.length) {
+      const match = parseRepeatedExtglob(pattern.slice(index), false);
+      if (!match || match.type !== "*") {
+        return;
+      }
+      const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+      if (branches.length !== 1) {
+        return;
+      }
+      const branch = normalizeSimpleBranch(branches[0]);
+      if (!branch || branch.length !== 1) {
+        return;
+      }
+      chars.push(branch);
+      index += match.end + 1;
+    }
+    if (chars.length < 1) {
+      return;
+    }
+    const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+    return `${source}*`;
+  };
+  var repeatedExtglobRecursion = (pattern) => {
+    let depth = 0;
+    let value = pattern.trim();
+    let match = parseRepeatedExtglob(value);
+    while (match) {
+      depth++;
+      value = match.body.trim();
+      match = parseRepeatedExtglob(value);
+    }
+    return depth;
+  };
+  var analyzeRepeatedExtglob = (body, options) => {
+    if (options.maxExtglobRecursion === false) {
+      return { risky: false };
+    }
+    const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+    const branches = splitTopLevel(body).map((branch) => branch.trim());
+    if (branches.length > 1) {
+      if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+        return { risky: true };
+      }
+    }
+    for (const branch of branches) {
+      const safeOutput = getStarExtglobSequenceOutput(branch);
+      if (safeOutput) {
+        return { risky: true, safeOutput };
+      }
+      if (repeatedExtglobRecursion(branch) > max) {
+        return { risky: true };
+      }
+    }
+    return { risky: false };
+  };
   var parse = (input, options) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
@@ -11420,6 +11631,8 @@ var require_parse3 = __commonJS((exports2, module2) => {
       token.prev = prev;
       token.parens = state.parens;
       token.output = state.output;
+      token.startIndex = state.index;
+      token.tokensIndex = tokens.length;
       const output = (opts.capture ? "(" : "") + token.open;
       increment("parens");
       push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
@@ -11427,6 +11640,26 @@ var require_parse3 = __commonJS((exports2, module2) => {
       extglobs.push(token);
     };
     const extglobClose = (token) => {
+      const literal = input.slice(token.startIndex, state.index + 1);
+      const body = input.slice(token.startIndex + 2, state.index);
+      const analysis = analyzeRepeatedExtglob(body, opts);
+      if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+        const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : undefined;
+        const open = tokens[token.tokensIndex];
+        open.type = "text";
+        open.value = literal;
+        open.output = safeOutput || utils.escapeRegex(literal);
+        for (let i = token.tokensIndex + 1;i < tokens.length; i++) {
+          tokens[i].value = "";
+          tokens[i].output = "";
+          delete tokens[i].suffix;
+        }
+        state.output = token.output + open.output;
+        state.backtrack = true;
+        push({ type: "paren", extglob: true, value, output: "" });
+        decrement("parens");
+        return;
+      }
       let output = token.close + (opts.capture ? ")" : "");
       let rest;
       if (token.type === "negate") {
@@ -98176,7 +98409,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1161";
+var version = "0.1.1162";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -98240,10 +98473,12 @@ var package_default = {
     redaxios: "^0.5.1",
     semver: "^7.6.3",
     tempy: "^3.1.0",
-    tscircuit: "0.0.1519-libonly",
+    tscircuit: "0.0.1563-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
-    zod: "^3.23.8"
+    zod: "^3.23.8",
+    "circuit-json-to-step": "^0.0.19",
+    stepts: "^0.0.3"
   },
   peerDependencies: {
     tscircuit: "*"
@@ -243346,6 +243581,2195 @@ var debug102 = Debug10("dsn-converter:parse-dsn-to-dsn-json");
 
 // lib/shared/export-snippet.ts
 var import_jszip5 = __toESM2(require_lib4(), 1);
+
+// node_modules/stepts/dist/index.js
+var Entity = class {
+  static parse(_a3, _ctx) {
+    throw new Error("not implemented");
+  }
+};
+var eid = (n3) => n3;
+var Ref = class {
+  constructor(id2) {
+    this.id = id2;
+  }
+  resolve(repo) {
+    const e4 = repo.get(this.id);
+    if (!e4)
+      throw new Error(`Unresolved #${this.id}`);
+    return e4;
+  }
+  toString() {
+    return `#${this.id}`;
+  }
+};
+var stepStr = (s2) => `'${s2.replace(/'/g, "''")}'`;
+var fmtNum = (n3) => Number.isInteger(n3) ? `${n3}.` : `${n3}`;
+var Repository = class {
+  map = /* @__PURE__ */ new Map;
+  order = [];
+  maxId = 0;
+  schema = "AP214";
+  units = { length: "MM", angle: "RAD", solidAngle: "SR" };
+  set(id2, e4) {
+    if (!this.map.has(id2)) {
+      this.order.push(id2);
+      if (id2 > this.maxId)
+        this.maxId = id2;
+    }
+    this.map.set(id2, e4);
+  }
+  add(e4) {
+    this.maxId++;
+    const id2 = eid(this.maxId);
+    this.set(id2, e4);
+    return new Ref(id2);
+  }
+  get(id2) {
+    return this.map.get(id2);
+  }
+  entries() {
+    return this.order.map((id2) => [id2, this.map.get(id2)]);
+  }
+  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(([id2, e4]) => `#${id2} = ${e4.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(a2, ctx) {
+    const name = ctx.parseString(a2[0]);
+    const loc = ctx.parseRef(a2[1]);
+    const axis = a2[2] !== "$" ? ctx.parseRef(a2[2]) : undefined;
+    const refd = a2[3] !== "$" ? ctx.parseRef(a2[3]) : undefined;
+    return new _Axis2Placement3D(name, loc, axis, refd);
+  }
+  toStep() {
+    const A4 = this.axis ? this.axis.toString() : "$";
+    const R4 = this.refDirection ? this.refDirection.toString() : "$";
+    return `AXIS2_PLACEMENT_3D(${stepStr(this.name)},${this.location},${A4},${R4})`;
+  }
+};
+register("AXIS2_PLACEMENT_3D", Axis2Placement3D.parse.bind(Axis2Placement3D));
+var CartesianPoint = class _CartesianPoint extends Entity {
+  constructor(name, x3, y4, z21) {
+    super();
+    this.name = name;
+    this.x = x3;
+    this.y = y4;
+    this.z = z21;
+  }
+  type = "CARTESIAN_POINT";
+  static parse(a2, ctx) {
+    const name = ctx.parseString(a2[0]);
+    const coords = a2[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 Circle3 = class _Circle extends Entity {
+  constructor(name, placement, radius) {
+    super();
+    this.name = name;
+    this.placement = placement;
+    this.radius = radius;
+  }
+  type = "CIRCLE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const pl4 = ctx.parseRef(a2[1]);
+    const r4 = ctx.parseNumber(a2[2]);
+    return new _Circle(name, pl4, r4);
+  }
+  toStep() {
+    return `CIRCLE(${this.name ? `'${this.name}'` : "''"},${this.placement},${fmtNum(this.radius)})`;
+  }
+};
+register("CIRCLE", Circle3.parse.bind(Circle3));
+var CylindricalSurface = class _CylindricalSurface extends Entity {
+  constructor(name, position2, radius) {
+    super();
+    this.name = name;
+    this.position = position2;
+    this.radius = radius;
+  }
+  type = "CYLINDRICAL_SURFACE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const position2 = ctx.parseRef(a2[1]);
+    const radius = ctx.parseNumber(a2[2]);
+    return new _CylindricalSurface(name, position2, 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, dx2, dy2, dz) {
+    super();
+    this.name = name;
+    this.dx = dx2;
+    this.dy = dy2;
+    this.dz = dz;
+  }
+  type = "DIRECTION";
+  static parse(a2, ctx) {
+    const name = ctx.parseString(a2[0]);
+    const comps = a2[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 Line3 = class _Line extends Entity {
+  constructor(name, pnt, dir) {
+    super();
+    this.name = name;
+    this.pnt = pnt;
+    this.dir = dir;
+  }
+  type = "LINE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const p3 = ctx.parseRef(a2[1]);
+    const vecTok = a2[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, p3, vec);
+  }
+  toStep() {
+    return `LINE(${this.name ? `'${this.name}'` : "''"},${this.pnt},${this.dir})`;
+  }
+};
+register("LINE", Line3.parse.bind(Line3));
+var Plane = class _Plane extends Entity {
+  constructor(name, placement) {
+    super();
+    this.name = name;
+    this.placement = placement;
+  }
+  type = "PLANE";
+  static parse(a2, ctx) {
+    return new _Plane(ctx.parseString(a2[0]), ctx.parseRef(a2[1]));
+  }
+  toStep() {
+    return `PLANE(${stepStr(this.name)},${this.placement})`;
+  }
+};
+register("PLANE", Plane.parse.bind(Plane));
+var ToroidalSurface = class _ToroidalSurface extends Entity {
+  constructor(name, position2, majorRadius, minorRadius) {
+    super();
+    this.name = name;
+    this.position = position2;
+    this.majorRadius = majorRadius;
+    this.minorRadius = minorRadius;
+  }
+  type = "TOROIDAL_SURFACE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const position2 = ctx.parseRef(a2[1]);
+    const majorRadius = ctx.parseNumber(a2[2]);
+    const minorRadius = ctx.parseNumber(a2[3]);
+    return new _ToroidalSurface(name, position2, 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 Vector3 = class _Vector extends Entity {
+  constructor(name, orientation3, magnitude) {
+    super();
+    this.name = name;
+    this.orientation = orientation3;
+    this.magnitude = magnitude;
+  }
+  type = "VECTOR";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const orientation3 = ctx.parseRef(a2[1]);
+    const magnitude = ctx.parseNumber(a2[2]);
+    return new _Vector(name, orientation3, magnitude);
+  }
+  toStep() {
+    return `VECTOR(${stepStr(this.name)},${this.orientation},${fmtNum(this.magnitude)})`;
+  }
+};
+register("VECTOR", Vector3.parse.bind(Vector3));
+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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const placement = ctx.parseRef(a2[1]);
+    const semiAxis1 = ctx.parseNumber(a2[2]);
+    const semiAxis2 = ctx.parseNumber(a2[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, position2, radius, semiAngle) {
+    super();
+    this.name = name;
+    this.position = position2;
+    this.radius = radius;
+    this.semiAngle = semiAngle;
+  }
+  type = "CONICAL_SURFACE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const position2 = ctx.parseRef(a2[1]);
+    const radius = ctx.parseNumber(a2[2]);
+    const semiAngle = ctx.parseNumber(a2[3]);
+    return new _ConicalSurface(name, position2, 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, position2, radius) {
+    super();
+    this.name = name;
+    this.position = position2;
+    this.radius = radius;
+  }
+  type = "SPHERICAL_SURFACE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const position2 = ctx.parseRef(a2[1]);
+    const radius = ctx.parseNumber(a2[2]);
+    return new _SphericalSurface(name, position2, 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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const degree = ctx.parseNumber(a2[1]);
+    const controlPoints = a2[2].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    const curveForm = a2[3].trim();
+    const closedCurve = a2[4].trim() === ".T.";
+    const selfIntersect = a2[5].trim() === ".T.";
+    const knotMults = a2[6].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knots = a2[7].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knotSpec = a2[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 ks3 = `(${this.knots.map(fmtNum).join(",")})`;
+    const closed = this.closedCurve ? ".T." : ".F.";
+    const self2 = this.selfIntersect ? ".T." : ".F.";
+    return `B_SPLINE_CURVE_WITH_KNOTS(${stepStr(this.name)},${this.degree},${cps},${this.curveForm},${closed},${self2},${kms},${ks3},${this.knotSpec})`;
+  }
+};
+register("B_SPLINE_CURVE_WITH_KNOTS", BSplineCurveWithKnots.parse.bind(BSplineCurveWithKnots));
+var ColourRgb = class _ColourRgb extends Entity {
+  constructor(name, r4, g6, b) {
+    super();
+    this.name = name;
+    this.r = r4;
+    this.g = g6;
+    this.b = b;
+  }
+  type = "COLOUR_RGB";
+  static parse(a2, ctx) {
+    return new _ColourRgb(ctx.parseString(a2[0]), ctx.parseNumber(a2[1]), ctx.parseNumber(a2[2]), ctx.parseNumber(a2[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(a2, ctx) {
+    const items = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _FillAreaStyle(a2[0] === "$" ? "" : ctx.parseString(a2[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(a2, ctx) {
+    return new _FillAreaStyleColour(ctx.parseString(a2[0]), ctx.parseRef(a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const items = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const contextOfItems = ctx.parseRef(a2[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(a2, ctx) {
+    const list = a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const styles = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const item = ctx.parseRef(a2[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(a2, ctx) {
+    const list = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    return new _SurfaceSideStyle(a2[0] === "$" ? "" : ctx.parseString(a2[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(a2, ctx) {
+    return new _SurfaceStyleFillArea(ctx.parseRef(a2[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(a2, ctx) {
+    return new _SurfaceStyleUsage(a2[0].trim(), ctx.parseRef(a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const items = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const c3 = ctx.parseRef(a2[2]);
+    return new _AdvancedBrepShapeRepresentation(name, items, c3);
+  }
+  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(a2, ctx) {
+    const application = ctx.parseString(a2[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(a2, ctx) {
+    const status = ctx.parseString(a2[0]);
+    const schemaName = ctx.parseString(a2[1]);
+    const year = ctx.parseNumber(a2[2]);
+    const application = ctx.parseRef(a2[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(a2, ctx) {
+    const representationRelation = ctx.parseRef(a2[0]);
+    const representedProductRelation = ctx.parseRef(a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const description = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const item1 = ctx.parseRef(a2[2]);
+    const item2 = ctx.parseRef(a2[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(id2, name, description, relatingProductDefinition, relatedProductDefinition, referenceDesignator) {
+    super();
+    this.id = id2;
+    this.name = name;
+    this.description = description;
+    this.relatingProductDefinition = relatingProductDefinition;
+    this.relatedProductDefinition = relatedProductDefinition;
+    this.referenceDesignator = referenceDesignator;
+  }
+  type = "NEXT_ASSEMBLY_USAGE_OCCURRENCE";
+  static parse(a2, ctx) {
+    const id2 = ctx.parseString(a2[0]);
+    const name = ctx.parseString(a2[1]);
+    const description = a2[2] === "$" ? "" : ctx.parseString(a2[2]);
+    const relating = ctx.parseRef(a2[3]);
+    const related = ctx.parseRef(a2[4]);
+    const designator = a2[5] === "$" ? "" : ctx.parseString(a2[5]);
+    return new _NextAssemblyUsageOccurrence(id2, 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, id2, description, frameOfReference) {
+    super();
+    this.name = name;
+    this.id = id2;
+    this.description = description;
+    this.frameOfReference = frameOfReference;
+  }
+  type = "PRODUCT";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const id2 = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const description = a2[2] === "$" ? "" : ctx.parseString(a2[2]);
+    const refs = a2[3].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    return new _Product(name, id2, 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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const frameOfReference = ctx.parseRef(a2[1]);
+    const disciplineType = ctx.parseString(a2[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(id2, description, formation, frameOfReference) {
+    super();
+    this.id = id2;
+    this.description = description;
+    this.formation = formation;
+    this.frameOfReference = frameOfReference;
+  }
+  type = "PRODUCT_DEFINITION";
+  static parse(a2, ctx) {
+    const id2 = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const description = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const formation = ctx.parseRef(a2[2]);
+    const frameOfReference = ctx.parseRef(a2[3]);
+    return new _ProductDefinition(id2, 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(a2, ctx) {
+    const name = ctx.parseString(a2[0]);
+    const frameOfReference = ctx.parseRef(a2[1]);
+    const lifecycleStage = ctx.parseString(a2[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(id2, description, ofProduct) {
+    super();
+    this.id = id2;
+    this.description = description;
+    this.ofProduct = ofProduct;
+  }
+  type = "PRODUCT_DEFINITION_FORMATION";
+  static parse(a2, ctx) {
+    const id2 = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const description = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const ofProduct = ctx.parseRef(a2[2]);
+    return new _ProductDefinitionFormation(id2, 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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const description = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const definition = ctx.parseRef(a2[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(a2, ctx) {
+    const name = ctx.parseString(a2[0]);
+    const description = a2[1] === "$" ? "" : ctx.parseString(a2[1]);
+    const products = a2[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(a2, ctx) {
+    const definition = ctx.parseRef(a2[0]);
+    const usedRepresentation = ctx.parseRef(a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const items = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok));
+    const contextOfItems = ctx.parseRef(a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const bounds = a2[1].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    const surf = ctx.parseRef(a2[2]);
+    const ss3 = a2[3].trim() === ".T.";
+    return new _AdvancedFace(name, bounds, surf, ss3);
+  }
+  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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const faces = a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const s2 = ctx.parseRef(a2[1]);
+    const e4 = ctx.parseRef(a2[2]);
+    const c3 = ctx.parseRef(a2[3]);
+    const same = a2[4].trim() === ".T.";
+    return new _EdgeCurve(name, s2, e4, c3, 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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const list = a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    return new _FaceBound(name, ctx.parseRef(a2[1]), a2[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(a2, ctx) {
+    return new _FaceOuterBound(ctx.parseString(a2[0]), ctx.parseRef(a2[1]), a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    return new _ManifoldSolidBrep(name, ctx.parseRef(a2[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, orientation3) {
+    super();
+    this.name = name;
+    this.edge = edge;
+    this.orientation = orientation3;
+  }
+  type = "ORIENTED_EDGE";
+  static parse(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    const edge = ctx.parseRef(a2[3]);
+    const orient = a2[4]?.trim?.() === ".T." || a2[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(a2, ctx) {
+    const name = a2[0] === "$" ? "" : ctx.parseString(a2[0]);
+    return new _VertexPoint(name, ctx.parseRef(a2[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 i2 = 0;i2 < entityStarts.length; i2++) {
+    const start = entityStarts[i2];
+    const nextStart = i2 + 1 < entityStarts.length ? entityStarts[i2 + 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(s2) {
+  const out = [];
+  let buf = "";
+  let depth = 0;
+  let inStr = false;
+  for (let i2 = 0;i2 < s2.length; i2++) {
+    const c3 = s2[i2];
+    if (c3 === "'" && s2[i2 - 1] !== "\\")
+      inStr = !inStr;
+    if (!inStr) {
+      if (c3 === "(")
+        depth++;
+      if (c3 === ")")
+        depth--;
+      if (c3 === "," && depth === 0) {
+        out.push(buf.trim());
+        buf = "";
+        continue;
+      }
+    }
+    buf += c3;
+  }
+  if (buf.trim())
+    out.push(buf.trim());
+  return out;
+}
+function parseRepository(data) {
+  const repo = new Repository;
+  const ctx = {
+    repo,
+    parseRef(_tok) {
+      const n3 = +_tok.replace("#", "").trim();
+      return new Ref(eid(n3));
+    },
+    parseNumber(tok) {
+      return Number(tok);
+    },
+    parseString(tok) {
+      const m3 = tok.match(/^'(.*)'$/);
+      if (!m3)
+        throw new Error(`Expected string: ${tok}`);
+      return m3[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/stepts/lib/core/EntityId.ts
+var eid2 = (n3) => n3;
+
+// node_modules/circuit-json-to-step/dist/index.js
+function createBoxTriangles(box2) {
+  const { center: center2, size: size2 } = box2;
+  const halfX = size2.x / 2;
+  const halfY = size2.y / 2;
+  const halfZ = size2.z / 2;
+  const corners = [
+    { x: -halfX, y: -halfY, z: -halfZ },
+    { x: halfX, y: -halfY, z: -halfZ },
+    { x: halfX, y: halfY, z: -halfZ },
+    { x: -halfX, y: halfY, z: -halfZ },
+    { x: -halfX, y: -halfY, z: halfZ },
+    { x: halfX, y: -halfY, z: halfZ },
+    { x: halfX, y: halfY, z: halfZ },
+    { x: -halfX, y: halfY, z: halfZ }
+  ].map((p3) => ({ x: p3.x + center2.x, y: p3.y + center2.y, z: p3.z + center2.z }));
+  const triangles = [
+    {
+      vertices: [corners[0], corners[1], corners[2]],
+      normal: { x: 0, y: 0, z: -1 }
+    },
+    {
+      vertices: [corners[0], corners[2], corners[3]],
+      normal: { x: 0, y: 0, z: -1 }
+    },
+    {
+      vertices: [corners[4], corners[6], corners[5]],
+      normal: { x: 0, y: 0, z: 1 }
+    },
+    {
+      vertices: [corners[4], corners[7], corners[6]],
+      normal: { x: 0, y: 0, z: 1 }
+    },
+    {
+      vertices: [corners[0], corners[5], corners[1]],
+      normal: { x: 0, y: -1, z: 0 }
+    },
+    {
+      vertices: [corners[0], corners[4], corners[5]],
+      normal: { x: 0, y: -1, z: 0 }
+    },
+    {
+      vertices: [corners[2], corners[6], corners[7]],
+      normal: { x: 0, y: 1, z: 0 }
+    },
+    {
+      vertices: [corners[2], corners[7], corners[3]],
+      normal: { x: 0, y: 1, z: 0 }
+    },
+    {
+      vertices: [corners[0], corners[3], corners[7]],
+      normal: { x: -1, y: 0, z: 0 }
+    },
+    {
+      vertices: [corners[0], corners[7], corners[4]],
+      normal: { x: -1, y: 0, z: 0 }
+    },
+    {
+      vertices: [corners[1], corners[6], corners[2]],
+      normal: { x: 1, y: 0, z: 0 }
+    },
+    {
+      vertices: [corners[1], corners[5], corners[6]],
+      normal: { x: 1, y: 0, z: 0 }
+    }
+  ];
+  return triangles;
+}
+function createStepFacesFromTriangles(repo, triangles) {
+  const faces = [];
+  for (const triangle of triangles) {
+    const v12 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", triangle.vertices[0].x, triangle.vertices[0].y, triangle.vertices[0].z))));
+    const v23 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", triangle.vertices[1].x, triangle.vertices[1].y, triangle.vertices[1].z))));
+    const v3 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", triangle.vertices[2].x, triangle.vertices[2].y, triangle.vertices[2].z))));
+    const p12 = v12.resolve(repo).pnt.resolve(repo);
+    const p23 = v23.resolve(repo).pnt.resolve(repo);
+    const createEdge = (vStart, vEnd) => {
+      const pStart = vStart.resolve(repo).pnt.resolve(repo);
+      const pEnd = vEnd.resolve(repo).pnt.resolve(repo);
+      const dir = repo.add(new Direction("", pEnd.x - pStart.x, pEnd.y - pStart.y, pEnd.z - pStart.z));
+      const vec = repo.add(new Vector3("", dir, 1));
+      const line2 = repo.add(new Line3("", vStart.resolve(repo).pnt, vec));
+      return repo.add(new EdgeCurve("", vStart, vEnd, line2, true));
+    };
+    const edge1 = createEdge(v12, v23);
+    const edge2 = createEdge(v23, v3);
+    const edge3 = createEdge(v3, v12);
+    const edgeLoop = repo.add(new EdgeLoop("", [
+      repo.add(new OrientedEdge("", edge1, true)),
+      repo.add(new OrientedEdge("", edge2, true)),
+      repo.add(new OrientedEdge("", edge3, true))
+    ]));
+    const normalDir = repo.add(new Direction("", triangle.normal.x, triangle.normal.y, triangle.normal.z));
+    const refX = p23.x - p12.x;
+    const refY = p23.y - p12.y;
+    const refZ = p23.z - p12.z;
+    const refDir = repo.add(new Direction("", refX, refY, refZ));
+    const placement = repo.add(new Axis2Placement3D("", v12.resolve(repo).pnt, normalDir, refDir));
+    const plane = repo.add(new Plane("", placement));
+    const face = repo.add(new AdvancedFace("", [repo.add(new FaceOuterBound("", edgeLoop, true))], plane, true));
+    faces.push(face);
+  }
+  return faces;
+}
+async function generateComponentMeshes(options) {
+  const {
+    repo,
+    circuitJson,
+    boardThickness,
+    includeExternalMeshes = false,
+    excludeCadComponentIds,
+    excludePcbComponentIds,
+    pcbComponentIdsWithStepUrl
+  } = options;
+  const solids = [];
+  try {
+    const filteredCircuitJson = circuitJson.filter((e4) => {
+      if (e4.type === "pcb_board")
+        return false;
+      if (e4.type === "cad_component" && e4.cad_component_id && excludeCadComponentIds?.has(e4.cad_component_id)) {
+        return false;
+      }
+      if (e4.type === "pcb_component" && e4.pcb_component_id && excludePcbComponentIds?.has(e4.pcb_component_id)) {
+        return false;
+      }
+      if (e4.type === "cad_component" && e4.model_step_url) {
+        return false;
+      }
+      if (e4.type === "cad_component" && e4.pcb_component_id && pcbComponentIdsWithStepUrl?.has(e4.pcb_component_id)) {
+        return false;
+      }
+      return true;
+    }).map((e4) => {
+      if (!includeExternalMeshes && e4.type === "cad_component") {
+        return {
+          ...e4,
+          model_3mf_url: undefined,
+          model_obj_url: undefined,
+          model_stl_url: undefined,
+          model_glb_url: undefined,
+          model_gltf_url: undefined
+        };
+      }
+      return e4;
+    });
+    const gltfModule = "circuit-json-to-gltf";
+    const { convertCircuitJsonTo3D } = await import(gltfModule);
+    const scene3d = await convertCircuitJsonTo3D(filteredCircuitJson, {
+      boardThickness,
+      renderBoardTextures: false
+    });
+    const allTriangles = [];
+    for (const box2 of scene3d.boxes) {
+      if (box2.mesh && "triangles" in box2.mesh) {
+        allTriangles.push(...box2.mesh.triangles);
+      } else {
+        const boxTriangles = createBoxTriangles(box2);
+        allTriangles.push(...boxTriangles);
+      }
+    }
+    if (allTriangles.length > 0) {
+      const transformedTriangles = allTriangles.map((tri) => ({
+        vertices: tri.vertices.map((v3) => ({
+          x: v3.x,
+          y: v3.z,
+          z: v3.y
+        })),
+        normal: {
+          x: tri.normal.x,
+          y: tri.normal.z,
+          z: tri.normal.y
+        }
+      }));
+      const componentFaces = createStepFacesFromTriangles(repo, transformedTriangles);
+      const componentShell = repo.add(new ClosedShell("", componentFaces));
+      const componentSolid = repo.add(new ManifoldSolidBrep("Components", componentShell));
+      solids.push(componentSolid);
+    }
+  } 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",
+  "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
+  "PRESENTATION_STYLE_ASSIGNMENT",
+  "SURFACE_STYLE_USAGE",
+  "SURFACE_SIDE_STYLE",
+  "SURFACE_STYLE_FILL_AREA",
+  "FILL_AREA_STYLE",
+  "FILL_AREA_STYLE_COLOUR",
+  "COLOUR_RGB",
+  "STYLED_ITEM",
+  "CURVE_STYLE",
+  "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
+  "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(rotation4) {
+  const factor = Math.PI / 180;
+  return {
+    x: rotation4.x * factor,
+    y: rotation4.y * factor,
+    z: rotation4.z * factor
+  };
+}
+function transformPoint(point5, rotation4, translation) {
+  const rotated = rotateVector(point5, rotation4);
+  return [
+    rotated[0] + translation.x,
+    rotated[1] + translation.y,
+    rotated[2] + translation.z
+  ];
+}
+function transformDirection(vector2, rotation4) {
+  return rotateVector(vector2, rotation4);
+}
+function rotateVector(vector2, rotation4) {
+  let [x3, y4, z21] = vector2;
+  if (rotation4.x !== 0) {
+    const cosX = Math.cos(rotation4.x);
+    const sinX = Math.sin(rotation4.x);
+    const y12 = y4 * cosX - z21 * sinX;
+    const z110 = y4 * sinX + z21 * cosX;
+    y4 = y12;
+    z21 = z110;
+  }
+  if (rotation4.y !== 0) {
+    const cosY = Math.cos(rotation4.y);
+    const sinY = Math.sin(rotation4.y);
+    const x12 = x3 * cosY + z21 * sinY;
+    const z110 = -x3 * sinY + z21 * cosY;
+    x3 = x12;
+    z21 = z110;
+  }
+  if (rotation4.z !== 0) {
+    const cosZ = Math.cos(rotation4.z);
+    const sinZ = Math.sin(rotation4.z);
+    const x12 = x3 * cosZ - y4 * sinZ;
+    const y12 = x3 * sinZ + y4 * cosZ;
+    x3 = x12;
+    y4 = y12;
+  }
+  return [x3, y4, z21];
+}
+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 res2 = await globalFetch(modelUrl);
+  if (!res2.ok) {
+    throw new Error(`HTTP ${res2.status} ${res2.statusText}`);
+  }
+  return await res2.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 transform2 = {
+        translation: asVector3(component.position),
+        rotation: asVector3(component.rotation)
+      };
+      const componentSolids = mergeSingleStepModel(repo, stepText, transform2, {
+        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, transform2, placement) {
+  const sourceRepo = parseRepository(stepText);
+  let entries = sourceRepo.entries().map(([id2, entity]) => [Number(id2), entity]).filter(([, entity]) => !EXCLUDED_ENTITY_TYPES.has(entity.type));
+  entries = pruneInvalidEntries(entries);
+  adjustTransformForPlacement(entries, transform2, placement);
+  applyTransform(entries, transform2);
+  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(eid2(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(eid2(mappedId)));
+      }
+    }
+  }
+  return solids;
+}
+function adjustTransformForPlacement(entries, transform2, 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(transform2.rotation);
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (const point5 of points) {
+    const [x3, y4, z21] = rotateVector(point5, rotationRadians);
+    if (x3 < minX)
+      minX = x3;
+    if (y4 < minY)
+      minY = y4;
+    if (z21 < minZ)
+      minZ = z21;
+    if (x3 > maxX)
+      maxX = x3;
+    if (y4 > maxY)
+      maxY = y4;
+    if (z21 > maxZ)
+      maxZ = z21;
+  }
+  if (!Number.isFinite(minX))
+    return;
+  const center2 = {
+    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 = transform2.translation.x;
+  const targetY = transform2.translation.y;
+  const targetZ = transform2.translation.z;
+  const THROUGH_HOLE_Z_TOLERANCE = 0.001;
+  const isThroughHoleComponent = minZ < -THROUGH_HOLE_Z_TOLERANCE && maxZ > THROUGH_HOLE_Z_TOLERANCE;
+  transform2.translation.x = targetX - center2.x;
+  transform2.translation.y = targetY - center2.y;
+  if (isThroughHoleComponent) {
+    transform2.translation.z = boardThickness;
+  }
+  if (!isThroughHoleComponent && boardThickness > 0) {
+    const halfThickness = boardThickness / 2;
+    const offsetZ = targetZ - halfThickness;
+    if (normalizedLayer === "bottom") {
+      transform2.translation.z = -maxZ + offsetZ;
+      transform2.rotation.x = normalizeDegrees2(transform2.rotation.x + 180);
+    } else {
+      transform2.translation.z = boardThickness - minZ + offsetZ;
+    }
+  } else if (!isThroughHoleComponent) {
+    transform2.translation.z = targetZ - center2.z;
+  }
+}
+function normalizeDegrees2(value) {
+  const wrapped = value % 360;
+  return wrapped < 0 ? wrapped + 360 : wrapped;
+}
+function pruneInvalidEntries(entries) {
+  let remaining = entries.slice();
+  let remainingIds = new Set(remaining.map(([id2]) => id2));
+  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(([id2]) => !toRemove.has(id2));
+      remainingIds = new Set(remaining.map(([id2]) => id2));
+    }
+  }
+  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, (_4, num) => {
+        result.add(Number(num));
+        return _4;
+      });
+    }
+    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, transform2) {
+  const rotation4 = toRadians(transform2.rotation);
+  for (const [, entity] of entries) {
+    if (entity instanceof CartesianPoint) {
+      const [x3, y4, z21] = transformPoint([entity.x, entity.y, entity.z], rotation4, transform2.translation);
+      entity.x = x3;
+      entity.y = y4;
+      entity.z = z21;
+    } else if (entity instanceof Direction) {
+      const [dx2, dy2, dz] = transformDirection([entity.dx, entity.dy, entity.dz], rotation4);
+      const length2 = Math.hypot(dx2, dy2, dz);
+      if (length2 > 0) {
+        entity.dx = dx2 / length2;
+        entity.dy = dy2 / length2;
+        entity.dz = dz / length2;
+      }
+    }
+  }
+}
+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 [id2] of repo.entries()) {
+    const numericId = Number(id2);
+    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 = eid2(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_default4 = {
+  name: "circuit-json-to-step",
+  main: "dist/index.js",
+  version: "0.0.18",
+  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.286",
+    "looks-same": "^10.0.1",
+    "occt-import-js": "^0.0.23",
+    poppygl: "^0.0.17",
+    stepts: "^0.0.3",
+    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.87",
+    "circuit-to-svg": "^0.0.327",
+    "schematic-symbols": "^0.0.202"
+  }
+};
+var VERSION = package_default4.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 rotation4 = ccwRotation * Math.PI / 180;
+  const isHorizontal2 = width >= height;
+  const radius = Math.min(width, height) / 2;
+  const straightHalfLength = Math.abs(width - height) / 2;
+  return {
+    centerX,
+    centerY,
+    width,
+    height,
+    rotation: rotation4,
+    radius,
+    straightHalfLength,
+    isHorizontal: isHorizontal2
+  };
+}
+function rotatePoint3(x3, y4, centerX, centerY, angle) {
+  const cos2 = Math.cos(angle);
+  const sin2 = Math.sin(angle);
+  const dx2 = x3 - centerX;
+  const dy2 = y4 - centerY;
+  return {
+    x: centerX + dx2 * cos2 - dy2 * sin2,
+    y: centerY + dx2 * sin2 + dy2 * cos2
+  };
+}
+function createLineEdge(repo, v12, v23) {
+  const p12 = v12.resolve(repo).pnt.resolve(repo);
+  const p23 = v23.resolve(repo).pnt.resolve(repo);
+  const dx2 = p23.x - p12.x;
+  const dy2 = p23.y - p12.y;
+  const dz = p23.z - p12.z;
+  const length2 = Math.sqrt(dx2 * dx2 + dy2 * dy2 + dz * dz);
+  if (length2 < 0.0000000001) {
+    const dir2 = repo.add(new Direction("", 1, 0, 0));
+    const vec2 = repo.add(new Vector3("", dir2, 0.0000000001));
+    const line22 = repo.add(new Line3("", v12.resolve(repo).pnt, vec2));
+    return repo.add(new EdgeCurve("", v12, v23, line22, true));
+  }
+  const dir = repo.add(new Direction("", dx2 / length2, dy2 / length2, dz / length2));
+  const vec = repo.add(new Vector3("", dir, length2));
+  const line2 = repo.add(new Line3("", v12.resolve(repo).pnt, vec));
+  return repo.add(new EdgeCurve("", v12, v23, line2, true));
+}
+function createArcEdge(repo, centerX, centerY, z21, radius, startAngle, endAngle, rotation4, 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 = rotatePoint3(startX, startY, centerX0, centerY0, rotation4);
+  const endRotated = rotatePoint3(endX, endY, centerX0, centerY0, rotation4);
+  const startVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", startRotated.x, startRotated.y, z21))));
+  const endVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", endRotated.x, endRotated.y, z21))));
+  const centerRotated = rotatePoint3(centerX, centerY, centerX0, centerY0, rotation4);
+  const centerPoint = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, z21));
+  const normalDir = repo.add(new Direction("", 0, 0, -1));
+  const refAngle = rotation4;
+  const refDir = repo.add(new Direction("", Math.cos(refAngle), Math.sin(refAngle), 0));
+  const placement = repo.add(new Axis2Placement3D("", centerPoint, normalDir, refDir));
+  const circle2 = repo.add(new Circle3("", placement, radius));
+  return repo.add(new EdgeCurve("", startVertex, endVertex, circle2, false));
+}
+function createPillHoleLoop(repo, hole, z21, xDir) {
+  const geom = getPillGeometry(hole);
+  const {
+    centerX,
+    centerY,
+    radius,
+    straightHalfLength,
+    rotation: rotation4,
+    isHorizontal: isHorizontal2
+  } = geom;
+  const edges = [];
+  if (isHorizontal2) {
+    const capOffset = straightHalfLength;
+    const rightArc = createArcEdge(repo, centerX + capOffset, centerY, z21, radius, -Math.PI / 2, Math.PI / 2, rotation4, centerX, centerY);
+    edges.push(rightArc);
+    const bottomStart = rotatePoint3(centerX + capOffset, centerY - radius, centerX, centerY, rotation4);
+    const bottomEnd = rotatePoint3(centerX - capOffset, centerY - radius, centerX, centerY, rotation4);
+    const bottomV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, z21))));
+    const bottomV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, z21))));
+    edges.push(createLineEdge(repo, bottomV1, bottomV2));
+    const leftArc = createArcEdge(repo, centerX - capOffset, centerY, z21, radius, Math.PI / 2, 3 * Math.PI / 2, rotation4, centerX, centerY);
+    edges.push(leftArc);
+    const topStart = rotatePoint3(centerX - capOffset, centerY + radius, centerX, centerY, rotation4);
+    const topEnd = rotatePoint3(centerX + capOffset, centerY + radius, centerX, centerY, rotation4);
+    const topV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", topStart.x, topStart.y, z21))));
+    const topV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", topEnd.x, topEnd.y, z21))));
+    edges.push(createLineEdge(repo, topV1, topV2));
+  } else {
+    const capOffset = straightHalfLength;
+    const topArc = createArcEdge(repo, centerX, centerY - capOffset, z21, radius, Math.PI, 0, rotation4, centerX, centerY);
+    edges.push(topArc);
+    const rightStart = rotatePoint3(centerX + radius, centerY - capOffset, centerX, centerY, rotation4);
+    const rightEnd = rotatePoint3(centerX + radius, centerY + capOffset, centerX, centerY, rotation4);
+    const rightV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", rightStart.x, rightStart.y, z21))));
+    const rightV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", rightEnd.x, rightEnd.y, z21))));
+    edges.push(createLineEdge(repo, rightV1, rightV2));
+    const bottomArc = createArcEdge(repo, centerX, centerY + capOffset, z21, radius, 0, Math.PI, rotation4, centerX, centerY);
+    edges.push(bottomArc);
+    const leftStart = rotatePoint3(centerX - radius, centerY + capOffset, centerX, centerY, rotation4);
+    const leftEnd = rotatePoint3(centerX - radius, centerY - capOffset, centerX, centerY, rotation4);
+    const leftV1 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", leftStart.x, leftStart.y, z21))));
+    const leftV2 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", leftEnd.x, leftEnd.y, z21))));
+    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, boardThickness, xDir, zDir) {
+  const geom = getPillGeometry(hole);
+  const {
+    centerX,
+    centerY,
+    radius,
+    straightHalfLength,
+    rotation: rotation4,
+    isHorizontal: isHorizontal2
+  } = geom;
+  const faces = [];
+  if (isHorizontal2) {
+    const capOffset = straightHalfLength;
+    faces.push(createCylindricalWall(repo, centerX + capOffset, centerY, radius, -Math.PI / 2, Math.PI / 2, rotation4, centerX, centerY, boardThickness, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX - capOffset, centerY - radius, centerX + capOffset, centerY - radius, rotation4, centerX, centerY, boardThickness, zDir));
+    faces.push(createCylindricalWall(repo, centerX - capOffset, centerY, radius, Math.PI / 2, 3 * Math.PI / 2, rotation4, centerX, centerY, boardThickness, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX + capOffset, centerY + radius, centerX - capOffset, centerY + radius, rotation4, centerX, centerY, boardThickness, zDir));
+  } else {
+    const capOffset = straightHalfLength;
+    faces.push(createCylindricalWall(repo, centerX, centerY - capOffset, radius, Math.PI, 0, rotation4, centerX, centerY, boardThickness, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX + radius, centerY - capOffset, centerX + radius, centerY + capOffset, rotation4, centerX, centerY, boardThickness, zDir));
+    faces.push(createCylindricalWall(repo, centerX, centerY + capOffset, radius, 0, Math.PI, rotation4, centerX, centerY, boardThickness, zDir, xDir));
+    faces.push(createPlanarWall(repo, centerX - radius, centerY + capOffset, centerX - radius, centerY - capOffset, rotation4, centerX, centerY, boardThickness, zDir));
+  }
+  return faces;
+}
+function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAngle, rotation4, centerX0, centerY0, boardThickness, 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 = rotatePoint3(bottomStartX, bottomStartY, centerX0, centerY0, rotation4);
+  const bottomEnd = rotatePoint3(bottomEndX, bottomEndY, centerX0, centerY0, rotation4);
+  const bottomStartVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, 0))));
+  const bottomEndVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, 0))));
+  const topStart = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, boardThickness))));
+  const topEnd = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, boardThickness))));
+  const centerRotated = rotatePoint3(centerX, centerY, centerX0, centerY0, rotation4);
+  const bottomCenter = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, 0));
+  const bottomPlacement = repo.add(new Axis2Placement3D("", bottomCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+  const bottomCircle = repo.add(new Circle3("", bottomPlacement, radius));
+  const bottomArc = repo.add(new EdgeCurve("", bottomStartVertex, bottomEndVertex, bottomCircle, false));
+  const topCenter = repo.add(new CartesianPoint("", centerRotated.x, centerRotated.y, boardThickness));
+  const topPlacement = repo.add(new Axis2Placement3D("", topCenter, zDir, xDir));
+  const topCircle = repo.add(new Circle3("", topPlacement, radius));
+  const topArc = repo.add(new EdgeCurve("", topEnd, topStart, topCircle, false));
+  const v12 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, 0))));
+  const v23 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomStart.x, bottomStart.y, boardThickness))));
+  const v3 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, 0))));
+  const v4 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", bottomEnd.x, bottomEnd.y, boardThickness))));
+  const dir1 = repo.add(new Direction("", 0, 0, 1));
+  const vec1 = repo.add(new Vector3("", dir1, boardThickness));
+  const line1 = repo.add(new Line3("", v12.resolve(repo).pnt, vec1));
+  const edge1 = repo.add(new EdgeCurve("", v12, v23, line1, true));
+  const dir2 = repo.add(new Direction("", 0, 0, 1));
+  const vec2 = repo.add(new Vector3("", dir2, boardThickness));
+  const line2 = repo.add(new Line3("", 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, rotation4, centerX0, centerY0, boardThickness, zDir) {
+  const start = rotatePoint3(startX, startY, centerX0, centerY0, rotation4);
+  const end = rotatePoint3(endX, endY, centerX0, centerY0, rotation4);
+  const v12 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", start.x, start.y, 0))));
+  const v23 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", end.x, end.y, 0))));
+  const v3 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", end.x, end.y, boardThickness))));
+  const v4 = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", start.x, start.y, boardThickness))));
+  const dx2 = end.x - start.x;
+  const dy2 = end.y - start.y;
+  const edgeLength = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+  const bottomDir = repo.add(new Direction("", dx2 / edgeLength, dy2 / edgeLength, 0));
+  const bottomVec = repo.add(new Vector3("", bottomDir, edgeLength));
+  const bottomLine = repo.add(new Line3("", v12.resolve(repo).pnt, bottomVec));
+  const bottomEdge = repo.add(new EdgeCurve("", v12, v23, bottomLine, true));
+  const topDir = repo.add(new Direction("", dx2 / edgeLength, dy2 / edgeLength, 0));
+  const topVec = repo.add(new Vector3("", topDir, edgeLength));
+  const topLine = repo.add(new Line3("", 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 vertVec1 = repo.add(new Vector3("", vertDir, boardThickness));
+  const vertLine1 = repo.add(new Line3("", v23.resolve(repo).pnt, vertVec1));
+  const vertEdge1 = repo.add(new EdgeCurve("", v23, v3, vertLine1, true));
+  const vertVec2 = repo.add(new Vector3("", vertDir, boardThickness));
+  const vertLine2 = repo.add(new Line3("", v12.resolve(repo).pnt, vertVec2));
+  const vertEdge2 = repo.add(new EdgeCurve("", v12, 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("", dy2 / edgeLength, -dx2 / edgeLength, 0));
+  const refDir = repo.add(new Direction("", dx2 / edgeLength, dy2 / edgeLength, 0));
+  const planeOrigin = repo.add(new CartesianPoint("", start.x, start.y, 0));
+  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;
+  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 i2 = 0;i2 < outline.length; i2++) {
+      const current2 = outline[i2];
+      const next = outline[(i2 + 1) % outline.length];
+      const dx2 = next.x - current2.x;
+      const dy2 = next.y - current2.y;
+      const dist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+      if (dist > 0.000001) {
+        cleanedOutline.push(current2);
+      }
+    }
+    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((point5) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point5.x, point5.y, 0)))));
+    topVertices = cleanedOutline.map((point5) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point5.x, point5.y, boardThickness)))));
+  } else {
+    const halfWidth = boardWidth / 2;
+    const halfHeight = boardHeight / 2;
+    const corners = [
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, 0],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, 0],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, 0],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, 0],
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, boardThickness],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, boardThickness],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, boardThickness],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, boardThickness]
+    ];
+    const vertices = corners.map(([x3, y4, z21]) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x3, y4, z21)))));
+    bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
+    topVertices = [vertices[4], vertices[5], vertices[6], vertices[7]];
+  }
+  function createEdge(v12, v23) {
+    const p12 = v12.resolve(repo).pnt.resolve(repo);
+    const p23 = v23.resolve(repo).pnt.resolve(repo);
+    const dx2 = p23.x - p12.x;
+    const dy2 = p23.y - p12.y;
+    const dz = p23.z - p12.z;
+    const length2 = Math.sqrt(dx2 * dx2 + dy2 * dy2 + dz * dz);
+    if (length2 < 0.0000000001) {
+      const dir2 = repo.add(new Direction("", 1, 0, 0));
+      const vec2 = repo.add(new Vector3("", dir2, 0.0000000001));
+      const line22 = repo.add(new Line3("", v12.resolve(repo).pnt, vec2));
+      return repo.add(new EdgeCurve("", v12, v23, line22, true));
+    }
+    const dir = repo.add(new Direction("", dx2 / length2, dy2 / length2, dz / length2));
+    const vec = repo.add(new Vector3("", dir, length2));
+    const line2 = repo.add(new Line3("", v12.resolve(repo).pnt, vec));
+    return repo.add(new EdgeCurve("", v12, v23, line2, true));
+  }
+  const bottomEdges = [];
+  const topEdges = [];
+  const verticalEdges = [];
+  for (let i2 = 0;i2 < bottomVertices.length; i2++) {
+    const v12 = bottomVertices[i2];
+    const v23 = bottomVertices[(i2 + 1) % bottomVertices.length];
+    bottomEdges.push(createEdge(v12, v23));
+  }
+  for (let i2 = 0;i2 < topVertices.length; i2++) {
+    const v12 = topVertices[i2];
+    const v23 = topVertices[(i2 + 1) % topVertices.length];
+    topEdges.push(createEdge(v12, v23));
+  }
+  for (let i2 = 0;i2 < bottomVertices.length; i2++) {
+    verticalEdges.push(createEdge(bottomVertices[i2], topVertices[i2]));
+  }
+  const origin = repo.add(new CartesianPoint("", 0, 0, 0));
+  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.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const holeCenter = repo.add(new CartesianPoint("", holeX, holeY, 0));
+      const holeVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, 0))));
+      const holePlacement = repo.add(new Axis2Placement3D("", holeCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+      const holeCircle = repo.add(new Circle3("", 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, 0, 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, boardThickness));
+  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.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const holeCenter = repo.add(new CartesianPoint("", holeX, holeY, boardThickness));
+      const holeVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, boardThickness))));
+      const holePlacement = repo.add(new Axis2Placement3D("", holeCenter, zDir, xDir));
+      const holeCircle = repo.add(new Circle3("", 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, boardThickness, 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 i2 = 0;i2 < bottomEdges.length; i2++) {
+    const nextI = (i2 + 1) % bottomEdges.length;
+    const bottomV1Pnt = bottomVertices[i2].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: 0
+    };
+    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[i2], true)),
+      repo.add(new OrientedEdge("", verticalEdges[nextI], true)),
+      repo.add(new OrientedEdge("", topEdges[i2], false)),
+      repo.add(new OrientedEdge("", verticalEdges[i2], 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.value;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
+      const radius = hole.hole_diameter / 2;
+      const bottomHoleCenter = repo.add(new CartesianPoint("", holeX, holeY, 0));
+      const bottomHoleVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, 0))));
+      const bottomHolePlacement = repo.add(new Axis2Placement3D("", bottomHoleCenter, repo.add(new Direction("", 0, 0, -1)), xDir));
+      const bottomHoleCircle = repo.add(new Circle3("", bottomHolePlacement, radius));
+      const bottomHoleEdge = repo.add(new EdgeCurve("", bottomHoleVertex, bottomHoleVertex, bottomHoleCircle, true));
+      const topHoleCenter = repo.add(new CartesianPoint("", holeX, holeY, boardThickness));
+      const topHoleVertex = repo.add(new VertexPoint("", repo.add(new CartesianPoint("", holeX + radius, holeY, boardThickness))));
+      const topHolePlacement = repo.add(new Axis2Placement3D("", topHoleCenter, zDir, xDir));
+      const topHoleCircle = repo.add(new Circle3("", 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, boardThickness, xDir, zDir);
+      holeCylindricalFaces.push(...pillFaces);
+    }
+  }
+  const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
+  const shell = repo.add(new ClosedShell("", allFaces));
+  const solid = repo.add(new ManifoldSolidBrep(productName, shell));
+  const allSolids = [solid];
+  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);
+  }
+  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
+      });
+      allSolids.push(...componentSolids);
+    }
+  }
+  const styledItems = [];
+  allSolids.forEach((solidRef, index) => {
+    const isBoard = index === 0;
+    const [r4, g6, b] = isBoard ? [0.2, 0.6, 0.2] : [0.75, 0.75, 0.75];
+    const color = repo.add(new ColourRgb("", r4, g6, b));
+    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));
+    const presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
+    const styledItem = repo.add(new StyledItem("", [presStyle], solidRef));
+    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);
+}
+
+// lib/shared/export-snippet.ts
 var writeFileAsync = promisify3(fs53.writeFile);
 var ALLOWED_EXPORT_FORMATS = [
   "json",
@@ -243361,7 +245785,8 @@ var ALLOWED_EXPORT_FORMATS = [
   "kicad_pcb",
   "kicad_zip",
   "kicad-library",
-  "srj"
+  "srj",
+  "step"
 ];
 var OUTPUT_EXTENSIONS = {
   json: ".circuit.json",
@@ -243377,7 +245802,8 @@ var OUTPUT_EXTENSIONS = {
   kicad_pcb: ".kicad_pcb",
   kicad_zip: "-kicad.zip",
   "kicad-library": "",
-  srj: ".simple-route.json"
+  srj: ".simple-route.json",
+  step: ".step"
 };
 var exportSnippet = async ({
   filePath,
@@ -243528,6 +245954,9 @@ var exportSnippet = async ({
       outputContent = await zip.generateAsync({ type: "nodebuffer" });
       break;
     }
+    case "step":
+      outputContent = await circuitJsonToStep(circuitJson);
+      break;
     default:
       outputContent = JSON.stringify(circuitJson, null, 2);
   }
@@ -262872,7 +265301,7 @@ class ExtendedSearch {
   }
 }
 var registeredSearchers = [];
-function register(...args) {
+function register2(...args) {
   registeredSearchers.push(...args);
 }
 function createSearcher(pattern, options) {
@@ -263204,7 +265633,7 @@ Fuse2.config = Config;
   Fuse2.parseQuery = parse3;
 }
 {
-  register(ExtendedSearch);
+  register2(ExtendedSearch);
 }
 
 // cli/search/register.ts