@tscircuit/cli 0.1.2287 → 0.1.2288

package/dist/cli/main.js

@@ -172192,6 +172192,3645 @@ var require_emoji_regex = __commonJS2(function(exports2, module2) {
   };
 });
 
+// node_modules/simulate-return-current/dist/index.js
+import { BaseSolver as BaseSolver43 } from "@tscircuit/solver-utils";
+import {
+  applyToPoint as applyToPoint49,
+  compose as compose19,
+  rotateDEG as rotateDEG4,
+  translate as translate19
+} from "transformation-matrix";
+import { applyToPoint as applyToPoint214, compose as compose24, scale as scale13, translate as translate24 } from "transformation-matrix";
+import {
+  any_circuit_element as any_circuit_element3,
+  current as current4,
+  getZodPrefixedIdWithDefault as getZodPrefixedIdWithDefault3,
+  point as point11,
+  pcb_silkscreen_text as pcb_silkscreen_text3,
+  simulation_return_current_excitation
+} from "circuit-json";
+import { z as z226 } from "zod";
+import {
+  simulation_experiment as simulation_experiment3,
+  simulation_return_current_excitation as simulation_return_current_excitation2
+} from "circuit-json";
+import {
+  applyToPoint as applyToPoint310,
+  compose as compose34,
+  rotateDEG as rotateDEG22,
+  translate as translate34
+} from "transformation-matrix";
+import { z as z227 } from "zod";
+function rectangleOutline(rect) {
+  if (![
+    rect.center.x,
+    rect.center.y,
+    rect.rotation ?? 0,
+    rect.width,
+    rect.height
+  ].every(Number.isFinite) || rect.width <= 0 || rect.height <= 0)
+    throw new Error("Rectangles need finite coordinates, rotation, and positive dimensions");
+  const localToWorld = compose19(translate19(rect.center.x, rect.center.y), rotateDEG4(rect.rotation ?? 0));
+  return [
+    { x: -rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: rect.height / 2 },
+    { x: -rect.width / 2, y: rect.height / 2 }
+  ].map((corner) => applyToPoint49(localToWorld, corner));
+}
+function flattenRing(vertices) {
+  const outline = [];
+  for (let vertexIndex = 0;vertexIndex < vertices.length; vertexIndex++) {
+    const start = vertices[vertexIndex];
+    const end = vertices[(vertexIndex + 1) % vertices.length];
+    outline.push({ x: start.x, y: start.y });
+    const bulge = start.bulge ?? 0;
+    if (Math.abs(bulge) < 0.000000000001)
+      continue;
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const center = {
+      x: (start.x + end.x) / 2 - dy * (1 - bulge * bulge) / (4 * bulge),
+      y: (start.y + end.y) / 2 + dx * (1 - bulge * bulge) / (4 * bulge)
+    };
+    const sweep = 4 * Math.atan(bulge);
+    const radius = Math.hypot(start.x - center.x, start.y - center.y);
+    const startAngle = Math.atan2(start.y - center.y, start.x - center.x);
+    const steps = Math.ceil(Math.abs(sweep) / (Math.PI / 60));
+    for (let arcIndex = 1;arcIndex < steps; arcIndex++) {
+      const angle = startAngle + sweep * arcIndex / steps;
+      outline.push({
+        x: center.x + radius * Math.cos(angle),
+        y: center.y + radius * Math.sin(angle)
+      });
+    }
+  }
+  return outline;
+}
+function pointInPolygon(point, outline) {
+  let inside = false;
+  for (let cornerIndex = 0;cornerIndex < outline.length; cornerIndex++) {
+    const start = outline[cornerIndex];
+    const end = outline[(cornerIndex + 1) % outline.length];
+    const cross = (point.x - start.x) * (end.y - start.y) - (point.y - start.y) * (end.x - start.x);
+    if (Math.abs(cross) < 0.000000001 && point.x >= Math.min(start.x, end.x) - 0.000000001 && point.x <= Math.max(start.x, end.x) + 0.000000001 && point.y >= Math.min(start.y, end.y) - 0.000000001 && point.y <= Math.max(start.y, end.y) + 0.000000001)
+      return true;
+    if (start.y > point.y !== end.y > point.y && point.x < start.x + (point.y - start.y) * (end.x - start.x) / (end.y - start.y))
+      inside = !inside;
+  }
+  return inside;
+}
+function pourRegion(pour) {
+  if (pour.shape === "rect")
+    return { outer: rectangleOutline(pour), holes: [] };
+  if (pour.shape === "polygon")
+    return { outer: pour.points, holes: [] };
+  return {
+    outer: flattenRing(pour.brep_shape.outer_ring.vertices),
+    holes: pour.brep_shape.inner_rings.map((ring) => flattenRing(ring.vertices))
+  };
+}
+function normalizeDisplayOffsets(element) {
+  if (element.type === "pcb_hole" && element.pcb_component_id === null)
+    return { ...element, pcb_component_id: undefined };
+  if (element.type === "pcb_plated_hole" && element.shape === "circular_hole_with_rect_pad")
+    return {
+      ...element,
+      hole_shape: element.hole_shape ?? "circle",
+      pad_shape: element.pad_shape ?? "rect"
+    };
+  if (element.type !== "pcb_component" && element.type !== "pcb_board")
+    return element;
+  return {
+    ...element,
+    display_offset_x: typeof element.display_offset_x === "number" ? String(element.display_offset_x) : element.display_offset_x,
+    display_offset_y: typeof element.display_offset_y === "number" ? String(element.display_offset_y) : element.display_offset_y
+  };
+}
+function parseReturnCurrentCircuitJson(input) {
+  const elements = z226.array(z226.object({ type: z226.string() }).passthrough()).parse(input);
+  return elements.map((element) => {
+    if (element.type === "pcb_silkscreen_text" && element.pcb_component_id === null)
+      return pcb_silkscreen_text3.extend({ pcb_component_id: z226.null() }).parse(element);
+    if (element.type !== "simulation_return_current_excitation")
+      return {
+        ...element,
+        ...any_circuit_element3.parse(normalizeDisplayOffsets(element))
+      };
+    if (element.simulation_experiment_id !== undefined)
+      return simulation_return_current_excitation.parse(element);
+    const excitation = excitationSchema.parse(element);
+    return excitation;
+  });
+}
+function normalizeLayeredRoute(trace) {
+  const route = [];
+  for (const [index, point2] of trace.route.entries()) {
+    if (point2.route_type === "wire") {
+      route.push(point2);
+      continue;
+    }
+    if (point2.route_type !== "via")
+      throw new Error("Through-pad route points are not supported");
+    const previous = route.at(-1);
+    const next = trace.route[index + 1];
+    if (!previous || previous.route_type !== "wire" || !next)
+      throw new Error("Via needs signal route endpoints on both sides");
+    if (previous.layer !== point2.from_layer)
+      throw new Error("Via from_layer does not match preceding wire layer");
+    if (previous.x !== point2.x || previous.y !== point2.y)
+      route.push({
+        route_type: "wire",
+        x: point2.x,
+        y: point2.y,
+        width: previous.width,
+        layer: point2.from_layer
+      });
+    route.push(point2);
+    if (next.route_type !== "wire" || next.x !== point2.x || next.y !== point2.y)
+      route.push({
+        route_type: "wire",
+        x: point2.x,
+        y: point2.y,
+        width: next.route_type === "wire" ? next.width : previous.width,
+        layer: point2.to_layer
+      });
+  }
+  return { ...trace, route };
+}
+function portNetIds(circuitJson, sourcePortId) {
+  const ports = new Set([sourcePortId]);
+  const nets = new Set;
+  const pending = circuitJson.filter((element) => element.type === "source_trace");
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const trace of pending) {
+      if (!trace.connected_source_port_ids.some((id) => ports.has(id)) && !trace.connected_source_net_ids.some((id) => nets.has(id)))
+        continue;
+      for (const id of trace.connected_source_port_ids)
+        if (!ports.has(id)) {
+          ports.add(id);
+          changed = true;
+        }
+      for (const id of trace.connected_source_net_ids)
+        if (!nets.has(id)) {
+          nets.add(id);
+          changed = true;
+        }
+    }
+  }
+  return [...nets];
+}
+function assertUniqueIds(circuitJson) {
+  const ids = new Set;
+  for (const element of circuitJson) {
+    const key = `${element.type}_id`;
+    const value = element[key];
+    if (typeof value !== "string")
+      continue;
+    if (ids.has(value))
+      throw new Error(`Duplicate circuit-json ID: ${value}`);
+    ids.add(value);
+  }
+}
+function validateContact(circuitJson, contact, groundId) {
+  if (contact.contact_type === "pcb_port") {
+    const port = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === contact.pcb_port_id);
+    if (!port || port.type !== "pcb_port" || !port.layers.includes(contact.layer) || Math.hypot(port.x - contact.x, port.y - contact.y) > 0.000001)
+      throw new Error(`Return PCB port ${contact.pcb_port_id} does not match contact location/layer`);
+    if (!portNetIds(circuitJson, port.source_port_id).includes(groundId))
+      throw new Error(`Return PCB port ${contact.pcb_port_id} is not on the selected ground net`);
+  } else if (contact.contact_type === "pcb_via") {
+    const via = circuitJson.find((e) => e.type === "pcb_via" && e.pcb_via_id === contact.pcb_via_id);
+    if (!via || via.type !== "pcb_via" || !via.layers.includes(contact.layer) || Math.hypot(via.x - contact.x, via.y - contact.y) > 0.000001)
+      throw new Error(`Return PCB via ${contact.pcb_via_id} does not match contact location/layer`);
+    if (via.source_net_id !== groundId)
+      throw new Error(`Return PCB via ${contact.pcb_via_id} needs explicit selected-ground ownership`);
+  } else {
+    const pour = circuitJson.find((e) => e.type === "pcb_copper_pour" && e.pcb_copper_pour_id === contact.pcb_copper_pour_id);
+    if (!pour || pour.type !== "pcb_copper_pour" || pour.layer !== contact.layer || pour.source_net_id !== groundId)
+      throw new Error(`Return copper pour ${contact.pcb_copper_pour_id} is missing or not on the selected ground/layer`);
+    const region = pourRegion(pour);
+    if (!pointInPolygon(contact, region.outer) || region.holes.some((h) => pointInPolygon(contact, h)))
+      throw new Error(`Return contact is outside copper pour ${contact.pcb_copper_pour_id}`);
+  }
+}
+function selectReturnCurrentExperiment(options) {
+  const { circuitJson } = options;
+  assertUniqueIds(circuitJson);
+  if (circuitJson.filter((e) => e.type === "pcb_board").length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const experiments = circuitJson.filter((e) => e.type === "simulation_experiment" && e.experiment_type === "pcb_return_current" && (!options.experimentId || e.simulation_experiment_id === options.experimentId));
+  if (experiments.length !== 1 || experiments[0].type !== "simulation_experiment")
+    throw new Error(`Select exactly one pcb_return_current experiment with --experiment-id; found ${experiments.length}`);
+  const experiment = simulation_experiment3.parse(experiments[0]);
+  const excitations = circuitJson.filter((e) => e.type === "simulation_return_current_excitation" && e.simulation_experiment_id === experiment.simulation_experiment_id).map((e) => simulation_return_current_excitation2.parse(e));
+  if (!excitations.length)
+    throw new Error(`Experiment ${experiment.simulation_experiment_id} has no excitations`);
+  if (new Set(excitations.map((e) => e.ground_source_net_id)).size !== 1)
+    throw new Error("Selected excitations must share one ground net");
+  if (new Set(excitations.map((e) => e.pcb_trace_id)).size !== excitations.length)
+    throw new Error("Selected excitations must reference distinct signal traces");
+  const oriented = new Map;
+  for (const excitation of excitations) {
+    const originalTrace = circuitJson.find((e) => e.type === "pcb_trace" && e.pcb_trace_id === excitation.pcb_trace_id);
+    if (!originalTrace || originalTrace.type !== "pcb_trace")
+      throw new Error(`Missing signal trace ${excitation.pcb_trace_id}`);
+    let trace = normalizeLayeredRoute(originalTrace);
+    if (excitation.source_port) {
+      const sourcePort = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === excitation.source_port.signal_pcb_port_id);
+      const first = trace.route[0], last = trace.route.at(-1);
+      if (sourcePort?.type === "pcb_port" && last?.route_type === "wire" && Math.hypot(sourcePort.x - last.x, sourcePort.y - last.y) < 0.000001 && !(first?.route_type === "wire" && Math.hypot(sourcePort.x - first.x, sourcePort.y - first.y) < 0.000001))
+        trace = {
+          ...trace,
+          route: trace.route.map((point2, index) => {
+            if (point2.route_type === "via")
+              return {
+                ...point2,
+                from_layer: point2.to_layer,
+                to_layer: point2.from_layer
+              };
+            if (point2.route_type !== "wire")
+              return point2;
+            const previous = trace.route[Math.max(0, index - 1)];
+            return {
+              ...point2,
+              width: previous.route_type === "wire" ? previous.width : point2.width,
+              start_pcb_port_id: point2.end_pcb_port_id,
+              end_pcb_port_id: point2.start_pcb_port_id
+            };
+          }).reverse()
+        };
+    }
+    oriented.set(trace.pcb_trace_id, trace);
+    if (!circuitJson.some((e) => e.type === "source_net" && e.source_net_id === excitation.ground_source_net_id))
+      throw new Error(`Missing ground net ${excitation.ground_source_net_id}`);
+    validateContact(circuitJson, excitation.return_source, excitation.ground_source_net_id);
+    validateContact(circuitJson, excitation.return_sink, excitation.ground_source_net_id);
+    for (const [terminal, contact, endpoint] of [
+      [excitation.source_port, excitation.return_sink, trace.route[0]],
+      [excitation.load_port, excitation.return_source, trace.route.at(-1)]
+    ]) {
+      if (!terminal) {
+        if (contact.contact_type === "pcb_port" || contact.layer !== "bottom")
+          throw new Error("An identified return PCB port or non-bottom reference requires explicit source_port/load_port terminal metadata");
+        continue;
+      }
+      if (contact.contact_type === "pcb_port" && terminal.reference_pcb_port_id !== contact.pcb_port_id)
+        throw new Error("A PCB-port return contact requires its matching reference_pcb_port_id");
+      if (terminal.reference_layer !== contact.layer || terminal.reference_pcb_port_id !== undefined && (contact.contact_type !== "pcb_port" || terminal.reference_pcb_port_id !== contact.pcb_port_id))
+        throw new Error("Terminal reference must match the identified return contact");
+      const port = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === terminal.signal_pcb_port_id);
+      if (!port || port.type !== "pcb_port" || endpoint?.route_type !== "wire" || !port.layers.includes(endpoint.layer) || Math.hypot(port.x - endpoint.x, port.y - endpoint.y) > 0.000001)
+        throw new Error("Signal terminal must match the source/load trace endpoint");
+      if (terminal.signal_pcb_port_id === terminal.reference_pcb_port_id)
+        throw new Error("Signal and reference terminals must be different ports");
+    }
+    if ([excitation.return_source, excitation.return_sink].some((c) => c.contact_type === "pcb_via"))
+      throw new Error("Via return contacts are not supported by the current solver adapter; use a PCB port or copper-pour contact");
+  }
+  return {
+    experiment,
+    excitations,
+    solverCircuitJson: circuitJson.map((e) => e.type === "pcb_trace" ? oriented.get(e.pcb_trace_id) ?? e : e)
+  };
+}
+var excitationSchema, copperLayer, fabricationStackupSchema;
+var init_dist6 = __esm(() => {
+  excitationSchema = z226.object({
+    type: z226.literal("simulation_return_current_excitation"),
+    simulation_return_current_excitation_id: getZodPrefixedIdWithDefault3("simulation_return_current_excitation"),
+    pcb_trace_id: z226.string(),
+    ground_source_net_id: z226.string(),
+    current: current4.pipe(z226.number().finite()),
+    return_source: point11.refine((contact) => Number.isFinite(contact.x) && Number.isFinite(contact.y)),
+    return_sink: point11.refine((contact) => Number.isFinite(contact.x) && Number.isFinite(contact.y)),
+    source_port: z226.object({
+      signal_pcb_port_id: z226.string(),
+      reference_pcb_port_id: z226.string().optional(),
+      reference_layer: z226.string().regex(/^(top|bottom|inner[1-8])$/).transform((layer) => layer),
+      resistance: z226.number().finite().positive()
+    }).optional(),
+    load_port: z226.object({
+      signal_pcb_port_id: z226.string(),
+      reference_pcb_port_id: z226.string().optional(),
+      reference_layer: z226.string().regex(/^(top|bottom|inner[1-8])$/).transform((layer) => layer),
+      resistance: z226.number().finite().positive()
+    }).optional()
+  });
+  copperLayer = z227.string().regex(/^(top|bottom|inner[1-8])$/);
+  fabricationStackupSchema = z227.object({
+    nominalBoardThicknessMm: z227.number().finite().positive().optional(),
+    layers: z227.array(z227.union([
+      z227.object({
+        name: copperLayer,
+        copperThicknessMm: z227.number().finite().positive()
+      }),
+      z227.object({
+        material: z227.string().min(1),
+        dielectricThicknessMm: z227.number().finite().positive(),
+        dielectricConstant: z227.number().finite().positive(),
+        lossTangent: z227.number().finite().nonnegative().optional()
+      })
+    ]))
+  });
+});
+
+// node_modules/simulate-return-current/dist/palace.js
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve32, join as join22 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { resolve as resolve12, join as join18 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { spawn as spawn2 } from "node:child_process";
+import { open as open2 } from "node:fs/promises";
+import { mkdir as mkdir22, writeFile as writeFile22 } from "node:fs/promises";
+import { resolve as resolve22 } from "node:path";
+import {
+  applyToPoint as applyToPoint50,
+  compose as compose20,
+  rotateDEG as rotateDEG5,
+  translate as translate20
+} from "transformation-matrix";
+import {
+  applyToPoint as applyToPoint215,
+  compose as compose25,
+  rotateDEG as rotateDEG23,
+  translate as translate25
+} from "transformation-matrix";
+import { z as z228 } from "zod";
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
+import { writeFile as writeFile32 } from "node:fs/promises";
+import { Resvg as Resvg3 } from "@resvg/resvg-js";
+import { applyToPoint as applyToPoint311, compose as compose35, scale as scale14, translate as translate35 } from "transformation-matrix";
+import { Resvg as Resvg22 } from "@resvg/resvg-js";
+import { BaseSolver as BaseSolver44 } from "@tscircuit/solver-utils";
+function normalizeLayeredRoute2(trace) {
+  const route = [];
+  for (const [index, point] of trace.route.entries()) {
+    if (point.route_type === "wire") {
+      route.push(point);
+      continue;
+    }
+    if (point.route_type !== "via")
+      throw new Error("Through-pad route points are not supported");
+    const previous = route.at(-1);
+    const next = trace.route[index + 1];
+    if (!previous || previous.route_type !== "wire" || !next)
+      throw new Error("Via needs signal route endpoints on both sides");
+    if (previous.layer !== point.from_layer)
+      throw new Error("Via from_layer does not match preceding wire layer");
+    if (previous.x !== point.x || previous.y !== point.y)
+      route.push({
+        route_type: "wire",
+        x: point.x,
+        y: point.y,
+        width: previous.width,
+        layer: point.from_layer
+      });
+    route.push(point);
+    if (next.route_type !== "wire" || next.x !== point.x || next.y !== point.y)
+      route.push({
+        route_type: "wire",
+        x: point.x,
+        y: point.y,
+        width: next.route_type === "wire" ? next.width : previous.width,
+        layer: point.to_layer
+      });
+  }
+  return { ...trace, route };
+}
+function parseCurrentAmps(value) {
+  return parseQuantity(value, { A: 1, mA: 0.001, uA: 0.000001, µA: 0.000001, μA: 0.000001, nA: 0.000000001 }, "current", false);
+}
+function parseResistanceOhms(value) {
+  return parseQuantity(value, {
+    ohm: 1,
+    ohms: 1,
+    Ohm: 1,
+    Ω: 1,
+    kohm: 1000,
+    kOhm: 1000,
+    kΩ: 1000,
+    Mohm: 1e6,
+    MOhm: 1e6,
+    MΩ: 1e6
+  }, "resistance", true);
+}
+function parseQuantity(value, units, label, positive) {
+  let result;
+  if (typeof value === "number")
+    result = value;
+  else if (typeof value === "string") {
+    const match = /^\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*([^\s]*)\s*$/.exec(value);
+    const scale = match ? match[2] === "" ? 1 : units[match[2]] : undefined;
+    if (!match || scale === undefined)
+      throw new Error(`Invalid ${label} "${value}"; supported units: ${Object.keys(units).join(", ")}`);
+    result = Number(match[1]) * scale;
+  } else
+    throw new Error(`${label} must be a number or a value with units`);
+  if (!Number.isFinite(result) || positive && result <= 0)
+    throw new Error(`${label} must be finite${positive ? " and greater than zero" : ""}`);
+  return result;
+}
+function portNetIds2(circuitJson, sourcePortId) {
+  const ports = new Set([sourcePortId]);
+  const nets = new Set;
+  const pending = circuitJson.filter((element) => element.type === "source_trace");
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const trace of pending) {
+      if (!trace.connected_source_port_ids.some((id) => ports.has(id)) && !trace.connected_source_net_ids.some((id) => nets.has(id)))
+        continue;
+      for (const id of trace.connected_source_port_ids)
+        if (!ports.has(id)) {
+          ports.add(id);
+          changed = true;
+        }
+      for (const id of trace.connected_source_net_ids)
+        if (!nets.has(id)) {
+          nets.add(id);
+          changed = true;
+        }
+    }
+  }
+  return [...nets];
+}
+function aliases2(port) {
+  return [
+    ...new Set([
+      port.name,
+      ...port.port_hints ?? [],
+      ...port.pin_number === undefined ? [] : [`pin${port.pin_number}`, String(port.pin_number)]
+    ])
+  ];
+}
+function resolvePort(circuitJson, selector) {
+  const match = /^([^\.\s]+)\.([^\.\s]+)$/.exec(selector);
+  if (!match)
+    throw new Error(`Port "${selector}" must use refdes.pin syntax, e.g. R1.pin1 or U1.VDDIO1`);
+  const components = circuitJson.filter((element) => element.type === "source_component" && element.name === match[1]);
+  if (components.length !== 1 || components[0].type !== "source_component")
+    throw new Error(`Component "${match[1]}" is ${components.length ? "ambiguous" : "missing"}`);
+  const componentId = components[0].source_component_id;
+  const ports = circuitJson.filter((element) => element.type === "source_port" && element.source_component_id === componentId && aliases2(element).includes(match[2]));
+  if (ports.length !== 1)
+    throw new Error(`Port "${selector}" is ${ports.length ? "ambiguous" : "missing"}; use the ports command to inspect selectors`);
+  const pcbPorts = circuitJson.filter((element) => element.type === "pcb_port" && element.source_port_id === ports[0].source_port_id);
+  if (pcbPorts.length !== 1)
+    throw new Error(`Port "${selector}" needs exactly one PCB port location`);
+  return { source: ports[0], pcb: pcbPorts[0] };
+}
+function endpointMatches(circuitJson, trace, endpoint, port) {
+  if (endpoint.route_type !== "wire" || !port.pcb.layers.includes(endpoint.layer) || Math.hypot(endpoint.x - port.pcb.x, endpoint.y - port.pcb.y) > 0.000001)
+    return false;
+  const ids = [endpoint.start_pcb_port_id, endpoint.end_pcb_port_id].filter(Boolean);
+  if (ids.length)
+    return ids.includes(port.pcb.pcb_port_id);
+  const sourceTrace = circuitJson.find((element) => element.type === "source_trace" && element.source_trace_id === trace.source_trace_id);
+  return sourceTrace?.type === "source_trace" && sourceTrace.connected_source_port_ids.includes(port.source.source_port_id);
+}
+function withNamedExcitations(options) {
+  options = {
+    ...options,
+    circuitJson: options.circuitJson.map((e) => e.type === "pcb_trace" ? normalizeLayeredRoute2(e) : e)
+  };
+  if (!options.ports.length)
+    throw new Error("Specify at least one source/load/current excitation");
+  const nets = options.circuitJson.filter((element) => element.type === "source_net" && (element.name === options.groundNet || element.source_net_id === options.groundNet));
+  if (nets.length !== 1 || nets[0].type !== "source_net")
+    throw new Error(`Ground net "${options.groundNet}" is ${nets.length ? "ambiguous" : "missing"}`);
+  const groundId = nets[0].source_net_id;
+  const oriented = new Map;
+  const excitations = [];
+  for (const [index, excitation] of options.ports.entries()) {
+    const current = parseCurrentAmps(excitation.current);
+    const source = resolvePort(options.circuitJson, excitation.source);
+    const load2 = resolvePort(options.circuitJson, excitation.load);
+    const reference = (selector, signal) => {
+      if (!selector)
+        return {
+          point: { x: signal.pcb.x, y: signal.pcb.y },
+          layer: options.referenceLayer ?? "bottom",
+          pcbPortId: undefined
+        };
+      const port = resolvePort(options.circuitJson, selector);
+      if (!portNetIds2(options.circuitJson, port.source.source_port_id).includes(groundId))
+        throw new Error(`Reference "${selector}" is not connected to the selected ground net; connect it explicitly in TSX`);
+      if (port.pcb.pcb_port_id === signal.pcb.pcb_port_id)
+        throw new Error("Signal and reference terminals must be different ports");
+      const layer = port.pcb.layers.includes("top") ? "top" : port.pcb.layers.includes("bottom") ? "bottom" : port.pcb.layers[0];
+      if (!port.pcb.layers.includes(layer))
+        throw new Error(`Reference "${selector}" needs a physical copper layer`);
+      return {
+        point: { x: port.pcb.x, y: port.pcb.y },
+        layer,
+        pcbPortId: port.pcb.pcb_port_id
+      };
+    };
+    const sourceReference = reference(excitation.sourceReference, source);
+    const loadReference = reference(excitation.loadReference, load2);
+    if (source.pcb.pcb_port_id === load2.pcb.pcb_port_id)
+      throw new Error("Source and load must be different ports");
+    const candidates = options.circuitJson.flatMap((element) => {
+      if (element.type !== "pcb_trace" || element.route.length < 2)
+        return [];
+      const first = element.route[0];
+      const last = element.route[element.route.length - 1];
+      const forward = endpointMatches(options.circuitJson, element, first, source) && endpointMatches(options.circuitJson, element, last, load2);
+      const reverse2 = endpointMatches(options.circuitJson, element, last, source) && endpointMatches(options.circuitJson, element, first, load2);
+      return forward || reverse2 ? [{ trace: element, reverse: reverse2 }] : [];
+    });
+    if (candidates.length !== 1)
+      throw new Error(`"${excitation.source}" → "${excitation.load}" needs exactly one continuous PCB trace; found ${candidates.length}. Branched nets and component-spanning paths are not supported`);
+    const { trace, reverse } = candidates[0];
+    if (oriented.has(trace.pcb_trace_id))
+      throw new Error(`Trace ${trace.pcb_trace_id} is selected more than once`);
+    const route = reverse ? trace.route.map((point, routeIndex) => {
+      if (point.route_type === "via")
+        return {
+          ...point,
+          from_layer: point.to_layer,
+          to_layer: point.from_layer
+        };
+      if (point.route_type !== "wire")
+        return point;
+      const previous = trace.route[Math.max(0, routeIndex - 1)];
+      return {
+        ...point,
+        width: previous.route_type === "wire" ? previous.width : point.width,
+        start_pcb_port_id: point.end_pcb_port_id,
+        end_pcb_port_id: point.start_pcb_port_id
+      };
+    }).reverse() : trace.route;
+    oriented.set(trace.pcb_trace_id, { ...trace, route });
+    excitations.push({
+      type: "simulation_return_current_excitation",
+      simulation_return_current_excitation_id: `simulation_return_current_excitation_${index}`,
+      pcb_trace_id: trace.pcb_trace_id,
+      ground_source_net_id: groundId,
+      current,
+      return_source: loadReference.point,
+      return_sink: sourceReference.point,
+      source_port: {
+        signal_pcb_port_id: source.pcb.pcb_port_id,
+        reference_pcb_port_id: sourceReference.pcbPortId,
+        reference_layer: sourceReference.layer,
+        resistance: parseResistanceOhms(excitation.sourceImpedance ?? 50)
+      },
+      load_port: {
+        signal_pcb_port_id: load2.pcb.pcb_port_id,
+        reference_pcb_port_id: loadReference.pcbPortId,
+        reference_layer: loadReference.layer,
+        resistance: parseResistanceOhms(excitation.loadImpedance ?? 50)
+      }
+    });
+  }
+  return [
+    ...options.circuitJson.filter((element) => element.type !== "simulation_return_current_excitation").map((element) => element.type === "pcb_trace" ? oriented.get(element.pcb_trace_id) ?? element : element),
+    ...excitations
+  ];
+}
+async function runCommand2(options) {
+  const log = await open2(options.logPath, "w");
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn2(options.command[0], options.command.slice(1), {
+        cwd: options.cwd,
+        stdio: ["ignore", log.fd, log.fd]
+      });
+      child.once("error", (error) => reject(new Error(`Could not start ${options.command[0]}: ${error.message}; see ${options.logPath}`)));
+      child.once("close", (status, signal) => status === 0 ? resolve() : reject(new Error(`${options.command[0]} exited with ${status ?? signal}; see ${options.logPath}`)));
+    });
+  } finally {
+    await log.close();
+  }
+}
+function palacePythonAsset(filename) {
+  return fileURLToPath2(new URL(`./python/${filename}`, import.meta.url));
+}
+function venvPython(directory) {
+  return join18(directory, process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+}
+function palacePython(explicit) {
+  if (explicit || process.env.PALACE_PYTHON)
+    return explicit ?? process.env.PALACE_PYTHON;
+  const local = venvPython(resolve12(".return-current-python"));
+  return existsSync17(local) ? local : "python3";
+}
+function rectangleOutline2(rect) {
+  if (![
+    rect.center.x,
+    rect.center.y,
+    rect.rotation ?? 0,
+    rect.width,
+    rect.height
+  ].every(Number.isFinite) || rect.width <= 0 || rect.height <= 0)
+    throw new Error("Rectangles need finite coordinates, rotation, and positive dimensions");
+  const localToWorld = compose20(translate20(rect.center.x, rect.center.y), rotateDEG5(rect.rotation ?? 0));
+  return [
+    { x: -rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: rect.height / 2 },
+    { x: -rect.width / 2, y: rect.height / 2 }
+  ].map((corner) => applyToPoint50(localToWorld, corner));
+}
+function flattenRing2(vertices) {
+  const outline = [];
+  for (let vertexIndex = 0;vertexIndex < vertices.length; vertexIndex++) {
+    const start = vertices[vertexIndex];
+    const end = vertices[(vertexIndex + 1) % vertices.length];
+    outline.push({ x: start.x, y: start.y });
+    const bulge = start.bulge ?? 0;
+    if (Math.abs(bulge) < 0.000000000001)
+      continue;
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const center = {
+      x: (start.x + end.x) / 2 - dy * (1 - bulge * bulge) / (4 * bulge),
+      y: (start.y + end.y) / 2 + dx * (1 - bulge * bulge) / (4 * bulge)
+    };
+    const sweep = 4 * Math.atan(bulge);
+    const radius = Math.hypot(start.x - center.x, start.y - center.y);
+    const startAngle = Math.atan2(start.y - center.y, start.x - center.x);
+    const steps = Math.ceil(Math.abs(sweep) / (Math.PI / 60));
+    for (let arcIndex = 1;arcIndex < steps; arcIndex++) {
+      const angle = startAngle + sweep * arcIndex / steps;
+      outline.push({
+        x: center.x + radius * Math.cos(angle),
+        y: center.y + radius * Math.sin(angle)
+      });
+    }
+  }
+  return outline;
+}
+function cutoutOutline(cutout) {
+  if (cutout.shape === "polygon")
+    return cutout.points;
+  if (cutout.shape === "circle") {
+    if (!Number.isFinite(cutout.radius) || cutout.radius <= 0)
+      throw new Error("Circular cutouts need a finite positive radius");
+    return Array.from({ length: 120 }, (_, circleIndex) => ({
+      x: cutout.center.x + cutout.radius * Math.cos(circleIndex * Math.PI / 60),
+      y: cutout.center.y + cutout.radius * Math.sin(circleIndex * Math.PI / 60)
+    }));
+  }
+  if (cutout.shape === "rect" && !cutout.corner_radius)
+    return rectangleOutline2(cutout);
+  throw new Error("Path and rounded rectangular PCB cutouts are not supported; use a polygon cutout");
+}
+function pointInPolygon2(point, outline) {
+  let inside = false;
+  for (let cornerIndex = 0;cornerIndex < outline.length; cornerIndex++) {
+    const start = outline[cornerIndex];
+    const end = outline[(cornerIndex + 1) % outline.length];
+    const cross = (point.x - start.x) * (end.y - start.y) - (point.y - start.y) * (end.x - start.x);
+    if (Math.abs(cross) < 0.000000001 && point.x >= Math.min(start.x, end.x) - 0.000000001 && point.x <= Math.max(start.x, end.x) + 0.000000001 && point.y >= Math.min(start.y, end.y) - 0.000000001 && point.y <= Math.max(start.y, end.y) + 0.000000001)
+      return true;
+    if (start.y > point.y !== end.y > point.y && point.x < start.x + (point.y - start.y) * (end.x - start.x) / (end.y - start.y))
+      inside = !inside;
+  }
+  return inside;
+}
+function pointInRegion(point, region) {
+  return pointInPolygon2(point, region.outer) && !region.holes.some((hole) => pointInPolygon2(point, hole)) && !(region.maskCutouts ?? []).some((hole) => pointInPolygon2(point, hole));
+}
+function isCopper(point, geometry) {
+  return pointInPolygon2(point, geometry.boardOutline) && !geometry.cutouts.some((cutout) => pointInPolygon2(point, cutout)) && geometry.groundRegions.some((region) => pointInRegion(point, region));
+}
+function segmentInCopper(segment, geometry) {
+  const outlines = [
+    geometry.boardOutline,
+    ...geometry.cutouts,
+    ...geometry.groundRegions.flatMap((region) => [
+      region.outer,
+      ...region.holes
+    ])
+  ];
+  const dx = segment.end.x - segment.start.x;
+  const dy = segment.end.y - segment.start.y;
+  const crossings = [0, 1];
+  for (const outline of outlines) {
+    for (let cornerIndex = 0;cornerIndex < outline.length; cornerIndex++) {
+      const start = outline[cornerIndex];
+      const end = outline[(cornerIndex + 1) % outline.length];
+      const ex = end.x - start.x;
+      const ey = end.y - start.y;
+      const determinant = dx * ey - dy * ex;
+      if (Math.abs(determinant) < 0.000000000001)
+        continue;
+      const ax = start.x - segment.start.x;
+      const ay = start.y - segment.start.y;
+      const alongSegment = (ax * ey - ay * ex) / determinant;
+      const alongBoundary = (ax * dy - ay * dx) / determinant;
+      if (alongSegment > 0 && alongSegment < 1 && alongBoundary >= 0 && alongBoundary <= 1)
+        crossings.push(alongSegment);
+    }
+  }
+  crossings.sort((a, b) => a - b);
+  for (let crossingIndex = 1;crossingIndex < crossings.length; crossingIndex++) {
+    const fraction = (crossings[crossingIndex - 1] + crossings[crossingIndex]) / 2;
+    if (!isCopper({
+      x: segment.start.x + fraction * dx,
+      y: segment.start.y + fraction * dy
+    }, geometry))
+      return false;
+  }
+  return true;
+}
+function pourRegion2(pour) {
+  if (pour.shape === "rect")
+    return { outer: rectangleOutline2(pour), holes: [] };
+  if (pour.shape === "polygon")
+    return { outer: pour.points, holes: [] };
+  return {
+    outer: flattenRing2(pour.brep_shape.outer_ring.vertices),
+    holes: pour.brep_shape.inner_rings.map((ring) => flattenRing2(ring.vertices))
+  };
+}
+function positiveFinite(number, label) {
+  if (!Number.isFinite(number) || number <= 0)
+    throw new Error(`${label} must be finite and greater than zero`);
+  return number;
+}
+function validateOutline(outline) {
+  if (outline.length < 3 || outline.some((point) => !Number.isFinite(point.x) || !Number.isFinite(point.y)))
+    throw new Error("Copper and board polygons need at least three finite points");
+}
+function readGeometry(options) {
+  const boards = options.circuitJson.filter((element) => element.type === "pcb_board");
+  if (boards.length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const board = boards[0];
+  if (board.num_layers !== 2)
+    throw new Error("Return-current simulation currently requires a two-layer board");
+  if (options.circuitJson.some((element) => element.type === "pcb_hole" || element.type === "pcb_plated_hole" || element.type === "pcb_via"))
+    throw new Error("Drilled holes and vias are not supported yet; represent voids with PCB cutouts and model return contacts explicitly");
+  const boardOutline = board.outline?.length ? board.outline : rectangleOutline2({
+    center: board.center,
+    width: positiveFinite(board.width ?? 0, "Board width"),
+    height: positiveFinite(board.height ?? 0, "Board height")
+  });
+  const excitations = options.excitations ?? options.circuitJson.filter((element) => element.type === "simulation_return_current_excitation");
+  if (!excitations.length)
+    throw new Error("Specify return-current excitations with signal current and return contacts");
+  const groundNetIds = new Set(excitations.map((excitation) => excitation.ground_source_net_id));
+  if (groundNetIds.size !== 1)
+    throw new Error("All excitations must share one ground net");
+  const pours = options.circuitJson.filter((element) => element.type === "pcb_copper_pour" && element.layer === "bottom" && groundNetIds.has(element.source_net_id ?? ""));
+  const groundPlanes = options.circuitJson.filter((element) => element.type === "pcb_ground_plane" && groundNetIds.has(element.source_net_id));
+  const groundPlaneIds = new Set(groundPlanes.flatMap((element) => element.type === "pcb_ground_plane" ? [element.pcb_ground_plane_id] : []));
+  const planeRegions = options.circuitJson.filter((element) => element.type === "pcb_ground_plane_region" && element.layer === "bottom" && groundPlaneIds.has(element.pcb_ground_plane_id));
+  const groundRegions = [
+    ...pours.map(pourRegion2),
+    ...planeRegions.flatMap((region) => region.type === "pcb_ground_plane_region" ? [{ outer: region.points, holes: [] }] : [])
+  ];
+  if (!groundRegions.length)
+    throw new Error("The selected ground net needs a bottom-layer copper pour or ground-plane region");
+  const cutouts = options.circuitJson.filter((element) => element.type === "pcb_cutout").map(cutoutOutline);
+  for (const outline of [
+    boardOutline,
+    ...cutouts,
+    ...groundRegions.flatMap((region) => [region.outer, ...region.holes])
+  ])
+    validateOutline(outline);
+  const geometry = {
+    board,
+    boardOutline,
+    groundRegions,
+    cutouts,
+    signals: [],
+    segments: [],
+    excitations
+  };
+  for (const excitation of excitations) {
+    if (!Number.isFinite(excitation.current))
+      throw new Error("Excitation current must be finite (amperes)");
+    for (const contact of [excitation.return_source, excitation.return_sink]) {
+      if (!Number.isFinite(contact.x) || !Number.isFinite(contact.y) || !isCopper(contact, geometry))
+        throw new Error("Each return contact must lie on the selected ground copper");
+    }
+    const signal = options.circuitJson.find((element) => element.type === "pcb_trace" && element.pcb_trace_id === excitation.pcb_trace_id);
+    if (!signal || signal.type !== "pcb_trace")
+      throw new Error("An excitation references a missing signal trace");
+    if (signal.route.length < 2)
+      throw new Error("Each signal trace needs at least two route points");
+    const wires = signal.route.map((routePoint) => {
+      if (routePoint.route_type !== "wire" || routePoint.layer !== "top")
+        throw new Error("Only continuous top-layer wire routes are supported; split routes at vias or pads");
+      if (!Number.isFinite(routePoint.x) || !Number.isFinite(routePoint.y))
+        throw new Error("Signal coordinates must be finite");
+      positiveFinite(routePoint.width, "Signal width");
+      return routePoint;
+    });
+    geometry.signals.push(signal);
+    for (let routeIndex = 1;routeIndex < wires.length; routeIndex++) {
+      const start = wires[routeIndex - 1];
+      const end = wires[routeIndex];
+      if (start.x === end.x && start.y === end.y)
+        continue;
+      const boardMaterial = {
+        ...geometry,
+        groundRegions: [{ outer: boardOutline, holes: [] }]
+      };
+      if (!segmentInCopper({ start, end }, boardMaterial))
+        throw new Error("A top-layer signal leaves the board or crosses a physical PCB cutout");
+      geometry.segments.push({
+        start,
+        end,
+        width: start.width,
+        current: excitation.current
+      });
+    }
+  }
+  if (!geometry.segments.length)
+    throw new Error("Signal traces must contain a segment of nonzero length");
+  return geometry;
+}
+function copperConnectivity(circuitJson) {
+  const parents = new Map;
+  const find = (id) => {
+    const parent = parents.get(id);
+    if (!parent) {
+      parents.set(id, id);
+      return id;
+    }
+    if (parent === id)
+      return id;
+    const root = find(parent);
+    parents.set(id, root);
+    return root;
+  };
+  for (const element of circuitJson) {
+    if (element.type !== "source_trace")
+      continue;
+    const ids = [
+      element.source_trace_id,
+      ...element.connected_source_net_ids,
+      ...element.connected_source_port_ids
+    ];
+    for (const id of ids)
+      parents.set(find(id), find(ids[0]));
+  }
+  const netIds = new Map;
+  for (const element of circuitJson)
+    if (element.type === "source_net") {
+      const root = find(element.source_net_id);
+      const existing = netIds.get(root);
+      if (existing && existing !== element.source_net_id)
+        throw new Error(`Source connectivity joins distinct nets ${existing} and ${element.source_net_id}`);
+      netIds.set(root, element.source_net_id);
+    }
+  const owner = (id) => netIds.get(find(id)) ?? find(id);
+  const pcbPorts = new Map;
+  const pcbTraces = new Map;
+  for (const element of circuitJson) {
+    if (element.type === "pcb_port")
+      pcbPorts.set(element.pcb_port_id, owner(element.source_port_id));
+    if (element.type === "pcb_trace")
+      pcbTraces.set(element.pcb_trace_id, owner(element.source_trace_id ?? element.pcb_trace_id));
+  }
+  return { owner, pcbPorts, pcbTraces };
+}
+function traceOutline(segment) {
+  const dx = segment.end.x - segment.start.x;
+  const dy = segment.end.y - segment.start.y;
+  const length = Math.hypot(dx, dy);
+  const transform = compose25(translate25((segment.start.x + segment.end.x) / 2, (segment.start.y + segment.end.y) / 2), rotateDEG23(Math.atan2(dy, dx) * 180 / Math.PI));
+  return [-1, 1].flatMap((end) => Array.from({ length: 17 }, (_, index) => {
+    const angle = index * Math.PI / 16 + (end === 1 ? -Math.PI / 2 : Math.PI / 2);
+    return applyToPoint215(transform, {
+      x: end * length / 2 + segment.width / 2 * Math.cos(angle),
+      y: segment.width / 2 * Math.sin(angle)
+    });
+  }));
+}
+function roundedOutline(options) {
+  positiveFinite(options.width, "outline width");
+  positiveFinite(options.height, "outline height");
+  const radius = options.radius ?? Math.min(options.width, options.height) / 2;
+  if (!Number.isFinite(radius) || radius <= 0 || radius > Math.min(options.width, options.height) / 2 + 0.0000001)
+    throw new Error("Invalid rounded copper radius");
+  const transform = compose25(translate25(options.x, options.y), rotateDEG23(options.ccwRotationDegrees ?? 0));
+  return Array.from({ length: 32 }, (_, index) => {
+    const angle = index * 2 * Math.PI / 32;
+    const x = Math.cos(angle), y = Math.sin(angle);
+    return applyToPoint215(transform, {
+      x: Math.sign(x) * (options.width / 2 - radius) + radius * x,
+      y: Math.sign(y) * (options.height / 2 - radius) + radius * y
+    });
+  });
+}
+function smtPadOutline(pad) {
+  if (pad.shape === "polygon")
+    return pad.points;
+  if (pad.shape === "circle")
+    return roundedOutline({
+      ...pad,
+      width: 2 * pad.radius,
+      height: 2 * pad.radius
+    });
+  if (pad.shape === "rect" || pad.shape === "rotated_rect")
+    return rectangleOutline2({
+      center: pad,
+      width: pad.width,
+      height: pad.height,
+      rotation: pad.shape === "rotated_rect" ? pad.ccw_rotation : 0
+    });
+  if (pad.shape === "pill" || pad.shape === "rotated_pill")
+    return roundedOutline({
+      ...pad,
+      radius: pad.radius,
+      ccwRotationDegrees: pad.shape === "rotated_pill" ? pad.ccw_rotation : 0
+    });
+  throw new Error("Unsupported SMT pad shape");
+}
+function drillOutline(hole) {
+  if ("hole_diameter" in hole)
+    return roundedOutline({
+      x: hole.x + ("hole_offset_x" in hole ? hole.hole_offset_x ?? 0 : 0),
+      y: hole.y + ("hole_offset_y" in hole ? hole.hole_offset_y ?? 0 : 0),
+      width: positiveFinite(hole.hole_diameter ?? 0, "hole diameter"),
+      height: positiveFinite(hole.hole_diameter ?? 0, "hole diameter")
+    });
+  if ("hole_width" in hole)
+    return roundedOutline({
+      ...hole,
+      width: positiveFinite(hole.hole_width ?? 0, "hole width"),
+      height: positiveFinite(hole.hole_height ?? 0, "hole height"),
+      ccwRotationDegrees: "ccw_rotation" in hole ? hole.ccw_rotation : 0
+    });
+  throw new Error("Unsupported drilled hole shape");
+}
+function platedPadOutline(hole) {
+  if ("outer_diameter" in hole)
+    return roundedOutline({
+      ...hole,
+      width: hole.outer_diameter,
+      height: hole.outer_diameter
+    });
+  if ("outer_width" in hole)
+    return roundedOutline({
+      ...hole,
+      width: hole.outer_width,
+      height: hole.outer_height,
+      ccwRotationDegrees: "ccw_rotation" in hole ? hole.ccw_rotation : 0
+    });
+  if (hole.shape === "circular_hole_with_rect_pad")
+    return rectangleOutline2({
+      center: hole,
+      width: hole.rect_pad_width,
+      height: hole.rect_pad_height,
+      rotation: hole.rect_ccw_rotation
+    });
+  throw new Error(`Unsupported plated hole shape: ${hole.shape}`);
+}
+function parseFabricationStackup(input) {
+  return fabricationStackupSchema2.parse(input);
+}
+function physicalStackup(options) {
+  const stackup = parseFabricationStackup(options.stackup);
+  const expected = [
+    "top",
+    ...Array.from({ length: options.numLayers - 2 }, (_, i) => `inner${i + 1}`),
+    "bottom"
+  ];
+  if (stackup.layers.length !== 2 * options.numLayers - 1)
+    throw new Error("Stackup must alternate copper and dielectric, top to bottom");
+  const copperLayers = [];
+  const dielectrics = [];
+  const bottom = stackup.layers.at(-1);
+  if (!bottom || !("name" in bottom) || bottom.name !== "bottom")
+    throw new Error("Stackup must end with bottom copper");
+  let z2 = -bottom.copperThicknessMm;
+  for (let index = stackup.layers.length - 1;index >= 0; index--) {
+    const layer = stackup.layers[index];
+    if (index % 2 === 0) {
+      if (!("name" in layer) || layer.name !== expected[index / 2])
+        throw new Error(`Stackup copper order must be ${expected.join(", ")}`);
+      const thickness = positiveFinite(layer.copperThicknessMm, "copper thickness");
+      copperLayers.unshift({ name: layer.name, zMin: z2, zMax: z2 + thickness });
+      z2 += thickness;
+    } else {
+      if (!("material" in layer))
+        throw new Error("A dielectric is required between copper layers");
+      dielectrics.push({
+        material: layer.material,
+        zMin: z2,
+        zMax: z2 + layer.dielectricThicknessMm,
+        dielectricConstant: layer.dielectricConstant,
+        lossTangent: layer.lossTangent ?? options.lossTangent,
+        attribute: 100 + index
+      });
+      z2 += layer.dielectricThicknessMm;
+    }
+  }
+  return {
+    copperLayers,
+    dielectrics,
+    physicalThicknessMm: z2 + bottom.copperThicknessMm,
+    nominalBoardThicknessMm: stackup.nominalBoardThicknessMm
+  };
+}
+function createMultilayerPalaceModel(options) {
+  options = {
+    ...options,
+    circuitJson: options.circuitJson.map((e) => e.type === "pcb_trace" ? normalizeLayeredRoute2(e) : e)
+  };
+  const boards = options.circuitJson.filter((e) => e.type === "pcb_board");
+  if (boards.length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const board = boards[0];
+  if (options.copperModel === "surface_impedance_copper")
+    throw new Error("surface_impedance_copper currently supports the two-layer mesher only");
+  if (!options.stackup)
+    throw new Error("Multilayer boards require an explicit fabrication stackup (--stackup-file); layer spacing is not inferred");
+  if (!Number.isInteger(board.num_layers) || board.num_layers < 2)
+    throw new Error("Board must have at least two copper layers");
+  if (options.layerSeparation !== undefined || options.copperThickness !== undefined)
+    throw new Error("Use stackup layer thicknesses instead of layerSeparation/copperThickness");
+  const substrateLossTangent = options.substrateLossTangent ?? 0.02;
+  if (!Number.isFinite(substrateLossTangent) || substrateLossTangent < 0)
+    throw new Error("substrateLossTangent must be finite and nonnegative");
+  const stackup = physicalStackup({
+    stackup: options.stackup,
+    numLayers: board.num_layers,
+    lossTangent: substrateLossTangent
+  });
+  const sampleLayer = options.sampleLayer ?? "bottom";
+  const sampleFoil = stackup.copperLayers.find((layer) => layer.name === sampleLayer);
+  if (!sampleFoil)
+    throw new Error(`Sample layer ${sampleLayer} is absent from the stackup`);
+  const frequencyHz = positiveFinite(options.frequencyHz, "frequencyHz");
+  const copperConductivity = positiveFinite(options.copperConductivity ?? 58000000, "copperConductivity");
+  const skinDepthMm = 1000 / Math.sqrt(Math.PI * frequencyHz * 0.0000004 * Math.PI * copperConductivity);
+  if (stackup.copperLayers.some((layer) => layer.zMax - layer.zMin > skinDepthMm))
+    throw new Error("The current volume mesher requires copper thickness <= skin depth; refine copper through its thickness before using higher frequencies");
+  const excitations = options.excitations ?? options.circuitJson.filter((e) => e.type === "simulation_return_current_excitation");
+  const groundIds = new Set(excitations.map((e) => e.ground_source_net_id));
+  if (!excitations.length || groundIds.size !== 1)
+    throw new Error("Specify excitations sharing one reference net");
+  const referenceNetId = excitations[0].ground_source_net_id;
+  const connectivity = copperConnectivity(options.circuitJson);
+  const boardOutline = board.outline?.length ? board.outline : rectangleOutline2({
+    center: board.center,
+    width: board.width ?? 0,
+    height: board.height ?? 0
+  });
+  const boardCutouts = options.circuitJson.filter((e) => e.type === "pcb_cutout").map(cutoutOutline);
+  const viaClearance = positiveFinite(options.viaClearance ?? board.min_trace_to_pad_edge_clearance ?? 0.2, "viaClearance");
+  const layered = {
+    stackup,
+    sampleLayer,
+    referenceNetId,
+    viaClearance,
+    copper: [],
+    drills: [],
+    barrels: [],
+    boardCutouts,
+    audit: {
+      traces: 0,
+      vias: 0,
+      pads: 0,
+      platedHoles: 0,
+      unplatedHoles: 0,
+      pours: 0,
+      omittedCopperElements: 0,
+      warnings: [
+        "Component bodies, package/decoupling impedances, solder mask and silkscreen are not modeled.",
+        "Circular copper/drills use 32-sided polygons. Via plating uses 0.025 mm; override support is not yet provided."
+      ]
+    }
+  };
+  const copperByKey = new Map;
+  for (const layer of stackup.copperLayers)
+    for (const netId of [referenceNetId]) {
+      const copper = { layer: layer.name, netId, regions: [], segments: [] };
+      copperByKey.set(`${layer.name}:${netId}`, copper);
+      layered.copper.push(copper);
+    }
+  const traces = new Map;
+  for (const element of options.circuitJson) {
+    if (element.type === "pcb_trace")
+      traces.set(element.pcb_trace_id, element);
+    const additions = [];
+    if (element.type === "pcb_copper_pour") {
+      if (!element.source_net_id)
+        throw new Error("Copper pours require a source_net_id");
+      additions.push({
+        layer: element.layer,
+        netId: connectivity.owner(element.source_net_id),
+        region: { ...pourRegion2(element), isPlane: true }
+      });
+      layered.audit.pours++;
+    }
+    if (element.type === "pcb_ground_plane_region") {
+      const plane = options.circuitJson.find((e) => e.type === "pcb_ground_plane" && e.pcb_ground_plane_id === element.pcb_ground_plane_id);
+      if (!plane || plane.type !== "pcb_ground_plane")
+        throw new Error("Missing ground-plane owner");
+      additions.push({
+        layer: element.layer,
+        netId: connectivity.owner(plane.source_net_id),
+        region: { outer: element.points, holes: [], isPlane: true }
+      });
+    }
+    if (element.type === "pcb_smtpad") {
+      const netId = element.pcb_port_id ? connectivity.pcbPorts.get(element.pcb_port_id) : undefined;
+      if (!netId)
+        throw new Error(`Pad ${element.pcb_smtpad_id} has no PCB port ownership`);
+      additions.push({
+        layer: element.layer,
+        netId,
+        region: { outer: smtPadOutline(element), holes: [] }
+      });
+      layered.audit.pads++;
+    }
+    if (element.type === "pcb_trace") {
+      const netId = connectivity.pcbTraces.get(element.pcb_trace_id);
+      validateLayeredRoute(element, stackup.copperLayers.map((l) => l.name));
+      for (let index = 1;index < element.route.length; index++) {
+        const start = element.route[index - 1], end = element.route[index];
+        if (start.route_type !== "wire" || end.route_type !== "wire")
+          continue;
+        if (start.x === end.x && start.y === end.y)
+          continue;
+        additions.push({
+          layer: start.layer,
+          netId,
+          segment: {
+            start,
+            end,
+            width: positiveFinite(start.width, "trace width"),
+            current: 0
+          }
+        });
+      }
+      layered.audit.traces++;
+    }
+    for (const addition of additions) {
+      if (!stackup.copperLayers.some((l) => l.name === addition.layer))
+        throw new Error(`Copper on absent layer ${addition.layer}`);
+      const key = `${addition.layer}:${addition.netId}`;
+      let copper = copperByKey.get(key);
+      if (!copper) {
+        copper = {
+          layer: addition.layer,
+          netId: addition.netId,
+          regions: [],
+          segments: []
+        };
+        copperByKey.set(key, copper);
+        layered.copper.push(copper);
+      }
+      if (addition.region)
+        copper.regions.push(addition.region);
+      if (addition.segment)
+        copper.segments.push(addition.segment);
+    }
+  }
+  const bottom = stackup.copperLayers.at(-1), top = stackup.copperLayers[0];
+  for (const element of options.circuitJson) {
+    if (element.type === "pcb_hole") {
+      layered.drills.push({
+        hole: drillOutline(element),
+        zMin: bottom.zMin,
+        zMax: top.zMax
+      });
+      layered.audit.unplatedHoles++;
+    }
+    if (element.type !== "pcb_via" && element.type !== "pcb_plated_hole")
+      continue;
+    const netId = element.type === "pcb_via" ? element.source_net_id ? connectivity.owner(element.source_net_id) : element.pcb_trace_id ? connectivity.pcbTraces.get(element.pcb_trace_id) : undefined : element.pcb_port_id ? connectivity.pcbPorts.get(element.pcb_port_id) : undefined;
+    if (!netId)
+      throw new Error(`Cannot identify copper ownership for ${element.type}; supply source_net_id or pcb_trace_id`);
+    const layers = element.layers.map((name) => stackup.copperLayers.find((l) => l.name === name));
+    if (!layers.length || layers.some((l) => !l))
+      throw new Error("Via/hole references an absent stackup layer");
+    const zMin = Math.min(...layers.map((l) => l.zMin)), zMax = Math.max(...layers.map((l) => l.zMax));
+    const hole = element.type === "pcb_via" ? roundedOutline({
+      ...element,
+      width: element.hole_diameter,
+      height: element.hole_diameter
+    }) : drillOutline(element);
+    const pads = element.type === "pcb_via" ? roundedOutline({
+      ...element,
+      width: element.outer_diameter,
+      height: element.outer_diameter
+    }) : platedPadOutline(element);
+    layered.barrels.push({
+      netId,
+      hole,
+      outer: hole,
+      pads,
+      layers: element.layers,
+      zMin,
+      zMax,
+      platingThickness: 0.025
+    });
+    layered.drills.push({ hole, zMin, zMax });
+    if (element.type === "pcb_via")
+      layered.audit.vias++;
+    else
+      layered.audit.platedHoles++;
+  }
+  for (const trace of traces.values())
+    for (const route of trace.route) {
+      if (route.route_type !== "via")
+        continue;
+      const barrel = layered.barrels.find((b) => b.netId === connectivity.pcbTraces.get(trace.pcb_trace_id) && pointInPolygon2(route, b.hole) && b.layers.includes(route.from_layer) && b.layers.includes(route.to_layer));
+      if (!barrel)
+        throw new Error(`Trace ${trace.pcb_trace_id} changes layer without a matching physical pcb_via`);
+    }
+  for (const barrel of layered.barrels)
+    barrel.clearance = barrelClearanceOutline(barrel, viaClearance);
+  const groundCopper = copperByKey.get(`${sampleLayer}:${referenceNetId}`);
+  if (!groundCopper.regions.length)
+    throw new Error(`Reference net needs copper regions on sample layer ${sampleLayer}; no plane is invented`);
+  const geometry = {
+    board,
+    boardOutline,
+    groundRegions: groundCopper.regions.map((region) => ({
+      ...region,
+      holes: [...region.holes]
+    })),
+    cutouts: [...boardCutouts],
+    signals: [],
+    segments: [],
+    excitations
+  };
+  for (const segment of groundCopper.segments) {
+    geometry.groundRegions.push({
+      outer: traceOutline(segment),
+      holes: []
+    });
+  }
+  for (const barrel of layered.barrels) {
+    if (barrel.zMin > sampleFoil.zMin || barrel.zMax < sampleFoil.zMax)
+      continue;
+    if (barrel.netId === referenceNetId && barrel.layers.includes(sampleLayer))
+      geometry.groundRegions.push({ outer: barrel.pads, holes: [barrel.hole] });
+    else if (barrel.netId !== referenceNetId) {
+      for (const region of geometry.groundRegions.filter((region2) => region2.isPlane))
+        region.maskCutouts = [
+          ...region.maskCutouts ?? [],
+          barrelClearanceOutline(barrel, viaClearance)
+        ];
+    }
+  }
+  for (const drill of layered.drills)
+    if (drill.zMin <= sampleFoil.zMin && drill.zMax >= sampleFoil.zMax)
+      geometry.cutouts.push(drill.hole);
+  const ports = [];
+  for (const excitation of excitations) {
+    if (!Number.isFinite(excitation.current))
+      throw new Error("Excitation current must be finite");
+    const trace = traces.get(excitation.pcb_trace_id);
+    if (!trace)
+      throw new Error("Missing excited trace");
+    geometry.signals.push(trace);
+    for (let index = 1;index < trace.route.length; index++) {
+      const start = trace.route[index - 1], end = trace.route[index];
+      if (start.route_type === "wire" && end.route_type === "wire" && (start.x !== end.x || start.y !== end.y))
+        geometry.segments.push({
+          start,
+          end,
+          width: start.width,
+          current: excitation.current
+        });
+    }
+    for (const [endpoint, reference, terminal] of [
+      [trace.route[0], excitation.return_sink, excitation.source_port],
+      [trace.route.at(-1), excitation.return_source, excitation.load_port]
+    ]) {
+      if (endpoint.route_type !== "wire")
+        throw new Error("Ports require wire endpoints");
+      const signalFoil = stackup.copperLayers.find((l) => l.name === endpoint.layer);
+      const referenceFoil = stackup.copperLayers.find((l) => l.name === (terminal?.reference_layer ?? sampleLayer));
+      if (!referenceFoil)
+        throw new Error("Reference layer is absent");
+      if (terminal?.reference_pcb_port_id && connectivity.pcbPorts.get(terminal.reference_pcb_port_id) !== referenceNetId)
+        throw new Error("Reference pin is not on the reference net");
+      for (const [id, position, layer] of [
+        [terminal?.signal_pcb_port_id, endpoint, endpoint.layer],
+        [terminal?.reference_pcb_port_id, reference, referenceFoil.name]
+      ]) {
+        if (!id)
+          continue;
+        const pcb = options.circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === id);
+        if (!pcb || pcb.type !== "pcb_port" || !pcb.layers.includes(layer) || Math.hypot(pcb.x - position.x, pcb.y - position.y) > 0.000001)
+          throw new Error("Terminal does not match its PCB port position/layer");
+      }
+      const below = referenceFoil.zMin < signalFoil.zMin;
+      ports.push({
+        signal: { x: endpoint.x, y: endpoint.y },
+        reference: { x: reference.x, y: reference.y },
+        signalLayer: signalFoil.name,
+        referenceLayer: referenceFoil.name,
+        signalZ: below ? signalFoil.zMin : signalFoil.zMax,
+        referenceZ: below ? referenceFoil.zMax : referenceFoil.zMin === signalFoil.zMin ? signalFoil.zMax : referenceFoil.zMin,
+        resistance: positiveFinite(terminal?.resistance ?? options.portResistance ?? 50, "port resistance"),
+        signalPcbPortId: terminal?.signal_pcb_port_id,
+        referencePcbPortId: terminal?.reference_pcb_port_id
+      });
+    }
+  }
+  if (stackup.nominalBoardThicknessMm && Math.abs(stackup.physicalThicknessMm - stackup.nominalBoardThicknessMm) > 0.0001)
+    layered.audit.warnings.push(`Explicit stack sums to ${stackup.physicalThicknessMm} mm, nominal ${stackup.nominalBoardThicknessMm} mm; explicit dimensions are used without scaling.`);
+  geometry.physicalModelSignature = JSON.stringify({
+    ...layered,
+    traceEndCaps: "round_32",
+    audit: undefined
+  });
+  const order = options.order ?? 2;
+  if (order !== 1 && order !== 2)
+    throw new Error("order must be 1 or 2");
+  return {
+    schemaVersion: 1,
+    multilayer: layered,
+    geometry,
+    ports,
+    topPads: [],
+    frequencyHz,
+    layerSeparation: top.zMin - bottom.zMax,
+    copperThickness: sampleFoil.zMax - sampleFoil.zMin,
+    copperConductivity,
+    substratePermittivity: options.substratePermittivity ?? 4.3,
+    substrateLossTangent,
+    portResistance: positiveFinite(options.portResistance ?? 50, "portResistance"),
+    portWidth: positiveFinite(options.portWidth ?? 0.18, "portWidth"),
+    meshSize: positiveFinite(options.meshSize ?? 1, "meshSize"),
+    airPadding: positiveFinite(options.airPadding ?? 10, "airPadding"),
+    order,
+    copperModel: "volumetric_copper"
+  };
+}
+function validateLayeredRoute(trace, layers) {
+  for (const [index, route] of trace.route.entries()) {
+    if (route.route_type !== "wire" && route.route_type !== "via")
+      throw new Error("Unsupported route point type");
+    if (![route.x, route.y].every(Number.isFinite))
+      throw new Error("Trace coordinates must be finite");
+    if (route.route_type === "wire") {
+      positiveFinite(route.width, "trace width");
+      if (!layers.includes(route.layer))
+        throw new Error(`Unknown route layer ${route.layer}`);
+      const previous = trace.route[index - 1];
+      if (previous?.route_type === "wire" && previous.layer !== route.layer)
+        throw new Error("Layer transitions require a via route point");
+    } else if (route.route_type === "via") {
+      const previous = trace.route[index - 1], next = trace.route[index + 1];
+      if (previous?.route_type !== "wire" || next?.route_type !== "wire" || previous.layer !== route.from_layer || next.layer !== route.to_layer || Math.hypot(previous.x - route.x, previous.y - route.y) > 0.000001 || Math.hypot(next.x - route.x, next.y - route.y) > 0.000001)
+        throw new Error("Via route must join matching, colocated layer endpoints");
+    } else
+      throw new Error("Unsupported route point type");
+  }
+}
+function barrelClearanceOutline(barrel, clearance) {
+  const xs = barrel.pads.map((p) => p.x), ys = barrel.pads.map((p) => p.y);
+  const minX = Math.min(...xs), maxX = Math.max(...xs), minY = Math.min(...ys), maxY = Math.max(...ys);
+  return rectangleOutline2({
+    center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+    width: maxX - minX + 2 * clearance,
+    height: maxY - minY + 2 * clearance
+  });
+}
+function createPalaceModel(options) {
+  if (options.stackup || options.circuitJson.some((element) => element.type === "pcb_board" && element.num_layers > 2))
+    return createMultilayerPalaceModel(options);
+  if (options.sampleLayer && options.sampleLayer !== "bottom")
+    throw new Error("A non-bottom sample layer requires an explicit stackup");
+  const frequencyHz = positiveFinite(options.frequencyHz, "frequencyHz");
+  const geometry = readGeometry({
+    ...options,
+    circuitJson: options.circuitJson.filter((element) => element.type !== "pcb_via")
+  });
+  const layerSeparation = positiveFinite(options.layerSeparation ?? geometry.board.thickness ?? 0.8, "layerSeparation");
+  const copperThickness = positiveFinite(options.copperThickness ?? 0.035, "copperThickness");
+  const copperConductivity = positiveFinite(options.copperConductivity ?? 58000000, "copperConductivity");
+  const skinDepthMm = 1000 / Math.sqrt(Math.PI * frequencyHz * 0.0000004 * Math.PI * copperConductivity);
+  const copperModel = options.copperModel ?? "volumetric_copper";
+  if (copperModel !== "volumetric_copper" && copperModel !== "surface_impedance_copper")
+    throw new Error("Unknown copperModel");
+  if (copperModel === "surface_impedance_copper" && copperThickness < 3 * skinDepthMm)
+    throw new Error("The half-space surface-impedance model requires foil and via-wall thickness >= 3 skin depths; use volumetric copper at lower frequencies");
+  if (copperModel === "volumetric_copper" && copperThickness > skinDepthMm)
+    throw new Error("The current volume mesher requires copper thickness <= skin depth; refine copper through its thickness before using higher frequencies");
+  const ports = [];
+  for (const [index, signal] of geometry.signals.entries()) {
+    const first = signal.route[0];
+    const last = signal.route.at(-1);
+    const excitation = geometry.excitations[index];
+    if (!last || first.route_type !== "wire" || last.route_type !== "wire")
+      throw new Error("Palace requires wire endpoints");
+    for (const [endpoint, contact, terminal] of [
+      [first, excitation.return_sink, excitation.source_port],
+      [last, excitation.return_source, excitation.load_port]
+    ]) {
+      if (!terminal && Math.hypot(endpoint.x - contact.x, endpoint.y - contact.y) > 0.000001)
+        throw new Error("Legacy Palace ports require return contacts directly below signal endpoints; specify explicit terminal metadata for offset references");
+      for (const [id, position, role] of [
+        [terminal?.signal_pcb_port_id, endpoint, "signal"],
+        [terminal?.reference_pcb_port_id, contact, "reference"]
+      ]) {
+        if (!id)
+          continue;
+        const pcb = options.circuitJson.find((element) => element.type === "pcb_port" && element.pcb_port_id === id);
+        if (!pcb || pcb.type !== "pcb_port" || Math.hypot(pcb.x - position.x, pcb.y - position.y) > 0.000001)
+          throw new Error(`Explicit ${role} terminal does not match its PCB port`);
+        const layer = role === "signal" ? "top" : terminal.reference_layer;
+        if (!pcb.layers.includes(layer))
+          throw new Error(`Explicit ${role} terminal is not on ${layer}`);
+        if (role === "reference" && !portNetIds2(options.circuitJson, pcb.source_port_id).includes(excitation.ground_source_net_id))
+          throw new Error("Explicit reference terminal is not connected to the ground net");
+      }
+      if (terminal?.reference_layer === "top" && !terminal.reference_pcb_port_id)
+        throw new Error("Top reference requires an explicit PCB port");
+      ports.push({
+        signal: { x: endpoint.x, y: endpoint.y },
+        reference: { x: contact.x, y: contact.y },
+        referenceLayer: terminal?.reference_layer ?? "bottom",
+        resistance: positiveFinite(terminal?.resistance ?? options.portResistance ?? 50, "port resistance"),
+        signalPcbPortId: terminal?.signal_pcb_port_id,
+        referencePcbPortId: terminal?.reference_pcb_port_id
+      });
+    }
+  }
+  const referenceIds = new Set(ports.filter((port) => port.referenceLayer === "top").map((port) => port.referencePcbPortId));
+  const topGroundPads = [];
+  const topPads = options.circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_smtpad" || element.layer !== "top")
+      return [];
+    if (element.shape !== "rect")
+      throw new Error("Palace currently supports rectangular top SMT pads");
+    const outline = rectangleOutline2({
+      center: { x: element.x, y: element.y },
+      width: element.width,
+      height: element.height
+    });
+    if (referenceIds.has(element.pcb_port_id)) {
+      topGroundPads.push(outline);
+      return [];
+    }
+    return [outline];
+  });
+  const groundVias = options.circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_via")
+      return [];
+    const pad = options.circuitJson.find((pad2) => pad2.type === "pcb_smtpad" && pad2.shape === "rect" && pad2.layer === "top" && referenceIds.has(pad2.pcb_port_id) && Math.hypot(pad2.x - element.x, pad2.y - element.y) < 0.000001);
+    if (!pad || pad.type !== "pcb_smtpad" || pad.shape !== "rect" || element.source_net_id !== geometry.excitations[0].ground_source_net_id || !element.layers.includes("top") || !element.layers.includes("bottom") || element.layers.length !== 2)
+      throw new Error("Only top-to-bottom ground vias centered in selected rectangular reference pads are supported");
+    const holeDiameter = positiveFinite(element.hole_diameter, "via hole diameter");
+    const outerDiameter = positiveFinite(element.outer_diameter, "via outer diameter");
+    if (holeDiameter + 2 * copperThickness >= outerDiameter || outerDiameter > Math.min(pad.width, pad.height) || !isCopper(element, geometry))
+      throw new Error("Ground via needs a plated barrel inside its pad and selected bottom copper");
+    return [
+      {
+        x: element.x,
+        y: element.y,
+        holeDiameter,
+        outerDiameter,
+        platingThickness: copperThickness
+      }
+    ];
+  });
+  for (const port of ports.filter((port2) => port2.referenceLayer === "top")) {
+    if (!groundVias.some((via) => Math.hypot(via.x - port.reference.x, via.y - port.reference.y) < 0.000001))
+      throw new Error("A top reference pad needs a real concentric ground via in circuit-json; ground-pad names alone do not connect copper");
+  }
+  for (const via of groundVias)
+    geometry.cutouts.push(Array.from({ length: 32 }, (_, index) => ({
+      x: via.x + via.holeDiameter / 2 * Math.cos(index * 2 * Math.PI / 32),
+      y: via.y + via.holeDiameter / 2 * Math.sin(index * 2 * Math.PI / 32)
+    })));
+  const substrateLossTangent = options.substrateLossTangent ?? 0.02;
+  if (!Number.isFinite(substrateLossTangent) || substrateLossTangent < 0)
+    throw new Error("substrateLossTangent must be finite and nonnegative");
+  const order = options.order ?? 2;
+  if (order !== 1 && order !== 2)
+    throw new Error("order must be 1 or 2");
+  return {
+    schemaVersion: 1,
+    geometry,
+    topPads,
+    topGroundPads,
+    groundVias,
+    ports,
+    frequencyHz,
+    layerSeparation,
+    copperThickness,
+    copperConductivity,
+    substratePermittivity: positiveFinite(options.substratePermittivity ?? 4.3, "substratePermittivity"),
+    substrateLossTangent,
+    portResistance: positiveFinite(options.portResistance ?? 50, "portResistance"),
+    portWidth: positiveFinite(options.portWidth ?? 0.18, "portWidth"),
+    meshSize: positiveFinite(options.meshSize ?? 1, "meshSize"),
+    airPadding: positiveFinite(options.airPadding ?? 10, "airPadding"),
+    order,
+    copperModel,
+    ...copperModel === "surface_impedance_copper" ? {
+      surfaceImpedance: {
+        boundaryModel: "half_space",
+        skinDepthMm,
+        minimumThicknessToSkinDepth: copperThickness / skinDepthMm,
+        currentSampling: "sum_foil_face_surface_currents"
+      }
+    } : {}
+  };
+}
+function boundedPolygon(outline) {
+  return {
+    outline,
+    minX: Math.min(...outline.map((p) => p.x)),
+    maxX: Math.max(...outline.map((p) => p.x)),
+    minY: Math.min(...outline.map((p) => p.y)),
+    maxY: Math.max(...outline.map((p) => p.y))
+  };
+}
+function contains2(point, polygon) {
+  return point.x >= polygon.minX - 0.000000001 && point.x <= polygon.maxX + 0.000000001 && point.y >= polygon.minY - 0.000000001 && point.y <= polygon.maxY + 0.000000001 && pointInPolygon2(point, polygon.outline);
+}
+function createSampleMask(geometry) {
+  const board = boundedPolygon(geometry.boardOutline);
+  const cutouts = geometry.cutouts.map(boundedPolygon);
+  const regions = geometry.groundRegions.map((r) => ({
+    outer: boundedPolygon(r.outer),
+    holes: [...r.holes, ...r.maskCutouts ?? []].map(boundedPolygon)
+  }));
+  return (point) => contains2(point, board) && !cutouts.some((cutout) => contains2(point, cutout)) && regions.some((r) => contains2(point, r.outer) && !r.holes.some((hole) => contains2(point, hole)));
+}
+async function writeSampleGrid(options) {
+  const cellSize = positiveFinite(options.cellSize ?? 0.2, "cellSize");
+  const outline = options.geometry.boardOutline;
+  const minX = Math.min(...outline.map((point) => point.x));
+  const maxX = Math.max(...outline.map((point) => point.x));
+  const minY = Math.min(...outline.map((point) => point.y));
+  const maxY = Math.max(...outline.map((point) => point.y));
+  const columns = Math.max(2, Math.ceil((maxX - minX) / cellSize));
+  const rows = Math.max(2, Math.ceil((maxY - minY) / cellSize));
+  if (columns * rows > 1e6)
+    throw new Error("The sample grid exceeds 1,000,000 cells; increase cellSize");
+  const cellWidth = (maxX - minX) / columns;
+  const cellHeight = (maxY - minY) / rows;
+  const containsCopper = createSampleMask(options.geometry);
+  const points = [];
+  for (let row = 0;row < rows; row++)
+    for (let column = 0;column < columns; column++) {
+      const point = {
+        x: minX + (column + 0.5) * cellWidth,
+        y: minY + (row + 0.5) * cellHeight
+      };
+      if (containsCopper(point))
+        points.push(point);
+    }
+  if (!points.length)
+    throw new Error("The sample grid contains no ground copper");
+  await writeFile3(`${options.destination}/sample-grid.json`, JSON.stringify({ columns, rows, cellWidth, cellHeight, points }));
+  return { columns, rows, cellWidth, cellHeight, copperSamples: points.length };
+}
+async function preparePalaceCase(options) {
+  const model = createPalaceModel(options);
+  const processes = options.processes ?? Number(process.env.PALACE_PROCESSES ?? 1);
+  if (!Number.isInteger(processes) || processes < 1)
+    throw new Error("processes must be a positive integer");
+  const destination = resolve22(options.destination);
+  await mkdir22(destination, { recursive: true });
+  await writeFile22(`${destination}/circuit.json`, JSON.stringify(options.circuitJson));
+  await writeFile22(`${destination}/model.json`, JSON.stringify(model, null, 2));
+  if (model.multilayer)
+    await writeFile22(`${destination}/model-audit.json`, JSON.stringify(model.multilayer.audit, null, 2));
+  const grid = await writeSampleGrid({
+    destination,
+    geometry: model.geometry,
+    cellSize: options.cellSize
+  });
+  return { model, destination, processes, grid };
+}
+async function runPalaceCase(options) {
+  const { model, destination, processes } = await preparePalaceCase(options);
+  const python = palacePython(options.python);
+  const meshScript = palacePythonAsset("mesh.py");
+  const sampleScript = palacePythonAsset("sample.py");
+  console.log(`Meshing ${destination}`);
+  await runCommand2({
+    command: [python, meshScript, `${destination}/model.json`],
+    cwd: destination,
+    logPath: `${destination}/mesh.log`
+  });
+  const palaceBin = options.palaceBin ?? process.env.PALACE_BIN;
+  const command = palaceBin ? [palaceBin, "-np", String(processes), "palace.json"] : [
+    "docker",
+    "run",
+    "--rm",
+    "--network",
+    "none",
+    "--user",
+    `${process.getuid?.() ?? 1000}:${process.getgid?.() ?? 1000}`,
+    "--cap-drop",
+    "ALL",
+    "--security-opt",
+    "no-new-privileges",
+    "--mount",
+    `type=bind,src=${destination},dst=/case`,
+    "--workdir",
+    "/case",
+    palaceImage,
+    "palace",
+    "-np",
+    String(processes),
+    "palace.json"
+  ];
+  console.log(`Running Palace at ${model.frequencyHz} Hz`);
+  await runCommand2({
+    command,
+    cwd: destination,
+    logPath: `${destination}/palace.log`
+  });
+  console.log("Sampling complex conduction current through ground copper");
+  await runCommand2({
+    command: [python, sampleScript, destination],
+    cwd: destination,
+    logPath: `${destination}/sample.log`
+  });
+}
+async function readJson(path) {
+  return JSON.parse(await readFile3(path, "utf8"));
+}
+function coordinate(number) {
+  return (number === 0 ? 0 : number).toFixed(9);
+}
+function point12(point2) {
+  return [coordinate(point2.x), coordinate(point2.y)];
+}
+function palaceGeometrySignature(geometry) {
+  return JSON.stringify([
+    geometry.boardOutline.map(point12),
+    geometry.groundRegions.map((region) => [
+      region.outer.map(point12),
+      [...region.holes, ...region.maskCutouts ?? []].map((hole) => hole.map(point12))
+    ]),
+    geometry.cutouts.map((outline) => outline.map(point12)),
+    geometry.signals.map((signal) => signal.route.filter((route) => route.route_type === "wire").map((route) => [
+      ...point12(route),
+      coordinate(route.width),
+      route.layer
+    ])),
+    ...geometry.physicalModelSignature ? [geometry.physicalModelSignature] : [],
+    geometry.excitations.map((excitation) => [
+      coordinate(excitation.current),
+      point12(excitation.return_source),
+      point12(excitation.return_sink),
+      ...excitation.source_port || excitation.load_port ? [
+        [
+          excitation.source_port?.reference_layer ?? "bottom",
+          coordinate(excitation.source_port?.resistance ?? 50),
+          excitation.load_port?.reference_layer ?? "bottom",
+          coordinate(excitation.load_port?.resistance ?? 50)
+        ]
+      ] : []
+    ])
+  ]);
+}
+function currentColor(fraction) {
+  const stops = [
+    [0, 99, 235],
+    [0, 180, 216],
+    [19, 202, 70],
+    [225, 233, 20],
+    [255, 175, 0],
+    [255, 60, 0]
+  ];
+  const position = Math.max(0, Math.min(1, fraction)) * (stops.length - 1);
+  const stopIndex = Math.min(stops.length - 2, Math.floor(position));
+  const blend = position - stopIndex;
+  const rgb = stops[stopIndex].map((channel, channelIndex) => Math.round(channel + blend * (stops[stopIndex + 1][channelIndex] - channel)));
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+function escapeXml6(text) {
+  return text.replace(/[&<>"']/g, (character) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&apos;"
+  })[character] ?? character);
+}
+function polygonPath(outline) {
+  return `${outline.map((point2, cornerIndex) => `${cornerIndex ? "L" : "M"}${svgNumber(point2.x)},${svgNumber(point2.y)}`).join(" ")} Z`;
+}
+function svgNumber(number) {
+  return Number(number.toFixed(5)).toString();
+}
+function renderCells(result, maxCurrentDensity) {
+  const pathsByColor = new Map;
+  for (const node of result.nodes) {
+    const color = currentColor(node.currentDensity / maxCurrentDensity);
+    const paths = pathsByColor.get(color) ?? [];
+    paths.push(`M${svgNumber(node.x - result.cellWidth / 2)},${svgNumber(node.y - result.cellHeight / 2)}h${svgNumber(result.cellWidth)}v${svgNumber(result.cellHeight)}h${svgNumber(-result.cellWidth)}z`);
+    pathsByColor.set(color, paths);
+  }
+  return [...pathsByColor].map(([color, paths]) => `<path fill="${color}" d="${paths.join(" ")}"/>`).join("");
+}
+function displayNumber(number) {
+  if (number === 0)
+    return "0";
+  return number >= 0.01 && number < 1e4 ? Number(number.toPrecision(3)).toString() : number.toExponential(1);
+}
+function renderCurrentFieldSvg(result, options) {
+  if (!result.diagnostics.converged)
+    throw new Error("Only a converged simulation can be rendered");
+  const width = options.width ?? 1100;
+  const height = options.height ?? 1100;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 300 || height < 300)
+    throw new Error("Image dimensions must be finite and at least 300 pixels");
+  const maxCurrentDensity = options.maxCurrentDensity ?? (result.diagnostics.maxCurrentDensity || 1);
+  if (!Number.isFinite(maxCurrentDensity) || maxCurrentDensity <= 0)
+    throw new Error("maxCurrentDensity must be finite and positive");
+  const vectorSpacing = options.vectorSpacing ?? 5;
+  if (!Number.isInteger(vectorSpacing) || vectorSpacing < 1)
+    throw new Error("vectorSpacing must be a positive integer");
+  const boardWidth = result.bounds.maxX - result.bounds.minX;
+  const boardHeight = result.bounds.maxY - result.bounds.minY;
+  const pixelsPerMm = Math.min((width - 120) / boardWidth, (height - 250) / boardHeight);
+  const left = (width - boardWidth * pixelsPerMm) / 2;
+  const top = 160;
+  const worldToSvg = compose35(translate35(left, top), scale14(pixelsPerMm, -pixelsPerMm), translate35(-result.bounds.minX, -result.bounds.maxY));
+  const groundPaths = result.geometry.groundRegions.map((region) => `<path d="${[region.outer, ...region.holes, ...region.maskCutouts ?? []].map(polygonPath).join(" ")}" clip-rule="evenodd"/>`).join("");
+  const boardPath = [result.geometry.boardOutline, ...result.geometry.cutouts].map(polygonPath).join(" ");
+  const cells = renderCells(result, maxCurrentDensity);
+  const arrows = [];
+  if (!options.hideVectors) {
+    const arrowLength = Math.min(result.cellWidth, result.cellHeight) * vectorSpacing * 0.58;
+    for (const node of result.nodes) {
+      if (node.column % vectorSpacing !== Math.floor(vectorSpacing / 2) || node.row % vectorSpacing !== Math.floor(vectorSpacing / 2) || node.currentDensity < result.diagnostics.maxCurrentDensity * 0.003)
+        continue;
+      const magnitude = Math.hypot(node.sheetCurrentX, node.sheetCurrentY);
+      if (magnitude === 0)
+        continue;
+      const dx = node.sheetCurrentX / magnitude * arrowLength / 2;
+      const dy = node.sheetCurrentY / magnitude * arrowLength / 2;
+      arrows.push(`<path d="M${svgNumber(node.x - dx)},${svgNumber(node.y - dy)} L${svgNumber(node.x + dx)},${svgNumber(node.y + dy)} M${svgNumber(node.x + dx * 0.25 + dy * 0.4)},${svgNumber(node.y + dy * 0.25 - dx * 0.4)} L${svgNumber(node.x + dx)},${svgNumber(node.y + dy)} L${svgNumber(node.x + dx * 0.25 - dy * 0.4)},${svgNumber(node.y + dy * 0.25 + dx * 0.4)}"/>`);
+    }
+  }
+  const traces = options.hideTraces ? "" : result.geometry.signals.map((signal) => {
+    const wires = signal.route.flatMap((routePoint) => routePoint.route_type === "wire" ? [routePoint] : []);
+    return `<polyline points="${wires.map((point2) => `${point2.x},${point2.y}`).join(" ")}" fill="none" stroke="#16383b" stroke-width="${wires[0].width}" stroke-linejoin="round" stroke-linecap="round"/>`;
+  }).join("");
+  const contacts = result.geometry.excitations.map((excitation, excitationIndex) => {
+    const route = result.geometry.signals[excitationIndex].route;
+    const explicit = [
+      {
+        terminal: excitation.source_port,
+        endpoint: route[0],
+        reference: excitation.return_sink,
+        label: `S${excitationIndex + 1}`,
+        color: "#19394c"
+      },
+      {
+        terminal: excitation.load_port,
+        endpoint: route.at(-1),
+        reference: excitation.return_source,
+        label: `L${excitationIndex + 1}`,
+        color: "#ae300f"
+      }
+    ].filter((port) => port.terminal?.reference_pcb_port_id && port.endpoint.route_type === "wire");
+    const links = explicit.map((port) => {
+      if (port.endpoint.route_type !== "wire")
+        return "";
+      const a = applyToPoint311(worldToSvg, port.endpoint), b = applyToPoint311(worldToSvg, port.reference);
+      return `<line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="#64748b" stroke-width="2" stroke-dasharray="4 3"/>`;
+    }).join("");
+    return links + [
+      {
+        point: excitation.return_sink,
+        label: `S${excitationIndex + 1}${excitation.source_port?.reference_pcb_port_id ? "−" : ""}`,
+        color: "#19394c"
+      },
+      {
+        point: excitation.return_source,
+        label: `L${excitationIndex + 1}${excitation.load_port?.reference_pcb_port_id ? "−" : ""}`,
+        color: "#ae300f"
+      },
+      ...explicit.map((port) => ({
+        point: port.endpoint,
+        label: `${port.label}+`,
+        color: port.color
+      }))
+    ].map((contact) => {
+      const scenePoint = applyToPoint311(worldToSvg, contact.point);
+      return `<circle cx="${scenePoint.x}" cy="${scenePoint.y}" r="5" fill="#fff" stroke="${contact.color}" stroke-width="2"/><text x="${scenePoint.x + 10}" y="${scenePoint.y - 8}" font-size="13" font-weight="600" fill="#122735" stroke="white" stroke-width="3" paint-order="stroke">${contact.label}</text>`;
+    }).join("");
+  }).join("");
+  const ticks = [0, 0.25, 0.5, 0.75, 1].map((fraction) => `<text x="${60 + fraction * (width - 120)}" y="136" text-anchor="middle" font-size="14" fill="#475569">${displayNumber(fraction * maxCurrentDensity)}</text>`).join("");
+  const boardBottom = top + boardHeight * pixelsPerMm;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-labelledby="title description">
+<title id="title">${escapeXml6(options.title ?? "Ground-plane return current")}</title>
+<desc id="description">${escapeXml6(options.description)}</desc>
+<defs><linearGradient id="current-scale">${Array.from({ length: 6 }, (_, stopIndex) => `<stop offset="${stopIndex * 20}%" stop-color="${currentColor(stopIndex / 5)}"/>`).join("")}</linearGradient><clipPath id="board-clip"><path d="${boardPath}" clip-rule="evenodd"/></clipPath><clipPath id="ground-clip">${groundPaths}</clipPath></defs>
+<rect width="100%" height="100%" fill="white"/>
+<g font-family="Arial, sans-serif"><text x="60" y="42" font-size="26" font-weight="600" fill="#172b3a">${escapeXml6(options.title ?? "Ground-plane return current")}</text>
+<text x="60" y="72" font-size="14" fill="#475569">${escapeXml6(options.subtitle)}</text>
+<rect x="60" y="90" width="${width - 120}" height="26" rx="3" fill="url(#current-scale)"/>${ticks}
+<g transform="matrix(${worldToSvg.a},${worldToSvg.b},${worldToSvg.c},${worldToSvg.d},${worldToSvg.e},${worldToSvg.f})">
+<g clip-path="url(#board-clip)"><g clip-path="url(#ground-clip)"><g shape-rendering="crispEdges">${cells}</g><g fill="none" stroke="white" stroke-width="${1 / pixelsPerMm}" opacity="0.75">${arrows.join("")}</g></g></g>
+<path d="${polygonPath(result.geometry.boardOutline)}" fill="none" stroke="#94a3b8" stroke-width="${1 / pixelsPerMm}"/>${traces}</g>
+${contacts}
+<text x="60" y="${boardBottom + 30}" font-size="14" fill="#334155">${result.geometry.excitations.map((excitation, excitationIndex) => `S${excitationIndex + 1} → L${excitationIndex + 1}: ${displayNumber(excitation.current)} A`).join("   ·   ")}</text>
+<text x="60" y="${boardBottom + 53}" font-size="13" fill="#64748b">${escapeXml6(options.separationLabel ?? "h")} = ${displayNumber(result.layerSeparation)} mm · copper = ${displayNumber(result.copperThickness)} mm · ${escapeXml6(options.gridLabel ?? "mesh")} = ${result.columns} × ${result.rows}</text>
+<text x="60" y="${boardBottom + 76}" font-size="12" fill="#64748b">${escapeXml6(options.footer)}</text></g>
+</svg>`;
+}
+function validatePalaceReference(reference) {
+  if (reference.femOrder !== 1 && reference.femOrder !== 2 || reference.schemaVersion !== 1 || reference.solver !== "palace" || !["volumetric_copper", "surface_impedance_copper"].includes(reference.copperModel) || reference.sampleLayer !== undefined && !/^(top|bottom|inner[1-8])$/.test(reference.sampleLayer))
+    throw new Error("Unsupported Palace reference");
+  if (reference.copperModel === "surface_impedance_copper" && (reference.samplingMethod !== "sum_foil_face_surface_currents" || !Number.isFinite(reference.surfaceCurrentScaleAmpsPerMm) || reference.surfaceCurrentScaleAmpsPerMm <= 0))
+    throw new Error("Surface impedance reference must identify its face-current sampling and finite positive A/mm scale");
+  if (![
+    reference.frequencyHz,
+    reference.copperThickness,
+    reference.layerSeparation,
+    reference.cellWidth,
+    reference.cellHeight,
+    reference.normalizationConditionNumber,
+    reference.electricFieldScaleVoltsPerMeter
+  ].every((number) => Number.isFinite(number) && number > 0))
+    throw new Error("Palace reference needs finite positive frequency, thickness, cell sizes and normalization condition");
+  if (![reference.columns, reference.rows].every((number) => Number.isInteger(number) && number > 0) || !reference.samples.length)
+    throw new Error("Palace reference needs a nonempty grid");
+  if (typeof reference.provenance.geometrySignature !== "string" || !reference.provenance.geometrySignature.length)
+    throw new Error("Palace reference needs a physical geometry signature");
+  const locations = new Set;
+  for (const sample of reference.samples) {
+    if (![
+      sample.x,
+      sample.y,
+      sample.sheetCurrentXReal,
+      sample.sheetCurrentYReal,
+      sample.sheetCurrentXImag,
+      sample.sheetCurrentYImag
+    ].every(Number.isFinite))
+      throw new Error("Non-finite Palace sample");
+    const location2 = `${sample.x},${sample.y}`;
+    if (locations.has(location2))
+      throw new Error("Duplicate Palace sample position");
+    locations.add(location2);
+  }
+  for (const current of [
+    ...reference.sourceCurrents,
+    ...reference.loadCurrents
+  ])
+    if (![current.real, current.imag].every(Number.isFinite))
+      throw new Error("Non-finite Palace port current");
+}
+function renderPalaceModelSvg(model, options) {
+  const { reference } = options;
+  validatePalaceReference(reference);
+  if (reference.frequencyHz !== model.frequencyHz || reference.femOrder !== model.order || reference.copperModel !== model.copperModel || reference.sampleLayer !== model.multilayer?.sampleLayer)
+    throw new Error("Palace model frequency, FEM order, copper model or sample layer differs from reference");
+  const outline = model.geometry.boardOutline;
+  const bounds = {
+    minX: Math.min(...outline.map((point2) => point2.x)),
+    maxX: Math.max(...outline.map((point2) => point2.x)),
+    minY: Math.min(...outline.map((point2) => point2.y)),
+    maxY: Math.max(...outline.map((point2) => point2.y))
+  };
+  if (Math.abs(reference.columns * reference.cellWidth - (bounds.maxX - bounds.minX)) > 0.00000001 || Math.abs(reference.rows * reference.cellHeight - (bounds.maxY - bounds.minY)) > 0.00000001)
+    throw new Error("Palace sample grid does not fit the model bounds");
+  const nodes = reference.samples.map((sample) => {
+    const column = Math.round((sample.x - bounds.minX) / reference.cellWidth - 0.5);
+    const row = Math.round((sample.y - bounds.minY) / reference.cellHeight - 0.5);
+    if (column < 0 || column >= reference.columns || row < 0 || row >= reference.rows || Math.abs(sample.x - (bounds.minX + (column + 0.5) * reference.cellWidth)) > 0.00000001 || Math.abs(sample.y - (bounds.minY + (row + 0.5) * reference.cellHeight)) > 0.00000001)
+      throw new Error("Palace sample is not at a grid cell center");
+    return {
+      x: sample.x,
+      y: sample.y,
+      column,
+      row,
+      injection: 0,
+      sheetCurrentX: 0,
+      sheetCurrentY: 0,
+      currentDensity: 0
+    };
+  });
+  return renderPalaceReferenceSvg({
+    geometry: model.geometry,
+    bounds,
+    nodes,
+    columns: reference.columns,
+    rows: reference.rows,
+    cellWidth: reference.cellWidth,
+    cellHeight: reference.cellHeight,
+    copperThickness: model.copperThickness,
+    layerSeparation: model.layerSeparation
+  }, options);
+}
+function renderPalaceReferenceSvg(result, options) {
+  const { reference } = options;
+  validatePalaceReference(reference);
+  if (palaceGeometrySignature(result.geometry) !== reference.provenance.geometrySignature)
+    throw new Error("Palace reference geometry differs from the simulation geometry");
+  if (reference.layerSeparation !== result.layerSeparation || reference.samples.length !== result.nodes.length || reference.columns !== result.columns || reference.rows !== result.rows || reference.cellWidth !== result.cellWidth || reference.cellHeight !== result.cellHeight || reference.copperThickness !== result.copperThickness)
+    throw new Error("Palace rendering requires the matching simulation grid");
+  if (reference.sourceCurrents.length !== result.geometry.excitations.length || reference.sourceCurrents.some((current, index) => Math.abs(current.real - result.geometry.excitations[index].current) > 0.00000001 || Math.abs(current.imag) > 0.00000001))
+    throw new Error("Palace rendering requires matching source currents");
+  const phaseDegrees = options.phaseDegrees ?? 0;
+  if (!Number.isFinite(phaseDegrees))
+    throw new Error("phaseDegrees must be finite");
+  const phase = phaseDegrees * Math.PI / 180;
+  let maxCurrentDensity = 0;
+  const nodes = reference.samples.map((sample, index) => {
+    const node = result.nodes[index];
+    if (Math.hypot(node.x - sample.x, node.y - sample.y) > 0.00000001)
+      throw new Error("Palace sample coordinates differ from the rendering grid");
+    const currentDensity = Math.hypot(sample.sheetCurrentXReal, sample.sheetCurrentYReal, sample.sheetCurrentXImag, sample.sheetCurrentYImag) / reference.copperThickness;
+    maxCurrentDensity = Math.max(maxCurrentDensity, currentDensity);
+    return {
+      ...node,
+      sheetCurrentX: sample.sheetCurrentXReal * Math.cos(phase) - sample.sheetCurrentXImag * Math.sin(phase),
+      sheetCurrentY: sample.sheetCurrentYReal * Math.cos(phase) - sample.sheetCurrentYImag * Math.sin(phase),
+      currentDensity
+    };
+  });
+  return renderCurrentFieldSvg({
+    ...result,
+    nodes,
+    diagnostics: {
+      converged: true,
+      maxCurrentDensity
+    }
+  }, {
+    ...options,
+    title: options.title ?? "Palace ground-plane return current",
+    description: reference.copperModel === "surface_impedance_copper" ? "Palace driven Maxwell reference with finite-conductivity surface impedance. Colors show the complex sheet current summed over exposed foil faces, divided by physical foil thickness for display. Arrows show the real instantaneous field at the selected phase. Copper uses a half-space surface-impedance boundary." : "Palace driven Maxwell reference. Colors show magnitude of the complex conduction-current vector averaged through copper thickness. Arrows show the real instantaneous field at the selected phase. Copper is an explicitly meshed conductive volume.",
+    subtitle: `Palace ${reference.solverVersion}${reference.sampleLayer ? ` · layer = ${reference.sampleLayer}` : ""} · f = ${reference.frequencyHz / 1e6} MHz · |K|/t (A/mm²) · peak phasors`,
+    gridLabel: "sample grid",
+    separationLabel: reference.sampleLayer ? "outer foil gap" : undefined,
+    footer: `FEM order ${reference.femOrder} · ${reference.copperModel === "surface_impedance_copper" ? "finite-conductivity surface impedance" : "conductive copper volumes"} · arrows at ${phaseDegrees}° · air/substrate domain · source currents normalized`
+  });
+}
+async function writePalaceImage(destination, imageSize = 1100) {
+  const readStarted = performance.now();
+  const model = await readJson(`${destination}/model.json`);
+  const reference = await readJson(`${destination}/reference.json`);
+  const readSeconds = (performance.now() - readStarted) / 1000;
+  const svgStarted = performance.now();
+  const svg = renderPalaceModelSvg(model, {
+    reference,
+    title: "Palace: ground-plane return current",
+    maxCurrentDensity: 50,
+    vectorSpacing: Math.max(1, Math.round(1 / reference.cellWidth)),
+    width: imageSize,
+    height: imageSize
+  });
+  await writeFile32(`${destination}/palace.svg`, svg);
+  const svgSeconds = (performance.now() - svgStarted) / 1000;
+  const pngStarted = performance.now();
+  await writeFile32(`${destination}/palace.png`, new Resvg3(svg).render().asPng());
+  const pngSeconds = (performance.now() - pngStarted) / 1000;
+  return {
+    readSeconds,
+    svgSeconds,
+    pngSeconds,
+    imageSize,
+    provenance: reference.provenance,
+    solverVersion: reference.solverVersion,
+    femOrder: reference.femOrder,
+    sourceCurrents: reference.sourceCurrents
+  };
+}
+function imageDimension(size = 1100) {
+  if (!Number.isInteger(size) || size < 300 || size > 8192)
+    throw new Error("imageSize must be an integer between 300 and 8192 pixels");
+  return size;
+}
+function caseOptions(options) {
+  imageDimension(options.imageSize);
+  if (options.ports && !options.groundNet)
+    throw new Error("Named ports require groundNet");
+  if (options.groundNet && !options.ports)
+    throw new Error("groundNet requires named ports");
+  if (options.ports && options.excitations)
+    throw new Error("Choose named ports or explicit excitation records");
+  const circuitJson = options.ports ? withNamedExcitations({
+    circuitJson: options.circuitJson,
+    ports: options.ports.map((port) => ({
+      ...port,
+      sourceImpedance: port.sourceImpedance ?? options.portResistance ?? 50,
+      loadImpedance: port.loadImpedance ?? options.portResistance ?? 50
+    })),
+    groundNet: options.groundNet,
+    referenceLayer: options.sampleLayer
+  }) : options.excitations ? [
+    ...options.circuitJson.filter((element) => element.type !== "simulation_return_current_excitation"),
+    ...options.excitations
+  ] : options.circuitJson;
+  return {
+    ...options,
+    circuitJson,
+    excitations: undefined,
+    destination: resolve32(options.outputDirectory)
+  };
+}
+async function writePortSpecification(options, destination) {
+  const model = await readJson(join22(destination, "model.json"));
+  await writeFile4(join22(destination, "excitation-ports.json"), JSON.stringify({
+    frequencyHz: options.frequencyHz,
+    copperModel: model.copperModel,
+    ...model.surfaceImpedance ? { surfaceImpedance: model.surfaceImpedance } : {},
+    ports: options.ports?.map((port) => ({
+      ...port,
+      current: parseCurrentAmps(port.current),
+      ...port.sourceImpedance === undefined ? {} : { sourceImpedance: parseResistanceOhms(port.sourceImpedance) },
+      ...port.loadImpedance === undefined ? {} : { loadImpedance: parseResistanceOhms(port.loadImpedance) }
+    })) ?? null,
+    groundNet: options.groundNet ?? null,
+    resolvedTerminals: model.ports,
+    metadataSource: options.ports ? "named_ports" : "circuit_json",
+    reference: model.ports?.some((port) => port.referencePcbPortId) ? "explicit reference pins; omitted references use plane beneath signal" : "ground plane directly beneath each signal endpoint",
+    currentConvention: "signed in-phase peak amperes"
+  }, null, 2));
+}
+async function runPalaceSimulation(options) {
+  const startedAt = new Date().toISOString();
+  const started = performance.now();
+  const resolved = caseOptions(options);
+  await runPalaceCase(resolved);
+  await writePortSpecification(options, resolved.destination);
+  const image = await writePalaceImage(resolved.destination, imageDimension(options.imageSize));
+  const timing = {
+    startedAt,
+    completedAt: new Date().toISOString(),
+    frequencyHz: options.frequencyHz,
+    copperModel: options.copperModel ?? "volumetric_copper",
+    totalSeconds: (performance.now() - started) / 1000,
+    reusedCompletedFemSolve: false,
+    image
+  };
+  await writeFile4(join22(resolved.destination, "run-timing.json"), JSON.stringify(timing, null, 2));
+  return {
+    outputDirectory: resolved.destination,
+    referencePath: join22(resolved.destination, "reference.json"),
+    svgPath: join22(resolved.destination, "palace.svg"),
+    pngPath: join22(resolved.destination, "palace.png"),
+    timing
+  };
+}
+var copperLayer2, fabricationStackupSchema2, palaceImage = "benvial/palace@sha256:f0f3a3cbbdf1ee2d8f856ddbe1f5bf4628a92ee8ab87d1e27dc33402ad9c8dda";
+var init_palace = __esm(() => {
+  copperLayer2 = z228.string().regex(/^(top|bottom|inner[1-8])$/);
+  fabricationStackupSchema2 = z228.object({
+    nominalBoardThicknessMm: z228.number().finite().positive().optional(),
+    layers: z228.array(z228.union([
+      z228.object({
+        name: copperLayer2,
+        copperThicknessMm: z228.number().finite().positive()
+      }),
+      z228.object({
+        material: z228.string().min(1),
+        dielectricThicknessMm: z228.number().finite().positive(),
+        dielectricConstant: z228.number().finite().positive(),
+        lossTangent: z228.number().finite().nonnegative().optional()
+      })
+    ]))
+  });
+});
+
+// node_modules/simulate-return-current/dist/circuit-json.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { gzipSync as gzipSync2 } from "node:zlib";
+import { Resvg as Resvg4 } from "@resvg/resvg-js";
+import {
+  simulation_return_current_excitation as simulation_return_current_excitation22,
+  simulation_pcb_return_current_result,
+  simulation_pcb_return_current_field,
+  simulation_pcb_return_current_heatmap,
+  simulation_pcb_return_current_marker,
+  getSimulationReturnCurrentGridJsonSchema
+} from "circuit-json";
+import {
+  applyToPoint as applyToPoint51,
+  compose as compose21,
+  rotateDEG as rotateDEG6,
+  translate as translate21
+} from "transformation-matrix";
+import {
+  applyToPoint as applyToPoint216,
+  compose as compose26,
+  rotateDEG as rotateDEG24,
+  translate as translate26
+} from "transformation-matrix";
+import { z as z229 } from "zod";
+import {
+  simulation_experiment as simulation_experiment4,
+  simulation_return_current_excitation as simulation_return_current_excitation3
+} from "circuit-json";
+function rectangleOutline3(rect) {
+  if (![
+    rect.center.x,
+    rect.center.y,
+    rect.rotation ?? 0,
+    rect.width,
+    rect.height
+  ].every(Number.isFinite) || rect.width <= 0 || rect.height <= 0)
+    throw new Error("Rectangles need finite coordinates, rotation, and positive dimensions");
+  const localToWorld = compose21(translate21(rect.center.x, rect.center.y), rotateDEG6(rect.rotation ?? 0));
+  return [
+    { x: -rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: -rect.height / 2 },
+    { x: rect.width / 2, y: rect.height / 2 },
+    { x: -rect.width / 2, y: rect.height / 2 }
+  ].map((corner) => applyToPoint51(localToWorld, corner));
+}
+function flattenRing3(vertices) {
+  const outline = [];
+  for (let vertexIndex = 0;vertexIndex < vertices.length; vertexIndex++) {
+    const start = vertices[vertexIndex];
+    const end = vertices[(vertexIndex + 1) % vertices.length];
+    outline.push({ x: start.x, y: start.y });
+    const bulge = start.bulge ?? 0;
+    if (Math.abs(bulge) < 0.000000000001)
+      continue;
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const center = {
+      x: (start.x + end.x) / 2 - dy * (1 - bulge * bulge) / (4 * bulge),
+      y: (start.y + end.y) / 2 + dx * (1 - bulge * bulge) / (4 * bulge)
+    };
+    const sweep = 4 * Math.atan(bulge);
+    const radius = Math.hypot(start.x - center.x, start.y - center.y);
+    const startAngle = Math.atan2(start.y - center.y, start.x - center.x);
+    const steps = Math.ceil(Math.abs(sweep) / (Math.PI / 60));
+    for (let arcIndex = 1;arcIndex < steps; arcIndex++) {
+      const angle = startAngle + sweep * arcIndex / steps;
+      outline.push({
+        x: center.x + radius * Math.cos(angle),
+        y: center.y + radius * Math.sin(angle)
+      });
+    }
+  }
+  return outline;
+}
+function cutoutOutline2(cutout) {
+  if (cutout.shape === "polygon")
+    return cutout.points;
+  if (cutout.shape === "circle") {
+    if (!Number.isFinite(cutout.radius) || cutout.radius <= 0)
+      throw new Error("Circular cutouts need a finite positive radius");
+    return Array.from({ length: 120 }, (_, circleIndex) => ({
+      x: cutout.center.x + cutout.radius * Math.cos(circleIndex * Math.PI / 60),
+      y: cutout.center.y + cutout.radius * Math.sin(circleIndex * Math.PI / 60)
+    }));
+  }
+  if (cutout.shape === "rect" && !cutout.corner_radius)
+    return rectangleOutline3(cutout);
+  throw new Error("Path and rounded rectangular PCB cutouts are not supported; use a polygon cutout");
+}
+function pointInPolygon3(point, outline) {
+  let inside = false;
+  for (let cornerIndex = 0;cornerIndex < outline.length; cornerIndex++) {
+    const start = outline[cornerIndex];
+    const end = outline[(cornerIndex + 1) % outline.length];
+    const cross = (point.x - start.x) * (end.y - start.y) - (point.y - start.y) * (end.x - start.x);
+    if (Math.abs(cross) < 0.000000001 && point.x >= Math.min(start.x, end.x) - 0.000000001 && point.x <= Math.max(start.x, end.x) + 0.000000001 && point.y >= Math.min(start.y, end.y) - 0.000000001 && point.y <= Math.max(start.y, end.y) + 0.000000001)
+      return true;
+    if (start.y > point.y !== end.y > point.y && point.x < start.x + (point.y - start.y) * (end.x - start.x) / (end.y - start.y))
+      inside = !inside;
+  }
+  return inside;
+}
+function pointInRegion2(point, region) {
+  return pointInPolygon3(point, region.outer) && !region.holes.some((hole) => pointInPolygon3(point, hole)) && !(region.maskCutouts ?? []).some((hole) => pointInPolygon3(point, hole));
+}
+function isCopper2(point, geometry) {
+  return pointInPolygon3(point, geometry.boardOutline) && !geometry.cutouts.some((cutout) => pointInPolygon3(point, cutout)) && geometry.groundRegions.some((region) => pointInRegion2(point, region));
+}
+function segmentInCopper2(segment, geometry) {
+  const outlines = [
+    geometry.boardOutline,
+    ...geometry.cutouts,
+    ...geometry.groundRegions.flatMap((region) => [
+      region.outer,
+      ...region.holes
+    ])
+  ];
+  const dx = segment.end.x - segment.start.x;
+  const dy = segment.end.y - segment.start.y;
+  const crossings = [0, 1];
+  for (const outline of outlines) {
+    for (let cornerIndex = 0;cornerIndex < outline.length; cornerIndex++) {
+      const start = outline[cornerIndex];
+      const end = outline[(cornerIndex + 1) % outline.length];
+      const ex = end.x - start.x;
+      const ey = end.y - start.y;
+      const determinant = dx * ey - dy * ex;
+      if (Math.abs(determinant) < 0.000000000001)
+        continue;
+      const ax = start.x - segment.start.x;
+      const ay = start.y - segment.start.y;
+      const alongSegment = (ax * ey - ay * ex) / determinant;
+      const alongBoundary = (ax * dy - ay * dx) / determinant;
+      if (alongSegment > 0 && alongSegment < 1 && alongBoundary >= 0 && alongBoundary <= 1)
+        crossings.push(alongSegment);
+    }
+  }
+  crossings.sort((a, b) => a - b);
+  for (let crossingIndex = 1;crossingIndex < crossings.length; crossingIndex++) {
+    const fraction = (crossings[crossingIndex - 1] + crossings[crossingIndex]) / 2;
+    if (!isCopper2({
+      x: segment.start.x + fraction * dx,
+      y: segment.start.y + fraction * dy
+    }, geometry))
+      return false;
+  }
+  return true;
+}
+function pourRegion3(pour) {
+  if (pour.shape === "rect")
+    return { outer: rectangleOutline3(pour), holes: [] };
+  if (pour.shape === "polygon")
+    return { outer: pour.points, holes: [] };
+  return {
+    outer: flattenRing3(pour.brep_shape.outer_ring.vertices),
+    holes: pour.brep_shape.inner_rings.map((ring) => flattenRing3(ring.vertices))
+  };
+}
+function positiveFinite2(number, label) {
+  if (!Number.isFinite(number) || number <= 0)
+    throw new Error(`${label} must be finite and greater than zero`);
+  return number;
+}
+function validateOutline2(outline) {
+  if (outline.length < 3 || outline.some((point) => !Number.isFinite(point.x) || !Number.isFinite(point.y)))
+    throw new Error("Copper and board polygons need at least three finite points");
+}
+function readGeometry2(options) {
+  const boards = options.circuitJson.filter((element) => element.type === "pcb_board");
+  if (boards.length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const board = boards[0];
+  if (board.num_layers !== 2)
+    throw new Error("Return-current simulation currently requires a two-layer board");
+  if (options.circuitJson.some((element) => element.type === "pcb_hole" || element.type === "pcb_plated_hole" || element.type === "pcb_via"))
+    throw new Error("Drilled holes and vias are not supported yet; represent voids with PCB cutouts and model return contacts explicitly");
+  const boardOutline = board.outline?.length ? board.outline : rectangleOutline3({
+    center: board.center,
+    width: positiveFinite2(board.width ?? 0, "Board width"),
+    height: positiveFinite2(board.height ?? 0, "Board height")
+  });
+  const excitations = options.excitations ?? options.circuitJson.filter((element) => element.type === "simulation_return_current_excitation");
+  if (!excitations.length)
+    throw new Error("Specify return-current excitations with signal current and return contacts");
+  const groundNetIds = new Set(excitations.map((excitation) => excitation.ground_source_net_id));
+  if (groundNetIds.size !== 1)
+    throw new Error("All excitations must share one ground net");
+  const pours = options.circuitJson.filter((element) => element.type === "pcb_copper_pour" && element.layer === "bottom" && groundNetIds.has(element.source_net_id ?? ""));
+  const groundPlanes = options.circuitJson.filter((element) => element.type === "pcb_ground_plane" && groundNetIds.has(element.source_net_id));
+  const groundPlaneIds = new Set(groundPlanes.flatMap((element) => element.type === "pcb_ground_plane" ? [element.pcb_ground_plane_id] : []));
+  const planeRegions = options.circuitJson.filter((element) => element.type === "pcb_ground_plane_region" && element.layer === "bottom" && groundPlaneIds.has(element.pcb_ground_plane_id));
+  const groundRegions = [
+    ...pours.map(pourRegion3),
+    ...planeRegions.flatMap((region) => region.type === "pcb_ground_plane_region" ? [{ outer: region.points, holes: [] }] : [])
+  ];
+  if (!groundRegions.length)
+    throw new Error("The selected ground net needs a bottom-layer copper pour or ground-plane region");
+  const cutouts = options.circuitJson.filter((element) => element.type === "pcb_cutout").map(cutoutOutline2);
+  for (const outline of [
+    boardOutline,
+    ...cutouts,
+    ...groundRegions.flatMap((region) => [region.outer, ...region.holes])
+  ])
+    validateOutline2(outline);
+  const geometry = {
+    board,
+    boardOutline,
+    groundRegions,
+    cutouts,
+    signals: [],
+    segments: [],
+    excitations
+  };
+  for (const excitation of excitations) {
+    if (!Number.isFinite(excitation.current))
+      throw new Error("Excitation current must be finite (amperes)");
+    for (const contact of [excitation.return_source, excitation.return_sink]) {
+      if (!Number.isFinite(contact.x) || !Number.isFinite(contact.y) || !isCopper2(contact, geometry))
+        throw new Error("Each return contact must lie on the selected ground copper");
+    }
+    const signal = options.circuitJson.find((element) => element.type === "pcb_trace" && element.pcb_trace_id === excitation.pcb_trace_id);
+    if (!signal || signal.type !== "pcb_trace")
+      throw new Error("An excitation references a missing signal trace");
+    if (signal.route.length < 2)
+      throw new Error("Each signal trace needs at least two route points");
+    const wires = signal.route.map((routePoint) => {
+      if (routePoint.route_type !== "wire" || routePoint.layer !== "top")
+        throw new Error("Only continuous top-layer wire routes are supported; split routes at vias or pads");
+      if (!Number.isFinite(routePoint.x) || !Number.isFinite(routePoint.y))
+        throw new Error("Signal coordinates must be finite");
+      positiveFinite2(routePoint.width, "Signal width");
+      return routePoint;
+    });
+    geometry.signals.push(signal);
+    for (let routeIndex = 1;routeIndex < wires.length; routeIndex++) {
+      const start = wires[routeIndex - 1];
+      const end = wires[routeIndex];
+      if (start.x === end.x && start.y === end.y)
+        continue;
+      const boardMaterial = {
+        ...geometry,
+        groundRegions: [{ outer: boardOutline, holes: [] }]
+      };
+      if (!segmentInCopper2({ start, end }, boardMaterial))
+        throw new Error("A top-layer signal leaves the board or crosses a physical PCB cutout");
+      geometry.segments.push({
+        start,
+        end,
+        width: start.width,
+        current: excitation.current
+      });
+    }
+  }
+  if (!geometry.segments.length)
+    throw new Error("Signal traces must contain a segment of nonzero length");
+  return geometry;
+}
+function validatePalaceReference2(reference) {
+  if (reference.femOrder !== 1 && reference.femOrder !== 2 || reference.schemaVersion !== 1 || reference.solver !== "palace" || !["volumetric_copper", "surface_impedance_copper"].includes(reference.copperModel) || reference.sampleLayer !== undefined && !/^(top|bottom|inner[1-8])$/.test(reference.sampleLayer))
+    throw new Error("Unsupported Palace reference");
+  if (reference.copperModel === "surface_impedance_copper" && (reference.samplingMethod !== "sum_foil_face_surface_currents" || !Number.isFinite(reference.surfaceCurrentScaleAmpsPerMm) || reference.surfaceCurrentScaleAmpsPerMm <= 0))
+    throw new Error("Surface impedance reference must identify its face-current sampling and finite positive A/mm scale");
+  if (![
+    reference.frequencyHz,
+    reference.copperThickness,
+    reference.layerSeparation,
+    reference.cellWidth,
+    reference.cellHeight,
+    reference.normalizationConditionNumber,
+    reference.electricFieldScaleVoltsPerMeter
+  ].every((number) => Number.isFinite(number) && number > 0))
+    throw new Error("Palace reference needs finite positive frequency, thickness, cell sizes and normalization condition");
+  if (![reference.columns, reference.rows].every((number) => Number.isInteger(number) && number > 0) || !reference.samples.length)
+    throw new Error("Palace reference needs a nonempty grid");
+  if (typeof reference.provenance.geometrySignature !== "string" || !reference.provenance.geometrySignature.length)
+    throw new Error("Palace reference needs a physical geometry signature");
+  const locations = new Set;
+  for (const sample of reference.samples) {
+    if (![
+      sample.x,
+      sample.y,
+      sample.sheetCurrentXReal,
+      sample.sheetCurrentYReal,
+      sample.sheetCurrentXImag,
+      sample.sheetCurrentYImag
+    ].every(Number.isFinite))
+      throw new Error("Non-finite Palace sample");
+    const location2 = `${sample.x},${sample.y}`;
+    if (locations.has(location2))
+      throw new Error("Duplicate Palace sample position");
+    locations.add(location2);
+  }
+  for (const current of [
+    ...reference.sourceCurrents,
+    ...reference.loadCurrents
+  ])
+    if (![current.real, current.imag].every(Number.isFinite))
+      throw new Error("Non-finite Palace port current");
+}
+function currentColor2(fraction) {
+  const stops = [
+    [0, 99, 235],
+    [0, 180, 216],
+    [19, 202, 70],
+    [225, 233, 20],
+    [255, 175, 0],
+    [255, 60, 0]
+  ];
+  const position = Math.max(0, Math.min(1, fraction)) * (stops.length - 1);
+  const stopIndex = Math.min(stops.length - 2, Math.floor(position));
+  const blend = position - stopIndex;
+  const rgb = stops[stopIndex].map((channel, channelIndex) => Math.round(channel + blend * (stops[stopIndex + 1][channelIndex] - channel)));
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+function coordinate2(number) {
+  return (number === 0 ? 0 : number).toFixed(9);
+}
+function point13(point2) {
+  return [coordinate2(point2.x), coordinate2(point2.y)];
+}
+function palaceGeometrySignature2(geometry) {
+  return JSON.stringify([
+    geometry.boardOutline.map(point13),
+    geometry.groundRegions.map((region) => [
+      region.outer.map(point13),
+      [...region.holes, ...region.maskCutouts ?? []].map((hole) => hole.map(point13))
+    ]),
+    geometry.cutouts.map((outline) => outline.map(point13)),
+    geometry.signals.map((signal) => signal.route.filter((route) => route.route_type === "wire").map((route) => [
+      ...point13(route),
+      coordinate2(route.width),
+      route.layer
+    ])),
+    ...geometry.physicalModelSignature ? [geometry.physicalModelSignature] : [],
+    geometry.excitations.map((excitation) => [
+      coordinate2(excitation.current),
+      point13(excitation.return_source),
+      point13(excitation.return_sink),
+      ...excitation.source_port || excitation.load_port ? [
+        [
+          excitation.source_port?.reference_layer ?? "bottom",
+          coordinate2(excitation.source_port?.resistance ?? 50),
+          excitation.load_port?.reference_layer ?? "bottom",
+          coordinate2(excitation.load_port?.resistance ?? 50)
+        ]
+      ] : []
+    ])
+  ]);
+}
+function normalizeLayeredRoute3(trace) {
+  const route = [];
+  for (const [index, point2] of trace.route.entries()) {
+    if (point2.route_type === "wire") {
+      route.push(point2);
+      continue;
+    }
+    if (point2.route_type !== "via")
+      throw new Error("Through-pad route points are not supported");
+    const previous = route.at(-1);
+    const next = trace.route[index + 1];
+    if (!previous || previous.route_type !== "wire" || !next)
+      throw new Error("Via needs signal route endpoints on both sides");
+    if (previous.layer !== point2.from_layer)
+      throw new Error("Via from_layer does not match preceding wire layer");
+    if (previous.x !== point2.x || previous.y !== point2.y)
+      route.push({
+        route_type: "wire",
+        x: point2.x,
+        y: point2.y,
+        width: previous.width,
+        layer: point2.from_layer
+      });
+    route.push(point2);
+    if (next.route_type !== "wire" || next.x !== point2.x || next.y !== point2.y)
+      route.push({
+        route_type: "wire",
+        x: point2.x,
+        y: point2.y,
+        width: next.route_type === "wire" ? next.width : previous.width,
+        layer: point2.to_layer
+      });
+  }
+  return { ...trace, route };
+}
+function copperConnectivity2(circuitJson) {
+  const parents = new Map;
+  const find = (id) => {
+    const parent = parents.get(id);
+    if (!parent) {
+      parents.set(id, id);
+      return id;
+    }
+    if (parent === id)
+      return id;
+    const root = find(parent);
+    parents.set(id, root);
+    return root;
+  };
+  for (const element of circuitJson) {
+    if (element.type !== "source_trace")
+      continue;
+    const ids = [
+      element.source_trace_id,
+      ...element.connected_source_net_ids,
+      ...element.connected_source_port_ids
+    ];
+    for (const id of ids)
+      parents.set(find(id), find(ids[0]));
+  }
+  const netIds = new Map;
+  for (const element of circuitJson)
+    if (element.type === "source_net") {
+      const root = find(element.source_net_id);
+      const existing = netIds.get(root);
+      if (existing && existing !== element.source_net_id)
+        throw new Error(`Source connectivity joins distinct nets ${existing} and ${element.source_net_id}`);
+      netIds.set(root, element.source_net_id);
+    }
+  const owner = (id) => netIds.get(find(id)) ?? find(id);
+  const pcbPorts = new Map;
+  const pcbTraces = new Map;
+  for (const element of circuitJson) {
+    if (element.type === "pcb_port")
+      pcbPorts.set(element.pcb_port_id, owner(element.source_port_id));
+    if (element.type === "pcb_trace")
+      pcbTraces.set(element.pcb_trace_id, owner(element.source_trace_id ?? element.pcb_trace_id));
+  }
+  return { owner, pcbPorts, pcbTraces };
+}
+function traceOutline2(segment) {
+  const dx = segment.end.x - segment.start.x;
+  const dy = segment.end.y - segment.start.y;
+  const length = Math.hypot(dx, dy);
+  const transform = compose26(translate26((segment.start.x + segment.end.x) / 2, (segment.start.y + segment.end.y) / 2), rotateDEG24(Math.atan2(dy, dx) * 180 / Math.PI));
+  return [-1, 1].flatMap((end) => Array.from({ length: 17 }, (_, index) => {
+    const angle = index * Math.PI / 16 + (end === 1 ? -Math.PI / 2 : Math.PI / 2);
+    return applyToPoint216(transform, {
+      x: end * length / 2 + segment.width / 2 * Math.cos(angle),
+      y: segment.width / 2 * Math.sin(angle)
+    });
+  }));
+}
+function roundedOutline2(options) {
+  positiveFinite2(options.width, "outline width");
+  positiveFinite2(options.height, "outline height");
+  const radius = options.radius ?? Math.min(options.width, options.height) / 2;
+  if (!Number.isFinite(radius) || radius <= 0 || radius > Math.min(options.width, options.height) / 2 + 0.0000001)
+    throw new Error("Invalid rounded copper radius");
+  const transform = compose26(translate26(options.x, options.y), rotateDEG24(options.ccwRotationDegrees ?? 0));
+  return Array.from({ length: 32 }, (_, index) => {
+    const angle = index * 2 * Math.PI / 32;
+    const x = Math.cos(angle), y = Math.sin(angle);
+    return applyToPoint216(transform, {
+      x: Math.sign(x) * (options.width / 2 - radius) + radius * x,
+      y: Math.sign(y) * (options.height / 2 - radius) + radius * y
+    });
+  });
+}
+function smtPadOutline2(pad) {
+  if (pad.shape === "polygon")
+    return pad.points;
+  if (pad.shape === "circle")
+    return roundedOutline2({
+      ...pad,
+      width: 2 * pad.radius,
+      height: 2 * pad.radius
+    });
+  if (pad.shape === "rect" || pad.shape === "rotated_rect")
+    return rectangleOutline3({
+      center: pad,
+      width: pad.width,
+      height: pad.height,
+      rotation: pad.shape === "rotated_rect" ? pad.ccw_rotation : 0
+    });
+  if (pad.shape === "pill" || pad.shape === "rotated_pill")
+    return roundedOutline2({
+      ...pad,
+      radius: pad.radius,
+      ccwRotationDegrees: pad.shape === "rotated_pill" ? pad.ccw_rotation : 0
+    });
+  throw new Error("Unsupported SMT pad shape");
+}
+function drillOutline2(hole) {
+  if ("hole_diameter" in hole)
+    return roundedOutline2({
+      x: hole.x + ("hole_offset_x" in hole ? hole.hole_offset_x ?? 0 : 0),
+      y: hole.y + ("hole_offset_y" in hole ? hole.hole_offset_y ?? 0 : 0),
+      width: positiveFinite2(hole.hole_diameter ?? 0, "hole diameter"),
+      height: positiveFinite2(hole.hole_diameter ?? 0, "hole diameter")
+    });
+  if ("hole_width" in hole)
+    return roundedOutline2({
+      ...hole,
+      width: positiveFinite2(hole.hole_width ?? 0, "hole width"),
+      height: positiveFinite2(hole.hole_height ?? 0, "hole height"),
+      ccwRotationDegrees: "ccw_rotation" in hole ? hole.ccw_rotation : 0
+    });
+  throw new Error("Unsupported drilled hole shape");
+}
+function platedPadOutline2(hole) {
+  if ("outer_diameter" in hole)
+    return roundedOutline2({
+      ...hole,
+      width: hole.outer_diameter,
+      height: hole.outer_diameter
+    });
+  if ("outer_width" in hole)
+    return roundedOutline2({
+      ...hole,
+      width: hole.outer_width,
+      height: hole.outer_height,
+      ccwRotationDegrees: "ccw_rotation" in hole ? hole.ccw_rotation : 0
+    });
+  if (hole.shape === "circular_hole_with_rect_pad")
+    return rectangleOutline3({
+      center: hole,
+      width: hole.rect_pad_width,
+      height: hole.rect_pad_height,
+      rotation: hole.rect_ccw_rotation
+    });
+  throw new Error(`Unsupported plated hole shape: ${hole.shape}`);
+}
+function parseFabricationStackup2(input) {
+  return fabricationStackupSchema3.parse(input);
+}
+function physicalStackup2(options) {
+  const stackup = parseFabricationStackup2(options.stackup);
+  const expected = [
+    "top",
+    ...Array.from({ length: options.numLayers - 2 }, (_, i) => `inner${i + 1}`),
+    "bottom"
+  ];
+  if (stackup.layers.length !== 2 * options.numLayers - 1)
+    throw new Error("Stackup must alternate copper and dielectric, top to bottom");
+  const copperLayers = [];
+  const dielectrics = [];
+  const bottom = stackup.layers.at(-1);
+  if (!bottom || !("name" in bottom) || bottom.name !== "bottom")
+    throw new Error("Stackup must end with bottom copper");
+  let z2 = -bottom.copperThicknessMm;
+  for (let index = stackup.layers.length - 1;index >= 0; index--) {
+    const layer = stackup.layers[index];
+    if (index % 2 === 0) {
+      if (!("name" in layer) || layer.name !== expected[index / 2])
+        throw new Error(`Stackup copper order must be ${expected.join(", ")}`);
+      const thickness = positiveFinite2(layer.copperThicknessMm, "copper thickness");
+      copperLayers.unshift({ name: layer.name, zMin: z2, zMax: z2 + thickness });
+      z2 += thickness;
+    } else {
+      if (!("material" in layer))
+        throw new Error("A dielectric is required between copper layers");
+      dielectrics.push({
+        material: layer.material,
+        zMin: z2,
+        zMax: z2 + layer.dielectricThicknessMm,
+        dielectricConstant: layer.dielectricConstant,
+        lossTangent: layer.lossTangent ?? options.lossTangent,
+        attribute: 100 + index
+      });
+      z2 += layer.dielectricThicknessMm;
+    }
+  }
+  return {
+    copperLayers,
+    dielectrics,
+    physicalThicknessMm: z2 + bottom.copperThicknessMm,
+    nominalBoardThicknessMm: stackup.nominalBoardThicknessMm
+  };
+}
+function createMultilayerPalaceModel2(options) {
+  options = {
+    ...options,
+    circuitJson: options.circuitJson.map((e) => e.type === "pcb_trace" ? normalizeLayeredRoute3(e) : e)
+  };
+  const boards = options.circuitJson.filter((e) => e.type === "pcb_board");
+  if (boards.length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const board = boards[0];
+  if (options.copperModel === "surface_impedance_copper")
+    throw new Error("surface_impedance_copper currently supports the two-layer mesher only");
+  if (!options.stackup)
+    throw new Error("Multilayer boards require an explicit fabrication stackup (--stackup-file); layer spacing is not inferred");
+  if (!Number.isInteger(board.num_layers) || board.num_layers < 2)
+    throw new Error("Board must have at least two copper layers");
+  if (options.layerSeparation !== undefined || options.copperThickness !== undefined)
+    throw new Error("Use stackup layer thicknesses instead of layerSeparation/copperThickness");
+  const substrateLossTangent = options.substrateLossTangent ?? 0.02;
+  if (!Number.isFinite(substrateLossTangent) || substrateLossTangent < 0)
+    throw new Error("substrateLossTangent must be finite and nonnegative");
+  const stackup = physicalStackup2({
+    stackup: options.stackup,
+    numLayers: board.num_layers,
+    lossTangent: substrateLossTangent
+  });
+  const sampleLayer = options.sampleLayer ?? "bottom";
+  const sampleFoil = stackup.copperLayers.find((layer) => layer.name === sampleLayer);
+  if (!sampleFoil)
+    throw new Error(`Sample layer ${sampleLayer} is absent from the stackup`);
+  const frequencyHz = positiveFinite2(options.frequencyHz, "frequencyHz");
+  const copperConductivity = positiveFinite2(options.copperConductivity ?? 58000000, "copperConductivity");
+  const skinDepthMm = 1000 / Math.sqrt(Math.PI * frequencyHz * 0.0000004 * Math.PI * copperConductivity);
+  if (stackup.copperLayers.some((layer) => layer.zMax - layer.zMin > skinDepthMm))
+    throw new Error("The current volume mesher requires copper thickness <= skin depth; refine copper through its thickness before using higher frequencies");
+  const excitations = options.excitations ?? options.circuitJson.filter((e) => e.type === "simulation_return_current_excitation");
+  const groundIds = new Set(excitations.map((e) => e.ground_source_net_id));
+  if (!excitations.length || groundIds.size !== 1)
+    throw new Error("Specify excitations sharing one reference net");
+  const referenceNetId = excitations[0].ground_source_net_id;
+  const connectivity = copperConnectivity2(options.circuitJson);
+  const boardOutline = board.outline?.length ? board.outline : rectangleOutline3({
+    center: board.center,
+    width: board.width ?? 0,
+    height: board.height ?? 0
+  });
+  const boardCutouts = options.circuitJson.filter((e) => e.type === "pcb_cutout").map(cutoutOutline2);
+  const viaClearance = positiveFinite2(options.viaClearance ?? board.min_trace_to_pad_edge_clearance ?? 0.2, "viaClearance");
+  const layered = {
+    stackup,
+    sampleLayer,
+    referenceNetId,
+    viaClearance,
+    copper: [],
+    drills: [],
+    barrels: [],
+    boardCutouts,
+    audit: {
+      traces: 0,
+      vias: 0,
+      pads: 0,
+      platedHoles: 0,
+      unplatedHoles: 0,
+      pours: 0,
+      omittedCopperElements: 0,
+      warnings: [
+        "Component bodies, package/decoupling impedances, solder mask and silkscreen are not modeled.",
+        "Circular copper/drills use 32-sided polygons. Via plating uses 0.025 mm; override support is not yet provided."
+      ]
+    }
+  };
+  const copperByKey = new Map;
+  for (const layer of stackup.copperLayers)
+    for (const netId of [referenceNetId]) {
+      const copper = { layer: layer.name, netId, regions: [], segments: [] };
+      copperByKey.set(`${layer.name}:${netId}`, copper);
+      layered.copper.push(copper);
+    }
+  const traces = new Map;
+  for (const element of options.circuitJson) {
+    if (element.type === "pcb_trace")
+      traces.set(element.pcb_trace_id, element);
+    const additions = [];
+    if (element.type === "pcb_copper_pour") {
+      if (!element.source_net_id)
+        throw new Error("Copper pours require a source_net_id");
+      additions.push({
+        layer: element.layer,
+        netId: connectivity.owner(element.source_net_id),
+        region: { ...pourRegion3(element), isPlane: true }
+      });
+      layered.audit.pours++;
+    }
+    if (element.type === "pcb_ground_plane_region") {
+      const plane = options.circuitJson.find((e) => e.type === "pcb_ground_plane" && e.pcb_ground_plane_id === element.pcb_ground_plane_id);
+      if (!plane || plane.type !== "pcb_ground_plane")
+        throw new Error("Missing ground-plane owner");
+      additions.push({
+        layer: element.layer,
+        netId: connectivity.owner(plane.source_net_id),
+        region: { outer: element.points, holes: [], isPlane: true }
+      });
+    }
+    if (element.type === "pcb_smtpad") {
+      const netId = element.pcb_port_id ? connectivity.pcbPorts.get(element.pcb_port_id) : undefined;
+      if (!netId)
+        throw new Error(`Pad ${element.pcb_smtpad_id} has no PCB port ownership`);
+      additions.push({
+        layer: element.layer,
+        netId,
+        region: { outer: smtPadOutline2(element), holes: [] }
+      });
+      layered.audit.pads++;
+    }
+    if (element.type === "pcb_trace") {
+      const netId = connectivity.pcbTraces.get(element.pcb_trace_id);
+      validateLayeredRoute2(element, stackup.copperLayers.map((l) => l.name));
+      for (let index = 1;index < element.route.length; index++) {
+        const start = element.route[index - 1], end = element.route[index];
+        if (start.route_type !== "wire" || end.route_type !== "wire")
+          continue;
+        if (start.x === end.x && start.y === end.y)
+          continue;
+        additions.push({
+          layer: start.layer,
+          netId,
+          segment: {
+            start,
+            end,
+            width: positiveFinite2(start.width, "trace width"),
+            current: 0
+          }
+        });
+      }
+      layered.audit.traces++;
+    }
+    for (const addition of additions) {
+      if (!stackup.copperLayers.some((l) => l.name === addition.layer))
+        throw new Error(`Copper on absent layer ${addition.layer}`);
+      const key = `${addition.layer}:${addition.netId}`;
+      let copper = copperByKey.get(key);
+      if (!copper) {
+        copper = {
+          layer: addition.layer,
+          netId: addition.netId,
+          regions: [],
+          segments: []
+        };
+        copperByKey.set(key, copper);
+        layered.copper.push(copper);
+      }
+      if (addition.region)
+        copper.regions.push(addition.region);
+      if (addition.segment)
+        copper.segments.push(addition.segment);
+    }
+  }
+  const bottom = stackup.copperLayers.at(-1), top = stackup.copperLayers[0];
+  for (const element of options.circuitJson) {
+    if (element.type === "pcb_hole") {
+      layered.drills.push({
+        hole: drillOutline2(element),
+        zMin: bottom.zMin,
+        zMax: top.zMax
+      });
+      layered.audit.unplatedHoles++;
+    }
+    if (element.type !== "pcb_via" && element.type !== "pcb_plated_hole")
+      continue;
+    const netId = element.type === "pcb_via" ? element.source_net_id ? connectivity.owner(element.source_net_id) : element.pcb_trace_id ? connectivity.pcbTraces.get(element.pcb_trace_id) : undefined : element.pcb_port_id ? connectivity.pcbPorts.get(element.pcb_port_id) : undefined;
+    if (!netId)
+      throw new Error(`Cannot identify copper ownership for ${element.type}; supply source_net_id or pcb_trace_id`);
+    const layers = element.layers.map((name) => stackup.copperLayers.find((l) => l.name === name));
+    if (!layers.length || layers.some((l) => !l))
+      throw new Error("Via/hole references an absent stackup layer");
+    const zMin = Math.min(...layers.map((l) => l.zMin)), zMax = Math.max(...layers.map((l) => l.zMax));
+    const hole = element.type === "pcb_via" ? roundedOutline2({
+      ...element,
+      width: element.hole_diameter,
+      height: element.hole_diameter
+    }) : drillOutline2(element);
+    const pads = element.type === "pcb_via" ? roundedOutline2({
+      ...element,
+      width: element.outer_diameter,
+      height: element.outer_diameter
+    }) : platedPadOutline2(element);
+    layered.barrels.push({
+      netId,
+      hole,
+      outer: hole,
+      pads,
+      layers: element.layers,
+      zMin,
+      zMax,
+      platingThickness: 0.025
+    });
+    layered.drills.push({ hole, zMin, zMax });
+    if (element.type === "pcb_via")
+      layered.audit.vias++;
+    else
+      layered.audit.platedHoles++;
+  }
+  for (const trace of traces.values())
+    for (const route of trace.route) {
+      if (route.route_type !== "via")
+        continue;
+      const barrel = layered.barrels.find((b) => b.netId === connectivity.pcbTraces.get(trace.pcb_trace_id) && pointInPolygon3(route, b.hole) && b.layers.includes(route.from_layer) && b.layers.includes(route.to_layer));
+      if (!barrel)
+        throw new Error(`Trace ${trace.pcb_trace_id} changes layer without a matching physical pcb_via`);
+    }
+  for (const barrel of layered.barrels)
+    barrel.clearance = barrelClearanceOutline2(barrel, viaClearance);
+  const groundCopper = copperByKey.get(`${sampleLayer}:${referenceNetId}`);
+  if (!groundCopper.regions.length)
+    throw new Error(`Reference net needs copper regions on sample layer ${sampleLayer}; no plane is invented`);
+  const geometry = {
+    board,
+    boardOutline,
+    groundRegions: groundCopper.regions.map((region) => ({
+      ...region,
+      holes: [...region.holes]
+    })),
+    cutouts: [...boardCutouts],
+    signals: [],
+    segments: [],
+    excitations
+  };
+  for (const segment of groundCopper.segments) {
+    geometry.groundRegions.push({
+      outer: traceOutline2(segment),
+      holes: []
+    });
+  }
+  for (const barrel of layered.barrels) {
+    if (barrel.zMin > sampleFoil.zMin || barrel.zMax < sampleFoil.zMax)
+      continue;
+    if (barrel.netId === referenceNetId && barrel.layers.includes(sampleLayer))
+      geometry.groundRegions.push({ outer: barrel.pads, holes: [barrel.hole] });
+    else if (barrel.netId !== referenceNetId) {
+      for (const region of geometry.groundRegions.filter((region2) => region2.isPlane))
+        region.maskCutouts = [
+          ...region.maskCutouts ?? [],
+          barrelClearanceOutline2(barrel, viaClearance)
+        ];
+    }
+  }
+  for (const drill of layered.drills)
+    if (drill.zMin <= sampleFoil.zMin && drill.zMax >= sampleFoil.zMax)
+      geometry.cutouts.push(drill.hole);
+  const ports = [];
+  for (const excitation of excitations) {
+    if (!Number.isFinite(excitation.current))
+      throw new Error("Excitation current must be finite");
+    const trace = traces.get(excitation.pcb_trace_id);
+    if (!trace)
+      throw new Error("Missing excited trace");
+    geometry.signals.push(trace);
+    for (let index = 1;index < trace.route.length; index++) {
+      const start = trace.route[index - 1], end = trace.route[index];
+      if (start.route_type === "wire" && end.route_type === "wire" && (start.x !== end.x || start.y !== end.y))
+        geometry.segments.push({
+          start,
+          end,
+          width: start.width,
+          current: excitation.current
+        });
+    }
+    for (const [endpoint, reference, terminal] of [
+      [trace.route[0], excitation.return_sink, excitation.source_port],
+      [trace.route.at(-1), excitation.return_source, excitation.load_port]
+    ]) {
+      if (endpoint.route_type !== "wire")
+        throw new Error("Ports require wire endpoints");
+      const signalFoil = stackup.copperLayers.find((l) => l.name === endpoint.layer);
+      const referenceFoil = stackup.copperLayers.find((l) => l.name === (terminal?.reference_layer ?? sampleLayer));
+      if (!referenceFoil)
+        throw new Error("Reference layer is absent");
+      if (terminal?.reference_pcb_port_id && connectivity.pcbPorts.get(terminal.reference_pcb_port_id) !== referenceNetId)
+        throw new Error("Reference pin is not on the reference net");
+      for (const [id, position, layer] of [
+        [terminal?.signal_pcb_port_id, endpoint, endpoint.layer],
+        [terminal?.reference_pcb_port_id, reference, referenceFoil.name]
+      ]) {
+        if (!id)
+          continue;
+        const pcb = options.circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === id);
+        if (!pcb || pcb.type !== "pcb_port" || !pcb.layers.includes(layer) || Math.hypot(pcb.x - position.x, pcb.y - position.y) > 0.000001)
+          throw new Error("Terminal does not match its PCB port position/layer");
+      }
+      const below = referenceFoil.zMin < signalFoil.zMin;
+      ports.push({
+        signal: { x: endpoint.x, y: endpoint.y },
+        reference: { x: reference.x, y: reference.y },
+        signalLayer: signalFoil.name,
+        referenceLayer: referenceFoil.name,
+        signalZ: below ? signalFoil.zMin : signalFoil.zMax,
+        referenceZ: below ? referenceFoil.zMax : referenceFoil.zMin === signalFoil.zMin ? signalFoil.zMax : referenceFoil.zMin,
+        resistance: positiveFinite2(terminal?.resistance ?? options.portResistance ?? 50, "port resistance"),
+        signalPcbPortId: terminal?.signal_pcb_port_id,
+        referencePcbPortId: terminal?.reference_pcb_port_id
+      });
+    }
+  }
+  if (stackup.nominalBoardThicknessMm && Math.abs(stackup.physicalThicknessMm - stackup.nominalBoardThicknessMm) > 0.0001)
+    layered.audit.warnings.push(`Explicit stack sums to ${stackup.physicalThicknessMm} mm, nominal ${stackup.nominalBoardThicknessMm} mm; explicit dimensions are used without scaling.`);
+  geometry.physicalModelSignature = JSON.stringify({
+    ...layered,
+    traceEndCaps: "round_32",
+    audit: undefined
+  });
+  const order = options.order ?? 2;
+  if (order !== 1 && order !== 2)
+    throw new Error("order must be 1 or 2");
+  return {
+    schemaVersion: 1,
+    multilayer: layered,
+    geometry,
+    ports,
+    topPads: [],
+    frequencyHz,
+    layerSeparation: top.zMin - bottom.zMax,
+    copperThickness: sampleFoil.zMax - sampleFoil.zMin,
+    copperConductivity,
+    substratePermittivity: options.substratePermittivity ?? 4.3,
+    substrateLossTangent,
+    portResistance: positiveFinite2(options.portResistance ?? 50, "portResistance"),
+    portWidth: positiveFinite2(options.portWidth ?? 0.18, "portWidth"),
+    meshSize: positiveFinite2(options.meshSize ?? 1, "meshSize"),
+    airPadding: positiveFinite2(options.airPadding ?? 10, "airPadding"),
+    order,
+    copperModel: "volumetric_copper"
+  };
+}
+function validateLayeredRoute2(trace, layers) {
+  for (const [index, route] of trace.route.entries()) {
+    if (route.route_type !== "wire" && route.route_type !== "via")
+      throw new Error("Unsupported route point type");
+    if (![route.x, route.y].every(Number.isFinite))
+      throw new Error("Trace coordinates must be finite");
+    if (route.route_type === "wire") {
+      positiveFinite2(route.width, "trace width");
+      if (!layers.includes(route.layer))
+        throw new Error(`Unknown route layer ${route.layer}`);
+      const previous = trace.route[index - 1];
+      if (previous?.route_type === "wire" && previous.layer !== route.layer)
+        throw new Error("Layer transitions require a via route point");
+    } else if (route.route_type === "via") {
+      const previous = trace.route[index - 1], next = trace.route[index + 1];
+      if (previous?.route_type !== "wire" || next?.route_type !== "wire" || previous.layer !== route.from_layer || next.layer !== route.to_layer || Math.hypot(previous.x - route.x, previous.y - route.y) > 0.000001 || Math.hypot(next.x - route.x, next.y - route.y) > 0.000001)
+        throw new Error("Via route must join matching, colocated layer endpoints");
+    } else
+      throw new Error("Unsupported route point type");
+  }
+}
+function barrelClearanceOutline2(barrel, clearance) {
+  const xs = barrel.pads.map((p) => p.x), ys = barrel.pads.map((p) => p.y);
+  const minX = Math.min(...xs), maxX = Math.max(...xs), minY = Math.min(...ys), maxY = Math.max(...ys);
+  return rectangleOutline3({
+    center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+    width: maxX - minX + 2 * clearance,
+    height: maxY - minY + 2 * clearance
+  });
+}
+function portNetIds3(circuitJson, sourcePortId) {
+  const ports = new Set([sourcePortId]);
+  const nets = new Set;
+  const pending = circuitJson.filter((element) => element.type === "source_trace");
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const trace of pending) {
+      if (!trace.connected_source_port_ids.some((id) => ports.has(id)) && !trace.connected_source_net_ids.some((id) => nets.has(id)))
+        continue;
+      for (const id of trace.connected_source_port_ids)
+        if (!ports.has(id)) {
+          ports.add(id);
+          changed = true;
+        }
+      for (const id of trace.connected_source_net_ids)
+        if (!nets.has(id)) {
+          nets.add(id);
+          changed = true;
+        }
+    }
+  }
+  return [...nets];
+}
+function createPalaceModel2(options) {
+  if (options.stackup || options.circuitJson.some((element) => element.type === "pcb_board" && element.num_layers > 2))
+    return createMultilayerPalaceModel2(options);
+  if (options.sampleLayer && options.sampleLayer !== "bottom")
+    throw new Error("A non-bottom sample layer requires an explicit stackup");
+  const frequencyHz = positiveFinite2(options.frequencyHz, "frequencyHz");
+  const geometry = readGeometry2({
+    ...options,
+    circuitJson: options.circuitJson.filter((element) => element.type !== "pcb_via")
+  });
+  const layerSeparation = positiveFinite2(options.layerSeparation ?? geometry.board.thickness ?? 0.8, "layerSeparation");
+  const copperThickness = positiveFinite2(options.copperThickness ?? 0.035, "copperThickness");
+  const copperConductivity = positiveFinite2(options.copperConductivity ?? 58000000, "copperConductivity");
+  const skinDepthMm = 1000 / Math.sqrt(Math.PI * frequencyHz * 0.0000004 * Math.PI * copperConductivity);
+  const copperModel = options.copperModel ?? "volumetric_copper";
+  if (copperModel !== "volumetric_copper" && copperModel !== "surface_impedance_copper")
+    throw new Error("Unknown copperModel");
+  if (copperModel === "surface_impedance_copper" && copperThickness < 3 * skinDepthMm)
+    throw new Error("The half-space surface-impedance model requires foil and via-wall thickness >= 3 skin depths; use volumetric copper at lower frequencies");
+  if (copperModel === "volumetric_copper" && copperThickness > skinDepthMm)
+    throw new Error("The current volume mesher requires copper thickness <= skin depth; refine copper through its thickness before using higher frequencies");
+  const ports = [];
+  for (const [index, signal] of geometry.signals.entries()) {
+    const first = signal.route[0];
+    const last = signal.route.at(-1);
+    const excitation = geometry.excitations[index];
+    if (!last || first.route_type !== "wire" || last.route_type !== "wire")
+      throw new Error("Palace requires wire endpoints");
+    for (const [endpoint, contact, terminal] of [
+      [first, excitation.return_sink, excitation.source_port],
+      [last, excitation.return_source, excitation.load_port]
+    ]) {
+      if (!terminal && Math.hypot(endpoint.x - contact.x, endpoint.y - contact.y) > 0.000001)
+        throw new Error("Legacy Palace ports require return contacts directly below signal endpoints; specify explicit terminal metadata for offset references");
+      for (const [id, position, role] of [
+        [terminal?.signal_pcb_port_id, endpoint, "signal"],
+        [terminal?.reference_pcb_port_id, contact, "reference"]
+      ]) {
+        if (!id)
+          continue;
+        const pcb = options.circuitJson.find((element) => element.type === "pcb_port" && element.pcb_port_id === id);
+        if (!pcb || pcb.type !== "pcb_port" || Math.hypot(pcb.x - position.x, pcb.y - position.y) > 0.000001)
+          throw new Error(`Explicit ${role} terminal does not match its PCB port`);
+        const layer = role === "signal" ? "top" : terminal.reference_layer;
+        if (!pcb.layers.includes(layer))
+          throw new Error(`Explicit ${role} terminal is not on ${layer}`);
+        if (role === "reference" && !portNetIds3(options.circuitJson, pcb.source_port_id).includes(excitation.ground_source_net_id))
+          throw new Error("Explicit reference terminal is not connected to the ground net");
+      }
+      if (terminal?.reference_layer === "top" && !terminal.reference_pcb_port_id)
+        throw new Error("Top reference requires an explicit PCB port");
+      ports.push({
+        signal: { x: endpoint.x, y: endpoint.y },
+        reference: { x: contact.x, y: contact.y },
+        referenceLayer: terminal?.reference_layer ?? "bottom",
+        resistance: positiveFinite2(terminal?.resistance ?? options.portResistance ?? 50, "port resistance"),
+        signalPcbPortId: terminal?.signal_pcb_port_id,
+        referencePcbPortId: terminal?.reference_pcb_port_id
+      });
+    }
+  }
+  const referenceIds = new Set(ports.filter((port) => port.referenceLayer === "top").map((port) => port.referencePcbPortId));
+  const topGroundPads = [];
+  const topPads = options.circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_smtpad" || element.layer !== "top")
+      return [];
+    if (element.shape !== "rect")
+      throw new Error("Palace currently supports rectangular top SMT pads");
+    const outline = rectangleOutline3({
+      center: { x: element.x, y: element.y },
+      width: element.width,
+      height: element.height
+    });
+    if (referenceIds.has(element.pcb_port_id)) {
+      topGroundPads.push(outline);
+      return [];
+    }
+    return [outline];
+  });
+  const groundVias = options.circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_via")
+      return [];
+    const pad = options.circuitJson.find((pad2) => pad2.type === "pcb_smtpad" && pad2.shape === "rect" && pad2.layer === "top" && referenceIds.has(pad2.pcb_port_id) && Math.hypot(pad2.x - element.x, pad2.y - element.y) < 0.000001);
+    if (!pad || pad.type !== "pcb_smtpad" || pad.shape !== "rect" || element.source_net_id !== geometry.excitations[0].ground_source_net_id || !element.layers.includes("top") || !element.layers.includes("bottom") || element.layers.length !== 2)
+      throw new Error("Only top-to-bottom ground vias centered in selected rectangular reference pads are supported");
+    const holeDiameter = positiveFinite2(element.hole_diameter, "via hole diameter");
+    const outerDiameter = positiveFinite2(element.outer_diameter, "via outer diameter");
+    if (holeDiameter + 2 * copperThickness >= outerDiameter || outerDiameter > Math.min(pad.width, pad.height) || !isCopper2(element, geometry))
+      throw new Error("Ground via needs a plated barrel inside its pad and selected bottom copper");
+    return [
+      {
+        x: element.x,
+        y: element.y,
+        holeDiameter,
+        outerDiameter,
+        platingThickness: copperThickness
+      }
+    ];
+  });
+  for (const port of ports.filter((port2) => port2.referenceLayer === "top")) {
+    if (!groundVias.some((via) => Math.hypot(via.x - port.reference.x, via.y - port.reference.y) < 0.000001))
+      throw new Error("A top reference pad needs a real concentric ground via in circuit-json; ground-pad names alone do not connect copper");
+  }
+  for (const via of groundVias)
+    geometry.cutouts.push(Array.from({ length: 32 }, (_, index) => ({
+      x: via.x + via.holeDiameter / 2 * Math.cos(index * 2 * Math.PI / 32),
+      y: via.y + via.holeDiameter / 2 * Math.sin(index * 2 * Math.PI / 32)
+    })));
+  const substrateLossTangent = options.substrateLossTangent ?? 0.02;
+  if (!Number.isFinite(substrateLossTangent) || substrateLossTangent < 0)
+    throw new Error("substrateLossTangent must be finite and nonnegative");
+  const order = options.order ?? 2;
+  if (order !== 1 && order !== 2)
+    throw new Error("order must be 1 or 2");
+  return {
+    schemaVersion: 1,
+    geometry,
+    topPads,
+    topGroundPads,
+    groundVias,
+    ports,
+    frequencyHz,
+    layerSeparation,
+    copperThickness,
+    copperConductivity,
+    substratePermittivity: positiveFinite2(options.substratePermittivity ?? 4.3, "substratePermittivity"),
+    substrateLossTangent,
+    portResistance: positiveFinite2(options.portResistance ?? 50, "portResistance"),
+    portWidth: positiveFinite2(options.portWidth ?? 0.18, "portWidth"),
+    meshSize: positiveFinite2(options.meshSize ?? 1, "meshSize"),
+    airPadding: positiveFinite2(options.airPadding ?? 10, "airPadding"),
+    order,
+    copperModel,
+    ...copperModel === "surface_impedance_copper" ? {
+      surfaceImpedance: {
+        boundaryModel: "half_space",
+        skinDepthMm,
+        minimumThicknessToSkinDepth: copperThickness / skinDepthMm,
+        currentSampling: "sum_foil_face_surface_currents"
+      }
+    } : {}
+  };
+}
+function boundedPolygon2(outline) {
+  return {
+    outline,
+    minX: Math.min(...outline.map((p) => p.x)),
+    maxX: Math.max(...outline.map((p) => p.x)),
+    minY: Math.min(...outline.map((p) => p.y)),
+    maxY: Math.max(...outline.map((p) => p.y))
+  };
+}
+function contains3(point2, polygon) {
+  return point2.x >= polygon.minX - 0.000000001 && point2.x <= polygon.maxX + 0.000000001 && point2.y >= polygon.minY - 0.000000001 && point2.y <= polygon.maxY + 0.000000001 && pointInPolygon3(point2, polygon.outline);
+}
+function createSampleMask2(geometry) {
+  const board = boundedPolygon2(geometry.boardOutline);
+  const cutouts = geometry.cutouts.map(boundedPolygon2);
+  const regions = geometry.groundRegions.map((r) => ({
+    outer: boundedPolygon2(r.outer),
+    holes: [...r.holes, ...r.maskCutouts ?? []].map(boundedPolygon2)
+  }));
+  return (point2) => contains3(point2, board) && !cutouts.some((cutout) => contains3(point2, cutout)) && regions.some((r) => contains3(point2, r.outer) && !r.holes.some((hole) => contains3(point2, hole)));
+}
+function assertUniqueIds2(circuitJson) {
+  const ids = new Set;
+  for (const element of circuitJson) {
+    const key = `${element.type}_id`;
+    const value = element[key];
+    if (typeof value !== "string")
+      continue;
+    if (ids.has(value))
+      throw new Error(`Duplicate circuit-json ID: ${value}`);
+    ids.add(value);
+  }
+}
+function validateContact2(circuitJson, contact, groundId) {
+  if (contact.contact_type === "pcb_port") {
+    const port = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === contact.pcb_port_id);
+    if (!port || port.type !== "pcb_port" || !port.layers.includes(contact.layer) || Math.hypot(port.x - contact.x, port.y - contact.y) > 0.000001)
+      throw new Error(`Return PCB port ${contact.pcb_port_id} does not match contact location/layer`);
+    if (!portNetIds3(circuitJson, port.source_port_id).includes(groundId))
+      throw new Error(`Return PCB port ${contact.pcb_port_id} is not on the selected ground net`);
+  } else if (contact.contact_type === "pcb_via") {
+    const via = circuitJson.find((e) => e.type === "pcb_via" && e.pcb_via_id === contact.pcb_via_id);
+    if (!via || via.type !== "pcb_via" || !via.layers.includes(contact.layer) || Math.hypot(via.x - contact.x, via.y - contact.y) > 0.000001)
+      throw new Error(`Return PCB via ${contact.pcb_via_id} does not match contact location/layer`);
+    if (via.source_net_id !== groundId)
+      throw new Error(`Return PCB via ${contact.pcb_via_id} needs explicit selected-ground ownership`);
+  } else {
+    const pour = circuitJson.find((e) => e.type === "pcb_copper_pour" && e.pcb_copper_pour_id === contact.pcb_copper_pour_id);
+    if (!pour || pour.type !== "pcb_copper_pour" || pour.layer !== contact.layer || pour.source_net_id !== groundId)
+      throw new Error(`Return copper pour ${contact.pcb_copper_pour_id} is missing or not on the selected ground/layer`);
+    const region = pourRegion3(pour);
+    if (!pointInPolygon3(contact, region.outer) || region.holes.some((h) => pointInPolygon3(contact, h)))
+      throw new Error(`Return contact is outside copper pour ${contact.pcb_copper_pour_id}`);
+  }
+}
+function selectReturnCurrentExperiment2(options) {
+  const { circuitJson } = options;
+  assertUniqueIds2(circuitJson);
+  if (circuitJson.filter((e) => e.type === "pcb_board").length !== 1)
+    throw new Error("Exactly one PCB board is required");
+  const experiments = circuitJson.filter((e) => e.type === "simulation_experiment" && e.experiment_type === "pcb_return_current" && (!options.experimentId || e.simulation_experiment_id === options.experimentId));
+  if (experiments.length !== 1 || experiments[0].type !== "simulation_experiment")
+    throw new Error(`Select exactly one pcb_return_current experiment with --experiment-id; found ${experiments.length}`);
+  const experiment = simulation_experiment4.parse(experiments[0]);
+  const excitations = circuitJson.filter((e) => e.type === "simulation_return_current_excitation" && e.simulation_experiment_id === experiment.simulation_experiment_id).map((e) => simulation_return_current_excitation3.parse(e));
+  if (!excitations.length)
+    throw new Error(`Experiment ${experiment.simulation_experiment_id} has no excitations`);
+  if (new Set(excitations.map((e) => e.ground_source_net_id)).size !== 1)
+    throw new Error("Selected excitations must share one ground net");
+  if (new Set(excitations.map((e) => e.pcb_trace_id)).size !== excitations.length)
+    throw new Error("Selected excitations must reference distinct signal traces");
+  const oriented = new Map;
+  for (const excitation of excitations) {
+    const originalTrace = circuitJson.find((e) => e.type === "pcb_trace" && e.pcb_trace_id === excitation.pcb_trace_id);
+    if (!originalTrace || originalTrace.type !== "pcb_trace")
+      throw new Error(`Missing signal trace ${excitation.pcb_trace_id}`);
+    let trace = normalizeLayeredRoute3(originalTrace);
+    if (excitation.source_port) {
+      const sourcePort = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === excitation.source_port.signal_pcb_port_id);
+      const first = trace.route[0], last = trace.route.at(-1);
+      if (sourcePort?.type === "pcb_port" && last?.route_type === "wire" && Math.hypot(sourcePort.x - last.x, sourcePort.y - last.y) < 0.000001 && !(first?.route_type === "wire" && Math.hypot(sourcePort.x - first.x, sourcePort.y - first.y) < 0.000001))
+        trace = {
+          ...trace,
+          route: trace.route.map((point2, index) => {
+            if (point2.route_type === "via")
+              return {
+                ...point2,
+                from_layer: point2.to_layer,
+                to_layer: point2.from_layer
+              };
+            if (point2.route_type !== "wire")
+              return point2;
+            const previous = trace.route[Math.max(0, index - 1)];
+            return {
+              ...point2,
+              width: previous.route_type === "wire" ? previous.width : point2.width,
+              start_pcb_port_id: point2.end_pcb_port_id,
+              end_pcb_port_id: point2.start_pcb_port_id
+            };
+          }).reverse()
+        };
+    }
+    oriented.set(trace.pcb_trace_id, trace);
+    if (!circuitJson.some((e) => e.type === "source_net" && e.source_net_id === excitation.ground_source_net_id))
+      throw new Error(`Missing ground net ${excitation.ground_source_net_id}`);
+    validateContact2(circuitJson, excitation.return_source, excitation.ground_source_net_id);
+    validateContact2(circuitJson, excitation.return_sink, excitation.ground_source_net_id);
+    for (const [terminal, contact, endpoint] of [
+      [excitation.source_port, excitation.return_sink, trace.route[0]],
+      [excitation.load_port, excitation.return_source, trace.route.at(-1)]
+    ]) {
+      if (!terminal) {
+        if (contact.contact_type === "pcb_port" || contact.layer !== "bottom")
+          throw new Error("An identified return PCB port or non-bottom reference requires explicit source_port/load_port terminal metadata");
+        continue;
+      }
+      if (contact.contact_type === "pcb_port" && terminal.reference_pcb_port_id !== contact.pcb_port_id)
+        throw new Error("A PCB-port return contact requires its matching reference_pcb_port_id");
+      if (terminal.reference_layer !== contact.layer || terminal.reference_pcb_port_id !== undefined && (contact.contact_type !== "pcb_port" || terminal.reference_pcb_port_id !== contact.pcb_port_id))
+        throw new Error("Terminal reference must match the identified return contact");
+      const port = circuitJson.find((e) => e.type === "pcb_port" && e.pcb_port_id === terminal.signal_pcb_port_id);
+      if (!port || port.type !== "pcb_port" || endpoint?.route_type !== "wire" || !port.layers.includes(endpoint.layer) || Math.hypot(port.x - endpoint.x, port.y - endpoint.y) > 0.000001)
+        throw new Error("Signal terminal must match the source/load trace endpoint");
+      if (terminal.signal_pcb_port_id === terminal.reference_pcb_port_id)
+        throw new Error("Signal and reference terminals must be different ports");
+    }
+    if ([excitation.return_source, excitation.return_sink].some((c) => c.contact_type === "pcb_via"))
+      throw new Error("Via return contacts are not supported by the current solver adapter; use a PCB port or copper-pour contact");
+  }
+  return {
+    experiment,
+    excitations,
+    solverCircuitJson: circuitJson.map((e) => e.type === "pcb_trace" ? oriented.get(e.pcb_trace_id) ?? e : e)
+  };
+}
+function fabricationStackup(model) {
+  if (!model.multilayer)
+    return;
+  const stackup = model.multilayer.stackup;
+  return {
+    nominalBoardThicknessMm: stackup.nominalBoardThicknessMm,
+    layers: [
+      ...stackup.copperLayers.map((foil) => ({
+        z: foil.zMax,
+        value: { name: foil.name, copperThicknessMm: foil.zMax - foil.zMin }
+      })),
+      ...stackup.dielectrics.map((d) => ({
+        z: d.zMax,
+        value: {
+          material: d.material,
+          dielectricThicknessMm: d.zMax - d.zMin,
+          dielectricConstant: d.dielectricConstant,
+          lossTangent: d.lossTangent
+        }
+      }))
+    ].sort((a, b) => b.z - a.z).map((l) => l.value)
+  };
+}
+function markersFor(circuitJson, excitations, resultId) {
+  const markers = [];
+  const portMarker = (role, portId, layer) => {
+    markers.push(simulation_pcb_return_current_marker.parse({
+      type: "simulation_pcb_return_current_marker",
+      simulation_pcb_return_current_marker_id: id2("simulation_pcb_return_current_marker"),
+      simulation_pcb_return_current_result_id: resultId,
+      role,
+      target_type: "pcb_port",
+      pcb_port_id: portId,
+      layer,
+      label: role.replaceAll("_", " ")
+    }));
+  };
+  for (const excitation of excitations) {
+    const trace = circuitJson.find((e) => e.type === "pcb_trace" && e.pcb_trace_id === excitation.pcb_trace_id);
+    for (const [role, terminal, endpoint] of [
+      ["signal_source", excitation.source_port, trace.route[0]],
+      ["signal_load", excitation.load_port, trace.route.at(-1)]
+    ])
+      if (terminal && endpoint?.route_type === "wire")
+        portMarker(role, terminal.signal_pcb_port_id, endpoint.layer);
+    for (const [role, contact] of [
+      ["return_source", excitation.return_source],
+      ["return_sink", excitation.return_sink]
+    ])
+      if (contact.contact_type === "pcb_port")
+        portMarker(role, contact.pcb_port_id, contact.layer);
+    for (const point2 of trace.route) {
+      if (point2.route_type !== "via")
+        continue;
+      const via = circuitJson.find((e) => e.type === "pcb_via" && Math.hypot(e.x - point2.x, e.y - point2.y) < 0.000001 && e.pcb_trace_id === trace.pcb_trace_id && e.layers.includes(point2.from_layer) && e.layers.includes(point2.to_layer));
+      if (!via || via.type !== "pcb_via")
+        continue;
+      markers.push(simulation_pcb_return_current_marker.parse({
+        type: "simulation_pcb_return_current_marker",
+        simulation_pcb_return_current_marker_id: id2("simulation_pcb_return_current_marker"),
+        simulation_pcb_return_current_result_id: resultId,
+        role: "signal_transition",
+        target_type: "pcb_via",
+        pcb_via_id: via.pcb_via_id,
+        from_layer: point2.from_layer,
+        to_layer: point2.to_layer,
+        label: `signal via: ${point2.from_layer} ↔ ${point2.to_layer}`
+      }));
+    }
+  }
+  return markers;
+}
+function exportReturnCurrentCircuitJson(options) {
+  const selected = selectReturnCurrentExperiment2(options);
+  const backendExcitations = "reference" in options.simulation ? options.simulation.model.geometry.excitations : options.simulation.geometry.excitations;
+  if (backendExcitations.length !== selected.excitations.length || backendExcitations.some((e, i) => JSON.stringify(simulation_return_current_excitation22.parse(e)) !== JSON.stringify(selected.excitations[i])))
+    throw new Error("Result is stale: selected excitation current, contacts, or terminal metadata changed");
+  const resultId = options.resultId ?? id2("simulation_pcb_return_current_result");
+  const frequencyHz = "reference" in options.simulation ? options.simulation.reference.frequencyHz : undefined;
+  const oldIds = new Set(options.circuitJson.flatMap((e) => e.type === "simulation_pcb_return_current_result" && e.simulation_experiment_id === options.experimentId && e.frequency_hz === frequencyHz ? [e.simulation_pcb_return_current_result_id] : []));
+  if (options.circuitJson.some((e) => e.type === "simulation_pcb_return_current_result" && e.simulation_pcb_return_current_result_id === resultId && !oldIds.has(resultId)))
+    throw new Error(`Result ID ${resultId} belongs to another experiment/frequency`);
+  const circuitJson = options.circuitJson.filter((e) => e.type === "simulation_pcb_return_current_result" ? !oldIds.has(e.simulation_pcb_return_current_result_id) : ("simulation_pcb_return_current_result_id" in e) ? !oldIds.has(String(e.simulation_pcb_return_current_result_id)) : true);
+  const board = circuitJson.find((e) => e.type === "pcb_board");
+  if (board.type !== "pcb_board")
+    throw new Error("Missing PCB board");
+  const fieldId = id2("simulation_pcb_return_current_field");
+  let grid;
+  let metadata;
+  if ("reference" in options.simulation) {
+    const { model, reference } = options.simulation;
+    validatePalaceReference2(reference);
+    if (reference.columns * reference.rows > 1e6)
+      throw new Error("The result grid exceeds 1,000,000 cells");
+    if (reference.frequencyHz !== model.frequencyHz)
+      throw new Error("Palace model/reference frequencies differ");
+    if (reference.copperModel !== model.copperModel)
+      throw new Error("Palace model/reference copper models differ");
+    if (reference.copperThickness !== model.copperThickness)
+      throw new Error("Palace model/reference copper thicknesses differ");
+    if (model.geometry.excitations.map((e) => e.simulation_return_current_excitation_id).join() !== selected.excitations.map((e) => e.simulation_return_current_excitation_id).join())
+      throw new Error("Palace model does not contain exactly the selected experiment excitations");
+    if (reference.provenance.geometrySignature !== palaceGeometrySignature2(model.geometry))
+      throw new Error("Palace reference provenance does not match its model geometry");
+    const expected = createPalaceModel2({
+      circuitJson: selected.solverCircuitJson,
+      excitations: selected.excitations,
+      frequencyHz: model.frequencyHz,
+      stackup: fabricationStackup(model),
+      sampleLayer: reference.sampleLayer ?? "bottom",
+      viaClearance: model.multilayer?.viaClearance,
+      ...model.multilayer ? {} : {
+        layerSeparation: model.layerSeparation,
+        copperThickness: model.copperThickness
+      },
+      copperConductivity: model.copperConductivity,
+      substratePermittivity: model.substratePermittivity,
+      substrateLossTangent: model.substrateLossTangent,
+      portResistance: model.portResistance,
+      portWidth: model.portWidth,
+      meshSize: model.meshSize,
+      copperModel: model.copperModel,
+      airPadding: model.airPadding,
+      order: model.order
+    });
+    if (palaceGeometrySignature2(expected.geometry) !== palaceGeometrySignature2(model.geometry))
+      throw new Error("Palace result is stale: input geometry, current, contacts, or termination changed");
+    const minX = Math.min(...model.geometry.boardOutline.map((p) => p.x));
+    const minY = Math.min(...model.geometry.boardOutline.map((p) => p.y));
+    metadata = {
+      layer: reference.sampleLayer ?? "bottom",
+      source_net_id: selected.excitations[0].ground_source_net_id,
+      field_type: "complex_phasor",
+      min_x: minX,
+      min_y: minY,
+      columns: reference.columns,
+      rows: reference.rows,
+      cell_width: reference.cellWidth,
+      cell_height: reference.cellHeight,
+      copper_thickness: reference.copperThickness
+    };
+    const blank = () => Array(reference.columns * reference.rows).fill(null);
+    grid = {
+      field_type: "complex_phasor",
+      sheet_current_x_real: blank(),
+      sheet_current_x_imag: blank(),
+      sheet_current_y_real: blank(),
+      sheet_current_y_imag: blank()
+    };
+    const seen = new Set;
+    const containsCopper = createSampleMask2(model.geometry);
+    for (const sample of reference.samples) {
+      const column = Math.round((sample.x - minX) / reference.cellWidth - 0.5);
+      const row = Math.round((sample.y - minY) / reference.cellHeight - 0.5);
+      if (column < 0 || column >= reference.columns || row < 0 || row >= reference.rows || Math.abs(sample.x - (minX + (column + 0.5) * reference.cellWidth)) > 0.000001 || Math.abs(sample.y - (minY + (row + 0.5) * reference.cellHeight)) > 0.000001)
+        throw new Error("Palace sample is not aligned with its declared grid");
+      const index = row * reference.columns + column;
+      if (!containsCopper(sample))
+        throw new Error("Palace sample lies outside the reference conductor mask");
+      if (seen.has(index))
+        throw new Error("Duplicate Palace grid cell");
+      seen.add(index);
+      grid.sheet_current_x_real[index] = sample.sheetCurrentXReal;
+      grid.sheet_current_x_imag[index] = sample.sheetCurrentXImag;
+      grid.sheet_current_y_real[index] = sample.sheetCurrentYReal;
+      grid.sheet_current_y_imag[index] = sample.sheetCurrentYImag;
+    }
+    for (let row = 0;row < reference.rows; row++)
+      for (let column = 0;column < reference.columns; column++)
+        if (containsCopper({
+          x: minX + (column + 0.5) * reference.cellWidth,
+          y: minY + (row + 0.5) * reference.cellHeight
+        }) !== seen.has(row * reference.columns + column))
+          throw new Error("Palace samples do not cover exactly the declared conductor mask");
+  } else {
+    const result2 = options.simulation;
+    if (!result2.diagnostics.converged)
+      throw new Error("Cannot export an unconverged approximation");
+    if (result2.columns * result2.rows > 1e6)
+      throw new Error("The result grid exceeds 1,000,000 cells");
+    if (result2.geometry.excitations.map((e) => e.simulation_return_current_excitation_id).join() !== selected.excitations.map((e) => e.simulation_return_current_excitation_id).join())
+      throw new Error("Approximation does not contain exactly the selected experiment excitations");
+    const expected = readGeometry2({
+      circuitJson: selected.solverCircuitJson,
+      excitations: selected.excitations
+    });
+    if (palaceGeometrySignature2(expected) !== palaceGeometrySignature2(result2.geometry))
+      throw new Error("Approximation result is stale: input geometry, current, contacts, or termination changed");
+    metadata = {
+      layer: "bottom",
+      source_net_id: selected.excitations[0].ground_source_net_id,
+      field_type: "real",
+      min_x: result2.bounds.minX,
+      min_y: result2.bounds.minY,
+      columns: result2.columns,
+      rows: result2.rows,
+      cell_width: result2.cellWidth,
+      cell_height: result2.cellHeight,
+      copper_thickness: result2.copperThickness
+    };
+    grid = {
+      field_type: "real",
+      sheet_current_x: Array(result2.columns * result2.rows).fill(null),
+      sheet_current_y: Array(result2.columns * result2.rows).fill(null)
+    };
+    const seen = new Set;
+    for (const node of result2.nodes) {
+      const index = node.row * result2.columns + node.column;
+      if (!Number.isInteger(node.column) || !Number.isInteger(node.row) || node.column < 0 || node.column >= result2.columns || node.row < 0 || node.row >= result2.rows || seen.has(index))
+        throw new Error("Invalid approximation grid node");
+      seen.add(index);
+      grid.sheet_current_x[index] = node.sheetCurrentX;
+      grid.sheet_current_y[index] = node.sheetCurrentY;
+    }
+  }
+  getSimulationReturnCurrentGridJsonSchema(metadata).parse(grid);
+  const format = options.fieldFormat ?? "gzip";
+  if (format !== "gzip" && format !== "json")
+    throw new Error("fieldFormat must be gzip or json");
+  const mime = format === "gzip" ? "application/gzip" : "application/json";
+  const bytes = Buffer.from(JSON.stringify(grid));
+  const assetBytes = format === "gzip" ? gzipSync2(bytes) : bytes;
+  const field = simulation_pcb_return_current_field.parse({
+    ...metadata,
+    type: "simulation_pcb_return_current_field",
+    simulation_pcb_return_current_field_id: fieldId,
+    simulation_pcb_return_current_result_id: resultId,
+    data_format: "simulation_return_current_grid_json_v1",
+    field_asset: {
+      project_relative_path: `simulation/${fieldId}.json${format === "gzip" ? ".gz" : ""}`,
+      mimetype: mime,
+      url: `data:${mime};base64,${assetBytes.toString("base64")}`
+    }
+  });
+  const maxX = metadata.min_x + metadata.columns * metadata.cell_width;
+  const maxY = metadata.min_y + metadata.rows * metadata.cell_height;
+  const magnitudes = Array.from({ length: metadata.columns * metadata.rows }, (_, index) => {
+    if (grid.field_type === "real")
+      return grid.sheet_current_x[index] === null ? null : Math.hypot(grid.sheet_current_x[index], grid.sheet_current_y[index]) / metadata.copper_thickness;
+    return grid.sheet_current_x_real[index] === null ? null : Math.hypot(grid.sheet_current_x_real[index], grid.sheet_current_x_imag[index], grid.sheet_current_y_real[index], grid.sheet_current_y_imag[index]) / metadata.copper_thickness;
+  });
+  const maximum = magnitudes.reduce((max, value) => Math.max(max, value ?? 0), 0);
+  const rectangles = magnitudes.flatMap((magnitude, index) => magnitude === null ? [] : [
+    `<rect x="${index % metadata.columns}" y="${metadata.rows - 1 - Math.floor(index / metadata.columns)}" width="1" height="1" fill="${currentColor2(maximum > 0 ? magnitude / maximum : 0)}"/>`
+  ]).join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${metadata.columns}" height="${metadata.rows}" viewBox="0 0 ${metadata.columns} ${metadata.rows}">${rectangles}</svg>`;
+  const png = new Resvg4(svg).render().asPng();
+  const heatmapId = id2("simulation_pcb_return_current_heatmap");
+  const heatmap = simulation_pcb_return_current_heatmap.parse({
+    type: "simulation_pcb_return_current_heatmap",
+    simulation_pcb_return_current_heatmap_id: heatmapId,
+    simulation_pcb_return_current_result_id: resultId,
+    layer: metadata.layer,
+    source_net_id: metadata.source_net_id,
+    min_x: metadata.min_x,
+    min_y: metadata.min_y,
+    max_x: maxX,
+    max_y: maxY,
+    image_asset: {
+      project_relative_path: `simulation/${heatmapId}.png`,
+      mimetype: "image/png",
+      url: `data:image/png;base64,${Buffer.from(png).toString("base64")}`
+    }
+  });
+  const result = simulation_pcb_return_current_result.parse({
+    type: "simulation_pcb_return_current_result",
+    simulation_pcb_return_current_result_id: resultId,
+    simulation_experiment_id: options.experimentId,
+    pcb_board_id: board.pcb_board_id,
+    simulation_return_current_excitation_ids: selected.excitations.map((e) => e.simulation_return_current_excitation_id),
+    ...frequencyHz === undefined ? {} : { frequency_hz: frequencyHz }
+  });
+  return [
+    ...circuitJson,
+    result,
+    field,
+    heatmap,
+    ...markersFor(selected.solverCircuitJson, selected.excitations, resultId)
+  ];
+}
+var copperLayer3, fabricationStackupSchema3, id2 = (prefix) => `${prefix}_${randomUUID2()}`;
+var init_circuit_json = __esm(() => {
+  copperLayer3 = z229.string().regex(/^(top|bottom|inner[1-8])$/);
+  fabricationStackupSchema3 = z229.object({
+    nominalBoardThicknessMm: z229.number().finite().positive().optional(),
+    layers: z229.array(z229.union([
+      z229.object({
+        name: copperLayer3,
+        copperThicknessMm: z229.number().finite().positive()
+      }),
+      z229.object({
+        material: z229.string().min(1),
+        dielectricThicknessMm: z229.number().finite().positive(),
+        dielectricConstant: z229.number().finite().positive(),
+        lossTangent: z229.number().finite().nonnegative().optional()
+      })
+    ]))
+  });
+});
+
 // node_modules/commander/index.js
 var exports_commander = {};
 __exportCjs(exports_commander, {
@@ -172386,7 +176025,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",
@@ -172402,7 +176041,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",
@@ -172418,7 +176057,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",
@@ -172450,6 +176089,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",
@@ -172459,7 +176099,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: {
@@ -172476,10 +176118,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",
@@ -344390,8 +348033,230 @@ function getTraceName(circuitJson, trace) {
   return sourceTrace?.type === "source_trace" && sourceTrace.display_name || from || to || "trace";
 }
 
+// node_modules/calculate-elbow/lib/calculateElbowBends.ts
+var calculateElbowBends2 = (p1, p2, overshootAmount) => {
+  const result = [{ x: p1.x, y: p1.y }];
+  const midX = (p1.x + p2.x) / 2;
+  const midY = (p1.y + p2.y) / 2;
+  const p2Target = { x: p2.x, y: p2.y };
+  switch (p2.facingDirection) {
+    case "x+":
+      p2Target.x += overshootAmount;
+      break;
+    case "x-":
+      p2Target.x -= overshootAmount;
+      break;
+    case "y+":
+      p2Target.y += overshootAmount;
+      break;
+    case "y-":
+      p2Target.y -= overshootAmount;
+      break;
+  }
+  const startDir = p1.facingDirection ?? "none";
+  const endDir = p2.facingDirection ?? "none";
+  const push = (pt) => {
+    const last = result[result.length - 1];
+    if (last.x !== pt.x || last.y !== pt.y)
+      result.push(pt);
+  };
+  const yAligned = Math.abs(p1.y - p2.y) <= Math.max(0.000001, overshootAmount * 0.1);
+  const xAligned = Math.abs(p1.x - p2.x) <= Math.max(0.000001, overshootAmount * 0.1);
+  if (startDir === "none" && endDir === "none") {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 1;
+    push({ x: midX, y: p1.y });
+    push({ x: midX, y: p2.y });
+  } else if (startDir === "x+" && endDir === "y+") {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2;
+    if (p1.x > p2.x && p1.y < p2.y) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.1;
+      push({ x: p1.x + overshootAmount, y: p1.y });
+      push({ x: p1.x + overshootAmount, y: p2.y + overshootAmount });
+      push({ x: p2.x, y: p2.y + overshootAmount });
+    } else if (!xAligned && !yAligned && p1.x < p2.x && p1.y > p2.y) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.2;
+      push({ x: p2.x, y: p1.y });
+    } else if (xAligned) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.3;
+      push({ x: p1.x + overshootAmount, y: p1.y });
+      push({ x: p1.x + overshootAmount, y: p2.y + overshootAmount });
+      push({ x: p2.x, y: p2.y + overshootAmount });
+    } else {
+      if (p1.x < p2.x) {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.4;
+        push({ x: midX, y: p1.y });
+        push({ x: midX, y: p2Target.y });
+        push({ x: p2.x, y: p2Target.y });
+      } else if (p1.y <= p2.y + overshootAmount) {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.5;
+        push({ x: p1.x + overshootAmount, y: p1.y });
+        push({ x: p1.x + overshootAmount, y: p1.y + overshootAmount });
+        push({ x: p2.x, y: p1.y + overshootAmount });
+        push({ x: p2.x, y: p2.y });
+      } else {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 2.6;
+        push({ x: p1.x + overshootAmount, y: p1.y });
+        push({ x: p1.x + overshootAmount, y: (p1.y + p2.y) / 2 });
+        push({ x: p2.x, y: (p1.y + p2.y) / 2 });
+      }
+    }
+  } else if (startDir === "x+" && endDir === "x+" && !yAligned) {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 3;
+    const commonX = Math.max(p1.x + overshootAmount, p2Target.x);
+    push({ x: commonX, y: p1.y });
+    push({ x: commonX, y: p2.y });
+  } else if (startDir === "x+" && endDir === "x+" && yAligned) {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 3.1;
+    push({ x: p1.x + overshootAmount, y: p1.y });
+    push({ x: p1.x + overshootAmount, y: p1.y + overshootAmount });
+    push({ x: p2.x + overshootAmount, y: p1.y + overshootAmount });
+    push({ x: p2.x + overshootAmount, y: p2.y });
+  } else if (startDir === "x+" && endDir === "y-") {
+    if (xAligned && p1.y <= p2.y) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.11;
+      push({ x: p1.x + overshootAmount, y: p1.y });
+      push({ x: p1.x + overshootAmount, y: midY });
+      push({ x: p2.x, y: midY });
+    } else if (xAligned && p1.y > p2.y) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.12;
+      push({ x: p1.x + overshootAmount, y: p1.y });
+      push({ x: p1.x + overshootAmount, y: p2.y - overshootAmount });
+      push({ x: p2.x, y: p2.y - overshootAmount });
+    } else if (p1.x < p2.x && p1.y < p2.y) {
+      globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.2;
+      push({ x: p2.x, y: p1.y });
+    } else {
+      if (p1.x > p2.x && p1.y < p2.y) {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.3;
+        const p1OvershootX = p1.x + overshootAmount;
+        push({ x: p1OvershootX, y: p1.y });
+        push({ x: p1OvershootX, y: midY });
+        push({ x: p2.x, y: midY });
+      } else if (p1.x > p2.x && p1.y > p2.y) {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.4;
+        const p1OvershootX = p1.x + overshootAmount;
+        push({ x: p1OvershootX, y: p1.y });
+        push({ x: p1OvershootX, y: p2Target.y });
+        push({ x: p2.x, y: p2Target.y });
+      } else if (p1.y === p2.y) {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.5;
+        push({ x: p1.x + overshootAmount, y: p1.y });
+        push({ x: p1.x + overshootAmount, y: p1.y - overshootAmount });
+        push({ x: p2.x, y: p1.y - overshootAmount });
+      } else {
+        globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 4.6;
+        push({ x: midX, y: p1.y });
+        push({ x: midX, y: p2Target.y });
+        push({ x: p2.x, y: p2Target.y });
+      }
+    }
+  } else if (startDir === "x+" && endDir === "x-" && p1.x + overshootAmount >= p2.x - overshootAmount && !yAligned) {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 5;
+    const p1OvershootX = p1.x + overshootAmount;
+    push({ x: p1OvershootX, y: p1.y });
+    push({ x: p1OvershootX, y: midY });
+    push({ x: p2Target.x, y: midY });
+    push({ x: p2Target.x, y: p2Target.y });
+  } else if (startDir === "x+" && endDir === "x-" && yAligned && p2.x > p1.x) {} else if (startDir === "x+" && endDir === "x-" && yAligned) {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 7;
+    push({ x: p1.x + overshootAmount, y: p1.y });
+    push({ x: p1.x + overshootAmount, y: p1.y + overshootAmount });
+    push({ x: p2.x - overshootAmount, y: p1.y + overshootAmount });
+    push({ x: p2.x - overshootAmount, y: p1.y });
+  } else {
+    globalThis.__DEBUG_CALCULATE_ELBOW_CASE = 8;
+    if (startDir === "x+") {
+      push({ x: p1.x + overshootAmount, y: p1.y });
+    }
+    push({ x: midX, y: result[result.length - 1].y });
+    push({ x: midX, y: p2Target.y });
+    push({ x: p2Target.x, y: p2Target.y });
+  }
+  push({ x: p2.x, y: p2.y });
+  return result;
+};
+
+// node_modules/calculate-elbow/lib/index.ts
+var calculateElbow2 = (point1, point2, options = {}) => {
+  let p1 = point1;
+  let p2 = point2;
+  let orderFlipped = false;
+  if (p1.x > p2.x || p1.x === p2.x && p1.y > p2.y) {
+    orderFlipped = true;
+    [p1, p2] = [p2, p1];
+  }
+  const mirrorX = p1.facingDirection === "x-";
+  const mirrorY = p1.facingDirection === "y-";
+  const mirrorPoint = (pt) => {
+    const x = mirrorX ? p1.x - (pt.x - p1.x) : pt.x;
+    const y = mirrorY ? p1.y - (pt.y - p1.y) : pt.y;
+    let facing = pt.facingDirection;
+    if (mirrorX) {
+      if (facing === "x+")
+        facing = "x-";
+      else if (facing === "x-")
+        facing = "x+";
+    }
+    if (mirrorY) {
+      if (facing === "y+")
+        facing = "y-";
+      else if (facing === "y-")
+        facing = "y+";
+    }
+    return { x, y, facingDirection: facing };
+  };
+  const rotateCW = (pt, centre) => {
+    const dx = pt.x - centre.x;
+    const dy = pt.y - centre.y;
+    const x = centre.x + dy;
+    const y = centre.y - dx;
+    let facing = pt.facingDirection;
+    switch (facing) {
+      case "x+":
+        facing = "y-";
+        break;
+      case "y-":
+        facing = "x-";
+        break;
+      case "x-":
+        facing = "y+";
+        break;
+      case "y+":
+        facing = "x+";
+        break;
+    }
+    return { x, y, facingDirection: facing };
+  };
+  const rotateCCW = (pt, centre) => {
+    const dx = pt.x - centre.x;
+    const dy = pt.y - centre.y;
+    return { x: centre.x - dy, y: centre.y + dx };
+  };
+  const mp1 = mirrorX || mirrorY ? mirrorPoint(p1) : p1;
+  const mp2 = mirrorX || mirrorY ? mirrorPoint(p2) : p2;
+  let rp1 = mp1;
+  let rp2 = mp2;
+  let rotated = false;
+  if (mp1.facingDirection === "y+") {
+    rotated = true;
+    rp1 = { ...mp1, facingDirection: "x+" };
+    rp2 = rotateCW(mp2, mp1);
+  }
+  const overshootAmount = options?.overshoot ?? 0.1 * Math.max(Math.abs(rp1.x - rp2.x), Math.abs(rp1.y - rp2.y));
+  let result = calculateElbowBends2(rp1, rp2, overshootAmount);
+  if (rotated) {
+    result = result.map((pt) => rotateCCW(pt, rp1));
+  }
+  if (mirrorX || mirrorY) {
+    result = result.map(({ x, y }) => ({
+      x: mirrorX ? p1.x - (x - p1.x) : x,
+      y: mirrorY ? p1.y - (y - p1.y) : y
+    }));
+  }
+  return orderFlipped ? result.reverse() : result;
+};
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
-import { calculateElbow as calculateElbow2 } from "calculate-elbow/lib";
 import { BaseSolver as BaseSolver37 } from "@tscircuit/solver-utils";
 class TraceSimplificationSolver extends BaseSolver37 {
   static EPSILON = 0.01;
@@ -402459,9 +406324,87 @@ var resultToTable = (result) => {
   return formatRows([headers, ...dataRows]);
 };
 
+// cli/simulate/register-return-current.ts
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname7, join as join19, resolve as resolve13 } from "node:path";
+var positiveNumber = (value) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError2("Must be a finite positive number");
+  }
+  return parsed;
+};
+var registerReturnCurrentSimulation = (simulateCommand) => {
+  simulateCommand.command("return-current").description("Run a PCB return-current EM simulation with Palace").argument("<file>", "TSX or circuit JSON containing a return-current experiment").requiredOption("--frequency-hz <hz>", "Simulation frequency in Hz", positiveNumber).addOption(new Option2("--copper-model <model>", "Conductive copper model").choices(["volumetric_copper", "surface_impedance_copper"]).default("volumetric_copper")).option("--output <directory>", "Palace case directory", "return-current").option("--result-json <path>", "Result circuit JSON (default: output/circuit-result.json)").option("--experiment-id <id>", "Select an experiment when the input contains several").option("--sample-layer <layer>", "Reference copper layer to sample", "bottom").option("--cell-size <mm>", "Current sampling pitch in mm", positiveNumber, 0.1).option("--mesh-size <mm>", "FEM mesh target in mm", positiveNumber, 2).option("--air-padding <mm>", "Air domain padding in mm", positiveNumber, 2).option("--order <order>", "FEM order: 1 or 2", (value) => {
+    if (value !== "1" && value !== "2") {
+      throw new InvalidArgumentError2("FEM order must be 1 or 2");
+    }
+    return Number(value);
+  }, 1).option("--processes <count>", "MPI processes", (value) => {
+    const parsed = positiveNumber(value);
+    if (!Number.isInteger(parsed)) {
+      throw new InvalidArgumentError2("MPI processes must be an integer");
+    }
+    return parsed;
+  }, 1).option("--python <path>", "Python with Gmsh/VTK (or PALACE_PYTHON)").action(async (file, options) => {
+    await Promise.resolve().then(() => init_dist6());
+    await Promise.resolve().then(() => init_palace());
+    await Promise.resolve().then(() => init_circuit_json());
+    let input;
+    if (file.endsWith(".json")) {
+      input = JSON.parse(await readFile4(resolve13(file), "utf8"));
+    } else {
+      const projectDir = findCircuitProjectDir(file);
+      const config = await loadRuntimeProjectConfig(projectDir);
+      const generated = await getOrGenerateCircuitJson({
+        filePath: file,
+        projectDir,
+        saveToFile: false,
+        platformConfig: getPlatformConfigWithCliDefaults(config?.platformConfig, {
+          projectDir
+        })
+      });
+      input = generated.circuitJson;
+    }
+    const circuitJson = parseReturnCurrentCircuitJson(input);
+    const selected = selectReturnCurrentExperiment({
+      circuitJson,
+      experimentId: options.experimentId
+    });
+    const run = await runPalaceSimulation({
+      circuitJson: selected.solverCircuitJson,
+      excitations: selected.excitations,
+      frequencyHz: options.frequencyHz,
+      copperModel: options.copperModel,
+      sampleLayer: options.sampleLayer,
+      cellSize: options.cellSize,
+      meshSize: options.meshSize,
+      airPadding: options.airPadding,
+      order: options.order,
+      processes: options.processes,
+      python: options.python,
+      imageSize: 600,
+      outputDirectory: resolve13(options.output)
+    });
+    const result = exportReturnCurrentCircuitJson({
+      circuitJson,
+      experimentId: selected.experiment.simulation_experiment_id,
+      simulation: {
+        model: JSON.parse(await readFile4(join19(run.outputDirectory, "model.json"), "utf8")),
+        reference: JSON.parse(await readFile4(run.referencePath, "utf8"))
+      }
+    });
+    const resultPath = resolve13(options.resultJson ?? join19(run.outputDirectory, "circuit-result.json"));
+    await mkdir4(dirname7(resultPath), { recursive: true });
+    await writeFile5(resultPath, JSON.stringify(result, null, 2));
+    console.log(`Circuit JSON simulation result: ${resultPath}`);
+  });
+};
+
 // cli/simulate/register.ts
 var registerSimulate = (program) => {
   const simulateCommand = program.command("simulate").description("Run a simulation");
+  registerReturnCurrentSimulation(simulateCommand);
   simulateCommand.command("analog").description("Run an analog SPICE simulation").argument("<file>", "Path to tscircuit tsx or circuit json file").option("--disable-parts-engine", "Disable the parts engine").action(async (file, options) => {
     const projectConfig = await loadRuntimeProjectConfig(process.cwd());
     const commandPlatformConfig = options.disablePartsEngine === true ? { partsEngineDisabled: true } : undefined;