@tscircuit/core 0.0.1072 → 0.0.1074

package/dist/index.d.ts

@@ -512,6 +512,11 @@ declare abstract class PrimitiveComponent<ZodProps extends ZodType = any> extend
     private _shouldAllowBoardVariablesByDefault;
     private _isInsideFootprint;
     private _isInsideNonBoardSubcircuit;
+    /**
+     * Check if this component has a user-defined PCB position.
+     * Position can be specified via pcbX/pcbY or edge-based props.
+     */
+    _hasUserDefinedPcbPosition(): boolean;
     resolvePcbCoordinate(rawValue: unknown, axis: "pcbX" | "pcbY", options?: {
         allowBoardVariables?: boolean;
         allowComponentVariables?: boolean;
@@ -6112,6 +6117,11 @@ declare class Subpanel extends Group<typeof subpanelProps> {
     add(component: PrimitiveComponent): void;
     _cachedGridWidth: number;
     _cachedGridHeight: number;
+    _panelPositionOffset: {
+        x: number;
+        y: number;
+    } | null;
+    _computePcbGlobalTransformBeforeLayout(): Matrix;
     /**
      * Get all board instances from this subpanel and nested subpanels
      */

package/dist/index.js

@@ -1285,6 +1285,14 @@ var PrimitiveComponent2 = class extends Renderable {
     }
     return false;
   }
+  /**
+   * Check if this component has a user-defined PCB position.
+   * Position can be specified via pcbX/pcbY or edge-based props.
+   */
+  _hasUserDefinedPcbPosition() {
+    const props = this._parsedProps;
+    return props.pcbX !== void 0 || props.pcbY !== void 0 || props.pcbLeftEdgeX !== void 0 || props.pcbRightEdgeX !== void 0 || props.pcbTopEdgeY !== void 0 || props.pcbBottomEdgeY !== void 0;
+  }
   resolvePcbCoordinate(rawValue, axis, options = {}) {
     return this._resolvePcbCoordinate(rawValue, axis, options);
   }
@@ -18094,7 +18102,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1071",
+  version: "0.0.1073",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -18127,8 +18135,8 @@ var package_default = {
     "@resvg/resvg-js": "^2.6.2",
     "@tscircuit/alphabet": "0.0.18",
     "@tscircuit/capacity-autorouter": "^0.0.299",
-    "@tscircuit/checks": "0.0.99",
-    "@tscircuit/circuit-json-util": "^0.0.80",
+    "@tscircuit/checks": "0.0.100",
+    "@tscircuit/circuit-json-util": "^0.0.81",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.20",
     "@tscircuit/footprinter": "^0.0.316",
@@ -19213,6 +19221,7 @@ import { distance as distance12 } from "circuit-json";
 // lib/components/normal-components/Subpanel.ts
 import { subpanelProps } from "@tscircuit/props";
 import { distance as distance11 } from "circuit-json";
+import { compose as compose8, identity as identity6, translate as translate8 } from "transformation-matrix";
 
 // lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
 import * as Flatten from "@flatten-js/core";
@@ -19423,7 +19432,7 @@ function generatePanelTabsAndMouseBites(boards, options) {
   };
 }
 
-// lib/utils/panels/pack-boards-into-grid.ts
+// lib/utils/panels/pack-into-grid.ts
 import { distance as distance10 } from "circuit-json";
 
 // lib/utils/panels/get-board-dimensions-from-props.ts
@@ -19455,52 +19464,9 @@ var getBoardDimensionsFromProps = (board) => {
   };
 };
 
-// lib/utils/panels/pack-boards-into-grid.ts
-function calculateOptimalGrid({
-  boardsWithDims,
-  availableWidth,
-  availableHeight,
-  boardGap,
-  minCellWidth,
-  minCellHeight
-}) {
-  const boardCount = boardsWithDims.length;
-  if (boardCount === 0) {
-    return { rows: 0, cols: 0 };
-  }
-  const maxBoardWidth = Math.max(
-    ...boardsWithDims.map((b) => b.width),
-    minCellWidth
-  );
-  const maxBoardHeight = Math.max(
-    ...boardsWithDims.map((b) => b.height),
-    minCellHeight
-  );
-  const maxCols = Math.max(
-    1,
-    Math.floor((availableWidth + boardGap) / (maxBoardWidth + boardGap))
-  );
-  const maxRows = Math.max(
-    1,
-    Math.floor((availableHeight + boardGap) / (maxBoardHeight + boardGap))
-  );
-  let bestCols = maxCols;
-  let bestRows = Math.ceil(boardCount / bestCols);
-  if (bestRows > maxRows) {
-    bestRows = maxRows;
-    bestCols = Math.ceil(boardCount / bestRows);
-    if (bestCols > maxCols) {
-      bestCols = maxCols;
-      bestRows = Math.ceil(boardCount / bestCols);
-    }
-  }
-  return {
-    rows: Math.max(1, bestRows),
-    cols: Math.max(1, bestCols)
-  };
-}
-var packBoardsIntoGrid = ({
-  boards,
+// lib/utils/panels/pack-into-grid.ts
+function packIntoGrid({
+  items,
   db,
   row,
   col,
@@ -19509,109 +19475,161 @@ var packBoardsIntoGrid = ({
   boardGap,
   availablePanelWidth,
   availablePanelHeight
-}) => {
-  const boardsWithDims = boards.map((board) => {
-    let width;
-    let height;
-    if (db && board.pcb_board_id) {
-      const pcbBoard = db.pcb_board.get(board.pcb_board_id);
-      if (pcbBoard?.width !== void 0 && pcbBoard?.height !== void 0) {
-        width = pcbBoard.width;
-        height = pcbBoard.height;
-      }
-    }
-    if (width === void 0 || height === void 0) {
-      const propsDims = getBoardDimensionsFromProps(board);
-      width = propsDims.width;
-      height = propsDims.height;
-    }
-    if (width === 0 && height === 0) {
-      return null;
-    }
-    return { board, width, height };
-  }).filter((b) => b !== null);
-  if (boardsWithDims.length === 0) {
-    return {
-      positions: [],
-      gridWidth: 0,
-      gridHeight: 0
-    };
+}) {
+  const itemsWithDims = items.map((item) => {
+    const dims = getItemDimensions(item, db);
+    return { item, width: dims.width, height: dims.height };
+  }).filter((item) => !(item.width === 0 && item.height === 0));
+  if (itemsWithDims.length === 0) {
+    return { positions: [], gridWidth: 0, gridHeight: 0 };
   }
-  const explicitRow = row;
-  const explicitCol = col;
   let cols;
   let rows;
-  if (explicitCol !== void 0) {
-    cols = explicitCol;
-    rows = explicitRow ?? Math.ceil(boardsWithDims.length / cols);
-  } else if (explicitRow !== void 0) {
-    rows = explicitRow;
-    cols = Math.ceil(boardsWithDims.length / rows);
+  const minCellWidth = cellWidth ? distance10.parse(cellWidth) : 0;
+  const minCellHeight = cellHeight ? distance10.parse(cellHeight) : 0;
+  if (col !== void 0) {
+    cols = col;
+    rows = row ?? Math.ceil(itemsWithDims.length / cols);
+  } else if (row !== void 0) {
+    rows = row;
+    cols = Math.ceil(itemsWithDims.length / rows);
   } else if (availablePanelWidth !== void 0 && availablePanelHeight !== void 0) {
-    const result = calculateOptimalGrid({
-      boardsWithDims,
-      availableWidth: availablePanelWidth,
-      availableHeight: availablePanelHeight,
-      boardGap,
-      minCellWidth: cellWidth ? distance10.parse(cellWidth) : 0,
-      minCellHeight: cellHeight ? distance10.parse(cellHeight) : 0
-    });
-    cols = result.cols;
-    rows = result.rows;
+    const maxItemWidth = Math.max(
+      ...itemsWithDims.map((b) => b.width),
+      minCellWidth
+    );
+    const maxItemHeight = Math.max(
+      ...itemsWithDims.map((b) => b.height),
+      minCellHeight
+    );
+    const maxCols = Math.max(
+      1,
+      Math.floor((availablePanelWidth + boardGap) / (maxItemWidth + boardGap))
+    );
+    const maxRows = Math.max(
+      1,
+      Math.floor(
+        (availablePanelHeight + boardGap) / (maxItemHeight + boardGap)
+      )
+    );
+    cols = maxCols;
+    rows = Math.ceil(itemsWithDims.length / cols);
+    if (rows > maxRows) {
+      rows = maxRows;
+      cols = Math.ceil(itemsWithDims.length / rows);
+      if (cols > maxCols) {
+        cols = maxCols;
+        rows = Math.ceil(itemsWithDims.length / cols);
+      }
+    }
+    cols = Math.max(1, cols);
+    rows = Math.max(1, rows);
   } else {
-    cols = Math.ceil(Math.sqrt(boardsWithDims.length));
-    rows = Math.ceil(boardsWithDims.length / cols);
+    cols = Math.ceil(Math.sqrt(itemsWithDims.length));
+    rows = Math.ceil(itemsWithDims.length / cols);
   }
   const colWidths = Array(cols).fill(0);
   const rowHeights = Array(rows).fill(0);
-  boardsWithDims.forEach((b, i) => {
+  itemsWithDims.forEach((item, i) => {
     const colIdx = i % cols;
     const rowIdx = Math.floor(i / cols);
-    if (rowIdx < rowHeights.length && b.height > rowHeights[rowIdx]) {
-      rowHeights[rowIdx] = b.height;
+    if (rowIdx < rowHeights.length && item.height > rowHeights[rowIdx]) {
+      rowHeights[rowIdx] = item.height;
     }
-    if (colIdx < colWidths.length && b.width > colWidths[colIdx]) {
-      colWidths[colIdx] = b.width;
+    if (colIdx < colWidths.length && item.width > colWidths[colIdx]) {
+      colWidths[colIdx] = item.width;
     }
   });
-  const minCellWidth = cellWidth ? distance10.parse(cellWidth) : 0;
-  const minCellHeight = cellHeight ? distance10.parse(cellHeight) : 0;
   for (let i = 0; i < colWidths.length; i++) {
     colWidths[i] = Math.max(colWidths[i], minCellWidth);
   }
   for (let i = 0; i < rowHeights.length; i++) {
     rowHeights[i] = Math.max(rowHeights[i], minCellHeight);
   }
-  const totalGridWidth = colWidths.reduce((a, b) => a + b, 0) + (cols > 1 ? (cols - 1) * boardGap : 0);
-  const totalGridHeight = rowHeights.reduce((a, b) => a + b, 0) + (rows > 1 ? (rows - 1) * boardGap : 0);
-  const startX = -totalGridWidth / 2;
-  const startY = -totalGridHeight / 2;
-  const rowYOffsets = [startY];
-  for (let i = 1; i < rows; i++) {
-    rowYOffsets.push(rowYOffsets[i - 1] + rowHeights[i - 1] + boardGap);
-  }
+  const gridWidth = colWidths.reduce((a, b) => a + b, 0) + (cols > 1 ? (cols - 1) * boardGap : 0);
+  const gridHeight = rowHeights.reduce((a, b) => a + b, 0) + (rows > 1 ? (rows - 1) * boardGap : 0);
+  const startX = -gridWidth / 2;
+  const startY = -gridHeight / 2;
   const colXOffsets = [startX];
   for (let i = 1; i < cols; i++) {
     colXOffsets.push(colXOffsets[i - 1] + colWidths[i - 1] + boardGap);
   }
+  const rowYOffsets = [startY];
+  for (let i = 1; i < rows; i++) {
+    rowYOffsets.push(rowYOffsets[i - 1] + rowHeights[i - 1] + boardGap);
+  }
   const positions = [];
-  boardsWithDims.forEach((b, i) => {
+  itemsWithDims.forEach((itemWithDims, i) => {
     const colIdx = i % cols;
     const rowIdx = Math.floor(i / cols);
     if (rowIdx >= rowYOffsets.length || colIdx >= colXOffsets.length) return;
-    const cellX = colXOffsets[colIdx];
-    const cellY = rowYOffsets[rowIdx];
-    const currentCellWidth = colWidths[colIdx];
-    const currentCellHeight = rowHeights[rowIdx];
-    const boardX = cellX + currentCellWidth / 2;
-    const boardY = cellY + currentCellHeight / 2;
-    positions.push({
-      board: b.board,
-      pos: { x: boardX, y: boardY }
-    });
+    const x = colXOffsets[colIdx] + colWidths[colIdx] / 2;
+    const y = rowYOffsets[rowIdx] + rowHeights[rowIdx] / 2;
+    positions.push({ item: itemWithDims.item, pos: { x, y } });
   });
-  return { positions, gridWidth: totalGridWidth, gridHeight: totalGridHeight };
-};
+  return { positions, gridWidth, gridHeight };
+}
+function getItemDimensions(item, db) {
+  if (item.componentName === "Board") {
+    const board = item;
+    if (db && board.pcb_board_id) {
+      const pcbBoard = db.pcb_board.get(board.pcb_board_id);
+      if (pcbBoard?.width !== void 0 && pcbBoard?.height !== void 0) {
+        return { width: pcbBoard.width, height: pcbBoard.height };
+      }
+    }
+    return getBoardDimensionsFromProps(board);
+  }
+  if (item.componentName === "Subpanel") {
+    const subpanel = item;
+    const props = subpanel._parsedProps;
+    if (props.width !== void 0 && props.height !== void 0) {
+      return {
+        width: distance10.parse(props.width),
+        height: distance10.parse(props.height)
+      };
+    }
+    const directBoards = subpanel._getDirectBoardChildren();
+    if (directBoards.length === 0) {
+      const allBoards = subpanel._getAllBoardInstances();
+      if (allBoards.length === 0) return { width: 0, height: 0 };
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const board of allBoards) {
+        const dims = getBoardDimensionsFromProps(board);
+        if (dims.width === 0 || dims.height === 0) continue;
+        const offset = board._panelPositionOffset ?? { x: 0, y: 0 };
+        minX = Math.min(minX, offset.x - dims.width / 2);
+        maxX = Math.max(maxX, offset.x + dims.width / 2);
+        minY = Math.min(minY, offset.y - dims.height / 2);
+        maxY = Math.max(maxY, offset.y + dims.height / 2);
+      }
+      if (minX === Infinity) return { width: 0, height: 0 };
+      return { width: maxX - minX, height: maxY - minY };
+    }
+    if (directBoards.length === 1) {
+      return getBoardDimensionsFromProps(directBoards[0]);
+    }
+    if (subpanel._cachedGridWidth > 0 && subpanel._cachedGridHeight > 0) {
+      const edgePadding = distance10.parse(props.edgePadding ?? 5);
+      return {
+        width: subpanel._cachedGridWidth + edgePadding * 2,
+        height: subpanel._cachedGridHeight + edgePadding * 2
+      };
+    }
+    let totalWidth = 0;
+    let totalHeight = 0;
+    for (const board of directBoards) {
+      const dims = getBoardDimensionsFromProps(board);
+      totalWidth = Math.max(totalWidth, dims.width);
+      totalHeight = Math.max(totalHeight, dims.height);
+    }
+    return { width: totalWidth, height: totalHeight };
+  }
+  return { width: 0, height: 0 };
+}
 
 // lib/components/normal-components/Subpanel.ts
 var Subpanel = class _Subpanel extends Group6 {
@@ -19642,6 +19660,17 @@ var Subpanel = class _Subpanel extends Group6 {
   }
   _cachedGridWidth = 0;
   _cachedGridHeight = 0;
+  _panelPositionOffset = null;
+  _computePcbGlobalTransformBeforeLayout() {
+    if (this._panelPositionOffset) {
+      const parentTransform = this.parent?._computePcbGlobalTransformBeforeLayout?.() ?? identity6();
+      return compose8(
+        parentTransform,
+        translate8(this._panelPositionOffset.x, this._panelPositionOffset.y)
+      );
+    }
+    return super._computePcbGlobalTransformBeforeLayout();
+  }
   /**
    * Get all board instances from this subpanel and nested subpanels
    */
@@ -19681,35 +19710,30 @@ var Subpanel = class _Subpanel extends Group6 {
   doInitialPanelBoardLayout() {
     if (this.root?.pcbDisabled) return;
     const layoutMode = this._parsedProps.layoutMode ?? "none";
-    const childBoardInstances = this._getDirectBoardChildren();
+    const gridItems = this.children.filter(
+      (c) => c instanceof Board || c instanceof _Subpanel
+    );
     if (layoutMode !== "none") {
-      for (const board of childBoardInstances) {
-        const hasPcbX = board._parsedProps.pcbX !== void 0;
-        const hasPcbY = board._parsedProps.pcbY !== void 0;
-        if (hasPcbX || hasPcbY) {
-          const properties = [];
-          if (hasPcbX) properties.push("pcbX");
-          if (hasPcbY) properties.push("pcbY");
-          const propertyNames = properties.join(" and ");
+      for (const child of gridItems) {
+        if (!(child instanceof Board)) continue;
+        if (child._hasUserDefinedPcbPosition()) {
           this.root.db.source_property_ignored_warning.insert({
-            source_component_id: board.source_component_id,
-            property_name: propertyNames,
-            message: `Board has manual positioning (${propertyNames}) but ${this._errorComponentName} layout mode is "${layoutMode}". Manual positioning will be ignored.`,
+            source_component_id: child.source_component_id,
+            property_name: "pcbX/pcbY",
+            message: `Board has manual positioning but ${this._errorComponentName} layout mode is "${layoutMode}". Manual positioning will be ignored.`,
             error_type: "source_property_ignored_warning"
           });
         }
       }
     }
-    if (layoutMode === "none" && childBoardInstances.length > 1) {
-      const boardsWithoutPosition = childBoardInstances.filter((board) => {
-        const hasPcbX = board._parsedProps.pcbX !== void 0;
-        const hasPcbY = board._parsedProps.pcbY !== void 0;
-        return !hasPcbX && !hasPcbY;
-      });
-      if (boardsWithoutPosition.length > 1) {
+    if (layoutMode === "none" && gridItems.length > 1) {
+      const unpositionedItems = gridItems.filter(
+        (c) => !c._hasUserDefinedPcbPosition()
+      );
+      if (unpositionedItems.length > 1) {
         this.root.db.pcb_placement_error.insert({
           error_type: "pcb_placement_error",
-          message: `Multiple boards in ${this._errorComponentName} without pcbX/pcbY positions. When layoutMode="none", each board must have explicit pcbX and pcbY coordinates to avoid overlapping. Either set pcbX/pcbY on each board, or use layoutMode="grid" for automatic positioning.`
+          message: `Multiple boards/subpanels in ${this._errorComponentName} without positions. When layoutMode="none", each item must have explicit positioning. Use layoutMode="grid" for automatic positioning.`
         });
       }
     }
@@ -19743,8 +19767,8 @@ var Subpanel = class _Subpanel extends Group6 {
       availablePanelWidth = panelWidth - edgePaddingLeft - edgePaddingRight;
       availablePanelHeight = panelHeight - edgePaddingTop - edgePaddingBottom;
     }
-    const { positions, gridWidth, gridHeight } = packBoardsIntoGrid({
-      boards: childBoardInstances,
+    const { positions, gridWidth, gridHeight } = packIntoGrid({
+      items: gridItems,
       row: this._parsedProps.row,
       col: this._parsedProps.col,
       cellWidth: this._parsedProps.cellWidth,
@@ -19755,28 +19779,40 @@ var Subpanel = class _Subpanel extends Group6 {
     });
     this._cachedGridWidth = gridWidth;
     this._cachedGridHeight = gridHeight;
-    for (const { board, pos } of positions) {
-      board._panelPositionOffset = pos;
+    for (const { item, pos } of positions) {
+      item._panelPositionOffset = pos;
     }
   }
   doInitialPanelLayout() {
     if (this.root?.pcbDisabled) return;
     const { db } = this.root;
-    const childBoardInstances = this._getDirectBoardChildren();
     const layoutMode = this._parsedProps.layoutMode ?? "none";
     if (layoutMode === "grid") {
-      for (const board of childBoardInstances) {
-        if (!board.pcb_board_id || !board._panelPositionOffset) continue;
-        db.pcb_board.update(board.pcb_board_id, {
-          position_mode: "relative_to_panel_anchor",
-          display_offset_x: `${board._panelPositionOffset.x}mm`,
-          display_offset_y: `${board._panelPositionOffset.y}mm`
-        });
+      for (const child of this.children) {
+        if (child instanceof Board) {
+          if (!child.pcb_board_id || !child._panelPositionOffset) continue;
+          db.pcb_board.update(child.pcb_board_id, {
+            position_mode: "relative_to_panel_anchor",
+            display_offset_x: `${child._panelPositionOffset.x}mm`,
+            display_offset_y: `${child._panelPositionOffset.y}mm`
+          });
+        } else if (child instanceof _Subpanel && child._panelPositionOffset) {
+          for (const board of child._getAllBoardInstances()) {
+            if (!board.pcb_board_id) continue;
+            const boardOffset = board._panelPositionOffset ?? { x: 0, y: 0 };
+            db.pcb_board.update(board.pcb_board_id, {
+              position_mode: "relative_to_panel_anchor",
+              display_offset_x: `${child._panelPositionOffset.x + boardOffset.x}mm`,
+              display_offset_y: `${child._panelPositionOffset.y + boardOffset.y}mm`
+            });
+          }
+        }
       }
       this._updatePanelDimensions();
     } else {
       const panelGlobalPos = this._getGlobalPcbPositionBeforeLayout();
-      for (const board of childBoardInstances) {
+      for (const board of this._getDirectBoardChildren()) {
+        if (!board.pcb_board_id) continue;
         const boardDb = db.pcb_board.get(board.pcb_board_id);
         if (!boardDb) continue;
         const relativeX = boardDb.center.x - panelGlobalPos.x;
@@ -21076,8 +21112,8 @@ var BreakoutPoint = class extends PrimitiveComponent2 {
 import { netLabelProps } from "@tscircuit/props";
 import {
   applyToPoint as applyToPoint19,
-  identity as identity6,
-  translate as translate8
+  identity as identity7,
+  translate as translate9
 } from "transformation-matrix";
 import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 var NetLabel = class extends PrimitiveComponent2 {
@@ -21127,10 +21163,10 @@ var NetLabel = class extends PrimitiveComponent2 {
       if (connectedPorts.length > 0) {
         const portPos = connectedPorts[0]._getGlobalSchematicPositionBeforeLayout();
         const parentCenter = applyToPoint19(
-          this.parent?.computeSchematicGlobalTransform?.() ?? identity6(),
+          this.parent?.computeSchematicGlobalTransform?.() ?? identity7(),
           { x: 0, y: 0 }
         );
-        return translate8(portPos.x - parentCenter.x, portPos.y - parentCenter.y);
+        return translate9(portPos.x - parentCenter.x, portPos.y - parentCenter.y);
       }
     }
     return super.computeSchematicPropsTransform();
@@ -23317,7 +23353,7 @@ var SchematicCell = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Symbol/Symbol.ts
 import { symbolProps } from "@tscircuit/props";
-import { compose as compose8, translate as translate9, scale as scale2 } from "transformation-matrix";
+import { compose as compose9, translate as translate10, scale as scale2 } from "transformation-matrix";
 var SymbolComponent = class extends PrimitiveComponent2 {
   isPrimitiveContainer = true;
   schematic_symbol_id;
@@ -23427,10 +23463,10 @@ var SymbolComponent = class extends PrimitiveComponent2 {
     const scaleX = targetWidth !== void 0 && currentWidth > 0 ? targetWidth / currentWidth : 1;
     const scaleY = targetHeight !== void 0 && currentHeight > 0 ? targetHeight / currentHeight : 1;
     const globalPos = this._getGlobalSchematicPositionBeforeLayout();
-    this.userCoordinateToResizedSymbolTransformMat = compose8(
-      translate9(globalPos.x, globalPos.y),
+    this.userCoordinateToResizedSymbolTransformMat = compose9(
+      translate10(globalPos.x, globalPos.y),
       scale2(scaleX, scaleY),
-      translate9(-currentCenterX, -currentCenterY)
+      translate10(-currentCenterX, -currentCenterY)
     );
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1072",
+  "version": "0.0.1074",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -34,8 +34,8 @@
     "@resvg/resvg-js": "^2.6.2",
     "@tscircuit/alphabet": "0.0.18",
     "@tscircuit/capacity-autorouter": "^0.0.299",
-    "@tscircuit/checks": "0.0.99",
-    "@tscircuit/circuit-json-util": "^0.0.80",
+    "@tscircuit/checks": "0.0.100",
+    "@tscircuit/circuit-json-util": "^0.0.81",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.20",
     "@tscircuit/footprinter": "^0.0.316",