circuit-json 0.0.528 → 0.0.529

package/dist/index.mjs

@@ -14,7 +14,20 @@ var length = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v)
 var frequency = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v, "Hz").value);
 var distance = length;
 var current = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v, "A").value);
-var duration_ms = z.string().or(z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var duration_ms = z.string().or(z.number()).transform((v, context) => {
+  try {
+    const { value, unitOfValue } = parseAndConvertSiUnit(v);
+    if ((unitOfValue === null || unitOfValue === "ms") && Number.isFinite(value)) {
+      return value;
+    }
+  } catch {
+  }
+  context.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: "Expected a finite number of milliseconds or a time unit"
+  });
+  return z.NEVER;
+});
 var time = duration_ms;
 var ms = duration_ms;
 var timestamp = z.string().datetime();
@@ -4761,6 +4774,8 @@ var simulation_experiment = z206.object({
   ),
   name: z206.string(),
   experiment_type,
+  subcircuit_id: z206.string().optional(),
+  spice_engine: z206.string().optional(),
   time_per_step: duration_ms.optional(),
   start_time_ms: ms.optional(),
   end_time_ms: ms.optional(),
@@ -4863,6 +4878,7 @@ var simulation_transient_voltage_graph = z208.object({
     "simulation_transient_voltage_graph"
   ),
   simulation_experiment_id: z208.string(),
+  simulation_voltage_probe_id: z208.string().optional(),
   simulation_parameter_sweep_coordinate: simulation_parameter_sweep_coordinate.optional(),
   timestamps_ms: z208.array(z208.number()).optional(),
   voltage_levels: z208.array(z208.number()),
@@ -5288,52 +5304,195 @@ var simulation_oscilloscope_trace = z224.object({
 });
 expectTypesMatch(true);
 
-// src/simulation/simulation_return_current_contact.ts
+// src/simulation/simulation_ibis_model.ts
 import { z as z225 } from "zod";
-var contact_position = z225.object({
-  x: z225.number().finite(),
-  y: z225.number().finite(),
+var ibisAssetPath = z225.string().min(1).regex(/^(?!\s|[a-z][a-z\d+.-]*:|[/\\])[^\\\u0000-\u001f\u007f]+$/i);
+var simulation_ibis_model = z225.object({
+  type: z225.literal("simulation_ibis_model"),
+  simulation_ibis_model_id: getZodPrefixedIdWithDefault(
+    "simulation_ibis_model"
+  ),
+  source_component_id: z225.string().min(1),
+  // Consumers must still apply their own fetch policy to prevent SSRF.
+  ibis_model_asset: asset.extend({
+    project_relative_path: ibisAssetPath,
+    url: z225.string().url().regex(/^https?:\/\//i).or(ibisAssetPath)
+  }).describe(
+    "Reference to the .ibs file containing the vendor's IBIS models"
+  ),
+  ibis_component_name: z225.string().min(1).describe("Name of the [Component] section in the IBIS file"),
+  ibis_pin_name_to_source_port_id: z225.record(z225.string().min(1), z225.string().min(1)).refine(
+    (pins) => Object.keys(pins).length > 0,
+    "At least one physical IBIS pin is required"
+  ).describe(
+    "Maps pin names from the IBIS [Pin] table, such as A1 or 12, to physical source_port_id values"
+  ),
+  ibis_pin_name_to_model_name: z225.record(z225.string().min(1), z225.string().min(1)).optional().describe(
+    "Maps an IBIS pin name to the selected [Model] name when its [Model Selector] has multiple buffers"
+  ),
+  ibis_pin_name_to_reference_source_port_ids: z225.record(
+    z225.string().min(1),
+    z225.object({
+      pullup_reference_source_port_id: z225.string().min(1).optional(),
+      pulldown_reference_source_port_id: z225.string().min(1).optional(),
+      power_clamp_reference_source_port_id: z225.string().min(1).optional(),
+      ground_clamp_reference_source_port_id: z225.string().min(1).optional(),
+      external_reference_source_port_id: z225.string().min(1).optional()
+    }).strict()
+  ).optional().describe(
+    "Maps each IBIS signal pin name to the physical source ports used as its buffer supply/clamp references"
+  ),
+  model_value_corner: z225.union([z225.literal("typical"), z225.literal("minimum"), z225.literal("maximum")]).describe(
+    "Selects the typ, min, or max column of numerical data in the IBIS model"
+  ),
+  include_package_parasitics: z225.boolean().describe(
+    "Whether the runner includes the IBIS vendor's package resistance, inductance, and capacitance"
+  )
+}).superRefine((model, context) => {
+  const boundPins = new Set(
+    Object.keys(model.ibis_pin_name_to_source_port_id)
+  );
+  for (const field of [
+    "ibis_pin_name_to_model_name",
+    "ibis_pin_name_to_reference_source_port_ids"
+  ]) {
+    for (const pin of Object.keys(model[field] ?? {})) {
+      if (!boundPins.has(pin)) {
+        context.addIssue({
+          code: z225.ZodIssueCode.custom,
+          path: [field, pin],
+          message: `IBIS pin "${pin}" must be bound in ibis_pin_name_to_source_port_id`
+        });
+      }
+    }
+  }
+}).describe(
+  "Attaches an IBIS component and its physical pin bindings to a source component"
+);
+
+// src/simulation/simulation_ibis_pin_state.ts
+import { z as z226 } from "zod";
+var simulation_ibis_pin_state = z226.object({
+  type: z226.literal("simulation_ibis_pin_state"),
+  simulation_ibis_pin_state_id: getZodPrefixedIdWithDefault(
+    "simulation_ibis_pin_state"
+  ),
+  simulation_experiment_id: z226.string().min(1),
+  source_port_id: z226.string().min(1),
+  is_output: z226.boolean().describe(
+    "True selects output mode; false selects input mode for this experiment"
+  ),
+  is_output_enabled: z226.boolean().optional()
+}).superRefine((pin, context) => {
+  if (pin.is_output && pin.is_output_enabled === void 0 || !pin.is_output && pin.is_output_enabled !== void 0) {
+    context.addIssue({
+      code: z226.ZodIssueCode.custom,
+      path: ["is_output_enabled"],
+      message: "Only output pins require an explicit is_output_enabled boolean"
+    });
+  }
+}).describe(
+  "Declares an IBIS pin's direction and output-enable state for one experiment"
+);
+
+// src/simulation/simulation_digital_stimulus.ts
+import { z as z227 } from "zod";
+var MAX_PATTERN_BITS = 65536;
+var simulation_digital_stimulus = z227.object({
+  type: z227.literal("simulation_digital_stimulus"),
+  simulation_digital_stimulus_id: getZodPrefixedIdWithDefault(
+    "simulation_digital_stimulus"
+  ),
+  name: z227.string().min(1),
+  simulation_experiment_id: z227.string().min(1),
+  source_port_id: z227.string().min(1),
+  bit_duration_ms: ms.refine((milliseconds) => milliseconds > 0),
+  start_time_ms: ms.refine((milliseconds) => milliseconds >= 0),
+  initial_state: z227.union([z227.literal(0), z227.literal(1)]),
+  inverted: z227.boolean(),
+  transmission_pattern: z227.object({
+    transmission_type: z227.literal("bits"),
+    bits: z227.string().max(MAX_PATTERN_BITS).regex(/^[01]+$/).or(
+      z227.array(z227.union([z227.literal(0), z227.literal(1)])).min(1).max(MAX_PATTERN_BITS)
+    ),
+    repeat: z227.boolean()
+  }).strict()
+}).describe(
+  "Declares a digital transmission pattern and bit duration in milliseconds for a physical source port"
+);
+
+// src/simulation/simulation_eye_diagram.ts
+import { z as z228 } from "zod";
+var simulation_eye_diagram = z228.object({
+  type: z228.literal("simulation_eye_diagram"),
+  simulation_eye_diagram_id: getZodPrefixedIdWithDefault(
+    "simulation_eye_diagram"
+  ),
+  name: z228.string().min(1),
+  simulation_experiment_id: z228.string().min(1),
+  simulation_voltage_probe_id: z228.string().min(1),
+  unit_interval_ms: ms.refine((milliseconds) => milliseconds > 0),
+  time_origin_ms: ms,
+  start_time_ms: ms.refine((milliseconds) => milliseconds >= 0).optional(),
+  end_time_ms: ms.refine((milliseconds) => milliseconds > 0).optional()
+}).superRefine((eye, context) => {
+  if (eye.start_time_ms !== void 0 && eye.end_time_ms !== void 0 && eye.start_time_ms >= eye.end_time_ms) {
+    context.addIssue({
+      code: z228.ZodIssueCode.custom,
+      path: ["end_time_ms"],
+      message: "Eye gate end must follow its start"
+    });
+  }
+}).describe(
+  "Declares probe-bound eye folding, fixed origin and optional measurement gate in milliseconds"
+);
+
+// src/simulation/simulation_return_current_contact.ts
+import { z as z229 } from "zod";
+var contact_position = z229.object({
+  x: z229.number().finite(),
+  y: z229.number().finite(),
   layer: layer_ref
 });
-var simulation_return_current_contact = z225.discriminatedUnion("contact_type", [
+var simulation_return_current_contact = z229.discriminatedUnion("contact_type", [
   contact_position.extend({
-    contact_type: z225.literal("pcb_port"),
-    pcb_port_id: z225.string().min(1)
+    contact_type: z229.literal("pcb_port"),
+    pcb_port_id: z229.string().min(1)
   }),
   contact_position.extend({
-    contact_type: z225.literal("pcb_via"),
-    pcb_via_id: z225.string().min(1)
+    contact_type: z229.literal("pcb_via"),
+    pcb_via_id: z229.string().min(1)
   }),
   contact_position.extend({
-    contact_type: z225.literal("pcb_copper_pour"),
-    pcb_copper_pour_id: z225.string().min(1)
+    contact_type: z229.literal("pcb_copper_pour"),
+    pcb_copper_pour_id: z229.string().min(1)
   })
 ]).describe("Identifies the reference conductor at a return-current contact");
 expectTypesMatch(true);
 
 // src/simulation/simulation_terminal_port.ts
-import { z as z226 } from "zod";
-var simulation_terminal_port = z226.object({
-  signal_pcb_port_id: z226.string().min(1),
-  reference_pcb_port_id: z226.string().min(1).optional(),
+import { z as z230 } from "zod";
+var simulation_terminal_port = z230.object({
+  signal_pcb_port_id: z230.string().min(1),
+  reference_pcb_port_id: z230.string().min(1).optional(),
   reference_layer: layer_ref,
-  resistance: z226.number().finite().positive()
+  resistance: z230.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 z227 } from "zod";
-var simulation_return_current_excitation = z227.object({
-  type: z227.literal("simulation_return_current_excitation"),
+import { z as z231 } from "zod";
+var simulation_return_current_excitation = z231.object({
+  type: z231.literal("simulation_return_current_excitation"),
   simulation_return_current_excitation_id: getZodPrefixedIdWithDefault(
     "simulation_return_current_excitation"
   ),
-  simulation_experiment_id: z227.string().min(1),
-  pcb_trace_id: z227.string().min(1),
-  ground_source_net_id: z227.string().min(1),
-  current: z227.number().finite(),
+  simulation_experiment_id: z231.string().min(1),
+  pcb_trace_id: z231.string().min(1),
+  ground_source_net_id: z231.string().min(1),
+  current: z231.number().finite(),
   return_source: simulation_return_current_contact,
   return_sink: simulation_return_current_contact,
   source_port: simulation_terminal_port.optional(),
@@ -5344,34 +5503,34 @@ var simulation_return_current_excitation = z227.object({
 expectTypesMatch(true);
 
 // src/simulation/simulation_pcb_return_current_result.ts
-import { z as z228 } from "zod";
-var simulation_pcb_return_current_result = z228.object({
-  type: z228.literal("simulation_pcb_return_current_result"),
+import { z as z232 } from "zod";
+var simulation_pcb_return_current_result = z232.object({
+  type: z232.literal("simulation_pcb_return_current_result"),
   simulation_pcb_return_current_result_id: getZodPrefixedIdWithDefault(
     "simulation_pcb_return_current_result"
   ),
-  simulation_experiment_id: z228.string().min(1),
-  pcb_board_id: z228.string().min(1),
-  simulation_return_current_excitation_ids: z228.array(z228.string().min(1)).min(1).refine(
+  simulation_experiment_id: z232.string().min(1),
+  pcb_board_id: z232.string().min(1),
+  simulation_return_current_excitation_ids: z232.array(z232.string().min(1)).min(1).refine(
     (ids) => new Set(ids).size === ids.length,
     "Excitation IDs must be unique"
   ),
-  frequency_hz: z228.number().finite().positive().optional()
+  frequency_hz: z232.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 z229 } from "zod";
+import { z as z233 } from "zod";
 function createSimulationReturnCurrentAssetSchema(mimetypes) {
   return asset.extend({
-    project_relative_path: z229.string().min(1),
-    url: z229.string().url()
+    project_relative_path: z233.string().min(1),
+    url: z233.string().url()
   }).superRefine((value, context) => {
     if (!mimetypes.includes(value.mimetype)) {
       context.addIssue({
-        code: z229.ZodIssueCode.custom,
+        code: z233.ZodIssueCode.custom,
         path: ["mimetype"],
         message: `Expected one of: ${mimetypes.join(", ")}`
       });
@@ -5380,7 +5539,7 @@ function createSimulationReturnCurrentAssetSchema(mimetypes) {
       const mediaType = /^data:([^;,]*)(?:;[^,]*)?,/i.exec(value.url)?.[1];
       if (mediaType?.toLowerCase() !== value.mimetype) {
         context.addIssue({
-          code: z229.ZodIssueCode.custom,
+          code: z233.ZodIssueCode.custom,
           path: ["url"],
           message: "Data URL media type must match asset.mimetype"
         });
@@ -5395,29 +5554,29 @@ var simulation_return_current_field_asset = createSimulationReturnCurrentAssetSc
 var simulation_return_current_image_asset = createSimulationReturnCurrentAssetSchema(["image/png", "image/webp"]);
 
 // src/simulation/simulation_pcb_return_current_field.ts
-import { z as z230 } from "zod";
-var simulation_pcb_return_current_field = z230.object({
-  type: z230.literal("simulation_pcb_return_current_field"),
+import { z as z234 } from "zod";
+var simulation_pcb_return_current_field = z234.object({
+  type: z234.literal("simulation_pcb_return_current_field"),
   simulation_pcb_return_current_field_id: getZodPrefixedIdWithDefault(
     "simulation_pcb_return_current_field"
   ),
-  simulation_pcb_return_current_result_id: z230.string().min(1),
+  simulation_pcb_return_current_result_id: z234.string().min(1),
   layer: layer_ref,
-  source_net_id: z230.string().min(1),
-  field_type: z230.enum(["real", "complex_phasor"]),
-  min_x: z230.number().finite(),
-  min_y: z230.number().finite(),
-  columns: z230.number().int().positive().safe(),
-  rows: z230.number().int().positive().safe(),
-  cell_width: z230.number().finite().positive(),
-  cell_height: z230.number().finite().positive(),
-  copper_thickness: z230.number().finite().positive(),
-  data_format: z230.literal("simulation_return_current_grid_json_v1"),
+  source_net_id: z234.string().min(1),
+  field_type: z234.enum(["real", "complex_phasor"]),
+  min_x: z234.number().finite(),
+  min_y: z234.number().finite(),
+  columns: z234.number().int().positive().safe(),
+  rows: z234.number().int().positive().safe(),
+  cell_width: z234.number().finite().positive(),
+  cell_height: z234.number().finite().positive(),
+  copper_thickness: z234.number().finite().positive(),
+  data_format: z234.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: z230.ZodIssueCode.custom,
+      code: z234.ZodIssueCode.custom,
       path: ["columns"],
       message: "The grid cell count must be a safe integer"
     });
@@ -5428,16 +5587,16 @@ var simulation_pcb_return_current_field = z230.object({
 expectTypesMatch(true);
 
 // src/simulation/simulation_return_current_grid_json.ts
-import { z as z231 } from "zod";
-var channel = z231.array(z231.number().finite().nullable()).min(1);
-var simulation_return_current_grid_json = z231.discriminatedUnion("field_type", [
-  z231.object({
-    field_type: z231.literal("real"),
+import { z as z235 } from "zod";
+var channel = z235.array(z235.number().finite().nullable()).min(1);
+var simulation_return_current_grid_json = z235.discriminatedUnion("field_type", [
+  z235.object({
+    field_type: z235.literal("real"),
     sheet_current_x: channel,
     sheet_current_y: channel
   }),
-  z231.object({
-    field_type: z231.literal("complex_phasor"),
+  z235.object({
+    field_type: z235.literal("complex_phasor"),
     sheet_current_x_real: channel,
     sheet_current_x_imag: channel,
     sheet_current_y_real: channel,
@@ -5453,7 +5612,7 @@ var simulation_return_current_grid_json = z231.discriminatedUnion("field_type",
   const first = channels[0];
   if (channels.some((values) => values.length !== first.length)) {
     context.addIssue({
-      code: z231.ZodIssueCode.custom,
+      code: z235.ZodIssueCode.custom,
       message: "Current channels must have equal lengths"
     });
     return;
@@ -5462,7 +5621,7 @@ var simulation_return_current_grid_json = z231.discriminatedUnion("field_type",
     const masked = first[index] === null;
     if (channels.some((values) => values[index] === null !== masked)) {
       context.addIssue({
-        code: z231.ZodIssueCode.custom,
+        code: z235.ZodIssueCode.custom,
         message: `Cell ${index} must be null in every channel or finite in every channel`
       });
       return;
@@ -5479,7 +5638,7 @@ function getSimulationReturnCurrentGridJsonSchema(field) {
   return simulation_return_current_grid_json.superRefine((grid, context) => {
     if (grid.field_type !== field.field_type) {
       context.addIssue({
-        code: z231.ZodIssueCode.custom,
+        code: z235.ZodIssueCode.custom,
         path: ["field_type"],
         message: "Decoded field_type must match the parent field"
       });
@@ -5487,7 +5646,7 @@ function getSimulationReturnCurrentGridJsonSchema(field) {
     const first = grid.field_type === "real" ? grid.sheet_current_x : grid.sheet_current_x_real;
     if (first.length !== count) {
       context.addIssue({
-        code: z231.ZodIssueCode.custom,
+        code: z235.ZodIssueCode.custom,
         message: `Each current channel must have ${count} entries (columns * rows)`
       });
     }
@@ -5495,25 +5654,25 @@ function getSimulationReturnCurrentGridJsonSchema(field) {
 }
 
 // src/simulation/simulation_pcb_return_current_heatmap.ts
-import { z as z232 } from "zod";
-var simulation_pcb_return_current_heatmap = z232.object({
-  type: z232.literal("simulation_pcb_return_current_heatmap"),
+import { z as z236 } from "zod";
+var simulation_pcb_return_current_heatmap = z236.object({
+  type: z236.literal("simulation_pcb_return_current_heatmap"),
   simulation_pcb_return_current_heatmap_id: getZodPrefixedIdWithDefault(
     "simulation_pcb_return_current_heatmap"
   ),
-  simulation_pcb_return_current_result_id: z232.string().min(1),
+  simulation_pcb_return_current_result_id: z236.string().min(1),
   layer: layer_ref,
-  source_net_id: z232.string().min(1),
-  min_x: z232.number().finite(),
-  min_y: z232.number().finite(),
-  max_x: z232.number().finite(),
-  max_y: z232.number().finite(),
+  source_net_id: z236.string().min(1),
+  min_x: z236.number().finite(),
+  min_y: z236.number().finite(),
+  max_x: z236.number().finite(),
+  max_y: z236.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: z232.ZodIssueCode.custom,
+        code: z236.ZodIssueCode.custom,
         path: [`max_${axis}`],
         message: "Heatmap bounds must have positive width and height"
       });
@@ -5525,14 +5684,14 @@ var simulation_pcb_return_current_heatmap = z232.object({
 expectTypesMatch(true);
 
 // src/simulation/simulation_pcb_return_current_marker.ts
-import { z as z233 } from "zod";
-var marker_base = z233.object({
-  type: z233.literal("simulation_pcb_return_current_marker"),
+import { z as z237 } from "zod";
+var marker_base = z237.object({
+  type: z237.literal("simulation_pcb_return_current_marker"),
   simulation_pcb_return_current_marker_id: getZodPrefixedIdWithDefault(
     "simulation_pcb_return_current_marker"
   ),
-  simulation_pcb_return_current_result_id: z233.string().min(1),
-  role: z233.enum([
+  simulation_pcb_return_current_result_id: z237.string().min(1),
+  role: z237.enum([
     "signal_source",
     "signal_load",
     "return_source",
@@ -5540,33 +5699,33 @@ var marker_base = z233.object({
     "signal_transition",
     "return_transition"
   ]),
-  label: z233.string().optional(),
-  label_x: z233.number().finite().optional(),
-  label_y: z233.number().finite().optional()
+  label: z237.string().optional(),
+  label_x: z237.number().finite().optional(),
+  label_y: z237.number().finite().optional()
 });
-var simulation_pcb_return_current_marker = z233.discriminatedUnion("target_type", [
+var simulation_pcb_return_current_marker = z237.discriminatedUnion("target_type", [
   marker_base.extend({
-    target_type: z233.literal("pcb_port"),
-    pcb_port_id: z233.string().min(1),
+    target_type: z237.literal("pcb_port"),
+    pcb_port_id: z237.string().min(1),
     layer: layer_ref
   }),
   marker_base.extend({
-    target_type: z233.literal("pcb_via"),
-    pcb_via_id: z233.string().min(1),
+    target_type: z237.literal("pcb_via"),
+    pcb_via_id: z237.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: z233.ZodIssueCode.custom,
+      code: z237.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: z233.ZodIssueCode.custom,
+      code: z237.ZodIssueCode.custom,
       path: ["to_layer"],
       message: "A via transition must connect distinct layers"
     });
@@ -5577,8 +5736,8 @@ var simulation_pcb_return_current_marker = z233.discriminatedUnion("target_type"
 expectTypesMatch(true);
 
 // src/any_circuit_element.ts
-import { z as z234 } from "zod";
-var any_circuit_element = z234.union([
+import { z as z238 } from "zod";
+var any_circuit_element = z238.union([
   source_runtime_error,
   source_datasheet,
   source_trace,
@@ -5744,6 +5903,10 @@ var any_circuit_element = z234.union([
   simulation_voltage_source,
   simulation_current_source,
   simulation_experiment,
+  simulation_ibis_model,
+  simulation_ibis_pin_state,
+  simulation_digital_stimulus,
+  simulation_eye_diagram,
   simulation_return_current_excitation,
   simulation_pcb_return_current_result,
   simulation_pcb_return_current_field,
@@ -5996,7 +6159,11 @@ export {
   simulation_dc_sweep_unit,
   simulation_dc_sweep_voltage_graph,
   simulation_dc_voltage_source,
+  simulation_digital_stimulus,
   simulation_experiment,
+  simulation_eye_diagram,
+  simulation_ibis_model,
+  simulation_ibis_pin_state,
   simulation_op_amp,
   simulation_oscilloscope_trace,
   simulation_parameter_sweep,