circuit-json 0.0.521 → 0.0.522

package/dist/index.mjs

@@ -4633,7 +4633,8 @@ var experiment_type = z203.union([
   z203.literal("spice_dc_sweep"),
   z203.literal("spice_dc_operating_point"),
   z203.literal("spice_transient_analysis"),
-  z203.literal("spice_ac_analysis")
+  z203.literal("spice_ac_analysis"),
+  z203.literal("pcb_return_current")
 ]);
 var spice_simulation_options = z203.object({
   method: z203.enum(["trap", "gear"]).optional(),
@@ -5175,9 +5176,297 @@ var simulation_oscilloscope_trace = z221.object({
 });
 expectTypesMatch(true);
 
-// src/any_circuit_element.ts
+// src/simulation/simulation_return_current_contact.ts
 import { z as z222 } from "zod";
-var any_circuit_element = z222.union([
+var contact_position = z222.object({
+  x: z222.number().finite(),
+  y: z222.number().finite(),
+  layer: layer_ref
+});
+var simulation_return_current_contact = z222.discriminatedUnion("contact_type", [
+  contact_position.extend({
+    contact_type: z222.literal("pcb_port"),
+    pcb_port_id: z222.string().min(1)
+  }),
+  contact_position.extend({
+    contact_type: z222.literal("pcb_via"),
+    pcb_via_id: z222.string().min(1)
+  }),
+  contact_position.extend({
+    contact_type: z222.literal("pcb_copper_pour"),
+    pcb_copper_pour_id: z222.string().min(1)
+  })
+]).describe("Identifies the reference conductor at a return-current contact");
+expectTypesMatch(true);
+
+// src/simulation/simulation_terminal_port.ts
+import { z as z223 } from "zod";
+var simulation_terminal_port = z223.object({
+  signal_pcb_port_id: z223.string().min(1),
+  reference_pcb_port_id: z223.string().min(1).optional(),
+  reference_layer: layer_ref,
+  resistance: z223.number().finite().positive()
+}).describe(
+  "A two-terminal return-current excitation port with resistance in ohms"
+);
+expectTypesMatch(true);
+
+// src/simulation/simulation_return_current_excitation.ts
+import { z as z224 } from "zod";
+var simulation_return_current_excitation = z224.object({
+  type: z224.literal("simulation_return_current_excitation"),
+  simulation_return_current_excitation_id: getZodPrefixedIdWithDefault(
+    "simulation_return_current_excitation"
+  ),
+  simulation_experiment_id: z224.string().min(1),
+  pcb_trace_id: z224.string().min(1),
+  ground_source_net_id: z224.string().min(1),
+  current: z224.number().finite(),
+  return_source: simulation_return_current_contact,
+  return_sink: simulation_return_current_contact,
+  source_port: simulation_terminal_port.optional(),
+  load_port: simulation_terminal_port.optional()
+}).describe(
+  "Excites a signal trace with signed current in amperes, peak for AC; return_source is near the load and return_sink near the driver for positive current"
+);
+expectTypesMatch(true);
+
+// src/simulation/simulation_pcb_return_current_result.ts
+import { z as z225 } from "zod";
+var simulation_pcb_return_current_result = z225.object({
+  type: z225.literal("simulation_pcb_return_current_result"),
+  simulation_pcb_return_current_result_id: getZodPrefixedIdWithDefault(
+    "simulation_pcb_return_current_result"
+  ),
+  simulation_experiment_id: z225.string().min(1),
+  pcb_board_id: z225.string().min(1),
+  simulation_return_current_excitation_ids: z225.array(z225.string().min(1)).min(1).refine(
+    (ids) => new Set(ids).size === ids.length,
+    "Excitation IDs must be unique"
+  ),
+  frequency_hz: z225.number().finite().positive().optional()
+}).describe(
+  "A PCB return-current result at one frequency, or a frequency-independent result when frequency_hz is absent"
+);
+expectTypesMatch(true);
+
+// src/simulation/simulation_return_current_asset.ts
+import { z as z226 } from "zod";
+function createSimulationReturnCurrentAssetSchema(mimetypes) {
+  return asset.extend({
+    project_relative_path: z226.string().min(1),
+    url: z226.string().url()
+  }).superRefine((value, context) => {
+    if (!mimetypes.includes(value.mimetype)) {
+      context.addIssue({
+        code: z226.ZodIssueCode.custom,
+        path: ["mimetype"],
+        message: `Expected one of: ${mimetypes.join(", ")}`
+      });
+    }
+    if (value.url.startsWith("data:")) {
+      const mediaType = /^data:([^;,]*)(?:;[^,]*)?,/i.exec(value.url)?.[1];
+      if (mediaType?.toLowerCase() !== value.mimetype) {
+        context.addIssue({
+          code: z226.ZodIssueCode.custom,
+          path: ["url"],
+          message: "Data URL media type must match asset.mimetype"
+        });
+      }
+    }
+  });
+}
+var simulation_return_current_field_asset = createSimulationReturnCurrentAssetSchema([
+  "application/json",
+  "application/gzip"
+]);
+var simulation_return_current_image_asset = createSimulationReturnCurrentAssetSchema(["image/png", "image/webp"]);
+
+// src/simulation/simulation_pcb_return_current_field.ts
+import { z as z227 } from "zod";
+var simulation_pcb_return_current_field = z227.object({
+  type: z227.literal("simulation_pcb_return_current_field"),
+  simulation_pcb_return_current_field_id: getZodPrefixedIdWithDefault(
+    "simulation_pcb_return_current_field"
+  ),
+  simulation_pcb_return_current_result_id: z227.string().min(1),
+  layer: layer_ref,
+  source_net_id: z227.string().min(1),
+  field_type: z227.enum(["real", "complex_phasor"]),
+  min_x: z227.number().finite(),
+  min_y: z227.number().finite(),
+  columns: z227.number().int().positive().safe(),
+  rows: z227.number().int().positive().safe(),
+  cell_width: z227.number().finite().positive(),
+  cell_height: z227.number().finite().positive(),
+  copper_thickness: z227.number().finite().positive(),
+  data_format: z227.literal("simulation_return_current_grid_json_v1"),
+  field_asset: simulation_return_current_field_asset
+}).superRefine((field, context) => {
+  if (!Number.isSafeInteger(field.columns * field.rows)) {
+    context.addIssue({
+      code: z227.ZodIssueCode.custom,
+      path: ["columns"],
+      message: "The grid cell count must be a safe integer"
+    });
+  }
+}).describe(
+  "A sampled sheet-current field in A/mm, using plain or gzipped JSON Asset URLs; dimensions are PCB millimeters"
+);
+expectTypesMatch(true);
+
+// src/simulation/simulation_return_current_grid_json.ts
+import { z as z228 } from "zod";
+var channel = z228.array(z228.number().finite().nullable()).min(1);
+var simulation_return_current_grid_json = z228.discriminatedUnion("field_type", [
+  z228.object({
+    field_type: z228.literal("real"),
+    sheet_current_x: channel,
+    sheet_current_y: channel
+  }),
+  z228.object({
+    field_type: z228.literal("complex_phasor"),
+    sheet_current_x_real: channel,
+    sheet_current_x_imag: channel,
+    sheet_current_y_real: channel,
+    sheet_current_y_imag: channel
+  })
+]).superRefine((grid, context) => {
+  const channels = grid.field_type === "real" ? [grid.sheet_current_x, grid.sheet_current_y] : [
+    grid.sheet_current_x_real,
+    grid.sheet_current_x_imag,
+    grid.sheet_current_y_real,
+    grid.sheet_current_y_imag
+  ];
+  const first = channels[0];
+  if (channels.some((values) => values.length !== first.length)) {
+    context.addIssue({
+      code: z228.ZodIssueCode.custom,
+      message: "Current channels must have equal lengths"
+    });
+    return;
+  }
+  for (let index = 0; index < first.length; index++) {
+    const masked = first[index] === null;
+    if (channels.some((values) => values[index] === null !== masked)) {
+      context.addIssue({
+        code: z228.ZodIssueCode.custom,
+        message: `Cell ${index} must be null in every channel or finite in every channel`
+      });
+      return;
+    }
+  }
+}).describe(
+  "Decoded real or complex sheet-current arrays with a shared conductor mask"
+);
+expectTypesMatch(true);
+function getSimulationReturnCurrentGridJsonSchema(field) {
+  const count = field.columns * field.rows;
+  if (!Number.isSafeInteger(field.columns) || field.columns <= 0 || !Number.isSafeInteger(field.rows) || field.rows <= 0 || !Number.isSafeInteger(count))
+    throw new Error("Grid dimensions must be positive safe integers");
+  return simulation_return_current_grid_json.superRefine((grid, context) => {
+    if (grid.field_type !== field.field_type) {
+      context.addIssue({
+        code: z228.ZodIssueCode.custom,
+        path: ["field_type"],
+        message: "Decoded field_type must match the parent field"
+      });
+    }
+    const first = grid.field_type === "real" ? grid.sheet_current_x : grid.sheet_current_x_real;
+    if (first.length !== count) {
+      context.addIssue({
+        code: z228.ZodIssueCode.custom,
+        message: `Each current channel must have ${count} entries (columns * rows)`
+      });
+    }
+  });
+}
+
+// src/simulation/simulation_pcb_return_current_heatmap.ts
+import { z as z229 } from "zod";
+var simulation_pcb_return_current_heatmap = z229.object({
+  type: z229.literal("simulation_pcb_return_current_heatmap"),
+  simulation_pcb_return_current_heatmap_id: getZodPrefixedIdWithDefault(
+    "simulation_pcb_return_current_heatmap"
+  ),
+  simulation_pcb_return_current_result_id: z229.string().min(1),
+  layer: layer_ref,
+  source_net_id: z229.string().min(1),
+  min_x: z229.number().finite(),
+  min_y: z229.number().finite(),
+  max_x: z229.number().finite(),
+  max_y: z229.number().finite(),
+  image_asset: simulation_return_current_image_asset
+}).superRefine((heatmap, context) => {
+  for (const axis of ["x", "y"]) {
+    if (heatmap[`max_${axis}`] <= heatmap[`min_${axis}`]) {
+      context.addIssue({
+        code: z229.ZodIssueCode.custom,
+        path: [`max_${axis}`],
+        message: "Heatmap bounds must have positive width and height"
+      });
+    }
+  }
+}).describe(
+  "A transparent PNG/WebP current-density overlay in A/mm\xB2; the top-left pixel maps to (min_x, max_y)"
+);
+expectTypesMatch(true);
+
+// src/simulation/simulation_pcb_return_current_marker.ts
+import { z as z230 } from "zod";
+var marker_base = z230.object({
+  type: z230.literal("simulation_pcb_return_current_marker"),
+  simulation_pcb_return_current_marker_id: getZodPrefixedIdWithDefault(
+    "simulation_pcb_return_current_marker"
+  ),
+  simulation_pcb_return_current_result_id: z230.string().min(1),
+  role: z230.enum([
+    "signal_source",
+    "signal_load",
+    "return_source",
+    "return_sink",
+    "signal_transition",
+    "return_transition"
+  ]),
+  label: z230.string().optional(),
+  label_x: z230.number().finite().optional(),
+  label_y: z230.number().finite().optional()
+});
+var simulation_pcb_return_current_marker = z230.discriminatedUnion("target_type", [
+  marker_base.extend({
+    target_type: z230.literal("pcb_port"),
+    pcb_port_id: z230.string().min(1),
+    layer: layer_ref
+  }),
+  marker_base.extend({
+    target_type: z230.literal("pcb_via"),
+    pcb_via_id: z230.string().min(1),
+    from_layer: layer_ref,
+    to_layer: layer_ref
+  })
+]).superRefine((marker, context) => {
+  if (marker.label_x === void 0 !== (marker.label_y === void 0)) {
+    context.addIssue({
+      code: z230.ZodIssueCode.custom,
+      path: ["label_x"],
+      message: "label_x and label_y must be provided together"
+    });
+  }
+  if (marker.target_type === "pcb_via" && marker.from_layer === marker.to_layer) {
+    context.addIssue({
+      code: z230.ZodIssueCode.custom,
+      path: ["to_layer"],
+      message: "A via transition must connect distinct layers"
+    });
+  }
+}).describe(
+  "A signal/return port or via highlight; markers do not assert measured via-transfer currents"
+);
+expectTypesMatch(true);
+
+// src/any_circuit_element.ts
+import { z as z231 } from "zod";
+var any_circuit_element = z231.union([
   source_runtime_error,
   source_trace,
   source_bus,
@@ -5340,6 +5629,11 @@ var any_circuit_element = z222.union([
   simulation_voltage_source,
   simulation_current_source,
   simulation_experiment,
+  simulation_return_current_excitation,
+  simulation_pcb_return_current_result,
+  simulation_pcb_return_current_field,
+  simulation_pcb_return_current_heatmap,
+  simulation_pcb_return_current_marker,
   simulation_transient_voltage_graph,
   simulation_transient_current_graph,
   simulation_dc_operating_point_voltage,
@@ -5385,6 +5679,7 @@ export {
   external_footprint_load_error,
   frequency,
   getRotationBetweenPcbPin1Locations,
+  getSimulationReturnCurrentGridJsonSchema,
   getZodPrefixedIdWithDefault,
   inductance,
   insertionDirectionToCanonical,
@@ -5591,8 +5886,18 @@ export {
   simulation_parameter_sweep_coordinate,
   simulation_parameter_type,
   simulation_parameter_unit,
+  simulation_pcb_return_current_field,
+  simulation_pcb_return_current_heatmap,
+  simulation_pcb_return_current_marker,
+  simulation_pcb_return_current_result,
+  simulation_return_current_contact,
+  simulation_return_current_excitation,
+  simulation_return_current_field_asset,
+  simulation_return_current_grid_json,
+  simulation_return_current_image_asset,
   simulation_spice_subcircuit,
   simulation_switch,
+  simulation_terminal_port,
   simulation_transient_current_graph,
   simulation_transient_voltage_graph,
   simulation_unknown_experiment_error,