@tscircuit/cli 0.1.2287 → 0.1.2288

package/dist/cli/python/sample.py

@@ -0,0 +1,352 @@
+"""Read Palace phasors, normalize port basis excitations, and sample ground only."""
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import numpy as np
+import vtk
+from vtk.util.numpy_support import numpy_to_vtk, vtk_to_numpy
+from surface_sample import sample_surface
+
+# Keep VTK sampling deterministic and avoid oversubscribing FEM jobs.
+vtk.vtkSMPTools.Initialize(1)
+
+
+def digest(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def read_ports(path):
+    with path.open() as stream:
+        rows = list(csv.DictReader(stream, skipinitialspace=True))
+    return [
+        {
+            key.strip(): (float(number) if number.strip() != "NULL" else None)
+            for key, number in row.items()
+        }
+        for row in rows
+    ]
+
+
+def read_ground(path):
+    # Read piece files directly. vtkXMLPUnstructuredGridReader in VTK 9.3 can
+    # expose invalid shared arrays to extract filters for Palace's output.
+    pieces = [
+        path.parent / piece.attrib["Source"] for piece in ET.parse(path).iter("Piece")
+    ]
+    readers = []
+    append = vtk.vtkAppendFilter()
+    for piece in pieces:
+        reader = vtk.vtkXMLUnstructuredGridReader()
+        reader.SetFileName(str(piece))
+        reader.Update()
+        if reader.GetOutput().GetNumberOfCells() == 0:
+            raise ValueError(f"Empty Palace volume piece: {piece}")
+        readers.append(reader)
+        append.AddInputData(reader.GetOutput())
+    if not readers:
+        raise ValueError("Palace data.pvtu contains no piece files")
+    if len(readers) == 1:
+        mesh = readers[0].GetOutput()
+    else:
+        append.Update()
+        mesh = append.GetOutput()
+    attributes = vtk_to_numpy(mesh.GetCellData().GetArray("attribute"))
+    copper_cells = np.flatnonzero(attributes == 3)
+    ground_cells = vtk.vtkIdList()
+    for index in copper_cells:
+        # Probe coordinates, not vertex heights, select bottom foil. A plated
+        # barrel can share valid copper tetrahedra across z=0; excluding those
+        # loses real bottom-plane samples around a ground via.
+        ground_cells.InsertNextId(int(index))
+    if ground_cells.GetNumberOfIds() == 0:
+        raise ValueError("Palace output has no bottom copper volume cells")
+    extract = vtk.vtkExtractCells()
+    extract.SetInputData(mesh)
+    extract.SetCellList(ground_cells)
+    extract.Update()
+    return extract.GetOutput()
+
+
+def probe_ground(ground, options):
+    coordinates = options["coordinates"]
+    model = options["model"]
+    electric_field_scale = options["electricFieldScale"]
+    locations = vtk.vtkPoints()
+    locations.SetData(numpy_to_vtk(coordinates, deep=True))
+    mesh = vtk.vtkPolyData()
+    mesh.SetPoints(locations)
+    probe = vtk.vtkProbeFilter()
+    probe.SetInputData(mesh)
+    probe.SetSourceData(ground)
+    probe.SetCellLocatorPrototype(vtk.vtkStaticCellLocator())
+    probe.SetComputeTolerance(False)
+    probe.SetTolerance(1e-5)
+    probe.Update()
+    sampled = probe.GetOutput().GetPointData()
+    valid = vtk_to_numpy(sampled.GetArray("vtkValidPointMask")).astype(bool)
+    if not valid.all():
+        raise ValueError(
+            f"{np.count_nonzero(~valid)} sample locations do not lie on Palace ground triangles"
+        )
+    real = vtk_to_numpy(sampled.GetArray("E_real"))
+    imag = vtk_to_numpy(sampled.GetArray("E_imag"))
+    if not np.isfinite(real).all() or not np.isfinite(imag).all():
+        raise ValueError("Non-finite Palace copper electric field")
+    # Ohmic J = sigma E, A/m² → A/mm². Integrate copper depth for K.
+    current = (
+        (real[:, :2] + 1j * imag[:, :2])
+        * electric_field_scale
+        * model["copperConductivity"]
+        / 1e6
+    )
+    current = current.reshape(5, -1, 2)
+    _, weights = np.polynomial.legendre.leggauss(5)
+    return np.einsum("d,dnc->nc", weights / 2, current) * model["copperThickness"]
+
+
+def coordinate(number):
+    return f"{0 if number == 0 else number:.9f}"
+
+
+def point(position):
+    return [coordinate(position["x"]), coordinate(position["y"])]
+
+
+def geometry_signature(geometry):
+    signature = [
+        [point(position) for position in geometry["boardOutline"]],
+        [
+            [
+                [point(position) for position in region["outer"]],
+                [[point(position) for position in hole] for hole in [*region["holes"], *region.get("maskCutouts", [])]],
+            ]
+            for region in geometry["groundRegions"]
+        ],
+        [[point(position) for position in outline] for outline in geometry["cutouts"]],
+        [
+            [
+                [*point(route), coordinate(route["width"]), route["layer"]]
+                for route in signal["route"]
+                if route["route_type"] == "wire"
+            ]
+            for signal in geometry["signals"]
+        ],
+        *([geometry["physicalModelSignature"]] if geometry.get("physicalModelSignature") else []),
+        [
+            [
+                coordinate(excitation["current"]),
+                point(excitation["return_source"]),
+                point(excitation["return_sink"]),
+                *([[excitation.get("source_port", {}).get("reference_layer", "bottom"), coordinate(excitation.get("source_port", {}).get("resistance", 50)), excitation.get("load_port", {}).get("reference_layer", "bottom"), coordinate(excitation.get("load_port", {}).get("resistance", 50))]] if excitation.get("source_port") or excitation.get("load_port") else []),
+            ]
+            for excitation in geometry["excitations"]
+        ],
+    ]
+    return json.dumps(signature, separators=(",", ":"))
+
+
+def serialize_currents(currents):
+    return [
+        {"real": float(current.real), "imag": float(current.imag)}
+        for current in currents
+    ]
+
+
+def sample_case(case):
+    model = json.loads((case / "model.json").read_text())
+    grid = json.loads((case / "sample-grid.json").read_text())
+    config = json.loads((case / "palace.json").read_text())
+    log = (case / "palace.log").read_text()
+    version = re.search(r"Git changeset ID:\s*(\S+)", log)
+    if not version or version[1] != "v0.14.0":
+        raise ValueError(
+            "This importer requires Palace v0.14.0, whose ParaView fields are nondimensional; other versions require an audited units adapter"
+        )
+    if not re.search(r"^Total\s+[0-9.]+\s+[0-9.]+\s+[0-9.]+", log, re.MULTILINE):
+        raise ValueError("Only completed Palace runs can be imported")
+    if re.search(r"solver.*(?:did not|failed to).*converge", log, re.IGNORECASE):
+        raise ValueError("Palace linear solver failed to converge")
+    postpro = case / config["Problem"]["Output"]
+    rows = read_ports(postpro / "port-I.csv")
+    excitations = model["geometry"]["excitations"]
+    count = len(excitations)
+    if len(rows) != 1:
+        raise ValueError(
+            "Expected exactly one frequency row containing all port basis solutions"
+        )
+    # Palace reports V/R, the current in each port's termination, not the net
+    # current injected into the PCB. A driven port also has a Norton source
+    # of 2*I_inc. Thus I_into_PCB = 2*I_inc - I_termination at active ports.
+    source_matrix = np.zeros((count, count), dtype=complex)
+    load_matrix = np.zeros_like(source_matrix)
+    fields = []
+    surface_receipts = []
+    outline = model["geometry"]["boardOutline"]
+    width = (
+        max(p["x"] for p in outline)
+        - min(p["x"] for p in outline)
+        + 2 * model["airPadding"]
+    )
+    height = (
+        max(p["y"] for p in outline)
+        - min(p["y"] for p in outline)
+        + 2 * model["airPadding"]
+    )
+    depth = model["layerSeparation"] + 2 * model["airPadding"]
+    characteristic_length_m = (
+        config["Model"].get("Lc", max(width, height, depth)) * config["Model"]["L0"]
+    )
+    impedance_free_space = math.sqrt((4e-7 * math.pi) / 8.8541878176e-12)
+    electric_field_scale = impedance_free_space**0.5 / characteristic_length_m
+    surface_impedance = model["copperModel"] == "surface_impedance_copper"
+    surface_current_scale = 1 / (impedance_free_space**0.5 * characteristic_length_m * 1000)
+    coordinates = np.array([[point["x"], point["y"]] for point in grid["points"]])
+    depth_nodes, _ = np.polynomial.legendre.leggauss(5)
+    depths = (depth_nodes - 1) / 2 * model["copperThickness"]
+    if model.get("multilayer"):
+        foil = next(layer for layer in model["multilayer"]["stackup"]["copperLayers"]
+                    if layer["name"] == model["multilayer"]["sampleLayer"])
+        depths = foil["zMin"] + (depth_nodes + 1) / 2 * (foil["zMax"] - foil["zMin"])
+    volume_coordinates = np.concatenate(
+        [
+            np.column_stack([coordinates, np.full(len(coordinates), depth)])
+            for depth in depths
+        ]
+    )
+    for basis in range(count):
+        row = rows[0]
+        excitation_index = 2 * basis + 1
+        if (
+            abs(row["f (GHz)"] * 1e9 - model["frequencyHz"])
+            > model["frequencyHz"] * 1e-8
+        ):
+            raise ValueError("Palace output frequency does not match the model")
+        for index in range(count):
+            source_index, load_index = 2 * index + 1, 2 * index + 2
+            source_label = (
+                f"[{source_index}][{excitation_index}]"
+                if count > 1
+                else f"[{source_index}]"
+            )
+            load_label = (
+                f"[{load_index}][{excitation_index}]"
+                if count > 1
+                else f"[{load_index}]"
+            )
+            incident_label = (
+                f"[{source_index}][{excitation_index}]"
+                if count > 1
+                else f"[{source_index}]"
+            )
+            termination = complex(
+                row[f"Re{{I{source_label}}} (A)"], row[f"Im{{I{source_label}}} (A)"]
+            )
+            incident = (
+                row.get(f"I_inc{incident_label} (A)", 0.0) if index == basis else 0.0
+            )
+            source_matrix[index, basis] = 2 * incident - termination
+            load_matrix[index, basis] = complex(
+                row[f"Re{{I{load_label}}} (A)"], row[f"Im{{I{load_label}}} (A)"]
+            )
+        boundary = postpro / "paraview" / ("driven_boundary" if surface_impedance else "driven")
+        if count > 1:
+            boundary = boundary / f"excitation_{excitation_index}"
+        path = boundary / "Cycle000001" / "data.pvtu"
+        fields.append(sample_surface(path, coordinates, model, surface_current_scale, surface_receipts) if surface_impedance else
+            probe_ground(
+                read_ground(path),
+                {
+                    "coordinates": volume_coordinates,
+                    "model": model,
+                    "electricFieldScale": electric_field_scale,
+                },
+            )
+        )
+    condition = float(np.linalg.cond(source_matrix))
+    if not np.isfinite(condition) or condition > 1e8:
+        raise ValueError("Source-current normalization is singular or ill-conditioned")
+    desired = np.array(
+        [excitation["current"] for excitation in excitations], dtype=complex
+    )
+    coefficients = np.linalg.solve(source_matrix, desired)
+    combined = np.einsum("b,bnc->nc", coefficients, np.stack(fields))
+    normalized_sources = source_matrix @ coefficients
+    normalized_loads = load_matrix @ coefficients
+    if not np.allclose(normalized_sources, desired, atol=1e-10, rtol=1e-10):
+        raise ValueError("Source-current normalization failed")
+    samples = [
+        {
+            "x": float(x),
+            "y": float(y),
+            "sheetCurrentXReal": float(current[0].real),
+            "sheetCurrentYReal": float(current[1].real),
+            "sheetCurrentXImag": float(current[0].imag),
+            "sheetCurrentYImag": float(current[1].imag),
+        }
+        for (x, y), current in zip(coordinates, combined)
+    ]
+    reference = {
+        "schemaVersion": 1,
+        **({"sampleLayer": model["multilayer"]["sampleLayer"]} if model.get("multilayer") else {}),
+        "solver": "palace",
+        "solverVersion": version[1],
+        "femOrder": model["order"],
+        "frequencyHz": model["frequencyHz"],
+        "copperModel": model["copperModel"],
+        **({"samplingMethod": "sum_foil_face_surface_currents", "surfaceCurrentScaleAmpsPerMm": surface_current_scale} if surface_impedance else {}),
+        "copperThickness": model["copperThickness"],
+        "layerSeparation": model["layerSeparation"],
+        **{key: grid[key] for key in ["cellWidth", "cellHeight", "columns", "rows"]},
+        "samples": samples,
+        "sourceCurrents": serialize_currents(normalized_sources),
+        "loadCurrents": serialize_currents(normalized_loads),
+        "normalizationConditionNumber": condition,
+        "electricFieldScaleVoltsPerMeter": electric_field_scale,
+        "provenance": {
+            "circuitSha256": digest(case / "circuit.json"),
+            "geometrySignature": geometry_signature(model["geometry"]),
+            "modelSha256": digest(case / "model.json"),
+            "meshSha256": digest(case / "mesh.msh"),
+        },
+    }
+    (case / "reference.json").write_text(
+        json.dumps(reference, separators=(",", ":"), allow_nan=False) + "\n"
+    )
+    (case / "normalization.json").write_text(
+        json.dumps(
+            {
+                "basisCoefficients": serialize_currents(coefficients),
+                "sourceCurrents": reference["sourceCurrents"],
+                "loadCurrents": reference["loadCurrents"],
+                "conditionNumber": condition,
+            },
+            indent=2,
+        )
+        + "\n"
+    )
+    if surface_impedance:
+        (case / "surface-sampling.json").write_text(json.dumps({
+            "copperModel": model["copperModel"],
+            "method": "sum_foil_face_surface_currents",
+            "normalConvention": "metal-outward normal crossed with H; no additional face sign flip",
+            "units": "A/mm, complex peak phasors after source-current basis normalization",
+            "bases": surface_receipts,
+        }, indent=2, allow_nan=False) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("case")
+    args = parser.parse_args()
+    sample_case(Path(args.case).resolve())
+
+
+if __name__ == "__main__":
+    main()

package/dist/cli/python/surface_sample.py

@@ -0,0 +1,88 @@
+"""Import Palace's actual finite-conductivity boundary current coefficients."""
+import xml.etree.ElementTree as ET
+import numpy as np
+import vtk
+from vtk.util.numpy_support import numpy_to_vtk, vtk_to_numpy
+
+
+def read_boundary(path):
+    pieces = [path.parent / piece.attrib["Source"] for piece in ET.parse(path).iter("Piece")]
+    readers, append = [], vtk.vtkAppendFilter()
+    append.MergePointsOff()
+    for piece in pieces:
+        reader = vtk.vtkXMLUnstructuredGridReader()
+        reader.SetFileName(str(piece))
+        reader.Update()
+        readers.append(reader)
+        append.AddInputData(reader.GetOutput())
+    if not readers:
+        raise ValueError("No Palace boundary pieces")
+    append.Update()
+    return append.GetOutput()
+
+
+def probe_face(boundary, coordinates, z, receipt=None):
+    attribute = boundary.GetCellData().GetArray("attribute")
+    if attribute is None:
+        raise ValueError("Palace boundary has no material-face attributes")
+    ids = vtk.vtkIdList()
+    attributes = vtk_to_numpy(attribute)
+    face_heights = []
+    for index in np.flatnonzero(attributes == 11):
+        cell = boundary.GetCell(int(index))
+        if all(abs(cell.GetPoints().GetPoint(point)[2] - z) < 1e-7 for point in range(cell.GetNumberOfPoints())):
+            ids.InsertNextId(int(index))
+            face_heights.extend(cell.GetPoints().GetPoint(point)[2] for point in range(cell.GetNumberOfPoints()))
+    if ids.GetNumberOfIds() == 0:
+        if receipt is not None:
+            receipt.update({"physicalZMm": z, "triangles": 0, "validSamples": 0})
+        return np.zeros((len(coordinates), 2), dtype=complex), np.zeros(len(coordinates), dtype=bool)
+    extract = vtk.vtkExtractCells()
+    extract.SetInputData(boundary)
+    extract.SetCellList(ids)
+    extract.Update()
+    # Palace writes float32 VTK coordinates. For a flat triangle locator its
+    # bounding box can reject the exact physical double-precision Z before the
+    # probe tolerance is applied (e.g. -0.035 versus -0.035000000149). Probe the
+    # verified exported face plane, without moving XY or filling absent faces.
+    probe_z = float(np.mean(face_heights))
+    if max(face_heights) - min(face_heights) > 1e-10:
+        raise ValueError("Selected Palace foil face is not planar")
+    locations = vtk.vtkPoints()
+    locations.SetData(numpy_to_vtk(np.column_stack([coordinates, np.full(len(coordinates), probe_z)]), deep=True))
+    points = vtk.vtkPolyData()
+    points.SetPoints(locations)
+    probe = vtk.vtkProbeFilter()
+    probe.SetInputData(points)
+    probe.SetSourceData(extract.GetOutput())
+    probe.SetCellLocatorPrototype(vtk.vtkStaticCellLocator())
+    probe.SetComputeTolerance(False)
+    probe.SetTolerance(1e-5)
+    probe.Update()
+    data = probe.GetOutput().GetPointData()
+    valid = vtk_to_numpy(data.GetArray("vtkValidPointMask")).astype(bool)
+    real, imag = data.GetArray("J_s_real"), data.GetArray("J_s_imag")
+    if real is None or imag is None:
+        raise ValueError("Palace did not export J_s_real/J_s_imag finite-conductivity boundary currents")
+    current = vtk_to_numpy(real)[:, :2] + 1j * vtk_to_numpy(imag)[:, :2]
+    if not np.isfinite(current[valid]).all():
+        raise ValueError("Non-finite Palace surface current")
+    current[~valid] = 0
+    if receipt is not None:
+        receipt.update({"physicalZMm": z, "exportedZMm": probe_z, "triangles": ids.GetNumberOfIds(), "validSamples": int(np.count_nonzero(valid))})
+    return current, valid
+
+
+def sample_surface(path, coordinates, model, scale_amps_per_mm, receipts=None):
+    boundary = read_boundary(path)
+    top_receipt, bottom_receipt = {}, {}
+    top, top_valid = probe_face(boundary, coordinates, 0, top_receipt)
+    bottom, bottom_valid = probe_face(boundary, coordinates, -model["copperThickness"], bottom_receipt)
+    if not (top_valid | bottom_valid).all():
+        raise ValueError(f"{np.count_nonzero(~(top_valid | bottom_valid))} declared conductor samples have no exposed foil face")
+    if receipts is not None:
+        receipts.append({"attribute": 11, "fieldArrays": ["J_s_real", "J_s_imag"], "scaleAmpsPerMm": scale_amps_per_mm, "declaredConductorSamples": len(coordinates), "bothFaces": int(np.count_nonzero(top_valid & bottom_valid)), "oneFace": int(np.count_nonzero(top_valid ^ bottom_valid)), "faces": [top_receipt, bottom_receipt]})
+    # J_s is n_out_of_metal × H, already signed on each exterior face. Sum the
+    # two physical currents; no extra normal/sign flip. A buried via junction
+    # may expose only one face and contributes only that physical face.
+    return (top + bottom) * scale_amps_per_mm

package/dist/lib/index.js

@@ -69139,7 +69139,7 @@ var package_default = {
     "@tscircuit/krt-wasm": "^0.1.6",
     "@tscircuit/math-utils": "0.0.36",
     "@tscircuit/modelprinter": "^0.0.11",
-    "@tscircuit/props": "^0.0.694",
+    "@tscircuit/props": "^0.0.698",
     "@tscircuit/runframe": "^0.0.2953",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
     "@tscircuit/schematic-trace-solver": "^0.0.204",
@@ -69155,7 +69155,7 @@ var package_default = {
     "@types/semver": "^7.5.8",
     "bun-match-svg": "^0.0.12",
     chokidar: "4.0.1",
-    "circuit-json": "^0.0.520",
+    "circuit-json": "^0.0.525",
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-altium": "github:tscircuit/circuit-json-to-altium#1a50d0dd2c0737cf940d92c0315852dc0111dd87",
     "circuit-json-to-bom-csv": "^0.0.19",
@@ -69171,7 +69171,7 @@ var package_default = {
     "circuit-json-to-tscircuit": "^0.0.50",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     "circuit-to-canvas": "^0.0.123",
-    "circuit-to-svg": "^0.0.444",
+    "circuit-to-svg": "^0.0.447",
     commander: "^14.0.0",
     conf: "^13.1.0",
     configstore: "^7.0.0",
@@ -69203,6 +69203,7 @@ var package_default = {
     redaxios: "^0.5.1",
     "schematic-symbols": "^0.0.246",
     semver: "^7.6.3",
+    "simulate-return-current": "https://pkg.pr.new/tscircuit/simulate-return-current@6a7c84cb4f9f66c2cb54199aee50d3c7453748e8",
     spicets: "^0.0.4",
     stepts: "^0.0.3",
     tempy: "^3.1.0",
@@ -69212,7 +69213,9 @@ var package_default = {
     zod: "^3.23.8"
   },
   peerDependencies: {
-    "circuit-json": "^0.0.520",
+    "@tscircuit/math-utils": "0.0.36",
+    "circuit-json": "^0.0.525",
+    "circuit-to-svg": "^0.0.447",
     tscircuit: "*"
   },
   bin: {
@@ -69229,10 +69232,11 @@ var package_default = {
     }
   },
   overrides: {
-    "circuit-json": "^0.0.520",
+    "circuit-json": "^0.0.525",
     altiumts: "0.0.59",
     poppygl: "0.0.34",
-    "@tscircuit/core": "^0.0.2104"
+    "@tscircuit/core": "^0.0.2121",
+    "jscad-planner": "0.0.18"
   },
   scripts: {
     start: "bun run dev",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2287",
+  "version": "0.1.2288",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/cli"
@@ -27,7 +27,7 @@
     "@tscircuit/krt-wasm": "^0.1.6",
     "@tscircuit/math-utils": "0.0.36",
     "@tscircuit/modelprinter": "^0.0.11",
-    "@tscircuit/props": "^0.0.694",
+    "@tscircuit/props": "^0.0.698",
     "@tscircuit/runframe": "^0.0.2953",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
     "@tscircuit/schematic-trace-solver": "^0.0.204",
@@ -43,7 +43,7 @@
     "@types/semver": "^7.5.8",
     "bun-match-svg": "^0.0.12",
     "chokidar": "4.0.1",
-    "circuit-json": "^0.0.520",
+    "circuit-json": "^0.0.525",
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-altium": "github:tscircuit/circuit-json-to-altium#1a50d0dd2c0737cf940d92c0315852dc0111dd87",
     "circuit-json-to-bom-csv": "^0.0.19",
@@ -59,7 +59,7 @@
     "circuit-json-to-tscircuit": "^0.0.50",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     "circuit-to-canvas": "^0.0.123",
-    "circuit-to-svg": "^0.0.444",
+    "circuit-to-svg": "^0.0.447",
     "commander": "^14.0.0",
     "conf": "^13.1.0",
     "configstore": "^7.0.0",
@@ -91,6 +91,7 @@
     "redaxios": "^0.5.1",
     "schematic-symbols": "^0.0.246",
     "semver": "^7.6.3",
+    "simulate-return-current": "https://pkg.pr.new/tscircuit/simulate-return-current@6a7c84cb4f9f66c2cb54199aee50d3c7453748e8",
     "spicets": "^0.0.4",
     "stepts": "^0.0.3",
     "tempy": "^3.1.0",
@@ -100,7 +101,9 @@
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "circuit-json": "^0.0.520",
+    "@tscircuit/math-utils": "0.0.36",
+    "circuit-json": "^0.0.525",
+    "circuit-to-svg": "^0.0.447",
     "tscircuit": "*"
   },
   "bin": {
@@ -117,10 +120,11 @@
     }
   },
   "overrides": {
-    "circuit-json": "^0.0.520",
+    "circuit-json": "^0.0.525",
     "altiumts": "0.0.59",
     "poppygl": "0.0.34",
-    "@tscircuit/core": "^0.0.2104"
+    "@tscircuit/core": "^0.0.2121",
+    "jscad-planner": "0.0.18"
   },
   "scripts": {
     "start": "bun run dev",