@tscircuit/pcb-viewer 1.11.218 → 1.11.220

package/dist/index.js

@@ -11478,20 +11478,90 @@ var any_soup_element = any_circuit_element;
 expectTypesMatch(true);
 expectStringUnionsMatch(true);
 
-// node_modules/@tscircuit/soup-util/dist/index.js
+// node_modules/@tscircuit/circuit-json-util/dist/index.js
 import { applyToPoint, decomposeTSR } from "transformation-matrix";
-var su = (soup, options = {}) => {
-  let internalStore = soup._internal_store;
+import { translate } from "transformation-matrix";
+import { translate as translate2 } from "transformation-matrix";
+import { translate as translate3 } from "transformation-matrix";
+import { translate as translate4 } from "transformation-matrix";
+function connect(map, a, b) {
+  if (!a || !b) return;
+  let setA = map.get(a);
+  if (!setA) {
+    setA = /* @__PURE__ */ new Set();
+    map.set(a, setA);
+  }
+  setA.add(b);
+  let setB = map.get(b);
+  if (!setB) {
+    setB = /* @__PURE__ */ new Set();
+    map.set(b, setB);
+  }
+  setB.add(a);
+}
+function buildSubtree(soup, opts) {
+  if (!opts.subcircuit_id && !opts.source_group_id) return [...soup];
+  const idMap = /* @__PURE__ */ new Map();
+  for (const elm of soup) {
+    const idVal = elm[`${elm.type}_id`];
+    if (typeof idVal === "string") {
+      idMap.set(idVal, elm);
+    }
+  }
+  const adj = /* @__PURE__ */ new Map();
+  for (const elm of soup) {
+    const entries = Object.entries(elm);
+    for (const [key, val] of entries) {
+      if (key === "parent_source_group_id") continue;
+      if (key.endsWith("_id") && typeof val === "string") {
+        const other = idMap.get(val);
+        connect(adj, elm, other);
+      } else if (key.endsWith("_ids") && Array.isArray(val)) {
+        for (const v of val) {
+          if (typeof v === "string") {
+            const other = idMap.get(v);
+            connect(adj, elm, other);
+          }
+        }
+      }
+    }
+  }
+  const queue = [];
+  const included = /* @__PURE__ */ new Set();
+  for (const elm of soup) {
+    if (opts.subcircuit_id && elm.subcircuit_id === opts.subcircuit_id || opts.source_group_id && (elm.source_group_id === opts.source_group_id || Array.isArray(elm.member_source_group_ids) && elm.member_source_group_ids.includes(
+      opts.source_group_id
+    ))) {
+      queue.push(elm);
+      included.add(elm);
+    }
+  }
+  while (queue.length > 0) {
+    const elm = queue.shift();
+    const neighbors = adj.get(elm);
+    if (!neighbors) continue;
+    for (const n of neighbors) {
+      if (!included.has(n)) {
+        included.add(n);
+        queue.push(n);
+      }
+    }
+  }
+  return soup.filter((e) => included.has(e));
+}
+var cju = (circuitJsonInput, options = {}) => {
+  const circuitJson = circuitJsonInput;
+  let internalStore = circuitJson._internal_store;
   if (!internalStore) {
     internalStore = {
-      counts: {}
+      counts: {},
+      editCount: 0
     };
-    soup._internal_store = internalStore;
-    for (const elm of soup) {
+    circuitJson._internal_store = internalStore;
+    for (const elm of circuitJson) {
       const type = elm.type;
       const idVal = elm[`${type}_id`];
-      if (!idVal)
-        continue;
+      if (!idVal) continue;
       const idNum = Number.parseInt(idVal.split("_").pop());
       if (!Number.isNaN(idNum)) {
         internalStore.counts[type] = Math.max(
@@ -11504,12 +11574,23 @@ var su = (soup, options = {}) => {
   const su2 = new Proxy(
     {},
     {
-      get: (proxy_target, component_type) => {
-        if (component_type === "toArray") {
-          return () => soup;
+      get: (proxy_target, prop) => {
+        if (prop === "toArray") {
+          return () => {
+            ;
+            circuitJson.editCount = internalStore.editCount;
+            return circuitJson;
+          };
+        }
+        if (prop === "editCount") {
+          return internalStore.editCount;
         }
+        if (prop === "subtree") {
+          return (opts) => cju(buildSubtree(circuitJson, opts), options);
+        }
+        const component_type = prop;
         return {
-          get: (id) => soup.find(
+          get: (id) => circuitJson.find(
             (e) => e.type === component_type && e[`${component_type}_id`] === id
           ),
           getUsing: (using) => {
@@ -11521,24 +11602,23 @@ var su = (soup, options = {}) => {
             }
             const join_key = keys[0];
             const join_type = join_key.replace("_id", "");
-            const joiner = soup.find(
+            const joiner = circuitJson.find(
               (e) => e.type === join_type && e[join_key] === using[join_key]
             );
-            if (!joiner)
-              return null;
-            return soup.find(
+            if (!joiner) return null;
+            return circuitJson.find(
               (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
             );
           },
           getWhere: (where) => {
             const keys = Object.keys(where);
-            return soup.find(
+            return circuitJson.find(
               (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
             );
           },
           list: (where) => {
             const keys = !where ? [] : Object.keys(where);
-            return soup.filter(
+            return circuitJson.filter(
               (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
             );
           },
@@ -11555,64 +11635,581 @@ var su = (soup, options = {}) => {
               const parser = dist_exports[component_type] ?? any_soup_element;
               parser.parse(newElm);
             }
-            soup.push(newElm);
+            circuitJson.push(newElm);
+            internalStore.editCount++;
             return newElm;
           },
           delete: (id) => {
-            const elm = soup.find(
+            const elm = circuitJson.find(
               (e) => e[`${component_type}_id`] === id
             );
-            if (!elm)
-              return;
-            soup.splice(soup.indexOf(elm), 1);
+            if (!elm) return;
+            circuitJson.splice(circuitJson.indexOf(elm), 1);
+            internalStore.editCount++;
           },
           update: (id, newProps) => {
-            const elm = soup.find(
+            const elm = circuitJson.find(
               (e) => e.type === component_type && e[`${component_type}_id`] === id
             );
-            if (!elm)
-              return;
+            if (!elm) return null;
             Object.assign(elm, newProps);
+            internalStore.editCount++;
             return elm;
           },
           select: (selector) => {
             if (component_type === "source_component") {
-              return soup.find(
+              return circuitJson.find(
                 (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
               );
+            } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
+              const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
+              const source_component = circuitJson.find(
+                (e) => e.type === "source_component" && e.name === component_name
+              );
+              if (!source_component) return null;
+              const source_port2 = circuitJson.find(
+                (e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector))
+              );
+              if (!source_port2) return null;
+              if (component_type === "source_port") return source_port2;
+              if (component_type === "pcb_port") {
+                return circuitJson.find(
+                  (e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id
+                );
+              } else if (component_type === "schematic_port") {
+                return circuitJson.find(
+                  (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
+                );
+              }
+            }
+          }
+        };
+      }
+    }
+  );
+  return su2;
+};
+cju.unparsed = cju;
+var su = cju;
+function createIdKey(element) {
+  const type = element.type;
+  return `${type}:${element[`${type}_id`]}`;
+}
+var cjuIndexed = (soup, options = {}) => {
+  let internalStore = soup._internal_store_indexed;
+  if (!internalStore) {
+    internalStore = {
+      counts: {},
+      editCount: 0,
+      indexes: {}
+    };
+    for (const elm of soup) {
+      const type = elm.type;
+      const idVal = elm[`${type}_id`];
+      if (!idVal) continue;
+      const idNum = Number.parseInt(idVal.split("_").pop() || "");
+      if (!Number.isNaN(idNum)) {
+        internalStore.counts[type] = Math.max(
+          internalStore.counts[type] ?? 0,
+          idNum
+        );
+      }
+    }
+    const indexConfig = options.indexConfig || {};
+    const indexes = internalStore.indexes;
+    if (indexConfig.byId) {
+      indexes.byId = /* @__PURE__ */ new Map();
+    }
+    if (indexConfig.byType) {
+      indexes.byType = /* @__PURE__ */ new Map();
+    }
+    if (indexConfig.byRelation) {
+      indexes.byRelation = /* @__PURE__ */ new Map();
+    }
+    if (indexConfig.bySubcircuit) {
+      indexes.bySubcircuit = /* @__PURE__ */ new Map();
+    }
+    if (indexConfig.byCustomField && indexConfig.byCustomField.length > 0) {
+      indexes.byCustomField = /* @__PURE__ */ new Map();
+      for (const field of indexConfig.byCustomField) {
+        indexes.byCustomField.set(field, /* @__PURE__ */ new Map());
+      }
+    }
+    for (const element of soup) {
+      if (indexConfig.byId) {
+        const idKey = createIdKey(element);
+        indexes.byId.set(idKey, element);
+      }
+      if (indexConfig.byType) {
+        const elementsOfType = indexes.byType.get(element.type) || [];
+        elementsOfType.push(element);
+        indexes.byType.set(element.type, elementsOfType);
+      }
+      if (indexConfig.byRelation) {
+        const elementEntries = Object.entries(element);
+        for (const [key, value] of elementEntries) {
+          if (key.endsWith("_id") && key !== `${element.type}_id` && typeof value === "string") {
+            const relationTypeMap = indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
+            const relatedElements = relationTypeMap.get(value) || [];
+            relatedElements.push(element);
+            relationTypeMap.set(value, relatedElements);
+            indexes.byRelation.set(key, relationTypeMap);
+          }
+        }
+      }
+      if (indexConfig.bySubcircuit && "subcircuit_id" in element) {
+        const subcircuitId = element.subcircuit_id;
+        if (subcircuitId && typeof subcircuitId === "string") {
+          const subcircuitElements = indexes.bySubcircuit.get(subcircuitId) || [];
+          subcircuitElements.push(element);
+          indexes.bySubcircuit.set(subcircuitId, subcircuitElements);
+        }
+      }
+      if (indexConfig.byCustomField && indexes.byCustomField) {
+        for (const field of indexConfig.byCustomField) {
+          if (field in element) {
+            const fieldValue = element[field];
+            if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
+              const fieldValueStr = String(fieldValue);
+              const fieldMap = indexes.byCustomField.get(field);
+              const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
+              elementsWithFieldValue.push(element);
+              fieldMap.set(fieldValueStr, elementsWithFieldValue);
+            }
+          }
+        }
+      }
+    }
+    ;
+    soup._internal_store_indexed = internalStore;
+  }
+  const suIndexed = new Proxy(
+    {},
+    {
+      get: (proxy_target, prop) => {
+        if (prop === "toArray") {
+          return () => {
+            ;
+            soup.editCount = internalStore.editCount;
+            return soup;
+          };
+        }
+        if (prop === "editCount") {
+          return internalStore.editCount;
+        }
+        const component_type = prop;
+        return {
+          get: (id) => {
+            const indexConfig = options.indexConfig || {};
+            if (indexConfig.byId && internalStore.indexes.byId) {
+              return internalStore.indexes.byId.get(
+                `${component_type}:${id}`
+              ) || null;
+            }
+            if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              return elementsOfType.find(
+                (e) => e[`${component_type}_id`] === id
+              ) || null;
+            }
+            return soup.find(
+              (e) => e.type === component_type && e[`${component_type}_id`] === id
+            ) || null;
+          },
+          getUsing: (using) => {
+            const indexConfig = options.indexConfig || {};
+            const keys = Object.keys(using);
+            if (keys.length !== 1) {
+              throw new Error(
+                "getUsing requires exactly one key, e.g. { pcb_component_id }"
+              );
+            }
+            const join_key = keys[0];
+            const join_type = join_key.replace("_id", "");
+            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
+              const relationMap = internalStore.indexes.byRelation.get(join_key);
+              if (relationMap) {
+                const relatedElements = relationMap.get(using[join_key]) || [];
+                const joiner2 = relatedElements.find((e) => e.type === join_type);
+                if (!joiner2) return null;
+                const joinerId = joiner2[`${component_type}_id`];
+                if (indexConfig.byId && internalStore.indexes.byId) {
+                  return internalStore.indexes.byId.get(
+                    `${component_type}:${joinerId}`
+                  ) || null;
+                }
+                if (indexConfig.byType && internalStore.indexes.byType) {
+                  const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+                  return elementsOfType.find(
+                    (e) => e[`${component_type}_id`] === joinerId
+                  ) || null;
+                }
+                return soup.find(
+                  (e) => e.type === component_type && e[`${component_type}_id`] === joinerId
+                ) || null;
+              }
+            }
+            const joiner = soup.find(
+              (e) => e.type === join_type && e[join_key] === using[join_key]
+            );
+            if (!joiner) return null;
+            return soup.find(
+              (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
+            ) || null;
+          },
+          getWhere: (where) => {
+            const indexConfig = options.indexConfig || {};
+            const keys = Object.keys(where);
+            if (keys.length === 1 && indexConfig.byCustomField && internalStore.indexes.byCustomField) {
+              const field = keys[0];
+              const fieldMap = internalStore.indexes.byCustomField.get(field);
+              if (fieldMap) {
+                const fieldValue = String(where[field]);
+                const elementsWithFieldValue = fieldMap.get(fieldValue) || [];
+                return elementsWithFieldValue.find(
+                  (e) => e.type === component_type
+                ) || null;
+              }
+            }
+            if ("subcircuit_id" in where && indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit) {
+              const subcircuitId = where.subcircuit_id;
+              const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
+              return subcircuitElements.find(
+                (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+              ) || null;
+            }
+            if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              return elementsOfType.find(
+                (e) => keys.every((key) => e[key] === where[key])
+              ) || null;
+            }
+            return soup.find(
+              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+            ) || null;
+          },
+          list: (where) => {
+            const indexConfig = options.indexConfig || {};
+            const keys = !where ? [] : Object.keys(where);
+            if (keys.length === 0 && indexConfig.byType && internalStore.indexes.byType) {
+              return internalStore.indexes.byType.get(component_type) || [];
+            }
+            if (keys.length === 1 && keys[0] === "subcircuit_id" && indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit) {
+              const subcircuitId = where.subcircuit_id;
+              const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
+              return subcircuitElements.filter(
+                (e) => e.type === component_type
+              );
+            }
+            let elementsToFilter;
+            if (indexConfig.byType && internalStore.indexes.byType) {
+              elementsToFilter = internalStore.indexes.byType.get(component_type) || [];
+            } else {
+              elementsToFilter = soup.filter((e) => e.type === component_type);
+            }
+            if (keys.length > 0) {
+              return elementsToFilter.filter(
+                (e) => keys.every((key) => e[key] === where[key])
+              );
+            }
+            return elementsToFilter;
+          },
+          insert: (elm) => {
+            internalStore.counts[component_type] ??= -1;
+            internalStore.counts[component_type]++;
+            const index = internalStore.counts[component_type];
+            const newElm = {
+              type: component_type,
+              [`${component_type}_id`]: `${component_type}_${index}`,
+              ...elm
+            };
+            if (options.validateInserts) {
+              const parser = dist_exports[component_type] ?? any_soup_element;
+              parser.parse(newElm);
+            }
+            soup.push(newElm);
+            internalStore.editCount++;
+            const indexConfig = options.indexConfig || {};
+            if (indexConfig.byId && internalStore.indexes.byId) {
+              const idKey = createIdKey(newElm);
+              internalStore.indexes.byId.set(idKey, newElm);
+            }
+            if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              elementsOfType.push(newElm);
+              internalStore.indexes.byType.set(component_type, elementsOfType);
+            }
+            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
+              const elementEntries = Object.entries(newElm);
+              for (const [key, value] of elementEntries) {
+                if (key.endsWith("_id") && key !== `${newElm.type}_id` && typeof value === "string") {
+                  const relationTypeMap = internalStore.indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
+                  const relatedElements = relationTypeMap.get(value) || [];
+                  relatedElements.push(newElm);
+                  relationTypeMap.set(value, relatedElements);
+                  internalStore.indexes.byRelation.set(key, relationTypeMap);
+                }
+              }
+            }
+            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in newElm) {
+              const subcircuitId = newElm.subcircuit_id;
+              if (subcircuitId && typeof subcircuitId === "string") {
+                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
+                subcircuitElements.push(newElm);
+                internalStore.indexes.bySubcircuit.set(
+                  subcircuitId,
+                  subcircuitElements
+                );
+              }
+            }
+            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
+              for (const field of indexConfig.byCustomField) {
+                if (field in newElm) {
+                  const fieldValue = newElm[field];
+                  if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
+                    const fieldValueStr = String(fieldValue);
+                    const fieldMap = internalStore.indexes.byCustomField.get(field);
+                    const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
+                    elementsWithFieldValue.push(newElm);
+                    fieldMap.set(fieldValueStr, elementsWithFieldValue);
+                  }
+                }
+              }
+            }
+            return newElm;
+          },
+          delete: (id) => {
+            const indexConfig = options.indexConfig || {};
+            let elm;
+            if (indexConfig.byId && internalStore.indexes.byId) {
+              elm = internalStore.indexes.byId.get(`${component_type}:${id}`);
+            } else if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              elm = elementsOfType.find(
+                (e) => e[`${component_type}_id`] === id
+              );
+            } else {
+              elm = soup.find((e) => e[`${component_type}_id`] === id);
+            }
+            if (!elm) return;
+            const elmIndex = soup.indexOf(elm);
+            if (elmIndex >= 0) {
+              soup.splice(elmIndex, 1);
+              internalStore.editCount++;
+            }
+            if (indexConfig.byId && internalStore.indexes.byId) {
+              const idKey = createIdKey(elm);
+              internalStore.indexes.byId.delete(idKey);
+            }
+            if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              const filteredElements = elementsOfType.filter(
+                (e) => e[`${component_type}_id`] !== id
+              );
+              internalStore.indexes.byType.set(component_type, filteredElements);
+            }
+            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
+              for (const [
+                relationKey,
+                relationMap
+              ] of internalStore.indexes.byRelation.entries()) {
+                for (const [relationValue, elements] of relationMap.entries()) {
+                  const updatedElements = elements.filter((e) => e !== elm);
+                  if (updatedElements.length === 0) {
+                    relationMap.delete(relationValue);
+                  } else {
+                    relationMap.set(relationValue, updatedElements);
+                  }
+                }
+              }
+            }
+            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm) {
+              const subcircuitId = elm.subcircuit_id;
+              if (subcircuitId) {
+                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
+                const updatedElements = subcircuitElements.filter(
+                  (e) => e !== elm
+                );
+                if (updatedElements.length === 0) {
+                  internalStore.indexes.bySubcircuit.delete(subcircuitId);
+                } else {
+                  internalStore.indexes.bySubcircuit.set(
+                    subcircuitId,
+                    updatedElements
+                  );
+                }
+              }
+            }
+            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
+              for (const fieldMap of internalStore.indexes.byCustomField.values()) {
+                for (const [fieldValue, elements] of fieldMap.entries()) {
+                  const updatedElements = elements.filter((e) => e !== elm);
+                  if (updatedElements.length === 0) {
+                    fieldMap.delete(fieldValue);
+                  } else {
+                    fieldMap.set(fieldValue, updatedElements);
+                  }
+                }
+              }
+            }
+          },
+          update: (id, newProps) => {
+            const indexConfig = options.indexConfig || {};
+            let elm;
+            if (indexConfig.byId && internalStore.indexes.byId) {
+              elm = internalStore.indexes.byId.get(`${component_type}:${id}`);
+            } else if (indexConfig.byType && internalStore.indexes.byType) {
+              const elementsOfType = internalStore.indexes.byType.get(component_type) || [];
+              elm = elementsOfType.find(
+                (e) => e[`${component_type}_id`] === id
+              );
+            } else {
+              elm = soup.find(
+                (e) => e.type === component_type && e[`${component_type}_id`] === id
+              );
+            }
+            if (!elm) return null;
+            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
+              const elementEntries = Object.entries(elm);
+              for (const [key, value] of elementEntries) {
+                if (key.endsWith("_id") && key !== `${elm.type}_id` && typeof value === "string") {
+                  if (key in newProps && newProps[key] !== value) {
+                    const relationTypeMap = internalStore.indexes.byRelation.get(key);
+                    if (relationTypeMap) {
+                      const relatedElements = relationTypeMap.get(value) || [];
+                      const updatedElements = relatedElements.filter(
+                        (e) => e !== elm
+                      );
+                      if (updatedElements.length === 0) {
+                        relationTypeMap.delete(value);
+                      } else {
+                        relationTypeMap.set(value, updatedElements);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm && "subcircuit_id" in newProps) {
+              const oldSubcircuitId = elm.subcircuit_id;
+              const newSubcircuitId = newProps.subcircuit_id;
+              if (oldSubcircuitId !== newSubcircuitId) {
+                const subcircuitElements = internalStore.indexes.bySubcircuit.get(oldSubcircuitId) || [];
+                const updatedElements = subcircuitElements.filter(
+                  (e) => e !== elm
+                );
+                if (updatedElements.length === 0) {
+                  internalStore.indexes.bySubcircuit.delete(oldSubcircuitId);
+                } else {
+                  internalStore.indexes.bySubcircuit.set(
+                    oldSubcircuitId,
+                    updatedElements
+                  );
+                }
+              }
+            }
+            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
+              for (const field of indexConfig.byCustomField) {
+                if (field in elm && field in newProps && elm[field] !== newProps[field]) {
+                  const fieldMap = internalStore.indexes.byCustomField.get(field);
+                  if (fieldMap) {
+                    const oldValue = String(elm[field]);
+                    const elements = fieldMap.get(oldValue) || [];
+                    const updatedElements = elements.filter((e) => e !== elm);
+                    if (updatedElements.length === 0) {
+                      fieldMap.delete(oldValue);
+                    } else {
+                      fieldMap.set(oldValue, updatedElements);
+                    }
+                  }
+                }
+              }
+            }
+            Object.assign(elm, newProps);
+            internalStore.editCount++;
+            if (indexConfig.byRelation && internalStore.indexes.byRelation) {
+              const elementEntries = Object.entries(elm);
+              for (const [key, value] of elementEntries) {
+                if (key.endsWith("_id") && key !== `${elm.type}_id` && typeof value === "string") {
+                  if (key in newProps) {
+                    const relationTypeMap = internalStore.indexes.byRelation.get(key) || /* @__PURE__ */ new Map();
+                    const relatedElements = relationTypeMap.get(value) || [];
+                    if (!relatedElements.includes(elm)) {
+                      relatedElements.push(elm);
+                      relationTypeMap.set(value, relatedElements);
+                      internalStore.indexes.byRelation.set(key, relationTypeMap);
+                    }
+                  }
+                }
+              }
+            }
+            if (indexConfig.bySubcircuit && internalStore.indexes.bySubcircuit && "subcircuit_id" in elm && "subcircuit_id" in newProps) {
+              const subcircuitId = elm.subcircuit_id;
+              if (subcircuitId && typeof subcircuitId === "string") {
+                const subcircuitElements = internalStore.indexes.bySubcircuit.get(subcircuitId) || [];
+                if (!subcircuitElements.includes(elm)) {
+                  subcircuitElements.push(elm);
+                  internalStore.indexes.bySubcircuit.set(
+                    subcircuitId,
+                    subcircuitElements
+                  );
+                }
+              }
+            }
+            if (indexConfig.byCustomField && internalStore.indexes.byCustomField) {
+              for (const field of indexConfig.byCustomField) {
+                if (field in elm && field in newProps) {
+                  const fieldValue = elm[field];
+                  if (fieldValue !== void 0 && (typeof fieldValue === "string" || typeof fieldValue === "number")) {
+                    const fieldValueStr = String(fieldValue);
+                    const fieldMap = internalStore.indexes.byCustomField.get(field);
+                    const elementsWithFieldValue = fieldMap.get(fieldValueStr) || [];
+                    if (!elementsWithFieldValue.includes(elm)) {
+                      elementsWithFieldValue.push(elm);
+                      fieldMap.set(fieldValueStr, elementsWithFieldValue);
+                    }
+                  }
+                }
+              }
+            }
+            return elm;
+          },
+          select: (selector) => {
+            if (component_type === "source_component") {
+              return soup.find(
+                (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
+              ) || null;
             } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
               const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
               const source_component = soup.find(
                 (e) => e.type === "source_component" && e.name === component_name
               );
-              if (!source_component)
-                return null;
+              if (!source_component) return null;
               const source_port2 = soup.find(
                 (e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector))
               );
-              if (!source_port2)
-                return null;
+              if (!source_port2) return null;
               if (component_type === "source_port")
                 return source_port2;
               if (component_type === "pcb_port") {
                 return soup.find(
                   (e) => e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id
-                );
+                ) || null;
               } else if (component_type === "schematic_port") {
                 return soup.find(
                   (e) => e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id
-                );
+                ) || null;
               }
             }
+            return null;
           }
         };
       }
     }
   );
-  return su2;
+  return suIndexed;
 };
-su.unparsed = su;
-var su_default = su;
+cjuIndexed.unparsed = cjuIndexed;
 var getElementId = (elm) => {
   const type = elm.type;
   const id = elm[`${type}_id`];
@@ -11624,24 +12221,45 @@ var getBoundsOfPcbElements = (elements) => {
   let maxX = Number.NEGATIVE_INFINITY;
   let maxY = Number.NEGATIVE_INFINITY;
   for (const elm of elements) {
-    if (!elm.type.startsWith("pcb_"))
-      continue;
+    if (!elm.type.startsWith("pcb_")) continue;
+    let centerX;
+    let centerY;
+    let width;
+    let height;
     if ("x" in elm && "y" in elm) {
-      minX = Math.min(minX, elm.x);
-      minY = Math.min(minY, elm.y);
-      maxX = Math.max(maxX, elm.x);
-      maxY = Math.max(maxY, elm.y);
-      if ("width" in elm) {
-        maxX = Math.max(maxX, elm.x + elm.width);
-      }
-      if ("height" in elm) {
-        maxY = Math.max(maxY, elm.y + elm.height);
+      centerX = Number(elm.x);
+      centerY = Number(elm.y);
+    }
+    if ("outer_diameter" in elm) {
+      width = Number(elm.outer_diameter);
+      height = Number(elm.outer_diameter);
+    }
+    if ("width" in elm) {
+      width = Number(elm.width);
+    }
+    if ("height" in elm) {
+      height = Number(elm.height);
+    }
+    if ("center" in elm) {
+      centerX = elm.center.x;
+      centerY = elm.center.y;
+    }
+    if (centerX !== void 0 && centerY !== void 0) {
+      minX = Math.min(minX, centerX);
+      minY = Math.min(minY, centerY);
+      maxX = Math.max(maxX, centerX);
+      maxY = Math.max(maxY, centerY);
+      if (width !== void 0 && height !== void 0) {
+        minX = Math.min(minX, centerX - width / 2);
+        minY = Math.min(minY, centerY - height / 2);
+        maxX = Math.max(maxX, centerX + width / 2);
+        maxY = Math.max(maxY, centerY + height / 2);
       }
       if ("radius" in elm) {
-        minX = Math.min(minX, elm.x - elm.radius);
-        minY = Math.min(minY, elm.y - elm.radius);
-        maxX = Math.max(maxX, elm.x + elm.radius);
-        maxY = Math.max(maxY, elm.y + elm.radius);
+        minX = Math.min(minX, centerX - elm.radius);
+        minY = Math.min(minY, centerY - elm.radius);
+        maxX = Math.max(maxX, centerX + elm.radius);
+        maxY = Math.max(maxY, centerY + elm.radius);
       }
     } else if (elm.type === "pcb_trace") {
       for (const point2 of elm.route) {
@@ -11656,8 +12274,7 @@ var getBoundsOfPcbElements = (elements) => {
 };
 function stringHash(str) {
   let hash = 0;
-  if (str.length == 0)
-    return hash;
+  if (str.length == 0) return hash;
   for (var i = 0; i < str.length; i++) {
     var char = str.charCodeAt(i);
     hash = (hash << 5) - hash + char;
@@ -11785,10 +12402,21 @@ var getDebugLayoutObject = (lo) => {
     width = Math.abs(lo.x1 - lo.x2);
     height = Math.abs(lo.y1 - lo.y2);
   }
+  if (lo.points && Array.isArray(lo.points) && lo.points.length > 0) {
+    const xCoords = lo.points.map((point2) => point2.x);
+    const yCoords = lo.points.map((point2) => point2.y);
+    const minX = Math.min(...xCoords);
+    const maxX = Math.max(...xCoords);
+    const minY = Math.min(...yCoords);
+    const maxY = Math.max(...yCoords);
+    x = (minX + maxX) / 2;
+    y = (minY + maxY) / 2;
+    width = maxX - minX;
+    height = maxY - minY;
+  }
   const title = lo.text || lo.name || lo.source?.text || lo.source?.name || "?";
   const content = lo;
-  if (x === void 0 || y === void 0)
-    return null;
+  if (x === void 0 || y === void 0) return null;
   if (width === void 0) {
     if ("outer_diameter" in lo) {
       width = lo.outer_diameter;
@@ -11811,8 +12439,12 @@ var getDebugLayoutObject = (lo) => {
 };
 var isTruthy = (value) => Boolean(value);
 var findBoundsAndCenter = (elements) => {
-  const debugObjects = elements.filter((elm) => elm.type.startsWith("pcb_")).concat(
-    elements.filter((elm) => elm.type === "pcb_trace").flatMap((elm) => elm.route)
+  const debugObjects = elements.filter(
+    (elm) => elm.type.startsWith("pcb_") || elm.type.startsWith("schematic_")
+  ).concat(
+    elements.filter(
+      (elm) => elm.type === "pcb_trace" || elm.type === "schematic_trace"
+    ).flatMap((elm) => elm.route)
   ).map((elm) => getDebugLayoutObject(elm)).filter(isTruthy);
   if (debugObjects.length === 0)
     return { center: { x: 0, y: 0 }, width: 0, height: 0 };
@@ -12006,10 +12638,10 @@ var useMeasure_default = isBrowser && typeof window.ResizeObserver !== "undefine
 };
 
 // src/PCBViewer.tsx
-import { compose as compose7, scale as scale5, translate as translate7 } from "transformation-matrix";
+import { compose as compose7, scale as scale5, translate as translate11 } from "transformation-matrix";
 
 // node_modules/use-mouse-matrix-transform/dist/chunk-TGYMZPTI.js
-import { compose, translate, scale } from "transformation-matrix";
+import { compose, translate as translate5, scale } from "transformation-matrix";
 var computePinchTransform = ({
   initialTransform,
   initialTouch1,
@@ -12040,10 +12672,10 @@ var computePinchTransform = ({
   const deltaX = currentCenter.x - initialCenter.x;
   const deltaY = currentCenter.y - initialCenter.y;
   const pinchTransform = compose(
-    translate(deltaX, deltaY),
-    translate(initialCenter.x, initialCenter.y),
+    translate5(deltaX, deltaY),
+    translate5(initialCenter.x, initialCenter.y),
     scale(s, s),
-    translate(-initialCenter.x, -initialCenter.y),
+    translate5(-initialCenter.x, -initialCenter.y),
     initialTransform
   );
   return pinchTransform;
@@ -12052,7 +12684,7 @@ var computePinchTransform = ({
 // node_modules/use-mouse-matrix-transform/dist/chunk-24EXXVA4.js
 import {
   identity,
-  translate as translate2,
+  translate as translate6,
   compose as compose2,
   applyToPoint as applyToPoint2,
   scale as scale2
@@ -12129,7 +12761,7 @@ var useMouseMatrixTransform = (props = {}) => {
       if (props.shouldDrag && !props.shouldDrag(e))
         return;
       m1 = getMousePos(e);
-      const new_tf = compose2(translate2(m1.x - m0.x, m1.y - m0.y), init_tf);
+      const new_tf = compose2(translate6(m1.x - m0.x, m1.y - m0.y), init_tf);
       setTransform(new_tf);
       init_tf = new_tf;
       md = false;
@@ -12141,7 +12773,7 @@ var useMouseMatrixTransform = (props = {}) => {
       if (props.shouldDrag && !props.shouldDrag(e))
         return;
       m1 = getMousePos(e);
-      const new_tf = compose2(translate2(m1.x - m0.x, m1.y - m0.y), init_tf);
+      const new_tf = compose2(translate6(m1.x - m0.x, m1.y - m0.y), init_tf);
       setTransform(new_tf);
     }
     function handleMouseWheel(e) {
@@ -12151,9 +12783,9 @@ var useMouseMatrixTransform = (props = {}) => {
         return;
       const center = getMousePos(e);
       const new_tf = compose2(
-        translate2(center.x, center.y),
+        translate6(center.x, center.y),
         scale2(1 - e.deltaY / 1e3, 1 - e.deltaY / 1e3),
-        translate2(-center.x, -center.y),
+        translate6(-center.x, -center.y),
         init_tf
       );
       setTransform(new_tf);
@@ -12173,7 +12805,7 @@ var useMouseMatrixTransform = (props = {}) => {
       }
       md = false;
       m1 = getMousePos(e);
-      const new_tf = compose2(translate2(m1.x - m0.x, m1.y - m0.y), init_tf);
+      const new_tf = compose2(translate6(m1.x - m0.x, m1.y - m0.y), init_tf);
       setTransform(new_tf);
       init_tf = new_tf;
     }
@@ -12211,7 +12843,7 @@ var useMouseMatrixTransform = (props = {}) => {
         const deltaX = currentTouch.x - dragDataRef.current.initialTouch.x;
         const deltaY = currentTouch.y - dragDataRef.current.initialTouch.y;
         const new_tf = compose2(
-          translate2(deltaX, deltaY),
+          translate6(deltaX, deltaY),
           dragDataRef.current.initialTransform
         );
         setTransform(new_tf);
@@ -12238,7 +12870,7 @@ var useMouseMatrixTransform = (props = {}) => {
         const deltaX = finalTouchPos.x - dragDataRef.current.initialTouch.x;
         const deltaY = finalTouchPos.y - dragDataRef.current.initialTouch.y;
         const new_tf = compose2(
-          translate2(deltaX, deltaY),
+          translate6(deltaX, deltaY),
           dragDataRef.current.initialTransform
         );
         setTransform(new_tf);
@@ -12596,7 +13228,7 @@ var convertElementToPrimitives = (element, allElements) => {
   const _parent_source_component = _parent_pcb_component && "source_component_id" in _parent_pcb_component ? allElements.find(
     (elm) => elm.type === "source_component" && elm.source_component_id === _parent_pcb_component.source_component_id
   ) : void 0;
-  const _source_port_id = "source_port_id" in element ? element.source_port_id : "pcb_port_id" in element ? su_default(allElements).pcb_port.get(element.pcb_port_id)?.source_port_id : void 0;
+  const _source_port_id = "source_port_id" in element ? element.source_port_id : "pcb_port_id" in element ? su(allElements).pcb_port.get(element.pcb_port_id)?.source_port_id : void 0;
   const _source_port = _source_port_id ? allElements.find(
     (e) => e.type === "source_port" && e.source_port_id === _source_port_id
   ) : void 0;
@@ -13242,31 +13874,47 @@ var convertElementToPrimitives = (element, allElements) => {
       const pour = element;
       switch (pour.shape) {
         case "rect": {
+          const { center, width, height, layer, rotation: rotation2 } = pour;
           return [
             {
               _pcb_drawing_object_id: getNewPcbDrawingObjectId(
                 "pcb_copper_pour_rect"
               ),
               pcb_drawing_type: "rect",
-              x: pour.center.x,
-              y: pour.center.y,
-              w: pour.width,
-              h: pour.height,
-              layer: pour.layer,
+              x: center.x,
+              y: center.y,
+              w: width,
+              h: height,
+              layer,
               _element: element,
-              ccw_rotation: pour.rotation
+              ccw_rotation: rotation2
             }
           ];
         }
         case "polygon": {
+          const { points, layer } = pour;
           return [
             {
               _pcb_drawing_object_id: getNewPcbDrawingObjectId(
                 "pcb_copper_pour_polygon"
               ),
               pcb_drawing_type: "polygon",
-              points: pour.points,
-              layer: pour.layer,
+              points,
+              layer,
+              _element: element
+            }
+          ];
+        }
+        case "brep": {
+          const { brep_shape: brep_shape2, layer } = pour;
+          return [
+            {
+              _pcb_drawing_object_id: getNewPcbDrawingObjectId(
+                "pcb_copper_pour_brep"
+              ),
+              pcb_drawing_type: "polygon_with_arcs",
+              brep_shape: brep_shape2,
+              layer,
               _element: element
             }
           ];
@@ -13354,7 +14002,7 @@ import {
   compose as compose3,
   identity as identity2,
   inverse,
-  translate as translate3
+  translate as translate7
 } from "transformation-matrix";
 
 // src/lib/colors.ts
@@ -13671,7 +14319,7 @@ var Drawer = class {
     );
     this.transform = identity2();
     this.transform.d *= -1;
-    this.transform = compose3(this.transform, translate3(0, -500));
+    this.transform = compose3(this.transform, translate7(0, -500));
     this.lastPoint = { x: 0, y: 0 };
     this.equip({});
   }
@@ -13912,7 +14560,7 @@ var Drawer = class {
       ctx.lineTo(transformedPoints[i][0], transformedPoints[i][1]);
     }
     ctx.closePath();
-    ctx.fill();
+    ctx.fill("evenodd");
     const lineWidth = scaleOnly(this.transform, this.aperture.size);
     ctx.lineWidth = lineWidth;
     ctx.stroke();
@@ -13976,6 +14624,7 @@ var Drawer = class {
     ctx.lineWidth = scaleOnly(transform, size2);
     ctx.lineCap = "round";
     if (mode === "add") {
+      ctx.globalCompositeOperation = "source-over";
       let colorString = color2?.[0] === "#" || color2?.startsWith("rgb") ? color2 : LAYER_NAME_TO_COLOR[color2?.toLowerCase()] ? LAYER_NAME_TO_COLOR[color2?.toLowerCase()] : null;
       if (colorString === null) {
         console.warn(`Color mapping for "${color2}" not found`);
@@ -14017,19 +14666,88 @@ var Drawer = class {
       ctx.fillRect(x$ - size$ / 2, y$ - size$ / 2, size$, size$);
     this.lastPoint = { x, y };
   }
+  polygonWithArcs(brep) {
+    const ctx = this.getLayerCtx();
+    const processRing = (ring2) => {
+      if (ring2.vertices.length === 0) return;
+      const startPoint = ring2.vertices[0];
+      const t_start_point = applyToPoint3(this.transform, [
+        startPoint.x,
+        startPoint.y
+      ]);
+      ctx.moveTo(t_start_point[0], t_start_point[1]);
+      for (let i = 0; i < ring2.vertices.length; i++) {
+        const p1 = ring2.vertices[i];
+        const p2 = ring2.vertices[(i + 1) % ring2.vertices.length];
+        if (p1.bulge && p1.bulge !== 0) {
+          const bulge = p1.bulge;
+          const dx = p2.x - p1.x;
+          const dy = p2.y - p1.y;
+          const chord = Math.sqrt(dx * dx + dy * dy);
+          if (chord < 1e-9) {
+            const t_p2 = applyToPoint3(this.transform, [p2.x, p2.y]);
+            ctx.lineTo(t_p2[0], t_p2[1]);
+            continue;
+          }
+          const angle = 4 * Math.atan(bulge);
+          const radius = Math.abs(chord / (2 * Math.sin(angle / 2)));
+          const mx = (p1.x + p2.x) / 2;
+          const my = (p1.y + p2.y) / 2;
+          const norm_dx = dx / chord;
+          const norm_dy = dy / chord;
+          const perp_vx = -norm_dy;
+          const perp_vy = norm_dx;
+          const dist_to_center = Math.sqrt(
+            Math.max(0, radius * radius - (chord / 2) ** 2)
+          );
+          const cx = mx + dist_to_center * perp_vx * Math.sign(bulge);
+          const cy = my + dist_to_center * perp_vy * Math.sign(bulge);
+          const startAngle = Math.atan2(p1.y - cy, p1.x - cx);
+          let endAngle = Math.atan2(p2.y - cy, p2.x - cx);
+          if (bulge > 0 && endAngle < startAngle) {
+            endAngle += 2 * Math.PI;
+          } else if (bulge < 0 && endAngle > startAngle) {
+            endAngle -= 2 * Math.PI;
+          }
+          const t_center = applyToPoint3(this.transform, [cx, cy]);
+          const t_radius = scaleOnly(this.transform, radius);
+          ctx.arc(
+            t_center[0],
+            t_center[1],
+            t_radius,
+            -startAngle,
+            -endAngle,
+            bulge > 0
+          );
+        } else {
+          const t_p2 = applyToPoint3(this.transform, [p2.x, p2.y]);
+          ctx.lineTo(t_p2[0], t_p2[1]);
+        }
+      }
+      ctx.closePath();
+    };
+    ctx.beginPath();
+    processRing(brep.outer_ring);
+    if (brep.inner_rings) {
+      for (const inner_ring of brep.inner_rings) {
+        processRing(inner_ring);
+      }
+    }
+    ctx.fill("evenodd");
+  }
 };
 
 // src/lib/util/rotate-text.ts
-import { compose as compose4, translate as translate4, rotate, applyToPoint as applyToPoint4 } from "transformation-matrix";
+import { compose as compose4, translate as translate8, rotate, applyToPoint as applyToPoint4 } from "transformation-matrix";
 function rotateText(rotateTextParams) {
   const { lines, anchorPoint, ccwRotation } = rotateTextParams;
   if (!ccwRotation) return lines;
   const rad = ccwRotation * Math.PI / 180;
   const rotationMatrix = rotate(rad);
   const transform = compose4(
-    translate4(anchorPoint.x, anchorPoint.y),
+    translate8(anchorPoint.x, anchorPoint.y),
     rotationMatrix,
-    translate4(-anchorPoint.x, -anchorPoint.y)
+    translate8(-anchorPoint.x, -anchorPoint.y)
   );
   applyToPoint4(transform, anchorPoint);
   return lines.map((line) => ({
@@ -14334,17 +15052,25 @@ var drawPolygon = (drawer, polygon) => {
   });
   drawer.polygon(polygon.points);
 };
+var drawPolygonWithArcs = (drawer, p) => {
+  drawer.equip({
+    color: getColor(p),
+    layer: p.layer
+  });
+  drawer.polygonWithArcs(p.brep_shape);
+};
 var drawPrimitive = (drawer, primitive) => {
   switch (primitive.pcb_drawing_type) {
     case "line":
       return drawLine(drawer, primitive);
     case "text":
       return drawText(drawer, primitive);
-    case "rect":
+    case "rect": {
       if (primitive.ccw_rotation) {
         return drawRotatedRect(drawer, primitive);
       }
       return drawRect(drawer, primitive);
+    }
     case "circle":
       return drawCircle(drawer, primitive);
     case "oval":
@@ -14356,6 +15082,8 @@ var drawPrimitive = (drawer, primitive) => {
       return drawPill(drawer, primitive);
     case "polygon":
       return drawPolygon(drawer, primitive);
+    case "polygon_with_arcs":
+      return drawPolygonWithArcs(drawer, primitive);
   }
 };
 var drawPrimitives = (drawer, primitives) => {
@@ -14457,7 +15185,7 @@ var import_svgson = __toESM(require_svgson_umd(), 1);
 var import_pretty = __toESM(require_pretty(), 1);
 import {
   compose as compose5,
-  translate as translate5,
+  translate as translate9,
   scale as scale3,
   applyToPoint as applyToPoint5
 } from "transformation-matrix";
@@ -14466,7 +15194,7 @@ import {
 import {
   compose as compose6,
   scale as scale4,
-  translate as translate6,
+  translate as translate10,
   applyToPoint as applyToPoint6
 } from "transformation-matrix";
 var defaultColors = [
@@ -14530,9 +15258,9 @@ function computeTransformFromViewbox(viewbox, canvasWidth, canvasHeight, options
     (canvasHeight - 2 * padding) / height
   );
   return compose6(
-    translate6(canvasWidth / 2, canvasHeight / 2),
+    translate10(canvasWidth / 2, canvasHeight / 2),
     scale4(scale_factor, yFlip ? -scale_factor : scale_factor),
-    translate6(-(bounds.minX + width / 2), -(bounds.minY + height / 2))
+    translate10(-(bounds.minX + width / 2), -(bounds.minY + height / 2))
   );
 }
 function getBounds(graphics) {
@@ -15502,7 +16230,7 @@ var EditTraceHintOverlay = ({
                 toast.error(`pcb_port_id is null on the selected "${e2.type}"`);
                 return;
               }
-              const pcb_port2 = su_default(soup).pcb_port.get(e2.pcb_port_id);
+              const pcb_port2 = su(soup).pcb_port.get(e2.pcb_port_id);
               if (!pcb_port2) {
                 toast.error(
                   `Could not find associated pcb_port for "${e2.pcb_port_id}"`
@@ -15661,7 +16389,7 @@ var EditTraceHintOverlay = ({
             height: containerBounds?.height,
             children: soup.filter((e) => e.type === "pcb_trace_hint").map((e) => {
               const { route } = e;
-              const pcb_port2 = su_default(soup).pcb_port.get(e.pcb_port_id);
+              const pcb_port2 = su(soup).pcb_port.get(e.pcb_port_id);
               const pcb_port_screen = applyToPoint10(transform, pcb_port2);
               return /* @__PURE__ */ jsxs7(Fragment2, { children: [
                 /* @__PURE__ */ jsx9(
@@ -15926,7 +16654,7 @@ var ErrorOverlay = ({
       const { pcb_port_ids, pcb_trace_id } = el;
       const port1 = pcb_port_ids?.[0] ? portsMap.get(pcb_port_ids[0]) : void 0;
       const port2 = pcb_port_ids?.[1] ? portsMap.get(pcb_port_ids[1]) : void 0;
-      const trace = elements ? su_default(elements).pcb_trace.get(pcb_trace_id) : void 0;
+      const trace = elements ? su(elements).pcb_trace.get(pcb_trace_id) : void 0;
       const errorId = el.pcb_trace_error_id || `error_${index}_${el.error_type}_${el.message?.slice(0, 20)}`;
       const isHighlighted = hoveredErrorId === errorId;
       if (port1 && port2) {
@@ -16265,7 +16993,7 @@ function getTraceOverlayInfo({
   elements
 }) {
   let text = primitiveElement.trace_length ? `${primitiveElement.trace_length.toFixed(3)}` : "";
-  const trace = su_default(elements).source_trace.get(
+  const trace = su(elements).source_trace.get(
     primitiveElement?.source_trace_id
   );
   if (trace?.display_name) {
@@ -16881,7 +17609,7 @@ var RatsNestOverlay = ({ transform, soup, children }) => {
   const ratsNestLines = useMemo4(() => {
     if (!soup || !isShowingRatsNest) return [];
     const getElementPosition = (id) => {
-      const element = su_default(soup)[id.replace(/_\d+$/, "")].get(id);
+      const element = su(soup)[id.replace(/_\d+$/, "")].get(id);
       if (element && "x" in element && "y" in element) {
         return { x: element.x, y: element.y };
       }
@@ -16905,8 +17633,8 @@ var RatsNestOverlay = ({ transform, soup, children }) => {
       });
       return nearestPoint;
     };
-    const pcbPorts = su_default(soup).pcb_port.list();
-    const sourceTraces = su_default(soup).source_trace.list();
+    const pcbPorts = su(soup).pcb_port.list();
+    const sourceTraces = su(soup).source_trace.list();
     const lines = [];
     pcbPorts.forEach((port, index) => {
       const netId = idToNetMap[port.pcb_port_id];
@@ -16983,7 +17711,7 @@ import { css as css3 } from "@emotion/css";
 // package.json
 var package_default = {
   name: "@tscircuit/pcb-viewer",
-  version: "1.11.217",
+  version: "1.11.219",
   main: "dist/index.js",
   type: "module",
   repository: "tscircuit/pcb-viewer",
@@ -17007,8 +17735,9 @@ var package_default = {
     "@semantic-release/npm": "^9.0.1",
     "@semantic-release/release-notes-generator": "^10.0.3",
     "@swc/core": "^1.4.12",
+    "@tscircuit/circuit-json-util": "^0.0.67",
     "@tscircuit/eagle-xml-converter": "^1.0.0",
-    "@tscircuit/soup-util": "^0.0.41",
+    "@types/bun": "latest",
     "@types/color": "^3.0.6",
     "@types/node": "18.7.23",
     "@types/react": "19",
@@ -17024,8 +17753,7 @@ var package_default = {
     "type-fest": "^3.0.0",
     typescript: "^5.4.4",
     "use-mouse-matrix-transform": "^1.3.4",
-    zod: "^3.23.5",
-    "@types/bun": "latest"
+    zod: "^3.23.5"
   },
   peerDependencies: {
     react: "*",
@@ -17896,7 +18624,7 @@ var calculateCircuitJsonKey = (circuitJson) => {
 
 // src/PCBViewer.tsx
 import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
-var defaultTransform = compose7(translate7(400, 300), scale5(40, -40));
+var defaultTransform = compose7(translate11(400, 300), scale5(40, -40));
 var PCBViewer = ({
   circuitJson,
   debugGraphics,
@@ -17944,9 +18672,9 @@ var PCBViewer = ({
       100
     ) * 0.75;
     const targetTransform = compose7(
-      translate7((elmBounds.width ?? 0) / 2, (elmBounds.height ?? 0) / 2),
+      translate11((elmBounds.width ?? 0) / 2, (elmBounds.height ?? 0) / 2),
       scale5(scaleFactor, -scaleFactor, 0, 0),
-      translate7(-center.x, -center.y)
+      translate11(-center.x, -center.y)
     );
     setTransform(targetTransform);
     return;