@tscircuit/props 0.0.703 → 0.0.705

package/dist/index.js

@@ -18491,6 +18491,19 @@ var symbolProps = z93.object({
   originalFacingDirection: z93.enum(["up", "down", "left", "right"]).default("right").optional(),
   width: distance.optional(),
   height: distance.optional(),
+  fit: z93.enum(["fill", "contain", "stretch"]).optional(),
+  viewbox: z93.object({
+    minX: distance,
+    maxX: distance,
+    minY: distance,
+    maxY: distance
+  }).refine((bounds) => bounds.maxX > bounds.minX, {
+    message: "viewbox maxX must exceed minX",
+    path: ["maxX"]
+  }).refine((bounds) => bounds.maxY > bounds.minY, {
+    message: "viewbox maxY must exceed minY",
+    path: ["maxY"]
+  }).optional(),
   name: z93.string().optional()
 });
 expectTypesMatch(true);
@@ -18625,9 +18638,7 @@ expectTypesMatch(true);
 // lib/components/analogsimulation.ts
 import { ms } from "circuit-json";
 import { z as z101 } from "zod";
-var spiceEngine = z101.custom(
-  (value) => typeof value === "string"
-);
+var spiceEngine = z101.custom((value) => typeof value === "string");
 var spiceOptions = z101.object({
   method: z101.enum(["trap", "gear"]).optional(),
   reltol: z101.union([z101.number(), z101.string()]).optional(),
@@ -18657,20 +18668,63 @@ expectTypesMatch(
 
 // lib/components/analogtransientsimulation.ts
 import { ms as ms2 } from "circuit-json";
+import { z as z103 } from "zod";
+
+// lib/common/ibis.ts
+import { asset } from "circuit-json";
 import { z as z102 } from "zod";
+var ibisPinRunState = z102.discriminatedUnion("isOutput", [
+  z102.object({ isOutput: z102.literal(false) }).strict(),
+  z102.object({ isOutput: z102.literal(true), isOutputEnabled: z102.boolean() }).strict()
+]);
+var ibisPinReferences = z102.object({
+  pullup: z102.string().min(1).optional(),
+  pulldown: z102.string().min(1).optional(),
+  powerClamp: z102.string().min(1).optional(),
+  groundClamp: z102.string().min(1).optional(),
+  external: z102.string().min(1).optional()
+}).strict();
+var ibisAssetPath = z102.string().min(1).regex(/^(?!\s|[a-z][a-z\d+.-]*:|[/\\])[^\\\u0000-\u001f\u007f]+$/i);
+var ibisModelAsset = asset.extend({
+  project_relative_path: ibisAssetPath,
+  url: z102.string().url().regex(/^https?:\/\//i).or(ibisAssetPath)
+});
+var ibisModelDefinition = z102.object({
+  ibisModelAsset,
+  ibisComponentName: z102.string().min(1),
+  ibisPinNameToPortLabel: z102.record(z102.string().min(1), z102.string().min(1)).refine((pins) => Object.keys(pins).length > 0),
+  ibisPinNameToModelName: z102.record(z102.string().min(1), z102.string().min(1)).optional(),
+  ibisPinNameToReferencePortLabels: z102.record(z102.string().min(1), ibisPinReferences).optional(),
+  modelValueCorner: z102.union([
+    z102.literal("typical"),
+    z102.literal("minimum"),
+    z102.literal("maximum")
+  ]),
+  includePackageParasitics: z102.boolean()
+});
+
+// lib/components/analogtransientsimulation.ts
 var positiveMilliseconds = ms2.refine(
   (milliseconds) => milliseconds > 0,
   "Time must be positive"
 );
-var analogTransientSimulationProps = z102.object({
+var analogTransientSimulationProps = z103.object({
   ...analogAnalysisSimulationBaseProps,
   duration: positiveMilliseconds.default("10ms"),
   startTime: ms2.default("0ms"),
-  timePerStep: positiveMilliseconds.default("0.01ms")
+  timePerStep: positiveMilliseconds.default("0.01ms"),
+  ibisPinStates: z103.record(z103.string().min(1), ibisPinRunState).optional()
 }).superRefine((simulation, context) => {
+  if (simulation.ibisPinStates && simulation.spiceEngine !== "pcb_spice") {
+    context.addIssue({
+      code: z103.ZodIssueCode.custom,
+      path: ["ibisPinStates"],
+      message: "IBIS pin states require spiceEngine=pcb_spice"
+    });
+  }
   if (simulation.startTime < 0 || simulation.startTime > simulation.duration) {
     context.addIssue({
-      code: z102.ZodIssueCode.custom,
+      code: z103.ZodIssueCode.custom,
       path: ["startTime"],
       message: "startTime must be between zero and duration"
     });
@@ -18678,20 +18732,77 @@ var analogTransientSimulationProps = z102.object({
 });
 expectTypesMatch(true);
 
+// lib/components/ibismodel.ts
+import { z as z104 } from "zod";
+var ibisModelProps = ibisModelDefinition.extend({ componentRef: z104.string().min(1) }).strict();
+expectTypesMatch(true);
+
+// lib/components/analogdigitalstimulus.ts
+import { ms as ms3 } from "circuit-json";
+import { z as z105 } from "zod";
+var MAX_TRANSMITTED_BITS = 65536;
+var analogDigitalStimulusProps = z105.object({
+  name: z105.string().min(1),
+  simulationRef: z105.string().min(1),
+  sourcePinRef: z105.string().min(1),
+  bitDuration: ms3.refine(
+    (milliseconds) => Number.isFinite(milliseconds) && milliseconds > 0
+  ),
+  startTime: ms3.refine(
+    (milliseconds) => Number.isFinite(milliseconds) && milliseconds >= 0
+  ),
+  initialState: z105.union([z105.literal(0), z105.literal(1)]),
+  inverted: z105.boolean().default(false),
+  transmittedData: z105.object({
+    transmissionType: z105.literal("bits"),
+    bits: z105.union([
+      z105.string().regex(/^[01]+$/).max(MAX_TRANSMITTED_BITS),
+      z105.array(z105.union([z105.literal(0), z105.literal(1)])).nonempty().max(MAX_TRANSMITTED_BITS)
+    ]),
+    repeat: z105.boolean()
+  }).strict()
+}).strict();
+expectTypesMatch(true);
+
+// lib/components/analogeyediagram.ts
+import { ms as ms4 } from "circuit-json";
+import { z as z106 } from "zod";
+var finiteMilliseconds = ms4.refine(Number.isFinite);
+var analogEyeDiagramProps = z106.object({
+  name: z106.string().min(1),
+  simulationRef: z106.string().min(1),
+  probeRef: z106.string().min(1),
+  unitInterval: finiteMilliseconds.refine((milliseconds) => milliseconds > 0),
+  timeOrigin: finiteMilliseconds,
+  startTime: finiteMilliseconds.refine((milliseconds) => milliseconds >= 0).optional(),
+  endTime: finiteMilliseconds.refine((milliseconds) => milliseconds > 0).optional()
+}).strict().superRefine((eye, context) => {
+  if (eye.startTime !== void 0 && eye.endTime !== void 0 && eye.startTime >= eye.endTime) {
+    context.addIssue({
+      code: z106.ZodIssueCode.custom,
+      path: ["endTime"],
+      message: "Eye gate end must follow its start"
+    });
+  }
+});
+expectTypesMatch(
+  true
+);
+
 // lib/components/analogdcoperatingpointsimulation.ts
-import { z as z103 } from "zod";
-var analogDcOperatingPointSimulationProps = z103.object({
+import { z as z107 } from "zod";
+var analogDcOperatingPointSimulationProps = z107.object({
   ...analogAnalysisSimulationBaseProps
 });
 expectTypesMatch(true);
 
 // lib/components/analogdcsweepsimulation.ts
 import { current, voltage as voltage3 } from "circuit-json";
-import { z as z104 } from "zod";
-var dcSweepQuantity = z104.union([voltage3, current]);
-var analogDcSweepSimulationProps = z104.object({
+import { z as z108 } from "zod";
+var dcSweepQuantity = z108.union([voltage3, current]);
+var analogDcSweepSimulationProps = z108.object({
   ...analogAnalysisSimulationBaseProps,
-  sweepSource: z104.string().min(1),
+  sweepSource: z108.string().min(1),
   sweepStart: dcSweepQuantity,
   sweepStop: dcSweepQuantity,
   sweepStep: dcSweepQuantity.refine(
@@ -18701,7 +18812,7 @@ var analogDcSweepSimulationProps = z104.object({
 }).superRefine((simulation, context) => {
   if (Math.sign(simulation.sweepStop - simulation.sweepStart) !== Math.sign(simulation.sweepStep)) {
     context.addIssue({
-      code: z104.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       path: ["sweepStep"],
       message: "sweepStep must move from sweepStart toward sweepStop"
     });
@@ -18711,10 +18822,10 @@ expectTypesMatch(true);
 
 // lib/components/analogacsweepsimulation.ts
 import { frequency as frequency3 } from "circuit-json";
-import { z as z105 } from "zod";
-var analogAcSweepSimulationProps = z105.object({
+import { z as z109 } from "zod";
+var analogAcSweepSimulationProps = z109.object({
   ...analogAnalysisSimulationBaseProps,
-  sweepType: z105.enum(["linear", "decade", "octave"]),
+  sweepType: z109.enum(["linear", "decade", "octave"]),
   startFrequency: frequency3.refine(
     (startFrequencyHz) => startFrequencyHz > 0,
     "startFrequency must be positive"
@@ -18723,12 +18834,12 @@ var analogAcSweepSimulationProps = z105.object({
     (stopFrequencyHz) => stopFrequencyHz > 0,
     "stopFrequency must be positive"
   ),
-  samplesPerInterval: z105.number().int().positive().optional(),
-  sampleCount: z105.number().int().positive().optional()
+  samplesPerInterval: z109.number().int().positive().optional(),
+  sampleCount: z109.number().int().positive().optional()
 }).superRefine((simulation, context) => {
   if (simulation.stopFrequency <= simulation.startFrequency) {
     context.addIssue({
-      code: z105.ZodIssueCode.custom,
+      code: z109.ZodIssueCode.custom,
       path: ["stopFrequency"],
       message: "stopFrequency must be greater than startFrequency"
     });
@@ -18736,14 +18847,14 @@ var analogAcSweepSimulationProps = z105.object({
   if (simulation.sweepType === "linear") {
     if (simulation.sampleCount === void 0) {
       context.addIssue({
-        code: z105.ZodIssueCode.custom,
+        code: z109.ZodIssueCode.custom,
         path: ["sampleCount"],
         message: "sampleCount is required for a linear AC sweep"
       });
     }
     if (simulation.samplesPerInterval !== void 0) {
       context.addIssue({
-        code: z105.ZodIssueCode.custom,
+        code: z109.ZodIssueCode.custom,
         path: ["samplesPerInterval"],
         message: "samplesPerInterval is only valid for decade or octave sweeps"
       });
@@ -18752,14 +18863,14 @@ var analogAcSweepSimulationProps = z105.object({
   }
   if (simulation.samplesPerInterval === void 0) {
     context.addIssue({
-      code: z105.ZodIssueCode.custom,
+      code: z109.ZodIssueCode.custom,
       path: ["samplesPerInterval"],
       message: "samplesPerInterval is required for decade or octave sweeps"
     });
   }
   if (simulation.sampleCount !== void 0) {
     context.addIssue({
-      code: z105.ZodIssueCode.custom,
+      code: z109.ZodIssueCode.custom,
       path: ["sampleCount"],
       message: "sampleCount is only valid for a linear sweep"
     });
@@ -18769,8 +18880,8 @@ expectTypesMatch(true);
 
 // lib/components/pcb-return-current-excitation.ts
 import { layer_ref as layer_ref9 } from "circuit-json";
-import { z as z106 } from "zod";
-var selector = z106.string().trim().min(1, "Provide a nonempty selector");
+import { z as z110 } from "zod";
+var selector = z110.string().trim().min(1, "Provide a nonempty selector");
 var quantity2 = "[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?";
 var prefixScale = {
   "": 1,
@@ -18797,14 +18908,14 @@ function positiveQuantity(unit, label, example) {
   const pattern = new RegExp(
     `^(${quantity2})\\s*(?:([yzafpnumkMGTPEZY\xB5\u03BC]?)(?:${unit}))?$`
   );
-  return z106.union([
-    z106.number(),
-    z106.string().trim().regex(pattern, `Use ${label} or a unit string, e.g. ${example}`)
+  return z110.union([
+    z110.number(),
+    z110.string().trim().regex(pattern, `Use ${label} or a unit string, e.g. ${example}`)
   ]).transform((value) => {
     if (typeof value === "number") return value;
     const match = pattern.exec(value);
     return Number(match[1]) * prefixScale[match[2] ?? ""];
-  }).pipe(z106.number().finite().positive(`${label} must be greater than zero`));
+  }).pipe(z110.number().finite().positive(`${label} must be greater than zero`));
 }
 var positiveCurrent = positiveQuantity("A", "peak amperes", "5mA");
 var positiveResistance = positiveQuantity(
@@ -18812,8 +18923,8 @@ var positiveResistance = positiveQuantity(
   "real ohms",
   "100ohm"
 );
-var pcbReturnCurrentExcitationProps = z106.object({
-  name: z106.string().trim().min(1).optional(),
+var pcbReturnCurrentExcitationProps = z110.object({
+  name: z110.string().trim().min(1).optional(),
   source: selector,
   load: selector,
   ground: selector,
@@ -18829,10 +18940,10 @@ var pcbReturnCurrentExcitationProps = z106.object({
 expectTypesMatch(true);
 
 // lib/components/pcb-return-current-simulation.ts
-import { z as z107 } from "zod";
-var pcbReturnCurrentSimulationProps = z107.object({
-  name: z107.string().trim().min(1).optional(),
-  children: z107.custom().optional()
+import { z as z111 } from "zod";
+var pcbReturnCurrentSimulationProps = z111.object({
+  name: z111.string().trim().min(1).optional(),
+  children: z111.custom().optional()
 }).strict();
 expectTypesMatch(true);
 
@@ -18850,43 +18961,43 @@ import {
   resistance as resistance4,
   voltage as voltage4
 } from "circuit-json";
-import { z as z108 } from "zod";
-var resistanceSweepQuantity = resistance4.pipe(z108.number());
-var capacitanceSweepQuantity = capacitance4.pipe(z108.number());
-var inductanceSweepQuantity = inductance.pipe(z108.number());
-var voltageSweepQuantity = voltage4.pipe(z108.number());
-var currentSweepQuantity = current2.pipe(z108.number());
+import { z as z112 } from "zod";
+var resistanceSweepQuantity = resistance4.pipe(z112.number());
+var capacitanceSweepQuantity = capacitance4.pipe(z112.number());
+var inductanceSweepQuantity = inductance.pipe(z112.number());
+var voltageSweepQuantity = voltage4.pipe(z112.number());
+var currentSweepQuantity = current2.pipe(z112.number());
 var createAnalogSweepCoordinateProps = (sweepQuantity) => ({
-  name: z108.string().optional(),
-  values: z108.array(sweepQuantity).min(1).optional(),
+  name: z112.string().optional(),
+  values: z112.array(sweepQuantity).min(1).optional(),
   start: sweepQuantity.optional(),
   stop: sweepQuantity.optional(),
   step: sweepQuantity.optional()
 });
-var analogResistanceSweepParameterProps = z108.object({
+var analogResistanceSweepParameterProps = z112.object({
   ...createAnalogSweepCoordinateProps(resistanceSweepQuantity),
-  parameterType: z108.literal("resistance"),
-  resistorRef: z108.string().min(1)
+  parameterType: z112.literal("resistance"),
+  resistorRef: z112.string().min(1)
 }).strict();
-var analogCapacitanceSweepParameterProps = z108.object({
+var analogCapacitanceSweepParameterProps = z112.object({
   ...createAnalogSweepCoordinateProps(capacitanceSweepQuantity),
-  parameterType: z108.literal("capacitance"),
-  capacitorRef: z108.string().min(1)
+  parameterType: z112.literal("capacitance"),
+  capacitorRef: z112.string().min(1)
 }).strict();
-var analogInductanceSweepParameterProps = z108.object({
+var analogInductanceSweepParameterProps = z112.object({
   ...createAnalogSweepCoordinateProps(inductanceSweepQuantity),
-  parameterType: z108.literal("inductance"),
-  inductorRef: z108.string().min(1)
+  parameterType: z112.literal("inductance"),
+  inductorRef: z112.string().min(1)
 }).strict();
-var analogVoltageSweepParameterProps = z108.object({
+var analogVoltageSweepParameterProps = z112.object({
   ...createAnalogSweepCoordinateProps(voltageSweepQuantity),
-  parameterType: z108.literal("voltage"),
-  net: z108.string().min(1)
+  parameterType: z112.literal("voltage"),
+  net: z112.string().min(1)
 }).strict();
-var analogCurrentSweepParameterProps = z108.object({
+var analogCurrentSweepParameterProps = z112.object({
   ...createAnalogSweepCoordinateProps(currentSweepQuantity),
-  parameterType: z108.literal("current"),
-  currentSourceRef: z108.string().min(1)
+  parameterType: z112.literal("current"),
+  currentSourceRef: z112.string().min(1)
 }).strict();
 var validateAnalogSweepCoordinates = (sweepCoordinates, context) => {
   const hasExplicitSweepCoordinates = sweepCoordinates.values !== void 0;
@@ -18898,34 +19009,34 @@ var validateAnalogSweepCoordinates = (sweepCoordinates, context) => {
   const hasRangeCoordinates = rangeCoordinateCount > 0;
   if (hasExplicitSweepCoordinates === hasRangeCoordinates) {
     context.addIssue({
-      code: z108.ZodIssueCode.custom,
+      code: z112.ZodIssueCode.custom,
       message: "Provide either values or start/stop/step"
     });
     return;
   }
   if (rangeCoordinateCount !== 0 && rangeCoordinateCount !== 3) {
     context.addIssue({
-      code: z108.ZodIssueCode.custom,
+      code: z112.ZodIssueCode.custom,
       message: "start, stop, and step must be provided together"
     });
     return;
   }
   if (sweepCoordinates.step === 0) {
     context.addIssue({
-      code: z108.ZodIssueCode.custom,
+      code: z112.ZodIssueCode.custom,
       path: ["step"],
       message: "step must be nonzero"
     });
   }
   if (sweepCoordinates.start !== void 0 && sweepCoordinates.stop !== void 0 && sweepCoordinates.step !== void 0 && Math.sign(sweepCoordinates.stop - sweepCoordinates.start) !== Math.sign(sweepCoordinates.step)) {
     context.addIssue({
-      code: z108.ZodIssueCode.custom,
+      code: z112.ZodIssueCode.custom,
       path: ["step"],
       message: "step must move from start toward stop"
     });
   }
 };
-var analogSweepParameterProps = z108.discriminatedUnion("parameterType", [
+var analogSweepParameterProps = z112.discriminatedUnion("parameterType", [
   analogResistanceSweepParameterProps,
   analogCapacitanceSweepParameterProps,
   analogInductanceSweepParameterProps,
@@ -18940,26 +19051,26 @@ expectTypesMatch(true);
 expectTypesMatch(true);
 
 // lib/components/autoroutingphase.ts
-import { z as z109 } from "zod";
-var autoroutingPhaseProps = z109.object({
-  key: z109.any().optional(),
-  name: z109.string().optional(),
+import { z as z113 } from "zod";
+var autoroutingPhaseProps = z113.object({
+  key: z113.any().optional(),
+  name: z113.string().optional(),
   autorouter: autorouterProp.optional(),
   algorithmFn: autorouterConfig.shape.algorithmFn,
   preflightRoutingCheckPolicy: preflightRoutingCheckPolicy.optional(),
-  phaseIndex: z109.number().optional(),
-  pcbTracePaths: z109.array(fanoutTracePath).optional(),
+  phaseIndex: z113.number().optional(),
+  pcbTracePaths: z113.array(fanoutTracePath).optional(),
   ...routingTolerances.shape,
-  region: z109.object({
-    shape: z109.literal("rect").optional(),
-    minX: z109.number(),
-    maxX: z109.number(),
-    minY: z109.number(),
-    maxY: z109.number()
+  region: z113.object({
+    shape: z113.literal("rect").optional(),
+    minX: z113.number(),
+    maxX: z113.number(),
+    minY: z113.number(),
+    maxY: z113.number()
   }).optional(),
-  connection: z109.string().optional(),
-  connections: z109.array(z109.string()).optional(),
-  reroute: z109.boolean().optional(),
+  connection: z113.string().optional(),
+  connections: z113.array(z113.string()).optional(),
+  reroute: z113.boolean().optional(),
   ...fanoutProps.shape
 }).superRefine((value, ctx) => {
   const isSimplifyAutorouter = value.autorouter === "simplify" || typeof value.autorouter === "object" && value.autorouter?.preset === "simplify";
@@ -18970,7 +19081,7 @@ var autoroutingPhaseProps = z109.object({
   }
   if (value.reroute !== void 0 && !(isSimplifyAutorouter && value.reroute === true) && value.region === void 0 && value.connection === void 0 && value.connections === void 0) {
     ctx.addIssue({
-      code: z109.ZodIssueCode.custom,
+      code: z113.ZodIssueCode.custom,
       message: "region, connection, or connections is required when reroute is provided",
       path: ["region"]
     });
@@ -18979,15 +19090,15 @@ var autoroutingPhaseProps = z109.object({
 expectTypesMatch(true);
 
 // lib/components/spicemodel.ts
-import { z as z110 } from "zod";
-var spicemodelProps = z110.object({
-  source: z110.string(),
-  spicePinMapping: z110.record(z110.string(), z110.string()).optional()
+import { z as z114 } from "zod";
+var spicemodelProps = z114.object({
+  source: z114.string(),
+  spicePinMapping: z114.record(z114.string(), z114.string()).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/transistor.ts
-import { z as z111 } from "zod";
+import { z as z115 } from "zod";
 var transistorPinsLabels = [
   "pin1",
   "pin2",
@@ -19000,7 +19111,7 @@ var transistorPinsLabels = [
   "drain"
 ];
 var transistorProps = commonComponentProps.extend({
-  type: z111.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"]),
+  type: z115.enum(["npn", "pnp", "bjt", "jfet", "mosfet", "igbt"]),
   connections: createConnectionsProp(transistorPinsLabels).optional()
 });
 var transistorPins = [
@@ -19014,7 +19125,7 @@ var transistorPins = [
 expectTypesMatch(true);
 
 // lib/components/mosfet.ts
-import { z as z112 } from "zod";
+import { z as z116 } from "zod";
 var mosfetPins = [
   "pin1",
   "drain",
@@ -19024,11 +19135,11 @@ var mosfetPins = [
   "gate"
 ];
 var mosfetProps = commonComponentProps.extend({
-  channelType: z112.enum(["n", "p"]),
-  mosfetMode: z112.enum(["enhancement", "depletion"]),
-  symbolDrainSide: z112.enum(["left", "right", "top", "bottom"]).optional(),
-  symbolSourceSide: z112.enum(["left", "right", "top", "bottom"]).optional(),
-  symbolGateSide: z112.enum(["left", "right", "top", "bottom"]).optional(),
+  channelType: z116.enum(["n", "p"]),
+  mosfetMode: z116.enum(["enhancement", "depletion"]),
+  symbolDrainSide: z116.enum(["left", "right", "top", "bottom"]).optional(),
+  symbolSourceSide: z116.enum(["left", "right", "top", "bottom"]).optional(),
+  symbolGateSide: z116.enum(["left", "right", "top", "bottom"]).optional(),
   connections: createConnectionsProp(mosfetPins).optional()
 });
 expectTypesMatch(true);
@@ -19050,29 +19161,29 @@ expectTypesMatch(true);
 
 // lib/components/inductor.ts
 import { inductance as inductance2 } from "circuit-json";
-import { z as z114 } from "zod";
+import { z as z118 } from "zod";
 var inductorPins = lrPins;
 var inductorProps = commonComponentProps.extend({
   inductance: inductance2,
-  maxCurrentRating: z114.union([z114.string(), z114.number()]).optional(),
+  maxCurrentRating: z118.union([z118.string(), z118.number()]).optional(),
   schOrientation: schematicOrientation.optional(),
   connections: createConnectionsProp(inductorPins).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/internal-circuit.ts
-import { z as z115 } from "zod";
-var internalCircuitProps = z115.object({
-  children: z115.custom().optional()
+import { z as z119 } from "zod";
+var internalCircuitProps = z119.object({
+  children: z119.custom().optional()
 });
 expectTypesMatch(
   true
 );
 
 // lib/components/diode.ts
-import { z as z116 } from "zod";
+import { z as z120 } from "zod";
 var diodePins = lrPolarPins;
-var diodeConnectionKeys = z116.enum([
+var diodeConnectionKeys = z120.enum([
   "anode",
   "cathode",
   "pin1",
@@ -19080,13 +19191,13 @@ var diodeConnectionKeys = z116.enum([
   "pos",
   "neg"
 ]);
-var connectionTarget3 = z116.string().or(z116.array(z116.string()).readonly()).or(z116.array(z116.string()));
-var connectionsProp2 = z116.record(diodeConnectionKeys, connectionTarget3);
-var diodePinLabelsProp = z116.record(
-  z116.enum(diodePins),
-  schematicPinLabel.or(z116.array(schematicPinLabel).readonly()).or(z116.array(schematicPinLabel))
+var connectionTarget3 = z120.string().or(z120.array(z120.string()).readonly()).or(z120.array(z120.string()));
+var connectionsProp2 = z120.record(diodeConnectionKeys, connectionTarget3);
+var diodePinLabelsProp = z120.record(
+  z120.enum(diodePins),
+  schematicPinLabel.or(z120.array(schematicPinLabel).readonly()).or(z120.array(schematicPinLabel))
 );
-var diodeVariant = z116.enum([
+var diodeVariant = z120.enum([
   "standard",
   "schottky",
   "zener",
@@ -19097,12 +19208,12 @@ var diodeVariant = z116.enum([
 var diodeProps = commonComponentProps.extend({
   connections: connectionsProp2.optional(),
   variant: diodeVariant.optional().default("standard"),
-  standard: z116.boolean().optional(),
-  schottky: z116.boolean().optional(),
-  zener: z116.boolean().optional(),
-  avalanche: z116.boolean().optional(),
-  photo: z116.boolean().optional(),
-  tvs: z116.boolean().optional(),
+  standard: z120.boolean().optional(),
+  schottky: z120.boolean().optional(),
+  zener: z120.boolean().optional(),
+  avalanche: z120.boolean().optional(),
+  photo: z120.boolean().optional(),
+  tvs: z120.boolean().optional(),
   schOrientation: schematicOrientation.optional(),
   schSize: schematicSymbolSize.optional(),
   pinLabels: diodePinLabelsProp.optional()
@@ -19117,11 +19228,11 @@ var diodeProps = commonComponentProps.extend({
   ].filter(Boolean).length;
   if (enabledFlags > 1) {
     ctx.addIssue({
-      code: z116.ZodIssueCode.custom,
+      code: z120.ZodIssueCode.custom,
       message: "Exactly one diode variant must be enabled",
       path: []
     });
-    return z116.INVALID;
+    return z120.INVALID;
   }
 }).transform((data) => {
   const result = {
@@ -19167,18 +19278,18 @@ var diodeProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/led.ts
-import { z as z117 } from "zod";
-var legacyNumericLedPinLabelsProp = z117.record(
-  z117.enum(["1", "2"]),
-  schematicPinLabel.or(z117.array(schematicPinLabel).readonly()).or(z117.array(schematicPinLabel))
+import { z as z121 } from "zod";
+var legacyNumericLedPinLabelsProp = z121.record(
+  z121.enum(["1", "2"]),
+  schematicPinLabel.or(z121.array(schematicPinLabel).readonly()).or(z121.array(schematicPinLabel))
 ).transform((pinLabels) => ({
   ...pinLabels["1"] === void 0 ? {} : { pin1: pinLabels["1"] },
   ...pinLabels["2"] === void 0 ? {} : { pin2: pinLabels["2"] }
 }));
 var ledProps = commonComponentProps.extend({
-  color: z117.string().optional(),
-  wavelength: z117.string().optional(),
-  schDisplayValue: z117.string().optional(),
+  color: z121.string().optional(),
+  wavelength: z121.string().optional(),
+  schDisplayValue: z121.string().optional(),
   schOrientation: schematicOrientation.optional(),
   /** Select a compact schematic symbol; omitted, default, and md retain the standard symbol. */
   schSize: schematicSymbolSize.optional(),
@@ -19186,28 +19297,28 @@ var ledProps = commonComponentProps.extend({
   // wrappers, then normalized to the canonical pin1/pin2 representation.
   pinLabels: diodePinLabelsProp.or(legacyNumericLedPinLabelsProp).optional(),
   connections: createConnectionsProp(lrPolarPins).optional(),
-  laser: z117.boolean().optional()
+  laser: z121.boolean().optional()
 });
 var ledPins = lrPolarPins;
 
 // lib/components/switch.ts
-import { ms as ms3, frequency as frequency4 } from "circuit-json";
-import { z as z118 } from "zod";
+import { ms as ms5, frequency as frequency4 } from "circuit-json";
+import { z as z122 } from "zod";
 var switchProps = commonComponentProps.extend({
-  type: z118.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
-  isNormallyClosed: z118.boolean().optional().default(false),
-  spst: z118.boolean().optional(),
-  spdt: z118.boolean().optional(),
-  dpst: z118.boolean().optional(),
-  dpdt: z118.boolean().optional(),
+  type: z122.enum(["spst", "spdt", "dpst", "dpdt"]).optional(),
+  isNormallyClosed: z122.boolean().optional().default(false),
+  spst: z122.boolean().optional(),
+  spdt: z122.boolean().optional(),
+  dpst: z122.boolean().optional(),
+  dpdt: z122.boolean().optional(),
   pinLabels: pinLabelsProp.optional(),
   noConnect: noConnectProp.optional(),
   simSwitchFrequency: frequency4.optional(),
-  simCloseAt: ms3.optional(),
-  simOpenAt: ms3.optional(),
-  simStartClosed: z118.boolean().optional(),
-  simStartOpen: z118.boolean().optional(),
-  connections: z118.custom().pipe(z118.record(z118.string(), connectionTarget)).optional()
+  simCloseAt: ms5.optional(),
+  simOpenAt: ms5.optional(),
+  simStartClosed: z122.boolean().optional(),
+  simStartOpen: z122.boolean().optional(),
+  connections: z122.custom().pipe(z122.record(z122.string(), connectionTarget)).optional()
 }).transform((props) => {
   const updatedProps = { ...props };
   if (updatedProps.dpdt) {
@@ -19239,33 +19350,33 @@ expectTypesMatch(true);
 
 // lib/components/fabrication-note-text.ts
 import { length as length4 } from "circuit-json";
-import { z as z119 } from "zod";
+import { z as z123 } from "zod";
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: z119.string(),
-  anchorAlignment: z119.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z119.enum(["tscircuit2024"]).optional(),
+  text: z123.string(),
+  anchorAlignment: z123.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z123.enum(["tscircuit2024"]).optional(),
   fontSize: length4.optional(),
-  color: z119.string().optional()
+  color: z123.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/fabrication-note-rect.ts
 import { distance as distance25 } from "circuit-json";
-import { z as z120 } from "zod";
+import { z as z124 } from "zod";
 var fabricationNoteRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   width: distance25,
   height: distance25,
   strokeWidth: distance25.optional(),
-  isFilled: z120.boolean().optional(),
-  hasStroke: z120.boolean().optional(),
-  isStrokeDashed: z120.boolean().optional(),
-  color: z120.string().optional(),
+  isFilled: z124.boolean().optional(),
+  hasStroke: z124.boolean().optional(),
+  isStrokeDashed: z124.boolean().optional(),
+  color: z124.string().optional(),
   cornerRadius: distance25.optional()
 });
 
 // lib/components/fabrication-note-path.ts
 import { length as length5, route_hint_point as route_hint_point3 } from "circuit-json";
-import { z as z121 } from "zod";
+import { z as z125 } from "zod";
 var fabricationNotePathProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -19277,19 +19388,19 @@ var fabricationNotePathProps = pcbLayoutProps.omit({
   pcbOffsetY: true,
   pcbRotation: true
 }).extend({
-  route: z121.array(route_hint_point3),
+  route: z125.array(route_hint_point3),
   strokeWidth: length5.optional(),
-  color: z121.string().optional(),
+  color: z125.string().optional(),
   /** Fill the route, closing its boundary implicitly. Omitted means false. */
-  isFilled: z121.boolean().optional(),
+  isFilled: z125.boolean().optional(),
   /** Draw the route's outline. Omitted means true; false disables it. */
-  hasStroke: z121.boolean().optional()
+  hasStroke: z125.boolean().optional()
 });
 
 // lib/components/fabrication-note-dimension.ts
 import { distance as distance26, length as length6 } from "circuit-json";
-import { z as z122 } from "zod";
-var dimensionTarget = z122.union([z122.string(), point]);
+import { z as z126 } from "zod";
+var dimensionTarget = z126.union([z126.string(), point]);
 var fabricationNoteDimensionProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -19303,44 +19414,44 @@ var fabricationNoteDimensionProps = pcbLayoutProps.omit({
 }).extend({
   from: dimensionTarget,
   to: dimensionTarget,
-  text: z122.string().optional(),
+  text: z126.string().optional(),
   offset: distance26.optional(),
-  offsetDirection: z122.object({ x: z122.number().finite(), y: z122.number().finite() }).optional(),
-  font: z122.enum(["tscircuit2024"]).optional(),
+  offsetDirection: z126.object({ x: z126.number().finite(), y: z126.number().finite() }).optional(),
+  font: z126.enum(["tscircuit2024"]).optional(),
   fontSize: length6.optional(),
-  color: z122.string().optional(),
+  color: z126.string().optional(),
   arrowSize: distance26.optional(),
-  units: z122.enum(["in", "mm"]).optional(),
-  outerEdgeToEdge: z122.literal(true).optional(),
-  centerToCenter: z122.literal(true).optional(),
-  innerEdgeToEdge: z122.literal(true).optional()
+  units: z126.enum(["in", "mm"]).optional(),
+  outerEdgeToEdge: z126.literal(true).optional(),
+  centerToCenter: z126.literal(true).optional(),
+  innerEdgeToEdge: z126.literal(true).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-trace.ts
 import { distance as distance27, route_hint_point as route_hint_point4 } from "circuit-json";
-import { z as z123 } from "zod";
-var pcbTraceProps = z123.object({
-  layer: z123.string().optional(),
+import { z as z127 } from "zod";
+var pcbTraceProps = z127.object({
+  layer: z127.string().optional(),
   thickness: distance27.optional(),
-  route: z123.array(route_hint_point4)
+  route: z127.array(route_hint_point4)
 });
 
 // lib/components/via.ts
 import { distance as distance28, layer_ref as layer_ref10 } from "circuit-json";
-import { z as z124 } from "zod";
+import { z as z128 } from "zod";
 var viaProps = commonLayoutProps.extend({
-  name: z124.string().optional(),
+  name: z128.string().optional(),
   fromLayer: layer_ref10.optional(),
   toLayer: layer_ref10.optional(),
   holeDiameter: distance28.optional(),
   outerDiameter: distance28.optional(),
-  layers: z124.array(layer_ref10).optional(),
-  connectsTo: z124.string().or(z124.array(z124.string())).optional(),
-  netIsAssignable: z124.boolean().optional(),
-  tented: z124.union([
-    z124.boolean(),
-    z124.enum([
+  layers: z128.array(layer_ref10).optional(),
+  connectsTo: z128.string().or(z128.array(z128.string())).optional(),
+  netIsAssignable: z128.boolean().optional(),
+  tented: z128.union([
+    z128.boolean(),
+    z128.enum([
       "both_sides",
       "top_and_bottom_tented",
       "top_tented",
@@ -19359,15 +19470,15 @@ expectTypesMatch(true);
 
 // lib/components/testpoint.ts
 import { distance as distance29 } from "circuit-json";
-import { z as z125 } from "zod";
+import { z as z129 } from "zod";
 var testpointPins = ["pin1"];
-var testpointConnectionsProp = z125.object({
+var testpointConnectionsProp = z129.object({
   pin1: connectionTarget
 }).strict();
 var testpointProps = commonComponentProps.extend({
   connections: testpointConnectionsProp.optional(),
-  footprintVariant: z125.enum(["pad", "through_hole"]).optional(),
-  padShape: z125.enum(["rect", "circle"]).optional().default("circle"),
+  footprintVariant: z129.enum(["pad", "through_hole"]).optional(),
+  padShape: z129.enum(["rect", "circle"]).optional().default("circle"),
   padDiameter: distance29.optional(),
   holeDiameter: distance29.optional(),
   width: distance29.optional(),
@@ -19379,42 +19490,42 @@ var testpointProps = commonComponentProps.extend({
 expectTypesMatch(true);
 
 // lib/components/breakoutpoint.ts
-import { z as z126 } from "zod";
+import { z as z130 } from "zod";
 var breakoutPointProps = pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-  connection: z126.string()
+  connection: z130.string()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-keepout.ts
 import { distance as distance30, layer_ref as layer_ref11 } from "circuit-json";
-import { z as z127 } from "zod";
-var pcbKeepoutProps = z127.union([
+import { z as z131 } from "zod";
+var pcbKeepoutProps = z131.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: z127.literal("circle"),
+    shape: z131.literal("circle"),
     radius: distance30,
-    layers: z127.array(layer_ref11).optional(),
+    layers: z131.array(layer_ref11).optional(),
     /** Report keepout violations as warnings when true. Omit for normal enforcement. */
-    warningOnly: z127.boolean().optional(),
+    warningOnly: z131.boolean().optional(),
     /** Allow trace crossings without keepout diagnostics. False or omitted retains enforcement; copper pours remain excluded. */
-    allowTraces: z127.boolean().optional(),
+    allowTraces: z131.boolean().optional(),
     /** Allow components and their pads/plated holes without keepout diagnostics. False or omitted retains enforcement; copper pours remain excluded. */
-    allowPlacements: z127.boolean().optional(),
-    excludeRefs: z127.array(z127.string()).optional().describe(
+    allowPlacements: z131.boolean().optional(),
+    excludeRefs: z131.array(z131.string()).optional().describe(
       'Component selectors excluded from the keepout, such as ".ANT1"'
     )
   }),
   pcbLayoutProps.extend({
-    shape: z127.literal("rect"),
+    shape: z131.literal("rect"),
     width: distance30,
     height: distance30,
-    layers: z127.array(layer_ref11).optional(),
+    layers: z131.array(layer_ref11).optional(),
     /** Report keepout violations as warnings when true. Omit for normal enforcement. */
-    warningOnly: z127.boolean().optional(),
+    warningOnly: z131.boolean().optional(),
     /** Allow trace crossings without keepout diagnostics. False or omitted retains enforcement; copper pours remain excluded. */
-    allowTraces: z127.boolean().optional(),
+    allowTraces: z131.boolean().optional(),
     /** Allow components and their pads/plated holes without keepout diagnostics. False or omitted retains enforcement; copper pours remain excluded. */
-    allowPlacements: z127.boolean().optional(),
-    excludeRefs: z127.array(z127.string()).optional().describe(
+    allowPlacements: z131.boolean().optional(),
+    excludeRefs: z131.array(z131.string()).optional().describe(
       'Component selectors excluded from the keepout, such as ".ANT1"'
     )
   })
@@ -19422,20 +19533,20 @@ var pcbKeepoutProps = z127.union([
 
 // lib/components/courtyard-rect.ts
 import { distance as distance31 } from "circuit-json";
-import { z as z128 } from "zod";
+import { z as z132 } from "zod";
 var courtyardRectProps = pcbLayoutProps.extend({
   width: distance31,
   height: distance31,
   strokeWidth: distance31.optional(),
-  isFilled: z128.boolean().optional(),
-  hasStroke: z128.boolean().optional(),
-  isStrokeDashed: z128.boolean().optional(),
-  color: z128.string().optional()
+  isFilled: z132.boolean().optional(),
+  hasStroke: z132.boolean().optional(),
+  isStrokeDashed: z132.boolean().optional(),
+  color: z132.string().optional()
 });
 
 // lib/components/courtyard-outline.ts
 import { length as length7 } from "circuit-json";
-import { z as z129 } from "zod";
+import { z as z133 } from "zod";
 var courtyardOutlineProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -19447,11 +19558,11 @@ var courtyardOutlineProps = pcbLayoutProps.omit({
   pcbOffsetY: true,
   pcbRotation: true
 }).extend({
-  outline: z129.array(point),
+  outline: z133.array(point),
   strokeWidth: length7.optional(),
-  isClosed: z129.boolean().optional(),
-  isStrokeDashed: z129.boolean().optional(),
-  color: z129.string().optional()
+  isClosed: z133.boolean().optional(),
+  isStrokeDashed: z133.boolean().optional(),
+  color: z133.string().optional()
 });
 
 // lib/components/courtyard-circle.ts
@@ -19471,16 +19582,16 @@ var courtyardPillProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 });
 
 // lib/components/copper-pour.ts
-import { z as z132 } from "zod";
+import { z as z136 } from "zod";
 import { layer_ref as layer_ref12 } from "circuit-json";
-var copperPourProps = z132.object({
-  name: z132.string().optional(),
+var copperPourProps = z136.object({
+  name: z136.string().optional(),
   layer: layer_ref12,
-  connectsTo: z132.string(),
-  crosshatch: z132.boolean().optional(),
-  crosshatchPitch: distance.pipe(z132.number().finite().positive()).optional(),
-  crosshatchWidth: distance.pipe(z132.number().finite().positive()).optional(),
-  unbroken: z132.boolean().optional().describe(
+  connectsTo: z136.string(),
+  crosshatch: z136.boolean().optional(),
+  crosshatchPitch: distance.pipe(z136.number().finite().positive()).optional(),
+  crosshatchWidth: distance.pipe(z136.number().finite().positive()).optional(),
+  unbroken: z136.boolean().optional().describe(
     "Reserves the pour region during autorouting so unrelated traces do not split it. Vias may still cross the region using antipads."
   ),
   padMargin: distance.optional(),
@@ -19488,13 +19599,13 @@ var copperPourProps = z132.object({
   clearance: distance.optional(),
   boardEdgeMargin: distance.optional(),
   cutoutMargin: distance.optional(),
-  useThermalReliefs: z132.boolean().optional(),
-  outline: z132.array(point).optional(),
-  coveredWithSolderMask: z132.boolean().optional().default(true)
+  useThermalReliefs: z136.boolean().optional(),
+  outline: z136.array(point).optional(),
+  coveredWithSolderMask: z136.boolean().optional().default(true)
 }).superRefine((props, ctx) => {
   if (props.crosshatch && (props.crosshatchWidth ?? 0.25) >= (props.crosshatchPitch ?? 1)) {
     ctx.addIssue({
-      code: z132.ZodIssueCode.custom,
+      code: z136.ZodIssueCode.custom,
       path: ["crosshatchWidth"],
       message: "crosshatchWidth must be less than crosshatchPitch"
     });
@@ -19504,16 +19615,16 @@ expectTypesMatch(true);
 
 // lib/components/cadassembly.ts
 import { layer_ref as layer_ref13 } from "circuit-json";
-import { z as z133 } from "zod";
-var cadassemblyProps = z133.object({
+import { z as z137 } from "zod";
+var cadassemblyProps = z137.object({
   originalLayer: layer_ref13.default("top").optional(),
-  children: z133.any().optional()
+  children: z137.any().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/cadmodel.ts
-import { z as z134 } from "zod";
-var pcbPosition = z134.object({
+import { z as z138 } from "zod";
+var pcbPosition = z138.object({
   pcbX: pcbCoordinate.optional(),
   pcbY: pcbCoordinate.optional(),
   pcbLeftEdgeX: pcbCoordinate.optional(),
@@ -19532,7 +19643,7 @@ var cadModelObject = cadModelBaseWithUrl.merge(pcbPosition);
 expectTypesMatch(true);
 var cadModelInputObject = cadModelBase.extend({
   /** Modelprinter specification or HTTP(S) URL; mutually exclusive with modelUrl. */
-  model: z134.string().trim().min(1).optional(),
+  model: z138.string().trim().min(1).optional(),
   modelUrl: url.optional()
 }).merge(pcbPosition).refine(
   (props) => props.model === void 0 !== (props.modelUrl === void 0),
@@ -19545,7 +19656,7 @@ var cadModelInputObject = cadModelBase.extend({
   modelUrl: model === void 0 ? props.modelUrl : /^https?:\/\//i.test(model) ? model : `https://modelcdn.tscircuit.com/jscad_models/${encodeURIComponent(model)}.glb`
 })).pipe(cadModelObject);
 expectTypesMatch(true);
-var cadmodelProps = z134.union([z134.null(), url, cadModelInputObject]);
+var cadmodelProps = z138.union([z138.null(), url, cadModelInputObject]);
 
 // lib/components/power-source.ts
 import { voltage as voltage5 } from "circuit-json";
@@ -19554,10 +19665,10 @@ var powerSourceProps = commonComponentProps.extend({
 });
 
 // lib/components/voltagesource.ts
-import { frequency as frequency5, ms as ms4, rotation as rotation6, voltage as voltage6 } from "circuit-json";
-import { z as z135 } from "zod";
+import { frequency as frequency5, ms as ms6, rotation as rotation6, voltage as voltage6 } from "circuit-json";
+import { z as z139 } from "zod";
 var voltageSourcePinLabels = ["pin1", "pin2", "pos", "neg"];
-var percentage = z135.union([z135.string(), z135.number()]).transform((val) => {
+var percentage = z139.union([z139.string(), z139.number()]).transform((val) => {
   if (typeof val === "string") {
     if (val.endsWith("%")) {
       return parseFloat(val.slice(0, -1)) / 100;
@@ -19566,20 +19677,20 @@ var percentage = z135.union([z135.string(), z135.number()]).transform((val) => {
   }
   return val;
 }).pipe(
-  z135.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
+  z139.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
 );
 var voltageSourceProps = commonComponentProps.extend({
   voltage: voltage6.optional(),
   frequency: frequency5.optional(),
   peakToPeakVoltage: voltage6.optional(),
-  waveShape: z135.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
+  waveShape: z139.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
   phase: rotation6.optional(),
   dutyCycle: percentage.optional(),
-  pulseDelay: ms4.optional(),
-  riseTime: ms4.optional(),
-  fallTime: ms4.optional(),
-  pulseWidth: ms4.optional(),
-  period: ms4.optional(),
+  pulseDelay: ms6.optional(),
+  riseTime: ms6.optional(),
+  fallTime: ms6.optional(),
+  pulseWidth: ms6.optional(),
+  period: ms6.optional(),
   acMagnitude: voltage6.optional(),
   acPhase: rotation6.optional(),
   connections: createConnectionsProp(voltageSourcePinLabels).optional()
@@ -19589,9 +19700,9 @@ expectTypesMatch(true);
 
 // lib/components/currentsource.ts
 import { frequency as frequency6, rotation as rotation7, current as current3 } from "circuit-json";
-import { z as z136 } from "zod";
+import { z as z140 } from "zod";
 var currentSourcePinLabels = ["pin1", "pin2", "pos", "neg"];
-var percentage2 = z136.union([z136.string(), z136.number()]).transform((val) => {
+var percentage2 = z140.union([z140.string(), z140.number()]).transform((val) => {
   if (typeof val === "string") {
     if (val.endsWith("%")) {
       return parseFloat(val.slice(0, -1)) / 100;
@@ -19600,13 +19711,13 @@ var percentage2 = z136.union([z136.string(), z136.number()]).transform((val) =>
   }
   return val;
 }).pipe(
-  z136.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
+  z140.number().min(0, "Duty cycle must be non-negative").max(1, "Duty cycle cannot be greater than 100%")
 );
 var currentSourceProps = commonComponentProps.extend({
   current: current3.optional(),
   frequency: frequency6.optional(),
   peakToPeakCurrent: current3.optional(),
-  waveShape: z136.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
+  waveShape: z140.enum(["sinewave", "square", "triangle", "sawtooth"]).optional(),
   phase: rotation7.optional(),
   dutyCycle: percentage2.optional(),
   acMagnitude: current3.optional(),
@@ -19617,21 +19728,21 @@ var currentSourcePins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/voltageprobe.ts
-import { z as z137 } from "zod";
+import { z as z141 } from "zod";
 var voltageProbeProps = commonComponentProps.omit({ name: true }).extend({
-  name: z137.string().optional(),
-  connectsTo: z137.string(),
-  referenceTo: z137.string().optional(),
-  color: z137.string().optional(),
-  graphDisplayName: z137.string().optional(),
-  graphCenter: z137.number().optional(),
-  graphVerticalOffset: z137.number().or(z137.string()).optional(),
-  graphVoltagePerDiv: z137.number().or(z137.string()).optional()
+  name: z141.string().optional(),
+  connectsTo: z141.string(),
+  referenceTo: z141.string().optional(),
+  color: z141.string().optional(),
+  graphDisplayName: z141.string().optional(),
+  graphCenter: z141.number().optional(),
+  graphVerticalOffset: z141.number().or(z141.string()).optional(),
+  graphVoltagePerDiv: z141.number().or(z141.string()).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/ammeter.ts
-import { z as z138 } from "zod";
+import { z as z142 } from "zod";
 var ammeterPinLabels = ["pin1", "pin2", "pos", "neg"];
 var hasAmmeterConnectionPair = (connections) => {
   return connections.pos !== void 0 && connections.neg !== void 0 || connections.pin1 !== void 0 && connections.pin2 !== void 0;
@@ -19641,64 +19752,64 @@ var ammeterProps = commonComponentProps.extend({
     hasAmmeterConnectionPair,
     "Ammeter connections must include either pos/neg or pin1/pin2"
   ),
-  color: z138.string().optional(),
-  graphDisplayName: z138.string().optional(),
-  graphCenter: z138.number().optional(),
-  graphVerticalOffset: z138.number().or(z138.string()).optional(),
-  graphCurrentPerDiv: z138.number().or(z138.string()).optional()
+  color: z142.string().optional(),
+  graphDisplayName: z142.string().optional(),
+  graphCenter: z142.number().optional(),
+  graphVerticalOffset: z142.number().or(z142.string()).optional(),
+  graphCurrentPerDiv: z142.number().or(z142.string()).optional()
 });
 var ammeterPins = ammeterPinLabels;
 expectTypesMatch(true);
 
 // lib/components/schematic-arc.ts
 import { distance as distance34, point as point5, rotation as rotation8 } from "circuit-json";
-import { z as z139 } from "zod";
-var schematicArcProps = z139.object({
+import { z as z143 } from "zod";
+var schematicArcProps = z143.object({
   center: point5,
   radius: distance34,
   startAngleDegrees: rotation8,
   endAngleDegrees: rotation8,
-  direction: z139.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
+  direction: z143.enum(["clockwise", "counterclockwise"]).default("counterclockwise"),
   strokeWidth: distance34.optional(),
-  color: z139.string().optional(),
-  isDashed: z139.boolean().optional().default(false)
+  color: z143.string().optional(),
+  isDashed: z143.boolean().optional().default(false)
 });
 expectTypesMatch(true);
 
 // lib/components/toolingrail.ts
-import { z as z140 } from "zod";
-var toolingrailProps = z140.object({
-  children: z140.any().optional()
+import { z as z144 } from "zod";
+var toolingrailProps = z144.object({
+  children: z144.any().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-box.ts
 import { distance as distance35 } from "circuit-json";
-import { z as z141 } from "zod";
-var schematicBoxProps = z141.object({
-  name: z141.string().optional(),
-  chipRef: z141.string().optional(),
+import { z as z145 } from "zod";
+var schematicBoxProps = z145.object({
+  name: z145.string().optional(),
+  chipRef: z145.string().optional(),
   pinLabels: pinLabelsProp.optional(),
   schPinArrangement: schematicPinArrangement.optional(),
   schPinStyle: schematicPinStyle.optional(),
   schX: distance35.optional(),
   schY: distance35.optional(),
-  schSectionName: z141.string().optional(),
-  schSheetName: z141.string().optional(),
+  schSectionName: z145.string().optional(),
+  schSheetName: z145.string().optional(),
   width: distance35.optional(),
   height: distance35.optional(),
-  overlay: z141.array(z141.string()).optional(),
+  overlay: z145.array(z145.string()).optional(),
   padding: distance35.optional(),
   paddingLeft: distance35.optional(),
   paddingRight: distance35.optional(),
   paddingTop: distance35.optional(),
   paddingBottom: distance35.optional(),
-  title: z141.string().optional(),
+  title: z145.string().optional(),
   titleAlignment: ninePointAnchor.default("top_left"),
-  titleColor: z141.string().optional(),
+  titleColor: z145.string().optional(),
   titleFontSize: distance35.optional(),
-  titleInside: z141.boolean().default(false),
-  strokeStyle: z141.enum(["solid", "dashed"]).default("solid")
+  titleInside: z145.boolean().default(false),
+  strokeStyle: z145.enum(["solid", "dashed"]).default("solid")
 }).refine(
   (elm) => elm.width !== void 0 && elm.height !== void 0 || Array.isArray(elm.overlay) && elm.overlay.length > 0,
   {
@@ -19714,21 +19825,21 @@ expectTypesMatch(true);
 
 // lib/components/schematic-symbol.ts
 import { rotation as rotation9 } from "circuit-json";
-import { z as z142 } from "zod";
-var schematicSymbolConnections = z142.custom().pipe(z142.record(z142.string(), connectionTarget)).refine((value) => Object.keys(value).length > 0, {
+import { z as z146 } from "zod";
+var schematicSymbolConnections = z146.custom().pipe(z146.record(z146.string(), connectionTarget)).refine((value) => Object.keys(value).length > 0, {
   message: "connections must map at least one schematic symbol port"
 });
-var schematicSymbolProps = z142.object({
-  name: z142.string().min(1),
-  displayName: z142.string().optional(),
-  chipRef: z142.string().min(1).optional(),
-  symbolName: z142.string().min(1),
+var schematicSymbolProps = z146.object({
+  name: z146.string().min(1),
+  displayName: z146.string().optional(),
+  chipRef: z146.string().min(1).optional(),
+  symbolName: z146.string().min(1),
   connections: schematicSymbolConnections.optional(),
   schX: distance.optional(),
   schY: distance.optional(),
   schRotation: rotation9.optional(),
-  schSectionName: z142.string().optional(),
-  schSheetName: z142.string().optional()
+  schSectionName: z146.string().optional(),
+  schSheetName: z146.string().optional()
 });
 expectTypesMatch(
   true
@@ -19736,15 +19847,15 @@ expectTypesMatch(
 
 // lib/components/schematic-circle.ts
 import { distance as distance36, point as point6 } from "circuit-json";
-import { z as z143 } from "zod";
-var schematicCircleProps = z143.object({
+import { z as z147 } from "zod";
+var schematicCircleProps = z147.object({
   center: point6,
   radius: distance36,
   strokeWidth: distance36.optional(),
-  color: z143.string().optional(),
-  isFilled: z143.boolean().optional().default(false),
-  fillColor: z143.string().optional(),
-  isDashed: z143.boolean().optional().default(false)
+  color: z147.string().optional(),
+  isFilled: z147.boolean().optional().default(false),
+  fillColor: z147.string().optional(),
+  isDashed: z147.boolean().optional().default(false)
 });
 expectTypesMatch(
   true
@@ -19752,32 +19863,32 @@ expectTypesMatch(
 
 // lib/components/schematic-rect.ts
 import { distance as distance37, rotation as rotation10 } from "circuit-json";
-import { z as z144 } from "zod";
-var schematicRectProps = z144.object({
+import { z as z148 } from "zod";
+var schematicRectProps = z148.object({
   schX: distance37.optional(),
   schY: distance37.optional(),
   width: distance37,
   height: distance37,
   rotation: rotation10.default(0),
   strokeWidth: distance37.optional(),
-  color: z144.string().optional(),
-  isFilled: z144.boolean().optional().default(false),
-  fillColor: z144.string().optional(),
-  isDashed: z144.boolean().optional().default(false)
+  color: z148.string().optional(),
+  isFilled: z148.boolean().optional().default(false),
+  fillColor: z148.string().optional(),
+  isDashed: z148.boolean().optional().default(false)
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-line.ts
 import { distance as distance38 } from "circuit-json";
-import { z as z145 } from "zod";
-var schematicLineProps = z145.object({
+import { z as z149 } from "zod";
+var schematicLineProps = z149.object({
   x1: distance38,
   y1: distance38,
   x2: distance38,
   y2: distance38,
   strokeWidth: distance38.optional(),
-  color: z145.string().optional(),
-  isDashed: z145.boolean().optional().default(false),
+  color: z149.string().optional(),
+  isDashed: z149.boolean().optional().default(false),
   dashLength: distance38.optional(),
   dashGap: distance38.optional()
 });
@@ -19785,11 +19896,11 @@ expectTypesMatch(true);
 
 // lib/components/schematic-text.ts
 import { distance as distance39, rotation as rotation11 } from "circuit-json";
-import { z as z147 } from "zod";
+import { z as z151 } from "zod";
 
 // lib/common/fivePointAnchor.ts
-import { z as z146 } from "zod";
-var fivePointAnchor = z146.enum([
+import { z as z150 } from "zod";
+var fivePointAnchor = z150.enum([
   "center",
   "left",
   "right",
@@ -19798,39 +19909,39 @@ var fivePointAnchor = z146.enum([
 ]);
 
 // lib/components/schematic-text.ts
-var schematicTextProps = z147.object({
+var schematicTextProps = z151.object({
   schX: distance39.optional(),
   schY: distance39.optional(),
-  text: z147.string(),
-  fontSize: z147.number().default(1),
-  anchor: z147.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
-  color: z147.string().default("#000000"),
+  text: z151.string(),
+  fontSize: z151.number().default(1),
+  anchor: z151.union([fivePointAnchor.describe("legacy"), ninePointAnchor]).default("center"),
+  color: z151.string().default("#000000"),
   schRotation: rotation11.default(0)
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-path.ts
 import { distance as distance40, point as point7 } from "circuit-json";
-import { z as z148 } from "zod";
-var schematicPathProps = z148.object({
-  points: z148.array(point7).optional(),
-  svgPath: z148.string().optional(),
+import { z as z152 } from "zod";
+var schematicPathProps = z152.object({
+  points: z152.array(point7).optional(),
+  svgPath: z152.string().optional(),
   strokeWidth: distance40.optional(),
-  strokeColor: z148.string().optional(),
+  strokeColor: z152.string().optional(),
   dashLength: distance40.optional(),
   dashGap: distance40.optional(),
-  isFilled: z148.boolean().optional().default(false),
-  fillColor: z148.string().optional()
+  isFilled: z152.boolean().optional().default(false),
+  fillColor: z152.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-table.ts
 import { distance as distance41 } from "circuit-json";
-import { z as z149 } from "zod";
-var schematicTableProps = z149.object({
+import { z as z153 } from "zod";
+var schematicTableProps = z153.object({
   schX: distance41.optional(),
   schY: distance41.optional(),
-  children: z149.any().optional(),
+  children: z153.any().optional(),
   cellPadding: distance41.optional(),
   borderWidth: distance41.optional(),
   anchor: ninePointAnchor.optional(),
@@ -19840,34 +19951,34 @@ expectTypesMatch(true);
 
 // lib/components/schematic-row.ts
 import { distance as distance42 } from "circuit-json";
-import { z as z150 } from "zod";
-var schematicRowProps = z150.object({
-  children: z150.any().optional(),
+import { z as z154 } from "zod";
+var schematicRowProps = z154.object({
+  children: z154.any().optional(),
   height: distance42.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-cell.ts
 import { distance as distance43 } from "circuit-json";
-import { z as z151 } from "zod";
-var schematicCellProps = z151.object({
-  children: z151.string().optional(),
-  horizontalAlign: z151.enum(["left", "center", "right"]).optional(),
-  verticalAlign: z151.enum(["top", "middle", "bottom"]).optional(),
+import { z as z155 } from "zod";
+var schematicCellProps = z155.object({
+  children: z155.string().optional(),
+  horizontalAlign: z155.enum(["left", "center", "right"]).optional(),
+  verticalAlign: z155.enum(["top", "middle", "bottom"]).optional(),
   fontSize: distance43.optional(),
-  rowSpan: z151.number().optional(),
-  colSpan: z151.number().optional(),
+  rowSpan: z155.number().optional(),
+  colSpan: z155.number().optional(),
   width: distance43.optional(),
-  text: z151.string().optional()
+  text: z155.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-section.ts
 import { distance as distance44 } from "circuit-json";
-import { z as z152 } from "zod";
-var schematicSectionProps = z152.object({
-  displayName: z152.string().optional(),
-  name: z152.string(),
+import { z as z156 } from "zod";
+var schematicSectionProps = z156.object({
+  displayName: z156.string().optional(),
+  name: z156.string(),
   sectionTitleFontSize: distance44.optional()
 });
 expectTypesMatch(
@@ -19875,30 +19986,30 @@ expectTypesMatch(
 );
 
 // lib/components/schematic-sheet.ts
-import { z as z153 } from "zod";
+import { z as z157 } from "zod";
 import { distance as distance45 } from "circuit-json";
-var schematicSheetProps = z153.object({
-  name: z153.string().optional(),
-  displayName: z153.string().optional(),
-  sheetIndex: z153.number().optional(),
-  sheetSize: z153.enum(["A4", "ANSI_B"]).default("A4"),
-  sheetWidth: distance45.pipe(z153.number().positive()).optional(),
-  sheetHeight: distance45.pipe(z153.number().positive()).optional(),
-  children: z153.any().optional()
+var schematicSheetProps = z157.object({
+  name: z157.string().optional(),
+  displayName: z157.string().optional(),
+  sheetIndex: z157.number().optional(),
+  sheetSize: z157.enum(["A4", "ANSI_B"]).default("A4"),
+  sheetWidth: distance45.pipe(z157.number().positive()).optional(),
+  sheetHeight: distance45.pipe(z157.number().positive()).optional(),
+  children: z157.any().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/schematic-graphic.ts
-import { z as z154 } from "zod";
+import { z as z158 } from "zod";
 var nonemptyUrl = url.refine((value) => value.trim().length > 0, {
   message: "imageUrl cannot be empty"
 });
 var positiveDistance6 = (fieldName) => distance.refine((value) => Number.isFinite(value) && value > 0, {
   message: `${fieldName} must be a positive finite distance`
 });
-var schematicGraphicProps = z154.object({
+var schematicGraphicProps = z158.object({
   imageUrl: nonemptyUrl.optional(),
-  svgContent: z154.string().refine((value) => value.trim().length > 0, {
+  svgContent: z158.string().refine((value) => value.trim().length > 0, {
     message: "svgContent cannot be empty"
   }).optional(),
   width: positiveDistance6("width").optional(),
@@ -19906,7 +20017,7 @@ var schematicGraphicProps = z154.object({
 }).superRefine(({ imageUrl, svgContent }, ctx) => {
   if (imageUrl === void 0 && svgContent === void 0) {
     ctx.addIssue({
-      code: z154.ZodIssueCode.custom,
+      code: z158.ZodIssueCode.custom,
       message: "At least one of imageUrl or svgContent is required"
     });
   }
@@ -19917,40 +20028,40 @@ expectTypesMatch(
 
 // lib/components/copper-text.ts
 import { layer_ref as layer_ref14, length as length8 } from "circuit-json";
-import { z as z155 } from "zod";
+import { z as z159 } from "zod";
 var copperTextProps = pcbLayoutProps.extend({
-  text: z155.string(),
+  text: z159.string(),
   anchorAlignment: ninePointAnchor.default("center"),
-  font: z155.enum(["tscircuit2024"]).optional(),
+  font: z159.enum(["tscircuit2024"]).optional(),
   fontSize: length8.optional(),
-  layers: z155.array(layer_ref14).optional(),
-  knockout: z155.boolean().optional(),
-  mirrored: z155.boolean().optional()
+  layers: z159.array(layer_ref14).optional(),
+  knockout: z159.boolean().optional(),
+  mirrored: z159.boolean().optional()
 });
 
 // lib/components/silkscreen-text.ts
 import { layer_ref as layer_ref15, length as length9 } from "circuit-json";
-import { z as z156 } from "zod";
+import { z as z160 } from "zod";
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: z156.string(),
+  text: z160.string(),
   anchorAlignment: ninePointAnchor.default("center"),
-  font: z156.enum(["tscircuit2024"]).optional(),
+  font: z160.enum(["tscircuit2024"]).optional(),
   fontSize: length9.optional(),
   /**
    * If true, text will knock out underlying silkscreen
    */
-  isKnockout: z156.boolean().optional(),
+  isKnockout: z160.boolean().optional(),
   knockoutPadding: length9.optional(),
   knockoutPaddingLeft: length9.optional(),
   knockoutPaddingRight: length9.optional(),
   knockoutPaddingTop: length9.optional(),
   knockoutPaddingBottom: length9.optional(),
-  layers: z156.array(layer_ref15).optional()
+  layers: z160.array(layer_ref15).optional()
 });
 
 // lib/components/silkscreen-path.ts
 import { length as length10, route_hint_point as route_hint_point5 } from "circuit-json";
-import { z as z157 } from "zod";
+import { z as z161 } from "zod";
 var silkscreenPathProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -19962,7 +20073,7 @@ var silkscreenPathProps = pcbLayoutProps.omit({
   pcbOffsetY: true,
   pcbRotation: true
 }).extend({
-  route: z157.array(route_hint_point5),
+  route: z161.array(route_hint_point5),
   strokeWidth: length10.optional()
 });
 
@@ -19984,10 +20095,10 @@ var silkscreenLineProps = pcbLayoutProps.omit({
 
 // lib/components/silkscreen-rect.ts
 import { distance as distance47 } from "circuit-json";
-import { z as z158 } from "zod";
+import { z as z162 } from "zod";
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  filled: z158.boolean().default(true).optional(),
-  stroke: z158.enum(["dashed", "solid", "none"]).optional(),
+  filled: z162.boolean().default(true).optional(),
+  stroke: z162.enum(["dashed", "solid", "none"]).optional(),
   strokeWidth: distance47.optional(),
   width: distance47,
   height: distance47,
@@ -19996,10 +20107,10 @@ var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 
 // lib/components/silkscreen-circle.ts
 import { distance as distance48 } from "circuit-json";
-import { z as z159 } from "zod";
+import { z as z163 } from "zod";
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z159.boolean().optional(),
-  isOutline: z159.boolean().optional(),
+  isFilled: z163.boolean().optional(),
+  isOutline: z163.boolean().optional(),
   strokeWidth: distance48.optional(),
   radius: distance48
 });
@@ -20017,69 +20128,69 @@ expectTypesMatch(true);
 
 // lib/components/trace-hint.ts
 import { distance as distance49, layer_ref as layer_ref16, route_hint_point as route_hint_point6 } from "circuit-json";
-import { z as z161 } from "zod";
-var routeHintPointProps = z161.object({
+import { z as z165 } from "zod";
+var routeHintPointProps = z165.object({
   x: distance49,
   y: distance49,
-  via: z161.boolean().optional(),
+  via: z165.boolean().optional(),
   toLayer: layer_ref16.optional()
 });
-var traceHintProps = z161.object({
-  for: z161.string().optional().describe(
+var traceHintProps = z165.object({
+  for: z165.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: z161.number().optional(),
+  order: z165.number().optional(),
   offset: route_hint_point6.or(routeHintPointProps).optional(),
-  offsets: z161.array(route_hint_point6).or(z161.array(routeHintPointProps)).optional(),
-  traceWidth: z161.number().optional()
+  offsets: z165.array(route_hint_point6).or(z165.array(routeHintPointProps)).optional(),
+  traceWidth: z165.number().optional()
 });
 
 // lib/components/port.ts
 import { distance as distance50 } from "circuit-json";
-import { z as z162 } from "zod";
+import { z as z166 } from "zod";
 var portProps = commonLayoutProps.extend({
-  name: z162.string().optional(),
-  pinNumber: z162.number().optional(),
-  schStemLength: z162.number().optional(),
-  schPinLabelFontSize: z162.enum(["default", "sm"]).or(
+  name: z166.string().optional(),
+  pinNumber: z166.number().optional(),
+  schStemLength: z166.number().optional(),
+  schPinLabelFontSize: z166.enum(["default", "sm"]).or(
     distance50.refine((value) => Number.isFinite(value) && value > 0, {
       message: "Schematic pin-label font size must be positive and finite"
     })
   ).optional(),
-  aliases: z162.array(z162.string()).optional(),
-  layer: z162.string().optional(),
-  layers: z162.array(z162.string()).optional(),
-  schX: z162.number().optional(),
-  schY: z162.number().optional(),
+  aliases: z166.array(z166.string()).optional(),
+  layer: z166.string().optional(),
+  layers: z166.array(z166.string()).optional(),
+  schX: z166.number().optional(),
+  schY: z166.number().optional(),
   direction: direction.optional(),
-  connectsTo: z162.string().or(z162.array(z162.string())).optional(),
+  connectsTo: z166.string().or(z166.array(z166.string())).optional(),
   kicadPinMetadata: kicadPinMetadata.optional(),
-  hasInversionCircle: z162.boolean().optional()
+  hasInversionCircle: z166.boolean().optional()
 });
 
 // lib/components/pcb-note-text.ts
 import { length as length11 } from "circuit-json";
-import { z as z163 } from "zod";
+import { z as z167 } from "zod";
 var pcbNoteTextProps = pcbLayoutProps.extend({
-  text: z163.string(),
-  anchorAlignment: z163.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z163.enum(["tscircuit2024"]).optional(),
+  text: z167.string(),
+  anchorAlignment: z167.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z167.enum(["tscircuit2024"]).optional(),
   fontSize: length11.optional(),
-  color: z163.string().optional()
+  color: z167.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-note-rect.ts
 import { distance as distance51 } from "circuit-json";
-import { z as z164 } from "zod";
+import { z as z168 } from "zod";
 var pcbNoteRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   width: distance51,
   height: distance51,
   strokeWidth: distance51.optional(),
-  isFilled: z164.boolean().optional(),
-  hasStroke: z164.boolean().optional(),
-  isStrokeDashed: z164.boolean().optional(),
-  color: z164.string().optional(),
+  isFilled: z168.boolean().optional(),
+  hasStroke: z168.boolean().optional(),
+  isStrokeDashed: z168.boolean().optional(),
+  color: z168.string().optional(),
   cornerRadius: distance51.optional()
 });
 expectTypesMatch(true);
@@ -20089,7 +20200,7 @@ import {
   length as length12,
   route_hint_point as route_hint_point7
 } from "circuit-json";
-import { z as z165 } from "zod";
+import { z as z169 } from "zod";
 var pcbNotePathProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -20101,15 +20212,15 @@ var pcbNotePathProps = pcbLayoutProps.omit({
   pcbOffsetY: true,
   pcbRotation: true
 }).extend({
-  route: z165.array(route_hint_point7),
+  route: z169.array(route_hint_point7),
   strokeWidth: length12.optional(),
-  color: z165.string().optional()
+  color: z169.string().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-note-line.ts
 import { distance as distance52 } from "circuit-json";
-import { z as z166 } from "zod";
+import { z as z170 } from "zod";
 var pcbNoteLineProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -20126,15 +20237,15 @@ var pcbNoteLineProps = pcbLayoutProps.omit({
   x2: distance52,
   y2: distance52,
   strokeWidth: distance52.optional(),
-  color: z166.string().optional(),
-  isDashed: z166.boolean().optional()
+  color: z170.string().optional(),
+  isDashed: z170.boolean().optional()
 });
 expectTypesMatch(true);
 
 // lib/components/pcb-note-dimension.ts
 import { distance as distance53, length as length13 } from "circuit-json";
-import { z as z167 } from "zod";
-var dimensionTarget2 = z167.union([z167.string(), point]);
+import { z as z171 } from "zod";
+var dimensionTarget2 = z171.union([z171.string(), point]);
 var pcbNoteDimensionProps = pcbLayoutProps.omit({
   pcbLeftEdgeX: true,
   pcbRightEdgeX: true,
@@ -20148,118 +20259,116 @@ var pcbNoteDimensionProps = pcbLayoutProps.omit({
 }).extend({
   from: dimensionTarget2,
   to: dimensionTarget2,
-  text: z167.string().optional(),
+  text: z171.string().optional(),
   offset: distance53.optional(),
-  offsetDirection: z167.object({ x: z167.number().finite(), y: z167.number().finite() }).optional(),
-  font: z167.enum(["tscircuit2024"]).optional(),
+  offsetDirection: z171.object({ x: z171.number().finite(), y: z171.number().finite() }).optional(),
+  font: z171.enum(["tscircuit2024"]).optional(),
   fontSize: length13.optional(),
-  color: z167.string().optional(),
+  color: z171.string().optional(),
   arrowSize: distance53.optional(),
-  units: z167.enum(["in", "mm"]).optional(),
-  outerEdgeToEdge: z167.literal(true).optional(),
-  centerToCenter: z167.literal(true).optional(),
-  innerEdgeToEdge: z167.literal(true).optional()
+  units: z171.enum(["in", "mm"]).optional(),
+  outerEdgeToEdge: z171.literal(true).optional(),
+  centerToCenter: z171.literal(true).optional(),
+  innerEdgeToEdge: z171.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
 
 // lib/platformConfig.ts
-import { z as z168 } from "zod";
-var unvalidatedCircuitJson = z168.array(z168.any()).describe("Circuit JSON");
-var footprintLibraryResult = z168.object({
-  footprintCircuitJson: z168.array(z168.any()),
+import { z as z172 } from "zod";
+var unvalidatedCircuitJson = z172.array(z172.any()).describe("Circuit JSON");
+var footprintLibraryResult = z172.object({
+  footprintCircuitJson: z172.array(z172.any()),
   cadModel: cadModelProp.optional()
 });
-var pathToCircuitJsonFn = z168.function().args(z168.string()).returns(z168.promise(footprintLibraryResult)).or(
-  z168.function().args(
-    z168.string(),
-    z168.object({ resolvedPcbStyle: pcbStyle.optional() }).optional()
-  ).returns(z168.promise(footprintLibraryResult))
+var pathToCircuitJsonFn = z172.function().args(z172.string()).returns(z172.promise(footprintLibraryResult)).or(
+  z172.function().args(
+    z172.string(),
+    z172.object({ resolvedPcbStyle: pcbStyle.optional() }).optional()
+  ).returns(z172.promise(footprintLibraryResult))
 ).describe("A function that takes a path and returns Circuit JSON");
-var footprintFileParserEntry = z168.object({
-  loadFromUrl: z168.function().args(z168.string()).returns(z168.promise(footprintLibraryResult)).describe(
+var footprintFileParserEntry = z172.object({
+  loadFromUrl: z172.function().args(z172.string()).returns(z172.promise(footprintLibraryResult)).describe(
     "A function that takes a footprint file URL and returns Circuit JSON"
   )
 });
-var spiceEngineSimulationResult = z168.object({
-  engineVersionString: z168.string().optional(),
+var spiceEngineSimulationResult = z172.object({
+  engineVersionString: z172.string().optional(),
   simulationResultCircuitJson: unvalidatedCircuitJson
 });
-var spiceEngineZod = z168.object({
-  simulate: z168.function().args(z168.string()).returns(z168.promise(spiceEngineSimulationResult)).describe(
+var spiceEngineZod = z172.object({
+  simulate: z172.function().args(z172.string()).returns(z172.promise(spiceEngineSimulationResult)).describe(
     "A function that takes a SPICE string and returns a simulation result"
   )
 });
-var defaultSpiceEngine = z168.custom(
-  (value) => typeof value === "string"
-);
-var autorouterInstance = z168.object({
-  run: z168.function().args().returns(z168.promise(z168.unknown())).describe("Run the autorouter"),
-  getOutputSimpleRouteJson: z168.function().args().returns(z168.promise(z168.any())).describe("Get the resulting SimpleRouteJson")
+var defaultSpiceEngine = z172.custom((value) => typeof value === "string");
+var autorouterInstance = z172.object({
+  run: z172.function().args().returns(z172.promise(z172.unknown())).describe("Run the autorouter"),
+  getOutputSimpleRouteJson: z172.function().args().returns(z172.promise(z172.any())).describe("Get the resulting SimpleRouteJson")
 });
-var autorouterDefinition = z168.object({
-  createAutorouter: z168.function().args(z168.any(), z168.any().optional()).returns(z168.union([autorouterInstance, z168.promise(autorouterInstance)])).describe("Create an autorouter instance")
+var autorouterDefinition = z172.object({
+  createAutorouter: z172.function().args(z172.any(), z172.any().optional()).returns(z172.union([autorouterInstance, z172.promise(autorouterInstance)])).describe("Create an autorouter instance")
 });
-var platformFetch = z168.custom((value) => typeof value === "function").describe("A fetch-like function to use for platform requests");
-var localCacheEngine = z168.custom(
+var platformFetch = z172.custom((value) => typeof value === "function").describe("A fetch-like function to use for platform requests");
+var localCacheEngine = z172.custom(
   (value) => typeof value === "object" && value !== null && "getItem" in value && typeof value.getItem === "function" && "setItem" in value && typeof value.setItem === "function"
 );
-var fabricatorEngine = z168.custom(
+var fabricatorEngine = z172.custom(
   (value) => typeof value === "object" && value !== null && "runDrcChecks" in value && typeof value.runDrcChecks === "function"
 );
-var platformConfig = z168.object({
+var platformConfig = z172.object({
   partsEngine: partsEngine.optional(),
-  checkAvailability: z168.boolean().describe(
+  checkAvailability: z172.boolean().describe(
     "Opt in to networked JLCPCB availability checks during rendering. Disabled by default; enabling adds non-deterministic diagnostics."
   ).optional(),
   fabricatorEngine: fabricatorEngine.optional(),
   autorouter: autorouterProp.optional(),
-  autorouterMap: z168.record(z168.string(), autorouterDefinition).optional(),
-  allowLegacyAutorouters: z168.boolean().optional(),
+  autorouterMap: z172.record(z172.string(), autorouterDefinition).optional(),
+  allowLegacyAutorouters: z172.boolean().optional(),
   registryApiUrl: url.optional(),
   cloudAutorouterUrl: url.optional(),
   jscdnBaseUrl: url.optional(),
-  projectName: z168.string().optional(),
+  projectName: z172.string().optional(),
   projectBaseUrl: url.optional(),
-  version: z168.string().optional(),
+  version: z172.string().optional(),
   url: url.optional(),
-  printBoardInformationToSilkscreen: z168.boolean().optional(),
-  includeBoardFiles: z168.array(z168.string()).describe(
+  printBoardInformationToSilkscreen: z172.boolean().optional(),
+  includeBoardFiles: z172.array(z172.string()).describe(
     'The board files to automatically build with "tsci build", defaults to ["**/*.circuit.tsx"]. Can be an array of files or globs'
   ).optional(),
-  snapshotsDir: z168.string().describe(
+  snapshotsDir: z172.string().describe(
     'The directory where snapshots are stored for "tsci snapshot", defaults to "tests/__snapshots__"'
   ).optional(),
   defaultSpiceEngine: defaultSpiceEngine.optional(),
-  unitPreference: z168.enum(["mm", "in", "mil"]).optional(),
+  unitPreference: z172.enum(["mm", "in", "mil"]).optional(),
   localCacheEngine: localCacheEngine.optional(),
-  useCloudAutorouter: z168.boolean().optional(),
-  enablePartOrientationAnalysis: z168.boolean().optional(),
-  pcbPackSolverTimeoutMs: z168.number().finite().positive().optional(),
-  pcbDisabled: z168.boolean().optional(),
-  routingDisabled: z168.boolean().optional(),
-  schematicDisabled: z168.boolean().optional(),
-  partsEngineDisabled: z168.boolean().optional(),
-  analogSimulationDisabled: z168.boolean().optional(),
-  drcChecksDisabled: z168.boolean().optional(),
-  netlistDrcChecksDisabled: z168.boolean().optional(),
-  routingDrcChecksDisabled: z168.boolean().optional(),
-  placementDrcChecksDisabled: z168.boolean().optional(),
-  pinSpecificationDrcChecksDisabled: z168.boolean().optional(),
-  spiceEngineMap: z168.record(z168.string(), spiceEngineZod).optional(),
-  footprintLibraryMap: z168.record(
-    z168.string(),
-    z168.union([
+  useCloudAutorouter: z172.boolean().optional(),
+  enablePartOrientationAnalysis: z172.boolean().optional(),
+  pcbPackSolverTimeoutMs: z172.number().finite().positive().optional(),
+  pcbDisabled: z172.boolean().optional(),
+  routingDisabled: z172.boolean().optional(),
+  schematicDisabled: z172.boolean().optional(),
+  partsEngineDisabled: z172.boolean().optional(),
+  analogSimulationDisabled: z172.boolean().optional(),
+  drcChecksDisabled: z172.boolean().optional(),
+  netlistDrcChecksDisabled: z172.boolean().optional(),
+  routingDrcChecksDisabled: z172.boolean().optional(),
+  placementDrcChecksDisabled: z172.boolean().optional(),
+  pinSpecificationDrcChecksDisabled: z172.boolean().optional(),
+  spiceEngineMap: z172.record(z172.string(), spiceEngineZod).optional(),
+  footprintLibraryMap: z172.record(
+    z172.string(),
+    z172.union([
       pathToCircuitJsonFn,
-      z168.record(
-        z168.string(),
-        z168.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
+      z172.record(
+        z172.string(),
+        z172.union([unvalidatedCircuitJson, pathToCircuitJsonFn])
       )
     ])
   ).optional(),
-  footprintFileParserMap: z168.record(z168.string(), footprintFileParserEntry).optional(),
-  resolveProjectStaticFileImportUrl: z168.function().args(z168.string()).returns(z168.promise(z168.string())).describe(
+  footprintFileParserMap: z172.record(z172.string(), footprintFileParserEntry).optional(),
+  resolveProjectStaticFileImportUrl: z172.function().args(z172.string()).returns(z172.promise(z172.string())).describe(
     "A function that returns a string URL for static files for the project"
   ).optional(),
   platformFetch: platformFetch.optional()
@@ -20293,6 +20402,8 @@ export {
   analogCurrentSweepParameterProps,
   analogDcOperatingPointSimulationProps,
   analogDcSweepSimulationProps,
+  analogDigitalStimulusProps,
+  analogEyeDiagramProps,
   analogInductanceSweepParameterProps,
   analogResistanceSweepParameterProps,
   analogSimulationProps,
@@ -20417,6 +20528,11 @@ export {
   fuseProps,
   groupProps,
   holeProps,
+  ibisModelAsset,
+  ibisModelDefinition,
+  ibisModelProps,
+  ibisPinReferences,
+  ibisPinRunState,
   impedanceTarget,
   inductorPins,
   inductorProps,